2008-11-13 19:19:54 +03:00
|
|
|
/*
|
|
|
|
* inet and unix socket functions for qemu
|
|
|
|
*
|
|
|
|
* (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; under version 2 of the License.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2012-07-09 13:08:39 +04:00
|
|
|
*
|
|
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
2008-11-13 19:19:54 +03:00
|
|
|
*/
|
2008-11-11 23:46:40 +03:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
2012-12-17 21:19:49 +04:00
|
|
|
#include "monitor/monitor.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/sockets.h"
|
|
|
|
#include "qemu/main-loop.h"
|
2008-11-11 23:46:40 +03:00
|
|
|
|
|
|
|
#ifndef AI_ADDRCONFIG
|
|
|
|
# define AI_ADDRCONFIG 0
|
|
|
|
#endif
|
|
|
|
|
2013-03-15 20:14:24 +04:00
|
|
|
/* used temporarily until all users are converted to QemuOpts */
|
|
|
|
QemuOptsList socket_optslist = {
|
|
|
|
.name = "socket",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(socket_optslist.head),
|
2009-09-10 12:58:37 +04:00
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = "path",
|
|
|
|
.type = QEMU_OPT_STRING,
|
2009-09-10 12:58:40 +04:00
|
|
|
},{
|
|
|
|
.name = "host",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "port",
|
|
|
|
.type = QEMU_OPT_STRING,
|
util: socket: Add missing localaddr and localport option for DGRAM socket
The 'socket_optslist' structure does not contain the 'localaddr' and
'localport' options that are parsed in case you are creating a
'connect' type UDP character device.
I've noticed it happening after commit f43e47dbf6de24db20ec9b588bb6cc762
made qemu abort() after seeing the invalid option.
A minimal reproducer for the case is:
$ qemu-system-x86_64 -chardev udp,id=charrng0,host=127.0.0.1,port=1234,localaddr=,localport=1234
qemu-system-x86_64: -chardev udp,id=charrng0,host=127.0.0.1,port=1234,localaddr=,localport=1234: Invalid parameter 'localaddr'
Aborted (core dumped)
Prior to the commit mentioned above the error would be printed but the
value for localaddr and localport was simply ignored. I did not go
through the code to find out when it was broken.
Add the two fields so that the options can again be parsed correctly and
qemu doesn't abort().
Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1220252
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2015-05-15 12:31:43 +03:00
|
|
|
},{
|
|
|
|
.name = "localaddr",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "localport",
|
|
|
|
.type = QEMU_OPT_STRING,
|
2009-09-10 12:58:40 +04:00
|
|
|
},{
|
|
|
|
.name = "to",
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
},{
|
|
|
|
.name = "ipv4",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
},{
|
|
|
|
.name = "ipv6",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
2009-09-10 12:58:37 +04:00
|
|
|
},
|
|
|
|
{ /* end if list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2008-11-11 23:46:40 +03:00
|
|
|
static int inet_getport(struct addrinfo *e)
|
|
|
|
{
|
|
|
|
struct sockaddr_in *i4;
|
|
|
|
struct sockaddr_in6 *i6;
|
|
|
|
|
|
|
|
switch (e->ai_family) {
|
|
|
|
case PF_INET6:
|
|
|
|
i6 = (void*)e->ai_addr;
|
|
|
|
return ntohs(i6->sin6_port);
|
|
|
|
case PF_INET:
|
|
|
|
i4 = (void*)e->ai_addr;
|
|
|
|
return ntohs(i4->sin_port);
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void inet_setport(struct addrinfo *e, int port)
|
|
|
|
{
|
|
|
|
struct sockaddr_in *i4;
|
|
|
|
struct sockaddr_in6 *i6;
|
|
|
|
|
|
|
|
switch (e->ai_family) {
|
|
|
|
case PF_INET6:
|
|
|
|
i6 = (void*)e->ai_addr;
|
|
|
|
i6->sin6_port = htons(port);
|
|
|
|
break;
|
|
|
|
case PF_INET:
|
|
|
|
i4 = (void*)e->ai_addr;
|
|
|
|
i4->sin_port = htons(port);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-18 10:43:30 +04:00
|
|
|
NetworkAddressFamily inet_netfamily(int family)
|
|
|
|
{
|
|
|
|
switch (family) {
|
|
|
|
case PF_INET6: return NETWORK_ADDRESS_FAMILY_IPV6;
|
|
|
|
case PF_INET: return NETWORK_ADDRESS_FAMILY_IPV4;
|
|
|
|
case PF_UNIX: return NETWORK_ADDRESS_FAMILY_UNIX;
|
|
|
|
}
|
|
|
|
return NETWORK_ADDRESS_FAMILY_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2012-05-10 20:28:26 +04:00
|
|
|
int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)
|
2008-11-11 23:46:40 +03:00
|
|
|
{
|
|
|
|
struct addrinfo ai,*res,*e;
|
2009-09-10 12:58:41 +04:00
|
|
|
const char *addr;
|
2008-11-11 23:46:40 +03:00
|
|
|
char port[33];
|
|
|
|
char uaddr[INET6_ADDRSTRLEN+1];
|
|
|
|
char uport[33];
|
2012-02-07 18:09:15 +04:00
|
|
|
int slisten, rc, to, port_min, port_max, p;
|
2008-11-11 23:46:40 +03:00
|
|
|
|
|
|
|
memset(&ai,0, sizeof(ai));
|
|
|
|
ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
|
|
|
|
ai.ai_family = PF_UNSPEC;
|
2009-09-10 12:58:41 +04:00
|
|
|
ai.ai_socktype = SOCK_STREAM;
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2010-04-12 12:51:01 +04:00
|
|
|
if ((qemu_opt_get(opts, "host") == NULL) ||
|
|
|
|
(qemu_opt_get(opts, "port") == NULL)) {
|
2012-10-02 11:18:02 +04:00
|
|
|
error_setg(errp, "host and/or port not specified");
|
2009-09-10 12:58:41 +04:00
|
|
|
return -1;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
2009-09-10 12:58:41 +04:00
|
|
|
pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
|
|
|
|
addr = qemu_opt_get(opts, "host");
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2009-09-10 12:58:41 +04:00
|
|
|
to = qemu_opt_get_number(opts, "to", 0);
|
|
|
|
if (qemu_opt_get_bool(opts, "ipv4", 0))
|
2008-11-11 23:46:40 +03:00
|
|
|
ai.ai_family = PF_INET;
|
2009-09-10 12:58:41 +04:00
|
|
|
if (qemu_opt_get_bool(opts, "ipv6", 0))
|
2008-11-11 23:46:40 +03:00
|
|
|
ai.ai_family = PF_INET6;
|
|
|
|
|
|
|
|
/* lookup */
|
2013-12-11 15:58:41 +04:00
|
|
|
if (port_offset) {
|
|
|
|
unsigned long long baseport;
|
|
|
|
if (parse_uint_full(port, &baseport, 10) < 0) {
|
|
|
|
error_setg(errp, "can't convert to a number: %s", port);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (baseport > 65535 ||
|
|
|
|
baseport + port_offset > 65535) {
|
|
|
|
error_setg(errp, "port %s out of range", port);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
snprintf(port, sizeof(port), "%d", (int)baseport + port_offset);
|
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
|
|
|
|
if (rc != 0) {
|
2012-10-02 11:18:02 +04:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
|
|
|
|
gai_strerror(rc));
|
2008-11-11 23:46:40 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create socket + bind */
|
|
|
|
for (e = res; e != NULL; e = e->ai_next) {
|
2009-05-06 13:57:03 +04:00
|
|
|
getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
|
|
|
|
uaddr,INET6_ADDRSTRLEN,uport,32,
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
2009-12-02 14:24:42 +03:00
|
|
|
slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
|
2009-05-06 13:57:03 +04:00
|
|
|
if (slisten < 0) {
|
2012-05-10 20:28:26 +04:00
|
|
|
if (!e->ai_next) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2012-05-10 20:28:26 +04:00
|
|
|
}
|
2009-05-06 13:57:03 +04:00
|
|
|
continue;
|
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2013-10-02 14:23:16 +04:00
|
|
|
socket_set_fast_reuse(slisten);
|
2008-11-11 23:46:40 +03:00
|
|
|
#ifdef IPV6_V6ONLY
|
|
|
|
if (e->ai_family == PF_INET6) {
|
|
|
|
/* listen on both ipv4 and ipv6 */
|
2014-06-07 20:48:03 +04:00
|
|
|
const int off = 0;
|
2013-03-08 22:58:32 +04:00
|
|
|
qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off,
|
|
|
|
sizeof(off));
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-02-07 18:09:15 +04:00
|
|
|
port_min = inet_getport(e);
|
|
|
|
port_max = to ? to + port_offset : port_min;
|
|
|
|
for (p = port_min; p <= port_max; p++) {
|
|
|
|
inet_setport(e, p);
|
2008-11-11 23:46:40 +03:00
|
|
|
if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
|
|
|
|
goto listen;
|
|
|
|
}
|
2012-02-07 18:09:15 +04:00
|
|
|
if (p == port_max) {
|
2012-05-10 20:28:26 +04:00
|
|
|
if (!e->ai_next) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to bind socket");
|
2012-05-10 20:28:26 +04:00
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
closesocket(slisten);
|
|
|
|
}
|
|
|
|
freeaddrinfo(res);
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
listen:
|
|
|
|
if (listen(slisten,1) != 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to listen on socket");
|
2008-11-11 23:46:40 +03:00
|
|
|
closesocket(slisten);
|
2009-05-06 13:57:03 +04:00
|
|
|
freeaddrinfo(res);
|
2008-11-11 23:46:40 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "host", uaddr, &error_abort);
|
2015-02-13 17:51:56 +03:00
|
|
|
qemu_opt_set_number(opts, "port", inet_getport(e) - port_offset,
|
|
|
|
&error_abort);
|
|
|
|
qemu_opt_set_bool(opts, "ipv6", e->ai_family == PF_INET6,
|
|
|
|
&error_abort);
|
|
|
|
qemu_opt_set_bool(opts, "ipv4", e->ai_family != PF_INET6,
|
|
|
|
&error_abort);
|
2008-11-11 23:46:40 +03:00
|
|
|
freeaddrinfo(res);
|
|
|
|
return slisten;
|
|
|
|
}
|
|
|
|
|
2012-09-24 15:11:07 +04:00
|
|
|
#ifdef _WIN32
|
|
|
|
#define QEMU_SOCKET_RC_INPROGRESS(rc) \
|
|
|
|
((rc) == -EINPROGRESS || (rc) == -EWOULDBLOCK || (rc) == -WSAEALREADY)
|
|
|
|
#else
|
|
|
|
#define QEMU_SOCKET_RC_INPROGRESS(rc) \
|
|
|
|
((rc) == -EINPROGRESS)
|
|
|
|
#endif
|
|
|
|
|
2012-09-24 15:11:09 +04:00
|
|
|
/* Struct to store connect state for non blocking connect */
|
|
|
|
typedef struct ConnectState {
|
|
|
|
int fd;
|
|
|
|
struct addrinfo *addr_list;
|
|
|
|
struct addrinfo *current_addr;
|
|
|
|
NonBlockingConnectHandler *callback;
|
|
|
|
void *opaque;
|
|
|
|
} ConnectState;
|
|
|
|
|
|
|
|
static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
|
2012-10-02 11:19:01 +04:00
|
|
|
ConnectState *connect_state, Error **errp);
|
2012-09-24 15:11:09 +04:00
|
|
|
|
|
|
|
static void wait_for_connect(void *opaque)
|
2008-11-11 23:46:40 +03:00
|
|
|
{
|
2012-09-24 15:11:09 +04:00
|
|
|
ConnectState *s = opaque;
|
|
|
|
int val = 0, rc = 0;
|
|
|
|
socklen_t valsize = sizeof(val);
|
|
|
|
bool in_progress;
|
2014-10-08 16:11:56 +04:00
|
|
|
Error *err = NULL;
|
2012-09-24 15:11:09 +04:00
|
|
|
|
Change qemu_set_fd_handler2(..., NULL, ...) to qemu_set_fd_handler
Done with following Coccinelle semantic patch, plus manual cosmetic changes in
net/*.c.
@@
expression E1, E2, E3, E4;
@@
- qemu_set_fd_handler2(E1, NULL, E2, E3, E4);
+ qemu_set_fd_handler(E1, E2, E3, E4);
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-id: 1433400324-7358-8-git-send-email-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-06-04 09:45:18 +03:00
|
|
|
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
|
2012-09-24 15:11:09 +04:00
|
|
|
|
|
|
|
do {
|
2013-03-08 22:58:32 +04:00
|
|
|
rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
|
2012-09-24 15:11:09 +04:00
|
|
|
} while (rc == -1 && socket_error() == EINTR);
|
|
|
|
|
|
|
|
/* update rc to contain error */
|
|
|
|
if (!rc && val) {
|
|
|
|
rc = -1;
|
2014-10-08 16:11:56 +04:00
|
|
|
errno = val;
|
2012-09-24 15:11:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* connect error */
|
|
|
|
if (rc < 0) {
|
2014-10-08 16:11:56 +04:00
|
|
|
error_setg_errno(&err, errno, "Error connecting to socket");
|
2012-09-24 15:11:09 +04:00
|
|
|
closesocket(s->fd);
|
|
|
|
s->fd = rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* try to connect to the next address on the list */
|
2012-10-03 15:37:46 +04:00
|
|
|
if (s->current_addr) {
|
|
|
|
while (s->current_addr->ai_next != NULL && s->fd < 0) {
|
|
|
|
s->current_addr = s->current_addr->ai_next;
|
2012-10-02 11:19:01 +04:00
|
|
|
s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
|
2014-10-08 16:11:56 +04:00
|
|
|
if (s->fd < 0) {
|
|
|
|
error_free(err);
|
|
|
|
err = NULL;
|
|
|
|
error_setg_errno(&err, errno, "Unable to start socket connect");
|
|
|
|
}
|
2012-10-03 15:37:46 +04:00
|
|
|
/* connect in progress */
|
|
|
|
if (in_progress) {
|
2014-10-08 16:11:56 +04:00
|
|
|
goto out;
|
2012-10-03 15:37:46 +04:00
|
|
|
}
|
2012-09-24 15:11:09 +04:00
|
|
|
}
|
2012-10-03 15:37:46 +04:00
|
|
|
|
|
|
|
freeaddrinfo(s->addr_list);
|
2012-09-24 15:11:09 +04:00
|
|
|
}
|
2012-09-24 15:11:07 +04:00
|
|
|
|
2012-09-24 15:11:09 +04:00
|
|
|
if (s->callback) {
|
2014-10-08 16:11:56 +04:00
|
|
|
s->callback(s->fd, err, s->opaque);
|
2012-09-24 15:11:07 +04:00
|
|
|
}
|
2012-09-24 15:11:09 +04:00
|
|
|
g_free(s);
|
2014-10-08 16:11:56 +04:00
|
|
|
out:
|
|
|
|
error_free(err);
|
2012-09-24 15:11:09 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
|
2012-10-02 11:19:01 +04:00
|
|
|
ConnectState *connect_state, Error **errp)
|
2012-09-24 15:11:09 +04:00
|
|
|
{
|
|
|
|
int sock, rc;
|
|
|
|
|
|
|
|
*in_progress = false;
|
2012-09-24 15:11:07 +04:00
|
|
|
|
|
|
|
sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
|
|
|
|
if (sock < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2012-09-24 15:11:07 +04:00
|
|
|
return -1;
|
|
|
|
}
|
2013-10-02 14:23:16 +04:00
|
|
|
socket_set_fast_reuse(sock);
|
2012-09-24 15:11:09 +04:00
|
|
|
if (connect_state != NULL) {
|
2013-03-27 13:10:43 +04:00
|
|
|
qemu_set_nonblock(sock);
|
2012-09-24 15:11:07 +04:00
|
|
|
}
|
|
|
|
/* connect to peer */
|
|
|
|
do {
|
|
|
|
rc = 0;
|
|
|
|
if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
|
|
|
|
rc = -socket_error();
|
|
|
|
}
|
|
|
|
} while (rc == -EINTR);
|
|
|
|
|
2012-09-24 15:11:09 +04:00
|
|
|
if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
|
|
|
|
connect_state->fd = sock;
|
Change qemu_set_fd_handler2(..., NULL, ...) to qemu_set_fd_handler
Done with following Coccinelle semantic patch, plus manual cosmetic changes in
net/*.c.
@@
expression E1, E2, E3, E4;
@@
- qemu_set_fd_handler2(E1, NULL, E2, E3, E4);
+ qemu_set_fd_handler(E1, E2, E3, E4);
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-id: 1433400324-7358-8-git-send-email-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-06-04 09:45:18 +03:00
|
|
|
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
|
2012-09-24 15:11:09 +04:00
|
|
|
*in_progress = true;
|
2012-09-24 15:11:07 +04:00
|
|
|
} else if (rc < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to connect socket");
|
2012-09-24 15:11:07 +04:00
|
|
|
closesocket(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)
|
|
|
|
{
|
|
|
|
struct addrinfo ai, *res;
|
|
|
|
int rc;
|
2009-09-10 12:58:40 +04:00
|
|
|
const char *addr;
|
|
|
|
const char *port;
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2012-09-24 15:11:07 +04:00
|
|
|
memset(&ai, 0, sizeof(ai));
|
2012-09-24 15:11:09 +04:00
|
|
|
|
2008-11-11 23:46:40 +03:00
|
|
|
ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
|
|
|
|
ai.ai_family = PF_UNSPEC;
|
2009-09-10 12:58:40 +04:00
|
|
|
ai.ai_socktype = SOCK_STREAM;
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2009-09-10 12:58:40 +04:00
|
|
|
addr = qemu_opt_get(opts, "host");
|
|
|
|
port = qemu_opt_get(opts, "port");
|
|
|
|
if (addr == NULL || port == NULL) {
|
2012-10-02 11:18:02 +04:00
|
|
|
error_setg(errp, "host and/or port not specified");
|
2012-09-24 15:11:07 +04:00
|
|
|
return NULL;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
|
2012-09-24 15:11:07 +04:00
|
|
|
if (qemu_opt_get_bool(opts, "ipv4", 0)) {
|
2008-11-11 23:46:40 +03:00
|
|
|
ai.ai_family = PF_INET;
|
2012-09-24 15:11:07 +04:00
|
|
|
}
|
|
|
|
if (qemu_opt_get_bool(opts, "ipv6", 0)) {
|
2008-11-11 23:46:40 +03:00
|
|
|
ai.ai_family = PF_INET6;
|
2012-09-24 15:11:07 +04:00
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
|
|
|
|
/* lookup */
|
2012-09-24 15:11:07 +04:00
|
|
|
rc = getaddrinfo(addr, port, &ai, &res);
|
|
|
|
if (rc != 0) {
|
2012-10-02 11:18:02 +04:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
|
|
|
|
gai_strerror(rc));
|
2012-09-24 15:11:07 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2012-09-24 15:11:08 +04:00
|
|
|
/**
|
|
|
|
* Create a socket and connect it to an address.
|
|
|
|
*
|
|
|
|
* @opts: QEMU options, recognized parameters strings "host" and "port",
|
|
|
|
* bools "ipv4" and "ipv6".
|
|
|
|
* @errp: set on error
|
2012-09-24 15:11:09 +04:00
|
|
|
* @callback: callback function for non-blocking connect
|
|
|
|
* @opaque: opaque for callback function
|
2012-09-24 15:11:08 +04:00
|
|
|
*
|
|
|
|
* Returns: -1 on error, file descriptor on success.
|
2012-09-24 15:11:09 +04:00
|
|
|
*
|
|
|
|
* If @callback is non-null, the connect is non-blocking. If this
|
|
|
|
* function succeeds, callback will be called when the connection
|
|
|
|
* completes, with the file descriptor on success, or -1 on error.
|
2012-09-24 15:11:08 +04:00
|
|
|
*/
|
2012-09-24 15:11:09 +04:00
|
|
|
int inet_connect_opts(QemuOpts *opts, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
2012-09-24 15:11:07 +04:00
|
|
|
{
|
2014-05-19 20:57:37 +04:00
|
|
|
Error *local_err = NULL;
|
2012-09-24 15:11:07 +04:00
|
|
|
struct addrinfo *res, *e;
|
|
|
|
int sock = -1;
|
2012-09-24 15:11:09 +04:00
|
|
|
bool in_progress;
|
|
|
|
ConnectState *connect_state = NULL;
|
2012-09-24 15:11:07 +04:00
|
|
|
|
|
|
|
res = inet_parse_connect_opts(opts, errp);
|
|
|
|
if (!res) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-09-24 15:11:09 +04:00
|
|
|
if (callback != NULL) {
|
|
|
|
connect_state = g_malloc0(sizeof(*connect_state));
|
|
|
|
connect_state->addr_list = res;
|
|
|
|
connect_state->callback = callback;
|
|
|
|
connect_state->opaque = opaque;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for (e = res; e != NULL; e = e->ai_next) {
|
2014-05-19 20:57:37 +04:00
|
|
|
error_free(local_err);
|
|
|
|
local_err = NULL;
|
2012-09-24 15:11:09 +04:00
|
|
|
if (connect_state != NULL) {
|
|
|
|
connect_state->current_addr = e;
|
|
|
|
}
|
2014-05-19 20:57:37 +04:00
|
|
|
sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
|
|
|
|
if (sock >= 0) {
|
2012-09-24 15:11:07 +04:00
|
|
|
break;
|
2012-05-10 20:28:16 +04:00
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
2014-05-19 20:57:37 +04:00
|
|
|
|
|
|
|
if (sock < 0) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
} else if (in_progress) {
|
|
|
|
/* wait_for_connect() will do the rest */
|
|
|
|
return sock;
|
|
|
|
} else {
|
|
|
|
if (callback) {
|
2014-10-08 16:11:56 +04:00
|
|
|
callback(sock, NULL, opaque);
|
2014-05-19 20:57:37 +04:00
|
|
|
}
|
|
|
|
}
|
2012-09-24 15:11:09 +04:00
|
|
|
g_free(connect_state);
|
2008-11-11 23:46:40 +03:00
|
|
|
freeaddrinfo(res);
|
2012-09-24 15:11:07 +04:00
|
|
|
return sock;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
|
2012-10-02 11:35:32 +04:00
|
|
|
int inet_dgram_opts(QemuOpts *opts, Error **errp)
|
2009-09-10 12:58:51 +04:00
|
|
|
{
|
|
|
|
struct addrinfo ai, *peer = NULL, *local = NULL;
|
|
|
|
const char *addr;
|
|
|
|
const char *port;
|
|
|
|
int sock = -1, rc;
|
|
|
|
|
|
|
|
/* lookup peer addr */
|
|
|
|
memset(&ai,0, sizeof(ai));
|
|
|
|
ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
|
|
|
|
ai.ai_family = PF_UNSPEC;
|
|
|
|
ai.ai_socktype = SOCK_DGRAM;
|
|
|
|
|
|
|
|
addr = qemu_opt_get(opts, "host");
|
|
|
|
port = qemu_opt_get(opts, "port");
|
|
|
|
if (addr == NULL || strlen(addr) == 0) {
|
|
|
|
addr = "localhost";
|
|
|
|
}
|
|
|
|
if (port == NULL || strlen(port) == 0) {
|
2012-10-02 11:25:14 +04:00
|
|
|
error_setg(errp, "remote port not specified");
|
2009-09-10 12:58:51 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qemu_opt_get_bool(opts, "ipv4", 0))
|
|
|
|
ai.ai_family = PF_INET;
|
|
|
|
if (qemu_opt_get_bool(opts, "ipv6", 0))
|
|
|
|
ai.ai_family = PF_INET6;
|
|
|
|
|
|
|
|
if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
|
2012-10-02 11:25:14 +04:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
|
|
|
|
gai_strerror(rc));
|
2009-09-10 12:58:51 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* lookup local addr */
|
|
|
|
memset(&ai,0, sizeof(ai));
|
|
|
|
ai.ai_flags = AI_PASSIVE;
|
|
|
|
ai.ai_family = peer->ai_family;
|
|
|
|
ai.ai_socktype = SOCK_DGRAM;
|
|
|
|
|
|
|
|
addr = qemu_opt_get(opts, "localaddr");
|
|
|
|
port = qemu_opt_get(opts, "localport");
|
|
|
|
if (addr == NULL || strlen(addr) == 0) {
|
|
|
|
addr = NULL;
|
|
|
|
}
|
|
|
|
if (!port || strlen(port) == 0)
|
|
|
|
port = "0";
|
|
|
|
|
|
|
|
if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
|
2012-10-02 11:25:14 +04:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
|
|
|
|
gai_strerror(rc));
|
2012-09-01 11:40:26 +04:00
|
|
|
goto err;
|
2009-09-10 12:58:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* create socket */
|
2009-12-02 14:24:42 +03:00
|
|
|
sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
|
2009-09-10 12:58:51 +04:00
|
|
|
if (sock < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2009-09-10 12:58:51 +04:00
|
|
|
goto err;
|
|
|
|
}
|
2013-10-02 14:23:16 +04:00
|
|
|
socket_set_fast_reuse(sock);
|
2009-09-10 12:58:51 +04:00
|
|
|
|
|
|
|
/* bind socket */
|
|
|
|
if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to bind socket");
|
2009-09-10 12:58:51 +04:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* connect to peer */
|
|
|
|
if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to connect socket");
|
2009-09-10 12:58:51 +04:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
freeaddrinfo(local);
|
|
|
|
freeaddrinfo(peer);
|
|
|
|
return sock;
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (-1 != sock)
|
|
|
|
closesocket(sock);
|
|
|
|
if (local)
|
|
|
|
freeaddrinfo(local);
|
|
|
|
if (peer)
|
|
|
|
freeaddrinfo(peer);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-09-10 12:58:40 +04:00
|
|
|
/* compatibility wrapper */
|
2013-03-15 14:55:29 +04:00
|
|
|
InetSocketAddress *inet_parse(const char *str, Error **errp)
|
2009-09-10 12:58:40 +04:00
|
|
|
{
|
2012-09-19 15:51:46 +04:00
|
|
|
InetSocketAddress *addr;
|
2009-09-10 12:58:40 +04:00
|
|
|
const char *optstr, *h;
|
2015-01-30 22:37:55 +03:00
|
|
|
char host[65];
|
2009-09-10 12:58:40 +04:00
|
|
|
char port[33];
|
2012-09-19 15:51:46 +04:00
|
|
|
int to;
|
2009-09-10 12:58:40 +04:00
|
|
|
int pos;
|
|
|
|
|
2012-09-19 15:51:46 +04:00
|
|
|
addr = g_new0(InetSocketAddress, 1);
|
|
|
|
|
2009-09-10 12:58:40 +04:00
|
|
|
/* parse address */
|
|
|
|
if (str[0] == ':') {
|
|
|
|
/* no host given */
|
2012-09-19 15:51:46 +04:00
|
|
|
host[0] = '\0';
|
|
|
|
if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
|
2012-09-19 15:22:21 +04:00
|
|
|
error_setg(errp, "error parsing port in address '%s'", str);
|
2012-09-19 15:51:46 +04:00
|
|
|
goto fail;
|
2009-09-10 12:58:40 +04:00
|
|
|
}
|
|
|
|
} else if (str[0] == '[') {
|
|
|
|
/* IPv6 addr */
|
2012-09-19 15:51:46 +04:00
|
|
|
if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
|
2012-09-19 15:22:21 +04:00
|
|
|
error_setg(errp, "error parsing IPv6 address '%s'", str);
|
2012-09-19 15:51:46 +04:00
|
|
|
goto fail;
|
2009-09-10 12:58:40 +04:00
|
|
|
}
|
2012-09-19 15:51:46 +04:00
|
|
|
addr->ipv6 = addr->has_ipv6 = true;
|
2009-09-10 12:58:40 +04:00
|
|
|
} else {
|
2013-06-03 19:54:55 +04:00
|
|
|
/* hostname or IPv4 addr */
|
2012-09-19 15:51:46 +04:00
|
|
|
if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
|
2012-09-19 15:22:21 +04:00
|
|
|
error_setg(errp, "error parsing address '%s'", str);
|
2012-09-19 15:51:46 +04:00
|
|
|
goto fail;
|
2009-09-10 12:58:40 +04:00
|
|
|
}
|
2013-06-03 19:54:55 +04:00
|
|
|
if (host[strspn(host, "0123456789.")] == '\0') {
|
|
|
|
addr->ipv4 = addr->has_ipv4 = true;
|
|
|
|
}
|
2009-09-10 12:58:40 +04:00
|
|
|
}
|
2012-09-19 15:51:46 +04:00
|
|
|
|
|
|
|
addr->host = g_strdup(host);
|
|
|
|
addr->port = g_strdup(port);
|
2009-09-10 12:58:40 +04:00
|
|
|
|
|
|
|
/* parse options */
|
|
|
|
optstr = str + pos;
|
|
|
|
h = strstr(optstr, ",to=");
|
2012-09-19 15:51:46 +04:00
|
|
|
if (h) {
|
2012-11-16 08:08:14 +04:00
|
|
|
h += 4;
|
|
|
|
if (sscanf(h, "%d%n", &to, &pos) != 1 ||
|
|
|
|
(h[pos] != '\0' && h[pos] != ',')) {
|
2012-09-19 15:51:46 +04:00
|
|
|
error_setg(errp, "error parsing to= argument");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
addr->has_to = true;
|
|
|
|
addr->to = to;
|
|
|
|
}
|
|
|
|
if (strstr(optstr, ",ipv4")) {
|
|
|
|
addr->ipv4 = addr->has_ipv4 = true;
|
|
|
|
}
|
|
|
|
if (strstr(optstr, ",ipv6")) {
|
|
|
|
addr->ipv6 = addr->has_ipv6 = true;
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
qapi_free_InetSocketAddress(addr);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-03-15 14:55:29 +04:00
|
|
|
static void inet_addr_to_opts(QemuOpts *opts, const InetSocketAddress *addr)
|
2012-09-19 15:51:46 +04:00
|
|
|
{
|
|
|
|
bool ipv4 = addr->ipv4 || !addr->has_ipv4;
|
|
|
|
bool ipv6 = addr->ipv6 || !addr->has_ipv6;
|
|
|
|
|
|
|
|
if (!ipv4 || !ipv6) {
|
2015-02-12 18:37:44 +03:00
|
|
|
qemu_opt_set_bool(opts, "ipv4", ipv4, &error_abort);
|
|
|
|
qemu_opt_set_bool(opts, "ipv6", ipv6, &error_abort);
|
2012-09-19 15:51:46 +04:00
|
|
|
}
|
|
|
|
if (addr->has_to) {
|
2015-02-13 17:51:56 +03:00
|
|
|
qemu_opt_set_number(opts, "to", addr->to, &error_abort);
|
2012-09-19 15:51:46 +04:00
|
|
|
}
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "host", addr->host, &error_abort);
|
|
|
|
qemu_opt_set(opts, "port", addr->port, &error_abort);
|
2009-09-10 12:58:40 +04:00
|
|
|
}
|
|
|
|
|
2009-09-10 12:58:41 +04:00
|
|
|
int inet_listen(const char *str, char *ostr, int olen,
|
2012-05-10 20:28:26 +04:00
|
|
|
int socktype, int port_offset, Error **errp)
|
2009-09-10 12:58:41 +04:00
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
char *optstr;
|
|
|
|
int sock = -1;
|
2012-09-19 15:51:46 +04:00
|
|
|
InetSocketAddress *addr;
|
2009-09-10 12:58:41 +04:00
|
|
|
|
2012-09-19 15:51:46 +04:00
|
|
|
addr = inet_parse(str, errp);
|
|
|
|
if (addr != NULL) {
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2012-09-19 15:51:46 +04:00
|
|
|
inet_addr_to_opts(opts, addr);
|
|
|
|
qapi_free_InetSocketAddress(addr);
|
2012-05-10 20:28:26 +04:00
|
|
|
sock = inet_listen_opts(opts, port_offset, errp);
|
2009-09-10 12:58:41 +04:00
|
|
|
if (sock != -1 && ostr) {
|
|
|
|
optstr = strchr(str, ',');
|
|
|
|
if (qemu_opt_get_bool(opts, "ipv6", 0)) {
|
|
|
|
snprintf(ostr, olen, "[%s]:%s%s",
|
|
|
|
qemu_opt_get(opts, "host"),
|
|
|
|
qemu_opt_get(opts, "port"),
|
|
|
|
optstr ? optstr : "");
|
|
|
|
} else {
|
|
|
|
snprintf(ostr, olen, "%s:%s%s",
|
|
|
|
qemu_opt_get(opts, "host"),
|
|
|
|
qemu_opt_get(opts, "port"),
|
|
|
|
optstr ? optstr : "");
|
|
|
|
}
|
|
|
|
}
|
2012-09-19 15:51:46 +04:00
|
|
|
qemu_opts_del(opts);
|
2009-09-10 12:58:41 +04:00
|
|
|
}
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-09-24 15:11:08 +04:00
|
|
|
/**
|
|
|
|
* Create a blocking socket and connect it to an address.
|
|
|
|
*
|
|
|
|
* @str: address string
|
|
|
|
* @errp: set in case of an error
|
|
|
|
*
|
|
|
|
* Returns -1 in case of error, file descriptor on success
|
|
|
|
**/
|
|
|
|
int inet_connect(const char *str, Error **errp)
|
2009-09-10 12:58:40 +04:00
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int sock = -1;
|
2012-09-19 15:51:46 +04:00
|
|
|
InetSocketAddress *addr;
|
2009-09-10 12:58:40 +04:00
|
|
|
|
2012-09-19 15:51:46 +04:00
|
|
|
addr = inet_parse(str, errp);
|
|
|
|
if (addr != NULL) {
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2012-09-19 15:51:46 +04:00
|
|
|
inet_addr_to_opts(opts, addr);
|
|
|
|
qapi_free_InetSocketAddress(addr);
|
2012-09-24 15:11:09 +04:00
|
|
|
sock = inet_connect_opts(opts, errp, NULL, NULL);
|
2012-09-19 15:51:46 +04:00
|
|
|
qemu_opts_del(opts);
|
2012-09-24 15:11:08 +04:00
|
|
|
}
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a non-blocking socket and connect it to an address.
|
2012-09-24 15:11:09 +04:00
|
|
|
* Calls the callback function with fd in case of success or -1 in case of
|
|
|
|
* error.
|
2012-09-24 15:11:08 +04:00
|
|
|
*
|
|
|
|
* @str: address string
|
2012-09-24 15:11:09 +04:00
|
|
|
* @callback: callback function that is called when connect completes,
|
|
|
|
* cannot be NULL.
|
|
|
|
* @opaque: opaque for callback function
|
2012-09-24 15:11:08 +04:00
|
|
|
* @errp: set in case of an error
|
|
|
|
*
|
2012-09-24 15:11:09 +04:00
|
|
|
* Returns: -1 on immediate error, file descriptor on success.
|
2012-09-24 15:11:08 +04:00
|
|
|
**/
|
2012-09-24 15:11:09 +04:00
|
|
|
int inet_nonblocking_connect(const char *str,
|
|
|
|
NonBlockingConnectHandler *callback,
|
|
|
|
void *opaque, Error **errp)
|
2012-09-24 15:11:08 +04:00
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int sock = -1;
|
2012-09-19 15:51:46 +04:00
|
|
|
InetSocketAddress *addr;
|
2012-09-24 15:11:08 +04:00
|
|
|
|
2012-09-24 15:11:09 +04:00
|
|
|
g_assert(callback != NULL);
|
|
|
|
|
2012-09-19 15:51:46 +04:00
|
|
|
addr = inet_parse(str, errp);
|
|
|
|
if (addr != NULL) {
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2012-09-19 15:51:46 +04:00
|
|
|
inet_addr_to_opts(opts, addr);
|
|
|
|
qapi_free_InetSocketAddress(addr);
|
2012-09-24 15:11:09 +04:00
|
|
|
sock = inet_connect_opts(opts, errp, callback, opaque);
|
2012-09-19 15:51:46 +04:00
|
|
|
qemu_opts_del(opts);
|
2012-05-10 20:28:16 +04:00
|
|
|
}
|
2009-09-10 12:58:40 +04:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2008-11-11 23:46:40 +03:00
|
|
|
#ifndef _WIN32
|
|
|
|
|
2012-10-02 11:35:32 +04:00
|
|
|
int unix_listen_opts(QemuOpts *opts, Error **errp)
|
2008-11-11 23:46:40 +03:00
|
|
|
{
|
|
|
|
struct sockaddr_un un;
|
2009-09-10 12:58:38 +04:00
|
|
|
const char *path = qemu_opt_get(opts, "path");
|
|
|
|
int sock, fd;
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2009-12-02 14:24:42 +03:00
|
|
|
sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
|
2008-11-11 23:46:40 +03:00
|
|
|
if (sock < 0) {
|
2015-01-26 14:12:24 +03:00
|
|
|
error_setg_errno(errp, errno, "Failed to create Unix socket");
|
2009-05-06 13:57:03 +04:00
|
|
|
return -1;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(&un, 0, sizeof(un));
|
|
|
|
un.sun_family = AF_UNIX;
|
|
|
|
if (path && strlen(path)) {
|
|
|
|
snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
|
|
|
|
} else {
|
2015-01-26 14:12:24 +03:00
|
|
|
const char *tmpdir = getenv("TMPDIR");
|
|
|
|
tmpdir = tmpdir ? tmpdir : "/tmp";
|
|
|
|
if (snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
|
|
|
|
tmpdir) >= sizeof(un.sun_path)) {
|
|
|
|
error_setg_errno(errp, errno,
|
|
|
|
"TMPDIR environment variable (%s) too large", tmpdir);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2008-11-11 23:46:40 +03:00
|
|
|
/*
|
|
|
|
* This dummy fd usage silences the mktemp() unsecure warning.
|
|
|
|
* Using mkstemp() doesn't make things more secure here
|
|
|
|
* though. bind() complains about existing files, so we have
|
|
|
|
* to unlink first and thus re-open the race window. The
|
|
|
|
* worst case possible is bind() failing, i.e. a DoS attack.
|
|
|
|
*/
|
2015-01-26 14:12:24 +03:00
|
|
|
fd = mkstemp(un.sun_path);
|
|
|
|
if (fd < 0) {
|
|
|
|
error_setg_errno(errp, errno,
|
|
|
|
"Failed to make a temporary socket name in %s", tmpdir);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
close(fd);
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", un.sun_path, &error_abort);
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
|
2015-05-05 18:07:19 +03:00
|
|
|
if ((access(un.sun_path, F_OK) == 0) &&
|
|
|
|
unlink(un.sun_path) < 0) {
|
|
|
|
error_setg_errno(errp, errno,
|
|
|
|
"Failed to unlink socket %s", un.sun_path);
|
|
|
|
goto err;
|
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
|
2015-01-26 14:12:24 +03:00
|
|
|
error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path);
|
2008-11-11 23:46:40 +03:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (listen(sock, 1) < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to listen on socket");
|
2008-11-11 23:46:40 +03:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sock;
|
|
|
|
|
|
|
|
err:
|
|
|
|
closesocket(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-10-03 15:37:46 +04:00
|
|
|
int unix_connect_opts(QemuOpts *opts, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
2008-11-11 23:46:40 +03:00
|
|
|
{
|
|
|
|
struct sockaddr_un un;
|
2009-09-10 12:58:37 +04:00
|
|
|
const char *path = qemu_opt_get(opts, "path");
|
2012-10-03 15:37:46 +04:00
|
|
|
ConnectState *connect_state = NULL;
|
|
|
|
int sock, rc;
|
2008-11-11 23:46:40 +03:00
|
|
|
|
2014-08-11 17:00:55 +04:00
|
|
|
if (path == NULL) {
|
error: Strip trailing '\n' from error string arguments (again)
Commit 6daf194d and be62a2eb got rid of a bunch, but they keep coming
back. Tracked down with this Coccinelle semantic patch:
@r@
expression err, eno, cls, fmt;
position p;
@@
(
error_report(fmt, ...)@p
|
error_set(err, cls, fmt, ...)@p
|
error_set_errno(err, eno, cls, fmt, ...)@p
|
error_setg(err, fmt, ...)@p
|
error_setg_errno(err, eno, fmt, ...)@p
)
@script:python@
fmt << r.fmt;
p << r.p;
@@
if "\\n" in str(fmt):
print "%s:%s:%s:%s" % (p[0].file, p[0].line, p[0].column, fmt)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-4-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-09 00:22:16 +04:00
|
|
|
error_setg(errp, "unix connect: no path specified");
|
2009-09-10 12:58:37 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-12-02 14:24:42 +03:00
|
|
|
sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
|
2008-11-11 23:46:40 +03:00
|
|
|
if (sock < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2009-05-06 13:57:03 +04:00
|
|
|
return -1;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
2012-10-03 15:37:46 +04:00
|
|
|
if (callback != NULL) {
|
|
|
|
connect_state = g_malloc0(sizeof(*connect_state));
|
|
|
|
connect_state->callback = callback;
|
|
|
|
connect_state->opaque = opaque;
|
2013-03-27 13:10:43 +04:00
|
|
|
qemu_set_nonblock(sock);
|
2012-10-03 15:37:46 +04:00
|
|
|
}
|
2008-11-11 23:46:40 +03:00
|
|
|
|
|
|
|
memset(&un, 0, sizeof(un));
|
|
|
|
un.sun_family = AF_UNIX;
|
|
|
|
snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
|
2012-10-03 15:37:46 +04:00
|
|
|
|
|
|
|
/* connect to peer */
|
|
|
|
do {
|
|
|
|
rc = 0;
|
|
|
|
if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
|
|
|
|
rc = -socket_error();
|
|
|
|
}
|
|
|
|
} while (rc == -EINTR);
|
|
|
|
|
|
|
|
if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
|
|
|
|
connect_state->fd = sock;
|
Change qemu_set_fd_handler2(..., NULL, ...) to qemu_set_fd_handler
Done with following Coccinelle semantic patch, plus manual cosmetic changes in
net/*.c.
@@
expression E1, E2, E3, E4;
@@
- qemu_set_fd_handler2(E1, NULL, E2, E3, E4);
+ qemu_set_fd_handler(E1, E2, E3, E4);
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-id: 1433400324-7358-8-git-send-email-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2015-06-04 09:45:18 +03:00
|
|
|
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
|
2012-10-03 15:37:46 +04:00
|
|
|
return sock;
|
|
|
|
} else if (rc >= 0) {
|
|
|
|
/* non blocking socket immediate success, call callback */
|
|
|
|
if (callback != NULL) {
|
2014-10-08 16:11:56 +04:00
|
|
|
callback(sock, NULL, opaque);
|
2012-10-03 15:37:46 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc < 0) {
|
2014-09-25 10:49:31 +04:00
|
|
|
error_setg_errno(errp, -rc, "Failed to connect socket");
|
2011-11-11 13:40:07 +04:00
|
|
|
close(sock);
|
2012-10-03 15:37:46 +04:00
|
|
|
sock = -1;
|
2008-11-11 23:46:40 +03:00
|
|
|
}
|
|
|
|
|
2012-10-03 15:37:46 +04:00
|
|
|
g_free(connect_state);
|
2008-11-11 23:46:40 +03:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-10-18 10:44:00 +04:00
|
|
|
#else
|
|
|
|
|
|
|
|
int unix_listen_opts(QemuOpts *opts, Error **errp)
|
|
|
|
{
|
2012-09-19 15:54:39 +04:00
|
|
|
error_setg(errp, "unix sockets are not available on windows");
|
2012-10-18 10:44:00 +04:00
|
|
|
errno = ENOTSUP;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-10-03 15:37:46 +04:00
|
|
|
int unix_connect_opts(QemuOpts *opts, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
2012-10-18 10:44:00 +04:00
|
|
|
{
|
2012-09-19 15:54:39 +04:00
|
|
|
error_setg(errp, "unix sockets are not available on windows");
|
2012-10-18 10:44:00 +04:00
|
|
|
errno = ENOTSUP;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-09-10 12:58:37 +04:00
|
|
|
/* compatibility wrapper */
|
2012-10-02 11:35:32 +04:00
|
|
|
int unix_listen(const char *str, char *ostr, int olen, Error **errp)
|
2009-09-10 12:58:38 +04:00
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
char *path, *optstr;
|
|
|
|
int sock, len;
|
|
|
|
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2009-09-10 12:58:38 +04:00
|
|
|
|
|
|
|
optstr = strchr(str, ',');
|
|
|
|
if (optstr) {
|
|
|
|
len = optstr - str;
|
|
|
|
if (len) {
|
2011-08-21 07:09:37 +04:00
|
|
|
path = g_malloc(len+1);
|
2009-09-10 12:58:38 +04:00
|
|
|
snprintf(path, len+1, "%.*s", len, str);
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", path, &error_abort);
|
2011-08-21 07:09:37 +04:00
|
|
|
g_free(path);
|
2009-09-10 12:58:38 +04:00
|
|
|
}
|
|
|
|
} else {
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", str, &error_abort);
|
2009-09-10 12:58:38 +04:00
|
|
|
}
|
|
|
|
|
2012-10-02 11:35:32 +04:00
|
|
|
sock = unix_listen_opts(opts, errp);
|
2009-09-10 12:58:38 +04:00
|
|
|
|
|
|
|
if (sock != -1 && ostr)
|
|
|
|
snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-10-02 11:35:32 +04:00
|
|
|
int unix_connect(const char *path, Error **errp)
|
2009-09-10 12:58:37 +04:00
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int sock;
|
|
|
|
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", path, &error_abort);
|
2012-10-03 15:37:46 +04:00
|
|
|
sock = unix_connect_opts(opts, errp, NULL, NULL);
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int unix_nonblocking_connect(const char *path,
|
|
|
|
NonBlockingConnectHandler *callback,
|
|
|
|
void *opaque, Error **errp)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int sock = -1;
|
|
|
|
|
|
|
|
g_assert(callback != NULL);
|
|
|
|
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", path, &error_abort);
|
2012-10-03 15:37:46 +04:00
|
|
|
sock = unix_connect_opts(opts, errp, callback, opaque);
|
2009-09-10 12:58:37 +04:00
|
|
|
qemu_opts_del(opts);
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-10-23 23:31:53 +04:00
|
|
|
SocketAddress *socket_parse(const char *str, Error **errp)
|
|
|
|
{
|
2013-06-24 10:39:44 +04:00
|
|
|
SocketAddress *addr;
|
2012-10-23 23:31:53 +04:00
|
|
|
|
2013-06-24 10:39:44 +04:00
|
|
|
addr = g_new0(SocketAddress, 1);
|
2012-10-23 23:31:53 +04:00
|
|
|
if (strstart(str, "unix:", NULL)) {
|
|
|
|
if (str[5] == '\0') {
|
error: Strip trailing '\n' from error string arguments (again)
Commit 6daf194d and be62a2eb got rid of a bunch, but they keep coming
back. Tracked down with this Coccinelle semantic patch:
@r@
expression err, eno, cls, fmt;
position p;
@@
(
error_report(fmt, ...)@p
|
error_set(err, cls, fmt, ...)@p
|
error_set_errno(err, eno, cls, fmt, ...)@p
|
error_setg(err, fmt, ...)@p
|
error_setg_errno(err, eno, fmt, ...)@p
)
@script:python@
fmt << r.fmt;
p << r.p;
@@
if "\\n" in str(fmt):
print "%s:%s:%s:%s" % (p[0].file, p[0].line, p[0].column, fmt)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-4-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-09 00:22:16 +04:00
|
|
|
error_setg(errp, "invalid Unix socket address");
|
2012-10-23 23:31:53 +04:00
|
|
|
goto fail;
|
|
|
|
} else {
|
|
|
|
addr->kind = SOCKET_ADDRESS_KIND_UNIX;
|
|
|
|
addr->q_unix = g_new(UnixSocketAddress, 1);
|
|
|
|
addr->q_unix->path = g_strdup(str + 5);
|
|
|
|
}
|
|
|
|
} else if (strstart(str, "fd:", NULL)) {
|
|
|
|
if (str[3] == '\0') {
|
error: Strip trailing '\n' from error string arguments (again)
Commit 6daf194d and be62a2eb got rid of a bunch, but they keep coming
back. Tracked down with this Coccinelle semantic patch:
@r@
expression err, eno, cls, fmt;
position p;
@@
(
error_report(fmt, ...)@p
|
error_set(err, cls, fmt, ...)@p
|
error_set_errno(err, eno, cls, fmt, ...)@p
|
error_setg(err, fmt, ...)@p
|
error_setg_errno(err, eno, fmt, ...)@p
)
@script:python@
fmt << r.fmt;
p << r.p;
@@
if "\\n" in str(fmt):
print "%s:%s:%s:%s" % (p[0].file, p[0].line, p[0].column, fmt)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-4-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-09 00:22:16 +04:00
|
|
|
error_setg(errp, "invalid file descriptor address");
|
2012-10-23 23:31:53 +04:00
|
|
|
goto fail;
|
|
|
|
} else {
|
|
|
|
addr->kind = SOCKET_ADDRESS_KIND_FD;
|
|
|
|
addr->fd = g_new(String, 1);
|
|
|
|
addr->fd->str = g_strdup(str + 3);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr->kind = SOCKET_ADDRESS_KIND_INET;
|
|
|
|
addr->inet = inet_parse(str, errp);
|
|
|
|
if (addr->inet == NULL) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
qapi_free_SocketAddress(addr);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int socket_connect(SocketAddress *addr, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int fd;
|
|
|
|
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2012-10-23 23:31:53 +04:00
|
|
|
switch (addr->kind) {
|
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
|
|
|
inet_addr_to_opts(opts, addr->inet);
|
|
|
|
fd = inet_connect_opts(opts, errp, callback, opaque);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_UNIX:
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort);
|
2012-10-23 23:31:53 +04:00
|
|
|
fd = unix_connect_opts(opts, errp, callback, opaque);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_FD:
|
|
|
|
fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
|
2013-06-24 10:39:46 +04:00
|
|
|
if (fd >= 0 && callback) {
|
2013-03-27 13:10:45 +04:00
|
|
|
qemu_set_nonblock(fd);
|
2014-10-08 16:11:56 +04:00
|
|
|
callback(fd, NULL, opaque);
|
2012-10-23 23:31:53 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
int socket_listen(SocketAddress *addr, Error **errp)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int fd;
|
|
|
|
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2012-10-23 23:31:53 +04:00
|
|
|
switch (addr->kind) {
|
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
|
|
|
inet_addr_to_opts(opts, addr->inet);
|
|
|
|
fd = inet_listen_opts(opts, 0, errp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_UNIX:
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "path", addr->q_unix->path, &error_abort);
|
2012-10-23 23:31:53 +04:00
|
|
|
fd = unix_listen_opts(opts, errp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_FD:
|
|
|
|
fd = monitor_get_fd(cur_mon, addr->fd->str, errp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2013-02-27 17:10:47 +04:00
|
|
|
int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
|
|
|
|
{
|
|
|
|
QemuOpts *opts;
|
|
|
|
int fd;
|
|
|
|
|
2014-01-02 06:49:17 +04:00
|
|
|
opts = qemu_opts_create(&socket_optslist, NULL, 0, &error_abort);
|
2013-02-27 17:10:47 +04:00
|
|
|
switch (remote->kind) {
|
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
2014-09-02 14:24:14 +04:00
|
|
|
inet_addr_to_opts(opts, remote->inet);
|
2013-02-27 17:10:47 +04:00
|
|
|
if (local) {
|
2015-02-12 19:52:20 +03:00
|
|
|
qemu_opt_set(opts, "localaddr", local->inet->host, &error_abort);
|
|
|
|
qemu_opt_set(opts, "localport", local->inet->port, &error_abort);
|
2013-02-27 17:10:47 +04:00
|
|
|
}
|
|
|
|
fd = inet_dgram_opts(opts, errp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error_setg(errp, "socket type unsupported for datagram");
|
2013-06-24 10:39:56 +04:00
|
|
|
fd = -1;
|
2013-02-27 17:10:47 +04:00
|
|
|
}
|
|
|
|
qemu_opts_del(opts);
|
|
|
|
return fd;
|
|
|
|
}
|