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