blob: 3537bf3d451e692580873ba1b0a8ca6c1df00925 [file] [log] [blame]
aliguori305b0eb2008-11-13 16:19:54 +00001/*
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.
Paolo Bonzinie6d91ab2012-07-09 11:08:39 +020014 *
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.
aliguori305b0eb2008-11-13 16:19:54 +000017 */
aliguorid247d252008-11-11 20:46:40 +000018#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21#include <ctype.h>
22#include <errno.h>
23#include <unistd.h>
24
Paolo Bonzini83c90892012-12-17 18:19:49 +010025#include "monitor/monitor.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010026#include "qemu/sockets.h"
blueswir147398b92008-11-22 20:04:24 +000027#include "qemu-common.h" /* for qemu_isdigit */
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010028#include "qemu/main-loop.h"
aliguorid247d252008-11-11 20:46:40 +000029
30#ifndef AI_ADDRCONFIG
31# define AI_ADDRCONFIG 0
32#endif
33
aliguorid247d252008-11-11 20:46:40 +000034static const int on=1, off=0;
35
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +020036/* used temporarely until all users are converted to QemuOpts */
Blue Swirlc1390902009-09-12 09:58:51 +000037static QemuOptsList dummy_opts = {
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +020038 .name = "dummy",
Blue Swirl72cf2d42009-09-12 07:36:22 +000039 .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +020040 .desc = {
41 {
42 .name = "path",
43 .type = QEMU_OPT_STRING,
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +020044 },{
45 .name = "host",
46 .type = QEMU_OPT_STRING,
47 },{
48 .name = "port",
49 .type = QEMU_OPT_STRING,
50 },{
51 .name = "to",
52 .type = QEMU_OPT_NUMBER,
53 },{
54 .name = "ipv4",
55 .type = QEMU_OPT_BOOL,
56 },{
57 .name = "ipv6",
58 .type = QEMU_OPT_BOOL,
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +020059 },
60 { /* end if list */ }
61 },
62};
63
aliguorid247d252008-11-11 20:46:40 +000064static int inet_getport(struct addrinfo *e)
65{
66 struct sockaddr_in *i4;
67 struct sockaddr_in6 *i6;
68
69 switch (e->ai_family) {
70 case PF_INET6:
71 i6 = (void*)e->ai_addr;
72 return ntohs(i6->sin6_port);
73 case PF_INET:
74 i4 = (void*)e->ai_addr;
75 return ntohs(i4->sin_port);
76 default:
77 return 0;
78 }
79}
80
81static void inet_setport(struct addrinfo *e, int port)
82{
83 struct sockaddr_in *i4;
84 struct sockaddr_in6 *i6;
85
86 switch (e->ai_family) {
87 case PF_INET6:
88 i6 = (void*)e->ai_addr;
89 i6->sin6_port = htons(port);
90 break;
91 case PF_INET:
92 i4 = (void*)e->ai_addr;
93 i4->sin_port = htons(port);
94 break;
95 }
96}
97
Luiz Capitulinoc9c4b342010-01-20 11:42:38 -020098const char *inet_strfamily(int family)
aliguorid247d252008-11-11 20:46:40 +000099{
100 switch (family) {
101 case PF_INET6: return "ipv6";
102 case PF_INET: return "ipv4";
103 case PF_UNIX: return "unix";
104 }
Luiz Capitulinoc4453212010-01-20 11:42:39 -0200105 return "unknown";
aliguorid247d252008-11-11 20:46:40 +0000106}
107
Amos Kong029409e2012-05-11 00:28:26 +0800108int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
aliguorid247d252008-11-11 20:46:40 +0000109{
110 struct addrinfo ai,*res,*e;
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200111 const char *addr;
aliguorid247d252008-11-11 20:46:40 +0000112 char port[33];
113 char uaddr[INET6_ADDRSTRLEN+1];
114 char uport[33];
Markus Armbruster877691f2012-02-07 15:09:15 +0100115 int slisten, rc, to, port_min, port_max, p;
aliguorid247d252008-11-11 20:46:40 +0000116
117 memset(&ai,0, sizeof(ai));
118 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
119 ai.ai_family = PF_UNSPEC;
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200120 ai.ai_socktype = SOCK_STREAM;
aliguorid247d252008-11-11 20:46:40 +0000121
Jens Osterkampe23a22e2010-04-12 10:51:01 +0200122 if ((qemu_opt_get(opts, "host") == NULL) ||
123 (qemu_opt_get(opts, "port") == NULL)) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200124 error_setg(errp, "host and/or port not specified");
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200125 return -1;
aliguorid247d252008-11-11 20:46:40 +0000126 }
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200127 pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
128 addr = qemu_opt_get(opts, "host");
aliguorid247d252008-11-11 20:46:40 +0000129
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200130 to = qemu_opt_get_number(opts, "to", 0);
131 if (qemu_opt_get_bool(opts, "ipv4", 0))
aliguorid247d252008-11-11 20:46:40 +0000132 ai.ai_family = PF_INET;
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200133 if (qemu_opt_get_bool(opts, "ipv6", 0))
aliguorid247d252008-11-11 20:46:40 +0000134 ai.ai_family = PF_INET6;
135
136 /* lookup */
137 if (port_offset)
138 snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
139 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
140 if (rc != 0) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200141 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
142 gai_strerror(rc));
aliguorid247d252008-11-11 20:46:40 +0000143 return -1;
144 }
aliguorid247d252008-11-11 20:46:40 +0000145
146 /* create socket + bind */
147 for (e = res; e != NULL; e = e->ai_next) {
vibi39b6efc2009-05-06 15:27:03 +0530148 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
149 uaddr,INET6_ADDRSTRLEN,uport,32,
150 NI_NUMERICHOST | NI_NUMERICSERV);
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100151 slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
vibi39b6efc2009-05-06 15:27:03 +0530152 if (slisten < 0) {
Amos Kong029409e2012-05-11 00:28:26 +0800153 if (!e->ai_next) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200154 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
Amos Kong029409e2012-05-11 00:28:26 +0800155 }
vibi39b6efc2009-05-06 15:27:03 +0530156 continue;
157 }
aliguorid247d252008-11-11 20:46:40 +0000158
159 setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
160#ifdef IPV6_V6ONLY
161 if (e->ai_family == PF_INET6) {
162 /* listen on both ipv4 and ipv6 */
vibi39b6efc2009-05-06 15:27:03 +0530163 setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
164 sizeof(off));
aliguorid247d252008-11-11 20:46:40 +0000165 }
166#endif
167
Markus Armbruster877691f2012-02-07 15:09:15 +0100168 port_min = inet_getport(e);
169 port_max = to ? to + port_offset : port_min;
170 for (p = port_min; p <= port_max; p++) {
171 inet_setport(e, p);
aliguorid247d252008-11-11 20:46:40 +0000172 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
aliguorid247d252008-11-11 20:46:40 +0000173 goto listen;
174 }
Markus Armbruster877691f2012-02-07 15:09:15 +0100175 if (p == port_max) {
Amos Kong029409e2012-05-11 00:28:26 +0800176 if (!e->ai_next) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200177 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
Amos Kong029409e2012-05-11 00:28:26 +0800178 }
aliguorid247d252008-11-11 20:46:40 +0000179 }
aliguorid247d252008-11-11 20:46:40 +0000180 }
181 closesocket(slisten);
182 }
aliguorid247d252008-11-11 20:46:40 +0000183 freeaddrinfo(res);
184 return -1;
185
186listen:
187 if (listen(slisten,1) != 0) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200188 error_set_errno(errp, errno, QERR_SOCKET_LISTEN_FAILED);
aliguorid247d252008-11-11 20:46:40 +0000189 closesocket(slisten);
vibi39b6efc2009-05-06 15:27:03 +0530190 freeaddrinfo(res);
aliguorid247d252008-11-11 20:46:40 +0000191 return -1;
192 }
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200193 snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
194 qemu_opt_set(opts, "host", uaddr);
195 qemu_opt_set(opts, "port", uport);
196 qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
197 qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
aliguorid247d252008-11-11 20:46:40 +0000198 freeaddrinfo(res);
199 return slisten;
200}
201
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200202#ifdef _WIN32
203#define QEMU_SOCKET_RC_INPROGRESS(rc) \
204 ((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
205#else
206#define QEMU_SOCKET_RC_INPROGRESS(rc) \
207 ((rc) == -EINPROGRESS)
208#endif
aliguorid247d252008-11-11 20:46:40 +0000209
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200210/* Struct to store connect state for non blocking connect */
211typedef struct ConnectState {
212 int fd;
213 struct addrinfo *addr_list;
214 struct addrinfo *current_addr;
215 NonBlockingConnectHandler *callback;
216 void *opaque;
217} ConnectState;
218
219static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
Paolo Bonzini11663b52012-10-02 09:19:01 +0200220 ConnectState *connect_state, Error **errp);
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200221
222static void wait_for_connect(void *opaque)
223{
224 ConnectState *s = opaque;
225 int val = 0, rc = 0;
226 socklen_t valsize = sizeof(val);
227 bool in_progress;
228
229 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
230
231 do {
232 rc = getsockopt(s->fd, SOL_SOCKET, SO_ERROR, (void *) &val, &valsize);
233 } while (rc == -1 && socket_error() == EINTR);
234
235 /* update rc to contain error */
236 if (!rc && val) {
237 rc = -1;
238 }
239
240 /* connect error */
241 if (rc < 0) {
242 closesocket(s->fd);
243 s->fd = rc;
244 }
245
246 /* try to connect to the next address on the list */
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200247 if (s->current_addr) {
248 while (s->current_addr->ai_next != NULL && s->fd < 0) {
249 s->current_addr = s->current_addr->ai_next;
Paolo Bonzini11663b52012-10-02 09:19:01 +0200250 s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200251 /* connect in progress */
252 if (in_progress) {
253 return;
254 }
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200255 }
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200256
257 freeaddrinfo(s->addr_list);
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200258 }
259
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200260 if (s->callback) {
261 s->callback(s->fd, s->opaque);
262 }
263 g_free(s);
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200264}
265
266static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
Paolo Bonzini11663b52012-10-02 09:19:01 +0200267 ConnectState *connect_state, Error **errp)
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200268{
269 int sock, rc;
aliguorid247d252008-11-11 20:46:40 +0000270
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200271 *in_progress = false;
Luiz Capitulino02a08fe2012-08-01 13:42:47 -0300272
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200273 sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
274 if (sock < 0) {
Paolo Bonzini11663b52012-10-02 09:19:01 +0200275 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200276 return -1;
277 }
Stefan Weil58455eb2012-09-28 19:07:39 +0200278 qemu_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200279 if (connect_state != NULL) {
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200280 socket_set_nonblock(sock);
281 }
282 /* connect to peer */
283 do {
284 rc = 0;
285 if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
286 rc = -socket_error();
287 }
288 } while (rc == -EINTR);
289
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200290 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
291 connect_state->fd = sock;
292 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
293 connect_state);
294 *in_progress = true;
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200295 } else if (rc < 0) {
Paolo Bonzini11663b52012-10-02 09:19:01 +0200296 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED);
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200297 closesocket(sock);
298 return -1;
299 }
300 return sock;
301}
302
303static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
304{
305 struct addrinfo ai, *res;
306 int rc;
307 const char *addr;
308 const char *port;
309
310 memset(&ai, 0, sizeof(ai));
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200311
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200312 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
313 ai.ai_family = PF_UNSPEC;
314 ai.ai_socktype = SOCK_STREAM;
315
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200316 addr = qemu_opt_get(opts, "host");
317 port = qemu_opt_get(opts, "port");
318 if (addr == NULL || port == NULL) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200319 error_setg(errp, "host and/or port not specified");
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200320 return NULL;
321 }
322
323 if (qemu_opt_get_bool(opts, "ipv4", 0)) {
324 ai.ai_family = PF_INET;
325 }
326 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
327 ai.ai_family = PF_INET6;
328 }
329
330 /* lookup */
331 rc = getaddrinfo(addr, port, &ai, &res);
332 if (rc != 0) {
Paolo Bonzinia12fb8a2012-10-02 09:18:02 +0200333 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
334 gai_strerror(rc));
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200335 return NULL;
336 }
337 return res;
338}
339
Orit Wasserman5db5f442012-09-24 13:11:08 +0200340/**
341 * Create a socket and connect it to an address.
342 *
343 * @opts: QEMU options, recognized parameters strings "host" and "port",
344 * bools "ipv4" and "ipv6".
Orit Wasserman5db5f442012-09-24 13:11:08 +0200345 * @errp: set on error
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200346 * @callback: callback function for non-blocking connect
347 * @opaque: opaque for callback function
Orit Wasserman5db5f442012-09-24 13:11:08 +0200348 *
349 * Returns: -1 on error, file descriptor on success.
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200350 *
351 * If @callback is non-null, the connect is non-blocking. If this
352 * function succeeds, callback will be called when the connection
353 * completes, with the file descriptor on success, or -1 on error.
Orit Wasserman5db5f442012-09-24 13:11:08 +0200354 */
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200355int inet_connect_opts(QemuOpts *opts, Error **errp,
356 NonBlockingConnectHandler *callback, void *opaque)
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200357{
358 struct addrinfo *res, *e;
359 int sock = -1;
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200360 bool in_progress;
361 ConnectState *connect_state = NULL;
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200362
363 res = inet_parse_connect_opts(opts, errp);
364 if (!res) {
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200365 return -1;
aliguorid247d252008-11-11 20:46:40 +0000366 }
367
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200368 if (callback != NULL) {
369 connect_state = g_malloc0(sizeof(*connect_state));
370 connect_state->addr_list = res;
371 connect_state->callback = callback;
372 connect_state->opaque = opaque;
aliguorid247d252008-11-11 20:46:40 +0000373 }
aliguorid247d252008-11-11 20:46:40 +0000374
375 for (e = res; e != NULL; e = e->ai_next) {
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200376 if (connect_state != NULL) {
377 connect_state->current_addr = e;
378 }
Paolo Bonzini11663b52012-10-02 09:19:01 +0200379 sock = inet_connect_addr(e, &in_progress, connect_state, errp);
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200380 if (in_progress) {
381 return sock;
382 } else if (sock >= 0) {
383 /* non blocking socket immediate success, call callback */
384 if (callback != NULL) {
385 callback(sock, opaque);
386 }
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200387 break;
vibi39b6efc2009-05-06 15:27:03 +0530388 }
aliguorid247d252008-11-11 20:46:40 +0000389 }
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200390 g_free(connect_state);
aliguorid247d252008-11-11 20:46:40 +0000391 freeaddrinfo(res);
Michael S. Tsirkin05bc1d82012-09-24 13:11:07 +0200392 return sock;
aliguorid247d252008-11-11 20:46:40 +0000393}
394
Paolo Bonzini7fc4e632012-10-02 09:35:32 +0200395int inet_dgram_opts(QemuOpts *opts, Error **errp)
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200396{
397 struct addrinfo ai, *peer = NULL, *local = NULL;
398 const char *addr;
399 const char *port;
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200400 int sock = -1, rc;
401
402 /* lookup peer addr */
403 memset(&ai,0, sizeof(ai));
404 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
405 ai.ai_family = PF_UNSPEC;
406 ai.ai_socktype = SOCK_DGRAM;
407
408 addr = qemu_opt_get(opts, "host");
409 port = qemu_opt_get(opts, "port");
410 if (addr == NULL || strlen(addr) == 0) {
411 addr = "localhost";
412 }
413 if (port == NULL || strlen(port) == 0) {
Paolo Bonzini4f085c82012-10-02 09:25:14 +0200414 error_setg(errp, "remote port not specified");
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200415 return -1;
416 }
417
418 if (qemu_opt_get_bool(opts, "ipv4", 0))
419 ai.ai_family = PF_INET;
420 if (qemu_opt_get_bool(opts, "ipv6", 0))
421 ai.ai_family = PF_INET6;
422
423 if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
Paolo Bonzini4f085c82012-10-02 09:25:14 +0200424 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
425 gai_strerror(rc));
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200426 return -1;
427 }
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200428
429 /* lookup local addr */
430 memset(&ai,0, sizeof(ai));
431 ai.ai_flags = AI_PASSIVE;
432 ai.ai_family = peer->ai_family;
433 ai.ai_socktype = SOCK_DGRAM;
434
435 addr = qemu_opt_get(opts, "localaddr");
436 port = qemu_opt_get(opts, "localport");
437 if (addr == NULL || strlen(addr) == 0) {
438 addr = NULL;
439 }
440 if (!port || strlen(port) == 0)
441 port = "0";
442
443 if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
Paolo Bonzini4f085c82012-10-02 09:25:14 +0200444 error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
445 gai_strerror(rc));
Stefan Weil39b38452012-09-01 09:40:26 +0200446 goto err;
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200447 }
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200448
449 /* create socket */
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100450 sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200451 if (sock < 0) {
Paolo Bonzini4f085c82012-10-02 09:25:14 +0200452 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200453 goto err;
454 }
455 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
456
457 /* bind socket */
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200458 if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
Paolo Bonzini4f085c82012-10-02 09:25:14 +0200459 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200460 goto err;
461 }
462
463 /* connect to peer */
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200464 if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
Paolo Bonzini4f085c82012-10-02 09:25:14 +0200465 error_set_errno(errp, errno, QERR_SOCKET_CONNECT_FAILED);
Gerd Hoffmann7e1b35b2009-09-10 10:58:51 +0200466 goto err;
467 }
468
469 freeaddrinfo(local);
470 freeaddrinfo(peer);
471 return sock;
472
473err:
474 if (-1 != sock)
475 closesocket(sock);
476 if (local)
477 freeaddrinfo(local);
478 if (peer)
479 freeaddrinfo(peer);
480 return -1;
481}
482
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200483/* compatibility wrapper */
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200484static InetSocketAddress *inet_parse(const char *str, Error **errp)
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200485{
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200486 InetSocketAddress *addr;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200487 const char *optstr, *h;
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200488 char host[64];
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200489 char port[33];
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200490 int to;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200491 int pos;
492
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200493 addr = g_new0(InetSocketAddress, 1);
494
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200495 /* parse address */
496 if (str[0] == ':') {
497 /* no host given */
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200498 host[0] = '\0';
499 if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
Paolo Bonzini2f002c42012-09-19 13:22:21 +0200500 error_setg(errp, "error parsing port in address '%s'", str);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200501 goto fail;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200502 }
503 } else if (str[0] == '[') {
504 /* IPv6 addr */
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200505 if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
Paolo Bonzini2f002c42012-09-19 13:22:21 +0200506 error_setg(errp, "error parsing IPv6 address '%s'", str);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200507 goto fail;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200508 }
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200509 addr->ipv6 = addr->has_ipv6 = true;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200510 } else if (qemu_isdigit(str[0])) {
511 /* IPv4 addr */
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200512 if (2 != sscanf(str, "%64[0-9.]:%32[^,]%n", host, port, &pos)) {
Paolo Bonzini2f002c42012-09-19 13:22:21 +0200513 error_setg(errp, "error parsing IPv4 address '%s'", str);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200514 goto fail;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200515 }
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200516 addr->ipv4 = addr->has_ipv4 = true;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200517 } else {
518 /* hostname */
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200519 if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
Paolo Bonzini2f002c42012-09-19 13:22:21 +0200520 error_setg(errp, "error parsing address '%s'", str);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200521 goto fail;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200522 }
523 }
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200524
525 addr->host = g_strdup(host);
526 addr->port = g_strdup(port);
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200527
528 /* parse options */
529 optstr = str + pos;
530 h = strstr(optstr, ",to=");
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200531 if (h) {
Anthony PERARD1ccbc282012-11-16 04:08:14 +0000532 h += 4;
533 if (sscanf(h, "%d%n", &to, &pos) != 1 ||
534 (h[pos] != '\0' && h[pos] != ',')) {
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200535 error_setg(errp, "error parsing to= argument");
536 goto fail;
537 }
538 addr->has_to = true;
539 addr->to = to;
540 }
541 if (strstr(optstr, ",ipv4")) {
542 addr->ipv4 = addr->has_ipv4 = true;
543 }
544 if (strstr(optstr, ",ipv6")) {
545 addr->ipv6 = addr->has_ipv6 = true;
546 }
547 return addr;
548
549fail:
550 qapi_free_InetSocketAddress(addr);
551 return NULL;
552}
553
554static void inet_addr_to_opts(QemuOpts *opts, InetSocketAddress *addr)
555{
556 bool ipv4 = addr->ipv4 || !addr->has_ipv4;
557 bool ipv6 = addr->ipv6 || !addr->has_ipv6;
558
559 if (!ipv4 || !ipv6) {
560 qemu_opt_set_bool(opts, "ipv4", ipv4);
561 qemu_opt_set_bool(opts, "ipv6", ipv6);
562 }
563 if (addr->has_to) {
564 char to[20];
565 snprintf(to, sizeof(to), "%d", addr->to);
566 qemu_opt_set(opts, "to", to);
567 }
568 qemu_opt_set(opts, "host", addr->host);
569 qemu_opt_set(opts, "port", addr->port);
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200570}
571
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200572int inet_listen(const char *str, char *ostr, int olen,
Amos Kong029409e2012-05-11 00:28:26 +0800573 int socktype, int port_offset, Error **errp)
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200574{
575 QemuOpts *opts;
576 char *optstr;
577 int sock = -1;
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200578 InetSocketAddress *addr;
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200579
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200580 addr = inet_parse(str, errp);
581 if (addr != NULL) {
Dong Xu Wange478b442012-12-06 14:47:22 +0800582 opts = qemu_opts_create_nofail(&dummy_opts);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200583 inet_addr_to_opts(opts, addr);
584 qapi_free_InetSocketAddress(addr);
Amos Kong029409e2012-05-11 00:28:26 +0800585 sock = inet_listen_opts(opts, port_offset, errp);
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200586 if (sock != -1 && ostr) {
587 optstr = strchr(str, ',');
588 if (qemu_opt_get_bool(opts, "ipv6", 0)) {
589 snprintf(ostr, olen, "[%s]:%s%s",
590 qemu_opt_get(opts, "host"),
591 qemu_opt_get(opts, "port"),
592 optstr ? optstr : "");
593 } else {
594 snprintf(ostr, olen, "%s:%s%s",
595 qemu_opt_get(opts, "host"),
596 qemu_opt_get(opts, "port"),
597 optstr ? optstr : "");
598 }
599 }
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200600 qemu_opts_del(opts);
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200601 }
Gerd Hoffmanne5bc7762009-09-10 10:58:41 +0200602 return sock;
603}
604
Orit Wasserman5db5f442012-09-24 13:11:08 +0200605/**
606 * Create a blocking socket and connect it to an address.
607 *
608 * @str: address string
609 * @errp: set in case of an error
610 *
611 * Returns -1 in case of error, file descriptor on success
612 **/
613int inet_connect(const char *str, Error **errp)
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200614{
615 QemuOpts *opts;
616 int sock = -1;
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200617 InetSocketAddress *addr;
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200618
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200619 addr = inet_parse(str, errp);
620 if (addr != NULL) {
Dong Xu Wange478b442012-12-06 14:47:22 +0800621 opts = qemu_opts_create_nofail(&dummy_opts);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200622 inet_addr_to_opts(opts, addr);
623 qapi_free_InetSocketAddress(addr);
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200624 sock = inet_connect_opts(opts, errp, NULL, NULL);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200625 qemu_opts_del(opts);
Orit Wasserman5db5f442012-09-24 13:11:08 +0200626 }
Orit Wasserman5db5f442012-09-24 13:11:08 +0200627 return sock;
628}
629
630/**
631 * Create a non-blocking socket and connect it to an address.
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200632 * Calls the callback function with fd in case of success or -1 in case of
633 * error.
Orit Wasserman5db5f442012-09-24 13:11:08 +0200634 *
635 * @str: address string
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200636 * @callback: callback function that is called when connect completes,
637 * cannot be NULL.
638 * @opaque: opaque for callback function
Orit Wasserman5db5f442012-09-24 13:11:08 +0200639 * @errp: set in case of an error
640 *
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200641 * Returns: -1 on immediate error, file descriptor on success.
Orit Wasserman5db5f442012-09-24 13:11:08 +0200642 **/
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200643int inet_nonblocking_connect(const char *str,
644 NonBlockingConnectHandler *callback,
645 void *opaque, Error **errp)
Orit Wasserman5db5f442012-09-24 13:11:08 +0200646{
647 QemuOpts *opts;
648 int sock = -1;
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200649 InetSocketAddress *addr;
Orit Wasserman5db5f442012-09-24 13:11:08 +0200650
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200651 g_assert(callback != NULL);
652
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200653 addr = inet_parse(str, errp);
654 if (addr != NULL) {
Dong Xu Wange478b442012-12-06 14:47:22 +0800655 opts = qemu_opts_create_nofail(&dummy_opts);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200656 inet_addr_to_opts(opts, addr);
657 qapi_free_InetSocketAddress(addr);
Orit Wasserman233aa5c2012-09-24 13:11:09 +0200658 sock = inet_connect_opts(opts, errp, callback, opaque);
Paolo Bonzini879e45c2012-09-19 13:51:46 +0200659 qemu_opts_del(opts);
Amos Konga6ba35b2012-05-11 00:28:16 +0800660 }
Gerd Hoffmannf4c94c72009-09-10 10:58:40 +0200661 return sock;
662}
663
aliguorid247d252008-11-11 20:46:40 +0000664#ifndef _WIN32
665
Paolo Bonzini7fc4e632012-10-02 09:35:32 +0200666int unix_listen_opts(QemuOpts *opts, Error **errp)
aliguorid247d252008-11-11 20:46:40 +0000667{
668 struct sockaddr_un un;
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200669 const char *path = qemu_opt_get(opts, "path");
670 int sock, fd;
aliguorid247d252008-11-11 20:46:40 +0000671
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100672 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
aliguorid247d252008-11-11 20:46:40 +0000673 if (sock < 0) {
Paolo Bonzini58899662012-09-19 13:54:39 +0200674 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
vibi39b6efc2009-05-06 15:27:03 +0530675 return -1;
aliguorid247d252008-11-11 20:46:40 +0000676 }
677
aliguorid247d252008-11-11 20:46:40 +0000678 memset(&un, 0, sizeof(un));
679 un.sun_family = AF_UNIX;
680 if (path && strlen(path)) {
681 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
682 } else {
683 char *tmpdir = getenv("TMPDIR");
684 snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
685 tmpdir ? tmpdir : "/tmp");
686 /*
687 * This dummy fd usage silences the mktemp() unsecure warning.
688 * Using mkstemp() doesn't make things more secure here
689 * though. bind() complains about existing files, so we have
690 * to unlink first and thus re-open the race window. The
691 * worst case possible is bind() failing, i.e. a DoS attack.
692 */
693 fd = mkstemp(un.sun_path); close(fd);
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200694 qemu_opt_set(opts, "path", un.sun_path);
aliguorid247d252008-11-11 20:46:40 +0000695 }
aliguorid247d252008-11-11 20:46:40 +0000696
697 unlink(un.sun_path);
698 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
Paolo Bonzini58899662012-09-19 13:54:39 +0200699 error_set_errno(errp, errno, QERR_SOCKET_BIND_FAILED);
aliguorid247d252008-11-11 20:46:40 +0000700 goto err;
701 }
702 if (listen(sock, 1) < 0) {
Paolo Bonzini58899662012-09-19 13:54:39 +0200703 error_set_errno(errp, errno, QERR_SOCKET_LISTEN_FAILED);
aliguorid247d252008-11-11 20:46:40 +0000704 goto err;
705 }
706
aliguorid247d252008-11-11 20:46:40 +0000707 return sock;
708
709err:
aliguorid247d252008-11-11 20:46:40 +0000710 closesocket(sock);
711 return -1;
712}
713
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200714int unix_connect_opts(QemuOpts *opts, Error **errp,
715 NonBlockingConnectHandler *callback, void *opaque)
aliguorid247d252008-11-11 20:46:40 +0000716{
717 struct sockaddr_un un;
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200718 const char *path = qemu_opt_get(opts, "path");
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200719 ConnectState *connect_state = NULL;
720 int sock, rc;
aliguorid247d252008-11-11 20:46:40 +0000721
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200722 if (NULL == path) {
Paolo Bonzini58899662012-09-19 13:54:39 +0200723 error_setg(errp, "unix connect: no path specified\n");
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200724 return -1;
725 }
726
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100727 sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
aliguorid247d252008-11-11 20:46:40 +0000728 if (sock < 0) {
Paolo Bonzini58899662012-09-19 13:54:39 +0200729 error_set_errno(errp, errno, QERR_SOCKET_CREATE_FAILED);
vibi39b6efc2009-05-06 15:27:03 +0530730 return -1;
aliguorid247d252008-11-11 20:46:40 +0000731 }
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200732 if (callback != NULL) {
733 connect_state = g_malloc0(sizeof(*connect_state));
734 connect_state->callback = callback;
735 connect_state->opaque = opaque;
736 socket_set_nonblock(sock);
737 }
aliguorid247d252008-11-11 20:46:40 +0000738
739 memset(&un, 0, sizeof(un));
740 un.sun_family = AF_UNIX;
741 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200742
743 /* connect to peer */
744 do {
745 rc = 0;
746 if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
747 rc = -socket_error();
748 }
749 } while (rc == -EINTR);
750
751 if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
752 connect_state->fd = sock;
753 qemu_set_fd_handler2(sock, NULL, NULL, wait_for_connect,
754 connect_state);
755 return sock;
756 } else if (rc >= 0) {
757 /* non blocking socket immediate success, call callback */
758 if (callback != NULL) {
759 callback(sock, opaque);
760 }
aliguorid247d252008-11-11 20:46:40 +0000761 }
762
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200763 if (rc < 0) {
Paolo Bonzini58899662012-09-19 13:54:39 +0200764 error_set_errno(errp, -rc, QERR_SOCKET_CONNECT_FAILED);
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200765 close(sock);
766 sock = -1;
767 }
768
769 g_free(connect_state);
aliguorid247d252008-11-11 20:46:40 +0000770 return sock;
771}
772
Paolo Bonzini0c814702012-10-18 08:44:00 +0200773#else
774
775int unix_listen_opts(QemuOpts *opts, Error **errp)
776{
Paolo Bonzini58899662012-09-19 13:54:39 +0200777 error_setg(errp, "unix sockets are not available on windows");
Paolo Bonzini0c814702012-10-18 08:44:00 +0200778 errno = ENOTSUP;
779 return -1;
780}
781
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200782int unix_connect_opts(QemuOpts *opts, Error **errp,
783 NonBlockingConnectHandler *callback, void *opaque)
Paolo Bonzini0c814702012-10-18 08:44:00 +0200784{
Paolo Bonzini58899662012-09-19 13:54:39 +0200785 error_setg(errp, "unix sockets are not available on windows");
Paolo Bonzini0c814702012-10-18 08:44:00 +0200786 errno = ENOTSUP;
787 return -1;
788}
789#endif
790
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200791/* compatibility wrapper */
Paolo Bonzini7fc4e632012-10-02 09:35:32 +0200792int unix_listen(const char *str, char *ostr, int olen, Error **errp)
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200793{
794 QemuOpts *opts;
795 char *path, *optstr;
796 int sock, len;
797
Dong Xu Wange478b442012-12-06 14:47:22 +0800798 opts = qemu_opts_create_nofail(&dummy_opts);
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200799
800 optstr = strchr(str, ',');
801 if (optstr) {
802 len = optstr - str;
803 if (len) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500804 path = g_malloc(len+1);
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200805 snprintf(path, len+1, "%.*s", len, str);
806 qemu_opt_set(opts, "path", path);
Anthony Liguori7267c092011-08-20 22:09:37 -0500807 g_free(path);
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200808 }
809 } else {
810 qemu_opt_set(opts, "path", str);
811 }
812
Paolo Bonzini7fc4e632012-10-02 09:35:32 +0200813 sock = unix_listen_opts(opts, errp);
Gerd Hoffmann62b6adf2009-09-10 10:58:38 +0200814
815 if (sock != -1 && ostr)
816 snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
817 qemu_opts_del(opts);
818 return sock;
819}
820
Paolo Bonzini7fc4e632012-10-02 09:35:32 +0200821int unix_connect(const char *path, Error **errp)
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200822{
823 QemuOpts *opts;
824 int sock;
825
Dong Xu Wange478b442012-12-06 14:47:22 +0800826 opts = qemu_opts_create_nofail(&dummy_opts);
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200827 qemu_opt_set(opts, "path", path);
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200828 sock = unix_connect_opts(opts, errp, NULL, NULL);
829 qemu_opts_del(opts);
830 return sock;
831}
832
833
834int unix_nonblocking_connect(const char *path,
835 NonBlockingConnectHandler *callback,
836 void *opaque, Error **errp)
837{
838 QemuOpts *opts;
839 int sock = -1;
840
841 g_assert(callback != NULL);
842
Dong Xu Wange478b442012-12-06 14:47:22 +0800843 opts = qemu_opts_create_nofail(&dummy_opts);
Paolo Bonzini1fc05ad2012-10-03 13:37:46 +0200844 qemu_opt_set(opts, "path", path);
845 sock = unix_connect_opts(opts, errp, callback, opaque);
Gerd Hoffmann2af2bf62009-09-10 10:58:37 +0200846 qemu_opts_del(opts);
847 return sock;
848}
849
Paolo Bonzini101f9cb2012-10-23 21:31:53 +0200850SocketAddress *socket_parse(const char *str, Error **errp)
851{
852 SocketAddress *addr = NULL;
853
854 addr = g_new(SocketAddress, 1);
855 if (strstart(str, "unix:", NULL)) {
856 if (str[5] == '\0') {
857 error_setg(errp, "invalid Unix socket address\n");
858 goto fail;
859 } else {
860 addr->kind = SOCKET_ADDRESS_KIND_UNIX;
861 addr->q_unix = g_new(UnixSocketAddress, 1);
862 addr->q_unix->path = g_strdup(str + 5);
863 }
864 } else if (strstart(str, "fd:", NULL)) {
865 if (str[3] == '\0') {
866 error_setg(errp, "invalid file descriptor address\n");
867 goto fail;
868 } else {
869 addr->kind = SOCKET_ADDRESS_KIND_FD;
870 addr->fd = g_new(String, 1);
871 addr->fd->str = g_strdup(str + 3);
872 }
873 } else {
874 addr->kind = SOCKET_ADDRESS_KIND_INET;
875 addr->inet = g_new(InetSocketAddress, 1);
876 addr->inet = inet_parse(str, errp);
877 if (addr->inet == NULL) {
878 goto fail;
879 }
880 }
881 return addr;
882
883fail:
884 qapi_free_SocketAddress(addr);
885 return NULL;
886}
887
888int socket_connect(SocketAddress *addr, Error **errp,
889 NonBlockingConnectHandler *callback, void *opaque)
890{
891 QemuOpts *opts;
892 int fd;
893
Dong Xu Wange478b442012-12-06 14:47:22 +0800894 opts = qemu_opts_create_nofail(&dummy_opts);
Paolo Bonzini101f9cb2012-10-23 21:31:53 +0200895 switch (addr->kind) {
896 case SOCKET_ADDRESS_KIND_INET:
897 inet_addr_to_opts(opts, addr->inet);
898 fd = inet_connect_opts(opts, errp, callback, opaque);
899 break;
900
901 case SOCKET_ADDRESS_KIND_UNIX:
902 qemu_opt_set(opts, "path", addr->q_unix->path);
903 fd = unix_connect_opts(opts, errp, callback, opaque);
904 break;
905
906 case SOCKET_ADDRESS_KIND_FD:
907 fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
908 if (callback) {
909 callback(fd, opaque);
910 }
911 break;
912
913 default:
914 abort();
915 }
916 qemu_opts_del(opts);
917 return fd;
918}
919
920int socket_listen(SocketAddress *addr, Error **errp)
921{
922 QemuOpts *opts;
923 int fd;
924
Dong Xu Wange478b442012-12-06 14:47:22 +0800925 opts = qemu_opts_create_nofail(&dummy_opts);
Paolo Bonzini101f9cb2012-10-23 21:31:53 +0200926 switch (addr->kind) {
927 case SOCKET_ADDRESS_KIND_INET:
928 inet_addr_to_opts(opts, addr->inet);
929 fd = inet_listen_opts(opts, 0, errp);
930 break;
931
932 case SOCKET_ADDRESS_KIND_UNIX:
933 qemu_opt_set(opts, "path", addr->q_unix->path);
934 fd = unix_listen_opts(opts, errp);
935 break;
936
937 case SOCKET_ADDRESS_KIND_FD:
938 fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
939 break;
940
941 default:
942 abort();
943 }
944 qemu_opts_del(opts);
945 return fd;
946}
947
Paolo Bonzini0706a4d2010-04-01 19:57:08 +0200948#ifdef _WIN32
949static void socket_cleanup(void)
950{
951 WSACleanup();
952}
953#endif
954
955int socket_init(void)
956{
957#ifdef _WIN32
958 WSADATA Data;
959 int ret, err;
960
961 ret = WSAStartup(MAKEWORD(2,2), &Data);
962 if (ret != 0) {
963 err = WSAGetLastError();
964 fprintf(stderr, "WSAStartup: %d\n", err);
965 return -1;
966 }
967 atexit(socket_cleanup);
968#endif
969 return 0;
970}