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