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