]>
Commit | Line | Data |
---|---|---|
305b0eb2 AL |
1 | /* |
2 | * inet and unix socket functions for qemu | |
3 | * | |
4 | * (c) 2008 Gerd Hoffmann <kraxel@redhat.com> | |
5 | * | |
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. | |
9 | * | |
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. | |
e6d91ab6 PB |
14 | * |
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. | |
305b0eb2 | 17 | */ |
aafd7584 | 18 | #include "qemu/osdep.h" |
d247d25f | 19 | |
6a02c806 SH |
20 | #ifdef CONFIG_AF_VSOCK |
21 | #include <linux/vm_sockets.h> | |
22 | #endif /* CONFIG_AF_VSOCK */ | |
23 | ||
83c9089e | 24 | #include "monitor/monitor.h" |
bd269ebc | 25 | #include "qapi/clone-visitor.h" |
da34e65c | 26 | #include "qapi/error.h" |
1de7afc9 | 27 | #include "qemu/sockets.h" |
1de7afc9 | 28 | #include "qemu/main-loop.h" |
216411b8 | 29 | #include "qapi/clone-visitor.h" |
b3db211f DB |
30 | #include "qapi/qobject-input-visitor.h" |
31 | #include "qapi/qobject-output-visitor.h" | |
2a8e21c7 | 32 | #include "qapi-visit.h" |
f348b6d1 | 33 | #include "qemu/cutils.h" |
d247d25f AL |
34 | |
35 | #ifndef AI_ADDRCONFIG | |
36 | # define AI_ADDRCONFIG 0 | |
37 | #endif | |
340849a9 | 38 | |
3de3d698 WB |
39 | #ifndef AI_V4MAPPED |
40 | # define AI_V4MAPPED 0 | |
41 | #endif | |
d247d25f | 42 | |
6979a813 DB |
43 | #ifndef AI_NUMERICSERV |
44 | # define AI_NUMERICSERV 0 | |
45 | #endif | |
46 | ||
2af2bf67 | 47 | |
d247d25f AL |
48 | static int inet_getport(struct addrinfo *e) |
49 | { | |
50 | struct sockaddr_in *i4; | |
51 | struct sockaddr_in6 *i6; | |
52 | ||
53 | switch (e->ai_family) { | |
54 | case PF_INET6: | |
55 | i6 = (void*)e->ai_addr; | |
56 | return ntohs(i6->sin6_port); | |
57 | case PF_INET: | |
58 | i4 = (void*)e->ai_addr; | |
59 | return ntohs(i4->sin_port); | |
60 | default: | |
61 | return 0; | |
62 | } | |
63 | } | |
64 | ||
65 | static void inet_setport(struct addrinfo *e, int port) | |
66 | { | |
67 | struct sockaddr_in *i4; | |
68 | struct sockaddr_in6 *i6; | |
69 | ||
70 | switch (e->ai_family) { | |
71 | case PF_INET6: | |
72 | i6 = (void*)e->ai_addr; | |
73 | i6->sin6_port = htons(port); | |
74 | break; | |
75 | case PF_INET: | |
76 | i4 = (void*)e->ai_addr; | |
77 | i4->sin_port = htons(port); | |
78 | break; | |
79 | } | |
80 | } | |
81 | ||
a589569f WX |
82 | NetworkAddressFamily inet_netfamily(int family) |
83 | { | |
84 | switch (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; | |
6a02c806 SH |
88 | #ifdef CONFIG_AF_VSOCK |
89 | case PF_VSOCK: return NETWORK_ADDRESS_FAMILY_VSOCK; | |
90 | #endif /* CONFIG_AF_VSOCK */ | |
a589569f WX |
91 | } |
92 | return NETWORK_ADDRESS_FAMILY_UNKNOWN; | |
93 | } | |
94 | ||
1856835d DB |
95 | /* |
96 | * Matrix we're trying to apply | |
97 | * | |
98 | * ipv4 ipv6 family | |
99 | * - - PF_UNSPEC | |
100 | * - f PF_INET | |
101 | * - t PF_INET6 | |
102 | * f - PF_INET6 | |
103 | * f f <error> | |
104 | * f t PF_INET6 | |
105 | * t - PF_INET | |
106 | * t f PF_INET | |
94bc0d19 | 107 | * t t PF_INET6/PF_UNSPEC |
1856835d | 108 | * |
d43eda3d | 109 | * NB, this matrix is only about getting the necessary results |
1856835d DB |
110 | * from getaddrinfo(). Some of the cases require further work |
111 | * after reading results from getaddrinfo in order to fully | |
94bc0d19 DB |
112 | * apply the logic the end user wants. |
113 | * | |
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. | |
1856835d | 117 | */ |
c1b412f1 DB |
118 | int inet_ai_family_from_address(InetSocketAddress *addr, |
119 | Error **errp) | |
1856835d DB |
120 | { |
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"); | |
124 | return PF_UNSPEC; | |
125 | } | |
94bc0d19 DB |
126 | if ((addr->has_ipv6 && addr->ipv6) && (addr->has_ipv4 && addr->ipv4)) { |
127 | /* | |
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 | |
135 | * branch entirely. | |
136 | */ | |
137 | if (!addr->host || g_str_equal(addr->host, "")) { | |
138 | return PF_INET6; | |
139 | } else { | |
140 | return PF_UNSPEC; | |
141 | } | |
142 | } | |
1856835d DB |
143 | if ((addr->has_ipv6 && addr->ipv6) || (addr->has_ipv4 && !addr->ipv4)) { |
144 | return PF_INET6; | |
145 | } | |
146 | if ((addr->has_ipv4 && addr->ipv4) || (addr->has_ipv6 && !addr->ipv6)) { | |
147 | return PF_INET; | |
148 | } | |
149 | return PF_UNSPEC; | |
150 | } | |
151 | ||
39f80521 KO |
152 | static int create_fast_reuse_socket(struct addrinfo *e) |
153 | { | |
154 | int slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol); | |
155 | if (slisten < 0) { | |
156 | return -1; | |
157 | } | |
158 | socket_set_fast_reuse(slisten); | |
159 | return slisten; | |
160 | } | |
161 | ||
89382c3d KO |
162 | static int try_bind(int socket, InetSocketAddress *saddr, struct addrinfo *e) |
163 | { | |
164 | #ifndef IPV6_V6ONLY | |
165 | return bind(socket, e->ai_addr, e->ai_addrlen); | |
166 | #else | |
167 | /* | |
168 | * Deals with first & last cases in matrix in comment | |
169 | * for inet_ai_family_from_address(). | |
170 | */ | |
171 | int v6only = | |
172 | ((!saddr->has_ipv4 && !saddr->has_ipv6) || | |
173 | (saddr->has_ipv4 && saddr->ipv4 && | |
174 | saddr->has_ipv6 && saddr->ipv6)) ? 0 : 1; | |
175 | int stat; | |
176 | ||
177 | rebind: | |
178 | if (e->ai_family == PF_INET6) { | |
179 | qemu_setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, &v6only, | |
180 | sizeof(v6only)); | |
181 | } | |
182 | ||
183 | stat = bind(socket, e->ai_addr, e->ai_addrlen); | |
184 | if (!stat) { | |
185 | return 0; | |
186 | } | |
187 | ||
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 | |
190 | * with v6only set | |
191 | */ | |
192 | if (e->ai_family == PF_INET6 && errno == EADDRINUSE && !v6only) { | |
193 | v6only = 1; | |
194 | goto rebind; | |
195 | } | |
196 | return stat; | |
197 | #endif | |
198 | } | |
199 | ||
1856835d DB |
200 | static int inet_listen_saddr(InetSocketAddress *saddr, |
201 | int port_offset, | |
202 | bool update_addr, | |
203 | Error **errp) | |
d247d25f AL |
204 | { |
205 | struct addrinfo ai,*res,*e; | |
d247d25f AL |
206 | char port[33]; |
207 | char uaddr[INET6_ADDRSTRLEN+1]; | |
208 | char uport[33]; | |
1856835d DB |
209 | int slisten, rc, port_min, port_max, p; |
210 | Error *err = NULL; | |
d247d25f AL |
211 | |
212 | memset(&ai,0, sizeof(ai)); | |
3de3d698 | 213 | ai.ai_flags = AI_PASSIVE; |
6979a813 DB |
214 | if (saddr->has_numeric && saddr->numeric) { |
215 | ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV; | |
216 | } | |
1856835d | 217 | ai.ai_family = inet_ai_family_from_address(saddr, &err); |
e5bc776f | 218 | ai.ai_socktype = SOCK_STREAM; |
d247d25f | 219 | |
1856835d DB |
220 | if (err) { |
221 | error_propagate(errp, err); | |
222 | return -1; | |
223 | } | |
224 | ||
225 | if (saddr->host == NULL) { | |
0983f5e6 | 226 | error_setg(errp, "host not specified"); |
e5bc776f | 227 | return -1; |
d247d25f | 228 | } |
1856835d DB |
229 | if (saddr->port != NULL) { |
230 | pstrcpy(port, sizeof(port), saddr->port); | |
0983f5e6 DB |
231 | } else { |
232 | port[0] = '\0'; | |
233 | } | |
d247d25f AL |
234 | |
235 | /* lookup */ | |
8bc89127 GH |
236 | if (port_offset) { |
237 | unsigned long long baseport; | |
0983f5e6 DB |
238 | if (strlen(port) == 0) { |
239 | error_setg(errp, "port not specified"); | |
240 | return -1; | |
241 | } | |
8bc89127 GH |
242 | if (parse_uint_full(port, &baseport, 10) < 0) { |
243 | error_setg(errp, "can't convert to a number: %s", port); | |
244 | return -1; | |
245 | } | |
246 | if (baseport > 65535 || | |
247 | baseport + port_offset > 65535) { | |
248 | error_setg(errp, "port %s out of range", port); | |
249 | return -1; | |
250 | } | |
251 | snprintf(port, sizeof(port), "%d", (int)baseport + port_offset); | |
252 | } | |
1856835d | 253 | rc = getaddrinfo(strlen(saddr->host) ? saddr->host : NULL, |
0983f5e6 | 254 | strlen(port) ? port : NULL, &ai, &res); |
d247d25f | 255 | if (rc != 0) { |
1856835d DB |
256 | error_setg(errp, "address resolution failed for %s:%s: %s", |
257 | saddr->host, port, gai_strerror(rc)); | |
d247d25f AL |
258 | return -1; |
259 | } | |
d247d25f AL |
260 | |
261 | /* create socket + bind */ | |
262 | for (e = res; e != NULL; e = e->ai_next) { | |
39b6efc8 VS |
263 | getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, |
264 | uaddr,INET6_ADDRSTRLEN,uport,32, | |
265 | NI_NUMERICHOST | NI_NUMERICSERV); | |
39f80521 KO |
266 | |
267 | slisten = create_fast_reuse_socket(e); | |
39b6efc8 | 268 | if (slisten < 0) { |
029409e5 | 269 | if (!e->ai_next) { |
235256a2 | 270 | error_setg_errno(errp, errno, "Failed to create socket"); |
029409e5 | 271 | } |
39b6efc8 VS |
272 | continue; |
273 | } | |
d247d25f | 274 | |
877691f9 | 275 | port_min = inet_getport(e); |
1856835d | 276 | port_max = saddr->has_to ? saddr->to + port_offset : port_min; |
877691f9 MA |
277 | for (p = port_min; p <= port_max; p++) { |
278 | inet_setport(e, p); | |
89382c3d | 279 | if (try_bind(slisten, saddr, e) >= 0) { |
d247d25f AL |
280 | goto listen; |
281 | } | |
877691f9 | 282 | if (p == port_max) { |
029409e5 | 283 | if (!e->ai_next) { |
235256a2 | 284 | error_setg_errno(errp, errno, "Failed to bind socket"); |
029409e5 | 285 | } |
d247d25f | 286 | } |
d247d25f AL |
287 | } |
288 | closesocket(slisten); | |
289 | } | |
d247d25f AL |
290 | freeaddrinfo(res); |
291 | return -1; | |
292 | ||
293 | listen: | |
294 | if (listen(slisten,1) != 0) { | |
235256a2 | 295 | error_setg_errno(errp, errno, "Failed to listen on socket"); |
d247d25f | 296 | closesocket(slisten); |
39b6efc8 | 297 | freeaddrinfo(res); |
d247d25f AL |
298 | return -1; |
299 | } | |
1856835d DB |
300 | if (update_addr) { |
301 | g_free(saddr->host); | |
302 | saddr->host = g_strdup(uaddr); | |
303 | g_free(saddr->port); | |
304 | saddr->port = g_strdup_printf("%d", | |
305 | inet_getport(e) - port_offset); | |
306 | saddr->has_ipv6 = saddr->ipv6 = e->ai_family == PF_INET6; | |
307 | saddr->has_ipv4 = saddr->ipv4 = e->ai_family != PF_INET6; | |
308 | } | |
d247d25f AL |
309 | freeaddrinfo(res); |
310 | return slisten; | |
311 | } | |
312 | ||
05bc1d8a MT |
313 | #ifdef _WIN32 |
314 | #define QEMU_SOCKET_RC_INPROGRESS(rc) \ | |
315 | ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY) | |
316 | #else | |
317 | #define QEMU_SOCKET_RC_INPROGRESS(rc) \ | |
318 | ((rc) == -EINPROGRESS) | |
319 | #endif | |
320 | ||
b2587932 | 321 | static int inet_connect_addr(struct addrinfo *addr, Error **errp); |
233aa5c2 | 322 | |
b2587932 | 323 | static int inet_connect_addr(struct addrinfo *addr, Error **errp) |
233aa5c2 OW |
324 | { |
325 | int sock, rc; | |
326 | ||
05bc1d8a MT |
327 | sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); |
328 | if (sock < 0) { | |
235256a2 | 329 | error_setg_errno(errp, errno, "Failed to create socket"); |
05bc1d8a MT |
330 | return -1; |
331 | } | |
04fd1c78 | 332 | socket_set_fast_reuse(sock); |
b2587932 | 333 | |
05bc1d8a MT |
334 | /* connect to peer */ |
335 | do { | |
336 | rc = 0; | |
337 | if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) { | |
b16a44e1 | 338 | rc = -errno; |
05bc1d8a MT |
339 | } |
340 | } while (rc == -EINTR); | |
341 | ||
b2587932 | 342 | if (rc < 0) { |
235256a2 | 343 | error_setg_errno(errp, errno, "Failed to connect socket"); |
05bc1d8a MT |
344 | closesocket(sock); |
345 | return -1; | |
346 | } | |
b2587932 | 347 | |
05bc1d8a MT |
348 | return sock; |
349 | } | |
350 | ||
2942e420 DB |
351 | static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr, |
352 | Error **errp) | |
05bc1d8a MT |
353 | { |
354 | struct addrinfo ai, *res; | |
355 | int rc; | |
2942e420 | 356 | Error *err = NULL; |
340849a9 | 357 | static int useV4Mapped = 1; |
d247d25f | 358 | |
05bc1d8a | 359 | memset(&ai, 0, sizeof(ai)); |
233aa5c2 | 360 | |
340849a9 DB |
361 | ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; |
362 | if (atomic_read(&useV4Mapped)) { | |
363 | ai.ai_flags |= AI_V4MAPPED; | |
364 | } | |
2942e420 | 365 | ai.ai_family = inet_ai_family_from_address(saddr, &err); |
f4c94c7c | 366 | ai.ai_socktype = SOCK_STREAM; |
d247d25f | 367 | |
2942e420 DB |
368 | if (err) { |
369 | error_propagate(errp, err); | |
05bc1d8a | 370 | return NULL; |
d247d25f AL |
371 | } |
372 | ||
2942e420 DB |
373 | if (saddr->host == NULL || saddr->port == NULL) { |
374 | error_setg(errp, "host and/or port not specified"); | |
375 | return NULL; | |
05bc1d8a | 376 | } |
d247d25f AL |
377 | |
378 | /* lookup */ | |
2942e420 | 379 | rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); |
340849a9 DB |
380 | |
381 | /* At least FreeBSD and OS-X 10.6 declare AI_V4MAPPED but | |
382 | * then don't implement it in their getaddrinfo(). Detect | |
383 | * this and retry without the flag since that's preferrable | |
384 | * to a fatal error | |
385 | */ | |
386 | if (rc == EAI_BADFLAGS && | |
387 | (ai.ai_flags & AI_V4MAPPED)) { | |
388 | atomic_set(&useV4Mapped, 0); | |
389 | ai.ai_flags &= ~AI_V4MAPPED; | |
390 | rc = getaddrinfo(saddr->host, saddr->port, &ai, &res); | |
391 | } | |
05bc1d8a | 392 | if (rc != 0) { |
2942e420 DB |
393 | error_setg(errp, "address resolution failed for %s:%s: %s", |
394 | saddr->host, saddr->port, gai_strerror(rc)); | |
05bc1d8a MT |
395 | return NULL; |
396 | } | |
397 | return res; | |
398 | } | |
399 | ||
5db5f44c OW |
400 | /** |
401 | * Create a socket and connect it to an address. | |
402 | * | |
2942e420 | 403 | * @saddr: Inet socket address specification |
5db5f44c OW |
404 | * @errp: set on error |
405 | * | |
406 | * Returns: -1 on error, file descriptor on success. | |
407 | */ | |
b2587932 | 408 | int inet_connect_saddr(InetSocketAddress *saddr, Error **errp) |
05bc1d8a | 409 | { |
3f9286b7 | 410 | Error *local_err = NULL; |
05bc1d8a MT |
411 | struct addrinfo *res, *e; |
412 | int sock = -1; | |
05bc1d8a | 413 | |
2942e420 | 414 | res = inet_parse_connect_saddr(saddr, errp); |
05bc1d8a MT |
415 | if (!res) { |
416 | return -1; | |
417 | } | |
418 | ||
d247d25f | 419 | for (e = res; e != NULL; e = e->ai_next) { |
3f9286b7 MA |
420 | error_free(local_err); |
421 | local_err = NULL; | |
b2587932 | 422 | sock = inet_connect_addr(e, &local_err); |
3f9286b7 | 423 | if (sock >= 0) { |
05bc1d8a | 424 | break; |
a6ba35b3 | 425 | } |
d247d25f | 426 | } |
3f9286b7 MA |
427 | |
428 | if (sock < 0) { | |
429 | error_propagate(errp, local_err); | |
3f9286b7 | 430 | } |
b2587932 | 431 | |
d247d25f | 432 | freeaddrinfo(res); |
05bc1d8a | 433 | return sock; |
d247d25f AL |
434 | } |
435 | ||
8b39910e DB |
436 | static int inet_dgram_saddr(InetSocketAddress *sraddr, |
437 | InetSocketAddress *sladdr, | |
438 | Error **errp) | |
7e1b35b4 GH |
439 | { |
440 | struct addrinfo ai, *peer = NULL, *local = NULL; | |
441 | const char *addr; | |
442 | const char *port; | |
7e1b35b4 | 443 | int sock = -1, rc; |
8b39910e | 444 | Error *err = NULL; |
7e1b35b4 GH |
445 | |
446 | /* lookup peer addr */ | |
447 | memset(&ai,0, sizeof(ai)); | |
3de3d698 | 448 | ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG; |
8b39910e | 449 | ai.ai_family = inet_ai_family_from_address(sraddr, &err); |
7e1b35b4 GH |
450 | ai.ai_socktype = SOCK_DGRAM; |
451 | ||
8b39910e DB |
452 | if (err) { |
453 | error_propagate(errp, err); | |
58c652c0 | 454 | goto err; |
8b39910e DB |
455 | } |
456 | ||
457 | addr = sraddr->host; | |
458 | port = sraddr->port; | |
7e1b35b4 GH |
459 | if (addr == NULL || strlen(addr) == 0) { |
460 | addr = "localhost"; | |
461 | } | |
462 | if (port == NULL || strlen(port) == 0) { | |
4f085c82 | 463 | error_setg(errp, "remote port not specified"); |
58c652c0 | 464 | goto err; |
7e1b35b4 GH |
465 | } |
466 | ||
9cd1883c | 467 | if ((rc = getaddrinfo(addr, port, &ai, &peer)) != 0) { |
4f085c82 PB |
468 | error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, |
469 | gai_strerror(rc)); | |
26015051 | 470 | goto err; |
7e1b35b4 | 471 | } |
7e1b35b4 GH |
472 | |
473 | /* lookup local addr */ | |
474 | memset(&ai,0, sizeof(ai)); | |
475 | ai.ai_flags = AI_PASSIVE; | |
476 | ai.ai_family = peer->ai_family; | |
477 | ai.ai_socktype = SOCK_DGRAM; | |
478 | ||
8b39910e DB |
479 | if (sladdr) { |
480 | addr = sladdr->host; | |
481 | port = sladdr->port; | |
482 | if (addr == NULL || strlen(addr) == 0) { | |
483 | addr = NULL; | |
484 | } | |
485 | if (!port || strlen(port) == 0) { | |
486 | port = "0"; | |
487 | } | |
488 | } else { | |
7e1b35b4 | 489 | addr = NULL; |
7e1b35b4 | 490 | port = "0"; |
8b39910e | 491 | } |
7e1b35b4 | 492 | |
9cd1883c | 493 | if ((rc = getaddrinfo(addr, port, &ai, &local)) != 0) { |
4f085c82 PB |
494 | error_setg(errp, "address resolution failed for %s:%s: %s", addr, port, |
495 | gai_strerror(rc)); | |
39b38459 | 496 | goto err; |
7e1b35b4 | 497 | } |
7e1b35b4 GH |
498 | |
499 | /* create socket */ | |
40ff6d7e | 500 | sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol); |
7e1b35b4 | 501 | if (sock < 0) { |
235256a2 | 502 | error_setg_errno(errp, errno, "Failed to create socket"); |
7e1b35b4 GH |
503 | goto err; |
504 | } | |
04fd1c78 | 505 | socket_set_fast_reuse(sock); |
7e1b35b4 GH |
506 | |
507 | /* bind socket */ | |
7e1b35b4 | 508 | if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) { |
235256a2 | 509 | error_setg_errno(errp, errno, "Failed to bind socket"); |
7e1b35b4 GH |
510 | goto err; |
511 | } | |
512 | ||
513 | /* connect to peer */ | |
7e1b35b4 | 514 | if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) { |
235256a2 | 515 | error_setg_errno(errp, errno, "Failed to connect socket"); |
7e1b35b4 GH |
516 | goto err; |
517 | } | |
518 | ||
519 | freeaddrinfo(local); | |
520 | freeaddrinfo(peer); | |
521 | return sock; | |
522 | ||
523 | err: | |
26015051 | 524 | if (sock != -1) { |
7e1b35b4 | 525 | closesocket(sock); |
26015051 C |
526 | } |
527 | if (local) { | |
7e1b35b4 | 528 | freeaddrinfo(local); |
26015051 C |
529 | } |
530 | if (peer) { | |
7e1b35b4 | 531 | freeaddrinfo(peer); |
26015051 C |
532 | } |
533 | ||
7e1b35b4 GH |
534 | return -1; |
535 | } | |
536 | ||
f4c94c7c | 537 | /* compatibility wrapper */ |
0785bd7a | 538 | int inet_parse(InetSocketAddress *addr, const char *str, Error **errp) |
f4c94c7c GH |
539 | { |
540 | const char *optstr, *h; | |
55a10996 | 541 | char host[65]; |
f4c94c7c | 542 | char port[33]; |
879e45c7 | 543 | int to; |
f4c94c7c GH |
544 | int pos; |
545 | ||
0785bd7a | 546 | memset(addr, 0, sizeof(*addr)); |
879e45c7 | 547 | |
f4c94c7c GH |
548 | /* parse address */ |
549 | if (str[0] == ':') { | |
550 | /* no host given */ | |
879e45c7 | 551 | host[0] = '\0'; |
9cd1883c | 552 | if (sscanf(str, ":%32[^,]%n", port, &pos) != 1) { |
2f002c43 | 553 | error_setg(errp, "error parsing port in address '%s'", str); |
0785bd7a | 554 | return -1; |
f4c94c7c GH |
555 | } |
556 | } else if (str[0] == '[') { | |
557 | /* IPv6 addr */ | |
9cd1883c | 558 | if (sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos) != 2) { |
2f002c43 | 559 | error_setg(errp, "error parsing IPv6 address '%s'", str); |
0785bd7a | 560 | return -1; |
f4c94c7c | 561 | } |
f4c94c7c | 562 | } else { |
391b7b97 | 563 | /* hostname or IPv4 addr */ |
9cd1883c | 564 | if (sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos) != 2) { |
2f002c43 | 565 | error_setg(errp, "error parsing address '%s'", str); |
0785bd7a | 566 | return -1; |
f4c94c7c GH |
567 | } |
568 | } | |
879e45c7 PB |
569 | |
570 | addr->host = g_strdup(host); | |
571 | addr->port = g_strdup(port); | |
f4c94c7c GH |
572 | |
573 | /* parse options */ | |
574 | optstr = str + pos; | |
575 | h = strstr(optstr, ",to="); | |
879e45c7 | 576 | if (h) { |
1ccbc285 AP |
577 | h += 4; |
578 | if (sscanf(h, "%d%n", &to, &pos) != 1 || | |
579 | (h[pos] != '\0' && h[pos] != ',')) { | |
879e45c7 | 580 | error_setg(errp, "error parsing to= argument"); |
0785bd7a | 581 | return -1; |
879e45c7 PB |
582 | } |
583 | addr->has_to = true; | |
584 | addr->to = to; | |
585 | } | |
586 | if (strstr(optstr, ",ipv4")) { | |
587 | addr->ipv4 = addr->has_ipv4 = true; | |
588 | } | |
589 | if (strstr(optstr, ",ipv6")) { | |
590 | addr->ipv6 = addr->has_ipv6 = true; | |
591 | } | |
0785bd7a | 592 | return 0; |
879e45c7 PB |
593 | } |
594 | ||
e5bc776f | 595 | |
5db5f44c OW |
596 | /** |
597 | * Create a blocking socket and connect it to an address. | |
598 | * | |
599 | * @str: address string | |
600 | * @errp: set in case of an error | |
601 | * | |
602 | * Returns -1 in case of error, file descriptor on success | |
603 | **/ | |
604 | int inet_connect(const char *str, Error **errp) | |
f4c94c7c | 605 | { |
f4c94c7c | 606 | int sock = -1; |
0785bd7a | 607 | InetSocketAddress *addr = g_new(InetSocketAddress, 1); |
f4c94c7c | 608 | |
0785bd7a | 609 | if (!inet_parse(addr, str, errp)) { |
b2587932 | 610 | sock = inet_connect_saddr(addr, errp); |
5db5f44c | 611 | } |
0785bd7a | 612 | qapi_free_InetSocketAddress(addr); |
5db5f44c OW |
613 | return sock; |
614 | } | |
615 | ||
6a02c806 SH |
616 | #ifdef CONFIG_AF_VSOCK |
617 | static bool vsock_parse_vaddr_to_sockaddr(const VsockSocketAddress *vaddr, | |
618 | struct sockaddr_vm *svm, | |
619 | Error **errp) | |
620 | { | |
621 | unsigned long long val; | |
622 | ||
623 | memset(svm, 0, sizeof(*svm)); | |
624 | svm->svm_family = AF_VSOCK; | |
625 | ||
626 | if (parse_uint_full(vaddr->cid, &val, 10) < 0 || | |
627 | val > UINT32_MAX) { | |
628 | error_setg(errp, "Failed to parse cid '%s'", vaddr->cid); | |
629 | return false; | |
630 | } | |
631 | svm->svm_cid = val; | |
632 | ||
633 | if (parse_uint_full(vaddr->port, &val, 10) < 0 || | |
634 | val > UINT32_MAX) { | |
635 | error_setg(errp, "Failed to parse port '%s'", vaddr->port); | |
636 | return false; | |
637 | } | |
638 | svm->svm_port = val; | |
639 | ||
640 | return true; | |
641 | } | |
642 | ||
b2587932 | 643 | static int vsock_connect_addr(const struct sockaddr_vm *svm, Error **errp) |
6a02c806 SH |
644 | { |
645 | int sock, rc; | |
646 | ||
6a02c806 SH |
647 | sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); |
648 | if (sock < 0) { | |
649 | error_setg_errno(errp, errno, "Failed to create socket"); | |
650 | return -1; | |
651 | } | |
b2587932 | 652 | |
6a02c806 SH |
653 | /* connect to peer */ |
654 | do { | |
655 | rc = 0; | |
656 | if (connect(sock, (const struct sockaddr *)svm, sizeof(*svm)) < 0) { | |
657 | rc = -errno; | |
658 | } | |
659 | } while (rc == -EINTR); | |
660 | ||
b2587932 | 661 | if (rc < 0) { |
6a02c806 SH |
662 | error_setg_errno(errp, errno, "Failed to connect socket"); |
663 | closesocket(sock); | |
664 | return -1; | |
665 | } | |
b2587932 | 666 | |
6a02c806 SH |
667 | return sock; |
668 | } | |
669 | ||
b2587932 | 670 | static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp) |
6a02c806 SH |
671 | { |
672 | struct sockaddr_vm svm; | |
673 | int sock = -1; | |
6a02c806 SH |
674 | |
675 | if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { | |
676 | return -1; | |
677 | } | |
678 | ||
b2587932 | 679 | sock = vsock_connect_addr(&svm, errp); |
6a02c806 | 680 | |
6a02c806 SH |
681 | return sock; |
682 | } | |
683 | ||
684 | static int vsock_listen_saddr(VsockSocketAddress *vaddr, | |
685 | Error **errp) | |
686 | { | |
687 | struct sockaddr_vm svm; | |
688 | int slisten; | |
689 | ||
690 | if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) { | |
691 | return -1; | |
692 | } | |
693 | ||
694 | slisten = qemu_socket(AF_VSOCK, SOCK_STREAM, 0); | |
695 | if (slisten < 0) { | |
696 | error_setg_errno(errp, errno, "Failed to create socket"); | |
697 | return -1; | |
698 | } | |
699 | ||
700 | if (bind(slisten, (const struct sockaddr *)&svm, sizeof(svm)) != 0) { | |
701 | error_setg_errno(errp, errno, "Failed to bind socket"); | |
702 | closesocket(slisten); | |
703 | return -1; | |
704 | } | |
705 | ||
706 | if (listen(slisten, 1) != 0) { | |
707 | error_setg_errno(errp, errno, "Failed to listen on socket"); | |
708 | closesocket(slisten); | |
709 | return -1; | |
710 | } | |
711 | return slisten; | |
712 | } | |
713 | ||
4db5c619 MA |
714 | static int vsock_parse(VsockSocketAddress *addr, const char *str, |
715 | Error **errp) | |
6a02c806 | 716 | { |
6a02c806 SH |
717 | char cid[33]; |
718 | char port[33]; | |
719 | int n; | |
720 | ||
721 | if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) { | |
722 | error_setg(errp, "error parsing address '%s'", str); | |
4db5c619 | 723 | return -1; |
6a02c806 SH |
724 | } |
725 | if (str[n] != '\0') { | |
726 | error_setg(errp, "trailing characters in address '%s'", str); | |
4db5c619 | 727 | return -1; |
6a02c806 SH |
728 | } |
729 | ||
6a02c806 SH |
730 | addr->cid = g_strdup(cid); |
731 | addr->port = g_strdup(port); | |
4db5c619 | 732 | return 0; |
6a02c806 SH |
733 | } |
734 | #else | |
735 | static void vsock_unsupported(Error **errp) | |
736 | { | |
737 | error_setg(errp, "socket family AF_VSOCK unsupported"); | |
738 | } | |
739 | ||
b2587932 | 740 | static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp) |
6a02c806 SH |
741 | { |
742 | vsock_unsupported(errp); | |
743 | return -1; | |
744 | } | |
745 | ||
746 | static int vsock_listen_saddr(VsockSocketAddress *vaddr, | |
747 | Error **errp) | |
748 | { | |
749 | vsock_unsupported(errp); | |
750 | return -1; | |
751 | } | |
752 | ||
4db5c619 MA |
753 | static int vsock_parse(VsockSocketAddress *addr, const char *str, |
754 | Error **errp) | |
6a02c806 SH |
755 | { |
756 | vsock_unsupported(errp); | |
4db5c619 | 757 | return -1; |
6a02c806 SH |
758 | } |
759 | #endif /* CONFIG_AF_VSOCK */ | |
760 | ||
d247d25f AL |
761 | #ifndef _WIN32 |
762 | ||
1856835d DB |
763 | static int unix_listen_saddr(UnixSocketAddress *saddr, |
764 | bool update_addr, | |
765 | Error **errp) | |
d247d25f AL |
766 | { |
767 | struct sockaddr_un un; | |
62b6adfb | 768 | int sock, fd; |
ad9579aa DB |
769 | char *pathbuf = NULL; |
770 | const char *path; | |
d247d25f | 771 | |
40ff6d7e | 772 | sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); |
d247d25f | 773 | if (sock < 0) { |
b658c53d | 774 | error_setg_errno(errp, errno, "Failed to create Unix socket"); |
39b6efc8 | 775 | return -1; |
d247d25f AL |
776 | } |
777 | ||
ad9579aa DB |
778 | if (saddr->path && saddr->path[0]) { |
779 | path = saddr->path; | |
d247d25f | 780 | } else { |
b658c53d PB |
781 | const char *tmpdir = getenv("TMPDIR"); |
782 | tmpdir = tmpdir ? tmpdir : "/tmp"; | |
ad9579aa DB |
783 | path = pathbuf = g_strdup_printf("%s/qemu-socket-XXXXXX", tmpdir); |
784 | } | |
b658c53d | 785 | |
ad9579aa DB |
786 | if (strlen(path) > sizeof(un.sun_path)) { |
787 | error_setg(errp, "UNIX socket path '%s' is too long", path); | |
788 | error_append_hint(errp, "Path must be less than %zu bytes\n", | |
789 | sizeof(un.sun_path)); | |
790 | goto err; | |
791 | } | |
792 | ||
793 | if (pathbuf != NULL) { | |
d247d25f AL |
794 | /* |
795 | * This dummy fd usage silences the mktemp() unsecure warning. | |
796 | * Using mkstemp() doesn't make things more secure here | |
797 | * though. bind() complains about existing files, so we have | |
798 | * to unlink first and thus re-open the race window. The | |
799 | * worst case possible is bind() failing, i.e. a DoS attack. | |
800 | */ | |
ad9579aa | 801 | fd = mkstemp(pathbuf); |
b658c53d PB |
802 | if (fd < 0) { |
803 | error_setg_errno(errp, errno, | |
ad9579aa | 804 | "Failed to make a temporary socket %s", pathbuf); |
b658c53d PB |
805 | goto err; |
806 | } | |
807 | close(fd); | |
d247d25f | 808 | } |
d247d25f | 809 | |
ad9579aa | 810 | if (unlink(path) < 0 && errno != ENOENT) { |
0ef705a2 | 811 | error_setg_errno(errp, errno, |
ad9579aa | 812 | "Failed to unlink socket %s", path); |
0ef705a2 CR |
813 | goto err; |
814 | } | |
ad9579aa DB |
815 | |
816 | memset(&un, 0, sizeof(un)); | |
817 | un.sun_family = AF_UNIX; | |
818 | strncpy(un.sun_path, path, sizeof(un.sun_path)); | |
819 | ||
d247d25f | 820 | if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { |
56382bd5 | 821 | error_setg_errno(errp, errno, "Failed to bind socket to %s", path); |
d247d25f AL |
822 | goto err; |
823 | } | |
824 | if (listen(sock, 1) < 0) { | |
235256a2 | 825 | error_setg_errno(errp, errno, "Failed to listen on socket"); |
d247d25f AL |
826 | goto err; |
827 | } | |
828 | ||
ad9579aa DB |
829 | if (update_addr && pathbuf) { |
830 | g_free(saddr->path); | |
831 | saddr->path = pathbuf; | |
832 | } else { | |
833 | g_free(pathbuf); | |
834 | } | |
d247d25f AL |
835 | return sock; |
836 | ||
837 | err: | |
ad9579aa | 838 | g_free(pathbuf); |
d247d25f AL |
839 | closesocket(sock); |
840 | return -1; | |
841 | } | |
842 | ||
b2587932 | 843 | static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp) |
d247d25f AL |
844 | { |
845 | struct sockaddr_un un; | |
1fc05adf | 846 | int sock, rc; |
d247d25f | 847 | |
2942e420 | 848 | if (saddr->path == NULL) { |
312fd5f2 | 849 | error_setg(errp, "unix connect: no path specified"); |
2af2bf67 GH |
850 | return -1; |
851 | } | |
852 | ||
40ff6d7e | 853 | sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0); |
d247d25f | 854 | if (sock < 0) { |
235256a2 | 855 | error_setg_errno(errp, errno, "Failed to create socket"); |
39b6efc8 | 856 | return -1; |
d247d25f AL |
857 | } |
858 | ||
ad9579aa DB |
859 | if (strlen(saddr->path) > sizeof(un.sun_path)) { |
860 | error_setg(errp, "UNIX socket path '%s' is too long", saddr->path); | |
861 | error_append_hint(errp, "Path must be less than %zu bytes\n", | |
862 | sizeof(un.sun_path)); | |
863 | goto err; | |
864 | } | |
865 | ||
d247d25f AL |
866 | memset(&un, 0, sizeof(un)); |
867 | un.sun_family = AF_UNIX; | |
ad9579aa | 868 | strncpy(un.sun_path, saddr->path, sizeof(un.sun_path)); |
1fc05adf PB |
869 | |
870 | /* connect to peer */ | |
871 | do { | |
872 | rc = 0; | |
873 | if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) { | |
b16a44e1 | 874 | rc = -errno; |
1fc05adf PB |
875 | } |
876 | } while (rc == -EINTR); | |
877 | ||
1fc05adf | 878 | if (rc < 0) { |
ad9579aa DB |
879 | error_setg_errno(errp, -rc, "Failed to connect socket %s", |
880 | saddr->path); | |
881 | goto err; | |
d247d25f AL |
882 | } |
883 | ||
d247d25f | 884 | return sock; |
ad9579aa DB |
885 | |
886 | err: | |
887 | close(sock); | |
ad9579aa | 888 | return -1; |
d247d25f AL |
889 | } |
890 | ||
0c814709 PB |
891 | #else |
892 | ||
1856835d DB |
893 | static int unix_listen_saddr(UnixSocketAddress *saddr, |
894 | bool update_addr, | |
895 | Error **errp) | |
0c814709 | 896 | { |
58899664 | 897 | error_setg(errp, "unix sockets are not available on windows"); |
0c814709 PB |
898 | errno = ENOTSUP; |
899 | return -1; | |
900 | } | |
901 | ||
b2587932 | 902 | static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp) |
0c814709 | 903 | { |
58899664 | 904 | error_setg(errp, "unix sockets are not available on windows"); |
0c814709 PB |
905 | errno = ENOTSUP; |
906 | return -1; | |
907 | } | |
908 | #endif | |
909 | ||
2af2bf67 | 910 | /* compatibility wrapper */ |
7fc4e63e | 911 | int unix_listen(const char *str, char *ostr, int olen, Error **errp) |
62b6adfb | 912 | { |
62b6adfb GH |
913 | char *path, *optstr; |
914 | int sock, len; | |
1856835d | 915 | UnixSocketAddress *saddr; |
62b6adfb | 916 | |
1856835d | 917 | saddr = g_new0(UnixSocketAddress, 1); |
62b6adfb GH |
918 | |
919 | optstr = strchr(str, ','); | |
920 | if (optstr) { | |
921 | len = optstr - str; | |
922 | if (len) { | |
7267c094 | 923 | path = g_malloc(len+1); |
62b6adfb | 924 | snprintf(path, len+1, "%.*s", len, str); |
1856835d | 925 | saddr->path = path; |
62b6adfb GH |
926 | } |
927 | } else { | |
1856835d | 928 | saddr->path = g_strdup(str); |
62b6adfb GH |
929 | } |
930 | ||
1856835d | 931 | sock = unix_listen_saddr(saddr, true, errp); |
62b6adfb | 932 | |
26015051 | 933 | if (sock != -1 && ostr) { |
1856835d | 934 | snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : ""); |
26015051 C |
935 | } |
936 | ||
1856835d | 937 | qapi_free_UnixSocketAddress(saddr); |
62b6adfb GH |
938 | return sock; |
939 | } | |
940 | ||
7fc4e63e | 941 | int unix_connect(const char *path, Error **errp) |
2af2bf67 | 942 | { |
2942e420 | 943 | UnixSocketAddress *saddr; |
2af2bf67 GH |
944 | int sock; |
945 | ||
2942e420 DB |
946 | saddr = g_new0(UnixSocketAddress, 1); |
947 | saddr->path = g_strdup(path); | |
b2587932 | 948 | sock = unix_connect_saddr(saddr, errp); |
2942e420 | 949 | qapi_free_UnixSocketAddress(saddr); |
1fc05adf PB |
950 | return sock; |
951 | } | |
952 | ||
953 | ||
bd269ebc | 954 | SocketAddress *socket_parse(const char *str, Error **errp) |
101f9cbc | 955 | { |
bd269ebc | 956 | SocketAddress *addr; |
101f9cbc | 957 | |
bd269ebc | 958 | addr = g_new0(SocketAddress, 1); |
101f9cbc PB |
959 | if (strstart(str, "unix:", NULL)) { |
960 | if (str[5] == '\0') { | |
312fd5f2 | 961 | error_setg(errp, "invalid Unix socket address"); |
101f9cbc PB |
962 | goto fail; |
963 | } else { | |
bd269ebc MA |
964 | addr->type = SOCKET_ADDRESS_TYPE_UNIX; |
965 | addr->u.q_unix.path = g_strdup(str + 5); | |
101f9cbc PB |
966 | } |
967 | } else if (strstart(str, "fd:", NULL)) { | |
968 | if (str[3] == '\0') { | |
312fd5f2 | 969 | error_setg(errp, "invalid file descriptor address"); |
101f9cbc PB |
970 | goto fail; |
971 | } else { | |
bd269ebc MA |
972 | addr->type = SOCKET_ADDRESS_TYPE_FD; |
973 | addr->u.fd.str = g_strdup(str + 3); | |
101f9cbc | 974 | } |
6a02c806 | 975 | } else if (strstart(str, "vsock:", NULL)) { |
bd269ebc MA |
976 | addr->type = SOCKET_ADDRESS_TYPE_VSOCK; |
977 | if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) { | |
6a02c806 SH |
978 | goto fail; |
979 | } | |
101f9cbc | 980 | } else { |
bd269ebc MA |
981 | addr->type = SOCKET_ADDRESS_TYPE_INET; |
982 | if (inet_parse(&addr->u.inet, str, errp)) { | |
101f9cbc PB |
983 | goto fail; |
984 | } | |
985 | } | |
986 | return addr; | |
987 | ||
988 | fail: | |
bd269ebc | 989 | qapi_free_SocketAddress(addr); |
101f9cbc PB |
990 | return NULL; |
991 | } | |
992 | ||
b2587932 | 993 | int socket_connect(SocketAddress *addr, Error **errp) |
101f9cbc | 994 | { |
101f9cbc PB |
995 | int fd; |
996 | ||
2d32adda | 997 | switch (addr->type) { |
bd269ebc | 998 | case SOCKET_ADDRESS_TYPE_INET: |
b2587932 | 999 | fd = inet_connect_saddr(&addr->u.inet, errp); |
101f9cbc PB |
1000 | break; |
1001 | ||
bd269ebc | 1002 | case SOCKET_ADDRESS_TYPE_UNIX: |
b2587932 | 1003 | fd = unix_connect_saddr(&addr->u.q_unix, errp); |
101f9cbc PB |
1004 | break; |
1005 | ||
bd269ebc MA |
1006 | case SOCKET_ADDRESS_TYPE_FD: |
1007 | fd = monitor_get_fd(cur_mon, addr->u.fd.str, errp); | |
101f9cbc PB |
1008 | break; |
1009 | ||
bd269ebc | 1010 | case SOCKET_ADDRESS_TYPE_VSOCK: |
b2587932 | 1011 | fd = vsock_connect_saddr(&addr->u.vsock, errp); |
6a02c806 SH |
1012 | break; |
1013 | ||
101f9cbc PB |
1014 | default: |
1015 | abort(); | |
1016 | } | |
101f9cbc PB |
1017 | return fd; |
1018 | } | |
1019 | ||
bd269ebc | 1020 | int socket_listen(SocketAddress *addr, Error **errp) |
101f9cbc | 1021 | { |
101f9cbc PB |
1022 | int fd; |
1023 | ||
2d32adda | 1024 | switch (addr->type) { |
bd269ebc MA |
1025 | case SOCKET_ADDRESS_TYPE_INET: |
1026 | fd = inet_listen_saddr(&addr->u.inet, 0, false, errp); | |
101f9cbc PB |
1027 | break; |
1028 | ||
bd269ebc MA |
1029 | case SOCKET_ADDRESS_TYPE_UNIX: |
1030 | fd = unix_listen_saddr(&addr->u.q_unix, false, errp); | |
101f9cbc PB |
1031 | break; |
1032 | ||
bd269ebc MA |
1033 | case SOCKET_ADDRESS_TYPE_FD: |
1034 | fd = monitor_get_fd(cur_mon, addr->u.fd.str, errp); | |
101f9cbc PB |
1035 | break; |
1036 | ||
bd269ebc MA |
1037 | case SOCKET_ADDRESS_TYPE_VSOCK: |
1038 | fd = vsock_listen_saddr(&addr->u.vsock, errp); | |
6a02c806 SH |
1039 | break; |
1040 | ||
101f9cbc PB |
1041 | default: |
1042 | abort(); | |
1043 | } | |
101f9cbc PB |
1044 | return fd; |
1045 | } | |
1046 | ||
74b6ce43 MAL |
1047 | void socket_listen_cleanup(int fd, Error **errp) |
1048 | { | |
bd269ebc | 1049 | SocketAddress *addr; |
74b6ce43 MAL |
1050 | |
1051 | addr = socket_local_address(fd, errp); | |
1052 | ||
bd269ebc MA |
1053 | if (addr->type == SOCKET_ADDRESS_TYPE_UNIX |
1054 | && addr->u.q_unix.path) { | |
1055 | if (unlink(addr->u.q_unix.path) < 0 && errno != ENOENT) { | |
74b6ce43 MAL |
1056 | error_setg_errno(errp, errno, |
1057 | "Failed to unlink socket %s", | |
bd269ebc | 1058 | addr->u.q_unix.path); |
74b6ce43 MAL |
1059 | } |
1060 | } | |
1061 | ||
bd269ebc | 1062 | qapi_free_SocketAddress(addr); |
74b6ce43 MAL |
1063 | } |
1064 | ||
bd269ebc | 1065 | int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp) |
3ecc059d | 1066 | { |
3ecc059d GH |
1067 | int fd; |
1068 | ||
ca0b64e5 | 1069 | /* |
bd269ebc | 1070 | * TODO SOCKET_ADDRESS_TYPE_FD when fd is AF_INET or AF_INET6 |
ca0b64e5 MA |
1071 | * (although other address families can do SOCK_DGRAM, too) |
1072 | */ | |
2d32adda | 1073 | switch (remote->type) { |
bd269ebc MA |
1074 | case SOCKET_ADDRESS_TYPE_INET: |
1075 | fd = inet_dgram_saddr(&remote->u.inet, | |
1076 | local ? &local->u.inet : NULL, errp); | |
3ecc059d GH |
1077 | break; |
1078 | ||
1079 | default: | |
1080 | error_setg(errp, "socket type unsupported for datagram"); | |
7a5b6af1 | 1081 | fd = -1; |
3ecc059d | 1082 | } |
3ecc059d GH |
1083 | return fd; |
1084 | } | |
17c55dec DB |
1085 | |
1086 | ||
bd269ebc | 1087 | static SocketAddress * |
17c55dec DB |
1088 | socket_sockaddr_to_address_inet(struct sockaddr_storage *sa, |
1089 | socklen_t salen, | |
1090 | Error **errp) | |
1091 | { | |
1092 | char host[NI_MAXHOST]; | |
1093 | char serv[NI_MAXSERV]; | |
bd269ebc | 1094 | SocketAddress *addr; |
0399293e | 1095 | InetSocketAddress *inet; |
17c55dec DB |
1096 | int ret; |
1097 | ||
1098 | ret = getnameinfo((struct sockaddr *)sa, salen, | |
1099 | host, sizeof(host), | |
1100 | serv, sizeof(serv), | |
1101 | NI_NUMERICHOST | NI_NUMERICSERV); | |
1102 | if (ret != 0) { | |
1103 | error_setg(errp, "Cannot format numeric socket address: %s", | |
1104 | gai_strerror(ret)); | |
1105 | return NULL; | |
1106 | } | |
1107 | ||
bd269ebc MA |
1108 | addr = g_new0(SocketAddress, 1); |
1109 | addr->type = SOCKET_ADDRESS_TYPE_INET; | |
1110 | inet = &addr->u.inet; | |
0399293e EB |
1111 | inet->host = g_strdup(host); |
1112 | inet->port = g_strdup(serv); | |
17c55dec | 1113 | if (sa->ss_family == AF_INET) { |
0399293e | 1114 | inet->has_ipv4 = inet->ipv4 = true; |
17c55dec | 1115 | } else { |
0399293e | 1116 | inet->has_ipv6 = inet->ipv6 = true; |
17c55dec DB |
1117 | } |
1118 | ||
1119 | return addr; | |
1120 | } | |
1121 | ||
1122 | ||
1123 | #ifndef WIN32 | |
bd269ebc | 1124 | static SocketAddress * |
17c55dec DB |
1125 | socket_sockaddr_to_address_unix(struct sockaddr_storage *sa, |
1126 | socklen_t salen, | |
1127 | Error **errp) | |
1128 | { | |
bd269ebc | 1129 | SocketAddress *addr; |
17c55dec DB |
1130 | struct sockaddr_un *su = (struct sockaddr_un *)sa; |
1131 | ||
bd269ebc MA |
1132 | addr = g_new0(SocketAddress, 1); |
1133 | addr->type = SOCKET_ADDRESS_TYPE_UNIX; | |
17c55dec | 1134 | if (su->sun_path[0]) { |
bd269ebc | 1135 | addr->u.q_unix.path = g_strndup(su->sun_path, sizeof(su->sun_path)); |
17c55dec DB |
1136 | } |
1137 | ||
1138 | return addr; | |
1139 | } | |
1140 | #endif /* WIN32 */ | |
1141 | ||
6a02c806 | 1142 | #ifdef CONFIG_AF_VSOCK |
bd269ebc | 1143 | static SocketAddress * |
6a02c806 SH |
1144 | socket_sockaddr_to_address_vsock(struct sockaddr_storage *sa, |
1145 | socklen_t salen, | |
1146 | Error **errp) | |
1147 | { | |
bd269ebc | 1148 | SocketAddress *addr; |
6a02c806 SH |
1149 | VsockSocketAddress *vaddr; |
1150 | struct sockaddr_vm *svm = (struct sockaddr_vm *)sa; | |
1151 | ||
bd269ebc MA |
1152 | addr = g_new0(SocketAddress, 1); |
1153 | addr->type = SOCKET_ADDRESS_TYPE_VSOCK; | |
1154 | vaddr = &addr->u.vsock; | |
6a02c806 SH |
1155 | vaddr->cid = g_strdup_printf("%u", svm->svm_cid); |
1156 | vaddr->port = g_strdup_printf("%u", svm->svm_port); | |
1157 | ||
1158 | return addr; | |
1159 | } | |
1160 | #endif /* CONFIG_AF_VSOCK */ | |
1161 | ||
bd269ebc | 1162 | SocketAddress * |
17c55dec DB |
1163 | socket_sockaddr_to_address(struct sockaddr_storage *sa, |
1164 | socklen_t salen, | |
1165 | Error **errp) | |
1166 | { | |
1167 | switch (sa->ss_family) { | |
1168 | case AF_INET: | |
1169 | case AF_INET6: | |
1170 | return socket_sockaddr_to_address_inet(sa, salen, errp); | |
1171 | ||
1172 | #ifndef WIN32 | |
1173 | case AF_UNIX: | |
1174 | return socket_sockaddr_to_address_unix(sa, salen, errp); | |
1175 | #endif /* WIN32 */ | |
1176 | ||
6a02c806 SH |
1177 | #ifdef CONFIG_AF_VSOCK |
1178 | case AF_VSOCK: | |
1179 | return socket_sockaddr_to_address_vsock(sa, salen, errp); | |
1180 | #endif | |
1181 | ||
17c55dec DB |
1182 | default: |
1183 | error_setg(errp, "socket family %d unsupported", | |
1184 | sa->ss_family); | |
1185 | return NULL; | |
1186 | } | |
1187 | return 0; | |
1188 | } | |
1189 | ||
1190 | ||
bd269ebc | 1191 | SocketAddress *socket_local_address(int fd, Error **errp) |
17c55dec DB |
1192 | { |
1193 | struct sockaddr_storage ss; | |
1194 | socklen_t sslen = sizeof(ss); | |
1195 | ||
1196 | if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { | |
b16a44e1 | 1197 | error_setg_errno(errp, errno, "%s", |
17c55dec DB |
1198 | "Unable to query local socket address"); |
1199 | return NULL; | |
1200 | } | |
1201 | ||
1202 | return socket_sockaddr_to_address(&ss, sslen, errp); | |
1203 | } | |
1204 | ||
1205 | ||
bd269ebc | 1206 | SocketAddress *socket_remote_address(int fd, Error **errp) |
17c55dec DB |
1207 | { |
1208 | struct sockaddr_storage ss; | |
1209 | socklen_t sslen = sizeof(ss); | |
1210 | ||
1211 | if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) { | |
b16a44e1 | 1212 | error_setg_errno(errp, errno, "%s", |
17c55dec DB |
1213 | "Unable to query remote socket address"); |
1214 | return NULL; | |
1215 | } | |
1216 | ||
1217 | return socket_sockaddr_to_address(&ss, sslen, errp); | |
1218 | } | |
2a8e21c7 | 1219 | |
216411b8 | 1220 | |
bd269ebc MA |
1221 | SocketAddress *socket_address_flatten(SocketAddressLegacy *addr_legacy) |
1222 | { | |
fc0f0059 | 1223 | SocketAddress *addr; |
bd269ebc MA |
1224 | |
1225 | if (!addr_legacy) { | |
1226 | return NULL; | |
1227 | } | |
1228 | ||
fc0f0059 MA |
1229 | addr = g_new(SocketAddress, 1); |
1230 | ||
bd269ebc MA |
1231 | switch (addr_legacy->type) { |
1232 | case SOCKET_ADDRESS_LEGACY_KIND_INET: | |
1233 | addr->type = SOCKET_ADDRESS_TYPE_INET; | |
1234 | QAPI_CLONE_MEMBERS(InetSocketAddress, &addr->u.inet, | |
1235 | addr_legacy->u.inet.data); | |
1236 | break; | |
1237 | case SOCKET_ADDRESS_LEGACY_KIND_UNIX: | |
1238 | addr->type = SOCKET_ADDRESS_TYPE_UNIX; | |
1239 | QAPI_CLONE_MEMBERS(UnixSocketAddress, &addr->u.q_unix, | |
1240 | addr_legacy->u.q_unix.data); | |
1241 | break; | |
1242 | case SOCKET_ADDRESS_LEGACY_KIND_VSOCK: | |
1243 | addr->type = SOCKET_ADDRESS_TYPE_VSOCK; | |
1244 | QAPI_CLONE_MEMBERS(VsockSocketAddress, &addr->u.vsock, | |
1245 | addr_legacy->u.vsock.data); | |
1246 | break; | |
1247 | case SOCKET_ADDRESS_LEGACY_KIND_FD: | |
1248 | addr->type = SOCKET_ADDRESS_TYPE_FD; | |
1249 | QAPI_CLONE_MEMBERS(String, &addr->u.fd, addr_legacy->u.fd.data); | |
1250 | break; | |
1251 | default: | |
1252 | abort(); | |
1253 | } | |
1254 | ||
1255 | return addr; | |
1256 | } |