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