2008-11-13 17:19:54 +01: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 11:08:39 +02: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 17:19:54 +01:00
|
|
|
*/
|
2016-01-29 18:49:55 +01:00
|
|
|
#include "qemu/osdep.h"
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "monitor/monitor.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/sockets.h"
|
|
|
|
#include "qemu/main-loop.h"
|
2015-08-14 19:18:41 +02:00
|
|
|
#include "qapi/qmp-input-visitor.h"
|
|
|
|
#include "qapi/qmp-output-visitor.h"
|
|
|
|
#include "qapi-visit.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2008-11-11 21:46:40 +01:00
|
|
|
|
|
|
|
#ifndef AI_ADDRCONFIG
|
|
|
|
# define AI_ADDRCONFIG 0
|
|
|
|
#endif
|
2016-04-04 18:22:00 +02:00
|
|
|
|
2015-05-21 14:33:29 +02:00
|
|
|
#ifndef AI_V4MAPPED
|
|
|
|
# define AI_V4MAPPED 0
|
|
|
|
#endif
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2009-09-10 10:58:37 +02:00
|
|
|
|
2008-11-11 21:46:40 +01: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 08:43:30 +02: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;
|
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:02 +01:00
|
|
|
/*
|
|
|
|
* Matrix we're trying to apply
|
|
|
|
*
|
|
|
|
* ipv4 ipv6 family
|
|
|
|
* - - PF_UNSPEC
|
|
|
|
* - f PF_INET
|
|
|
|
* - t PF_INET6
|
|
|
|
* f - PF_INET6
|
|
|
|
* f f <error>
|
|
|
|
* f t PF_INET6
|
|
|
|
* t - PF_INET
|
|
|
|
* t f PF_INET
|
|
|
|
* t t PF_INET6
|
|
|
|
*
|
2016-03-14 10:58:29 +01:00
|
|
|
* NB, this matrix is only about getting the necessary results
|
2016-01-11 14:17:02 +01:00
|
|
|
* from getaddrinfo(). Some of the cases require further work
|
|
|
|
* after reading results from getaddrinfo in order to fully
|
|
|
|
* apply the logic the end user wants. eg with the last case
|
|
|
|
* ipv4=t + ipv6=t + PF_INET6, getaddrinfo alone can only
|
|
|
|
* guarantee the ipv6=t part of the request - we need more
|
|
|
|
* checks to provide ipv4=t part of the guarantee. This is
|
|
|
|
* outside scope of this method and not currently handled by
|
|
|
|
* callers at all.
|
|
|
|
*/
|
|
|
|
static int inet_ai_family_from_address(InetSocketAddress *addr,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
if (addr->has_ipv6 && addr->has_ipv4 &&
|
|
|
|
!addr->ipv6 && !addr->ipv4) {
|
|
|
|
error_setg(errp, "Cannot disable IPv4 and IPv6 at same time");
|
|
|
|
return PF_UNSPEC;
|
|
|
|
}
|
|
|
|
if ((addr->has_ipv6 && addr->ipv6) || (addr->has_ipv4 && !addr->ipv4)) {
|
|
|
|
return PF_INET6;
|
|
|
|
}
|
|
|
|
if ((addr->has_ipv4 && addr->ipv4) || (addr->has_ipv6 && !addr->ipv6)) {
|
|
|
|
return PF_INET;
|
|
|
|
}
|
|
|
|
return PF_UNSPEC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_listen_saddr(InetSocketAddress *saddr,
|
|
|
|
int port_offset,
|
|
|
|
bool update_addr,
|
|
|
|
Error **errp)
|
2008-11-11 21:46:40 +01:00
|
|
|
{
|
|
|
|
struct addrinfo ai,*res,*e;
|
|
|
|
char port[33];
|
|
|
|
char uaddr[INET6_ADDRSTRLEN+1];
|
|
|
|
char uport[33];
|
2016-01-11 14:17:02 +01:00
|
|
|
int slisten, rc, port_min, port_max, p;
|
|
|
|
Error *err = NULL;
|
2008-11-11 21:46:40 +01:00
|
|
|
|
|
|
|
memset(&ai,0, sizeof(ai));
|
2015-05-21 14:33:29 +02:00
|
|
|
ai.ai_flags = AI_PASSIVE;
|
2016-01-11 14:17:02 +01:00
|
|
|
ai.ai_family = inet_ai_family_from_address(saddr, &err);
|
2009-09-10 10:58:41 +02:00
|
|
|
ai.ai_socktype = SOCK_STREAM;
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2016-01-11 14:17:02 +01:00
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (saddr->host == NULL) {
|
2015-09-01 15:46:50 +02:00
|
|
|
error_setg(errp, "host not specified");
|
2009-09-10 10:58:41 +02:00
|
|
|
return -1;
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
2016-01-11 14:17:02 +01:00
|
|
|
if (saddr->port != NULL) {
|
|
|
|
pstrcpy(port, sizeof(port), saddr->port);
|
2015-09-01 15:46:50 +02:00
|
|
|
} else {
|
|
|
|
port[0] = '\0';
|
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
|
|
|
|
/* lookup */
|
2013-12-11 12:58:41 +01:00
|
|
|
if (port_offset) {
|
|
|
|
unsigned long long baseport;
|
2015-09-01 15:46:50 +02:00
|
|
|
if (strlen(port) == 0) {
|
|
|
|
error_setg(errp, "port not specified");
|
|
|
|
return -1;
|
|
|
|
}
|
2013-12-11 12:58:41 +01:00
|
|
|
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);
|
|
|
|
}
|
2016-01-11 14:17:02 +01:00
|
|
|
rc = getaddrinfo(strlen(saddr->host) ? saddr->host : NULL,
|
2015-09-01 15:46:50 +02:00
|
|
|
strlen(port) ? port : NULL, &ai, &res);
|
2008-11-11 21:46:40 +01:00
|
|
|
if (rc != 0) {
|
2016-01-11 14:17:02 +01:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s",
|
|
|
|
saddr->host, port, gai_strerror(rc));
|
2008-11-11 21:46:40 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create socket + bind */
|
|
|
|
for (e = res; e != NULL; e = e->ai_next) {
|
2009-05-06 11:57:03 +02:00
|
|
|
getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
|
|
|
|
uaddr,INET6_ADDRSTRLEN,uport,32,
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
2009-12-02 12:24:42 +01:00
|
|
|
slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
|
2009-05-06 11:57:03 +02:00
|
|
|
if (slisten < 0) {
|
2012-05-10 18:28:26 +02:00
|
|
|
if (!e->ai_next) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2012-05-10 18:28:26 +02:00
|
|
|
}
|
2009-05-06 11:57:03 +02:00
|
|
|
continue;
|
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2013-10-02 12:23:16 +02:00
|
|
|
socket_set_fast_reuse(slisten);
|
2008-11-11 21:46:40 +01:00
|
|
|
#ifdef IPV6_V6ONLY
|
|
|
|
if (e->ai_family == PF_INET6) {
|
|
|
|
/* listen on both ipv4 and ipv6 */
|
2014-06-07 18:48:03 +02:00
|
|
|
const int off = 0;
|
2013-03-08 19:58:32 +01:00
|
|
|
qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off,
|
|
|
|
sizeof(off));
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-02-07 15:09:15 +01:00
|
|
|
port_min = inet_getport(e);
|
2016-01-11 14:17:02 +01:00
|
|
|
port_max = saddr->has_to ? saddr->to + port_offset : port_min;
|
2012-02-07 15:09:15 +01:00
|
|
|
for (p = port_min; p <= port_max; p++) {
|
|
|
|
inet_setport(e, p);
|
2008-11-11 21:46:40 +01:00
|
|
|
if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
|
|
|
|
goto listen;
|
|
|
|
}
|
2012-02-07 15:09:15 +01:00
|
|
|
if (p == port_max) {
|
2012-05-10 18:28:26 +02:00
|
|
|
if (!e->ai_next) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to bind socket");
|
2012-05-10 18:28:26 +02:00
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
closesocket(slisten);
|
|
|
|
}
|
|
|
|
freeaddrinfo(res);
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
listen:
|
|
|
|
if (listen(slisten,1) != 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to listen on socket");
|
2008-11-11 21:46:40 +01:00
|
|
|
closesocket(slisten);
|
2009-05-06 11:57:03 +02:00
|
|
|
freeaddrinfo(res);
|
2008-11-11 21:46:40 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2016-01-11 14:17:02 +01:00
|
|
|
if (update_addr) {
|
|
|
|
g_free(saddr->host);
|
|
|
|
saddr->host = g_strdup(uaddr);
|
|
|
|
g_free(saddr->port);
|
|
|
|
saddr->port = g_strdup_printf("%d",
|
|
|
|
inet_getport(e) - port_offset);
|
|
|
|
saddr->has_ipv6 = saddr->ipv6 = e->ai_family == PF_INET6;
|
|
|
|
saddr->has_ipv4 = saddr->ipv4 = e->ai_family != PF_INET6;
|
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
freeaddrinfo(res);
|
|
|
|
return slisten;
|
|
|
|
}
|
|
|
|
|
2012-09-24 13:11:07 +02: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 13:11:09 +02: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 09:19:01 +02:00
|
|
|
ConnectState *connect_state, Error **errp);
|
2012-09-24 13:11:09 +02:00
|
|
|
|
|
|
|
static void wait_for_connect(void *opaque)
|
2008-11-11 21:46:40 +01:00
|
|
|
{
|
2012-09-24 13:11:09 +02:00
|
|
|
ConnectState *s = opaque;
|
|
|
|
int val = 0, rc = 0;
|
|
|
|
socklen_t valsize = sizeof(val);
|
|
|
|
bool in_progress;
|
2014-10-08 14:11:56 +02:00
|
|
|
Error *err = NULL;
|
2012-09-24 13:11:09 +02: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 08:45:18 +02:00
|
|
|
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
|
2012-09-24 13:11:09 +02:00
|
|
|
|
|
|
|
do {
|
2013-03-08 19:58:32 +01:00
|
|
|
rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
|
2016-03-07 21:36:03 +01:00
|
|
|
} while (rc == -1 && errno == EINTR);
|
2012-09-24 13:11:09 +02:00
|
|
|
|
|
|
|
/* update rc to contain error */
|
|
|
|
if (!rc && val) {
|
|
|
|
rc = -1;
|
2014-10-08 14:11:56 +02:00
|
|
|
errno = val;
|
2012-09-24 13:11:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* connect error */
|
|
|
|
if (rc < 0) {
|
2014-10-08 14:11:56 +02:00
|
|
|
error_setg_errno(&err, errno, "Error connecting to socket");
|
2012-09-24 13:11:09 +02:00
|
|
|
closesocket(s->fd);
|
|
|
|
s->fd = rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* try to connect to the next address on the list */
|
2012-10-03 13:37:46 +02: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 09:19:01 +02:00
|
|
|
s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
|
2014-10-08 14:11:56 +02:00
|
|
|
if (s->fd < 0) {
|
|
|
|
error_free(err);
|
|
|
|
err = NULL;
|
|
|
|
error_setg_errno(&err, errno, "Unable to start socket connect");
|
|
|
|
}
|
2012-10-03 13:37:46 +02:00
|
|
|
/* connect in progress */
|
|
|
|
if (in_progress) {
|
2014-10-08 14:11:56 +02:00
|
|
|
goto out;
|
2012-10-03 13:37:46 +02:00
|
|
|
}
|
2012-09-24 13:11:09 +02:00
|
|
|
}
|
2012-10-03 13:37:46 +02:00
|
|
|
|
|
|
|
freeaddrinfo(s->addr_list);
|
2012-09-24 13:11:09 +02:00
|
|
|
}
|
2012-09-24 13:11:07 +02:00
|
|
|
|
2012-09-24 13:11:09 +02:00
|
|
|
if (s->callback) {
|
2014-10-08 14:11:56 +02:00
|
|
|
s->callback(s->fd, err, s->opaque);
|
2012-09-24 13:11:07 +02:00
|
|
|
}
|
2012-09-24 13:11:09 +02:00
|
|
|
g_free(s);
|
2014-10-08 14:11:56 +02:00
|
|
|
out:
|
|
|
|
error_free(err);
|
2012-09-24 13:11:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
|
2012-10-02 09:19:01 +02:00
|
|
|
ConnectState *connect_state, Error **errp)
|
2012-09-24 13:11:09 +02:00
|
|
|
{
|
|
|
|
int sock, rc;
|
|
|
|
|
|
|
|
*in_progress = false;
|
2012-09-24 13:11:07 +02:00
|
|
|
|
|
|
|
sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
|
|
|
|
if (sock < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2012-09-24 13:11:07 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2013-10-02 12:23:16 +02:00
|
|
|
socket_set_fast_reuse(sock);
|
2012-09-24 13:11:09 +02:00
|
|
|
if (connect_state != NULL) {
|
2013-03-27 10:10:43 +01:00
|
|
|
qemu_set_nonblock(sock);
|
2012-09-24 13:11:07 +02:00
|
|
|
}
|
|
|
|
/* connect to peer */
|
|
|
|
do {
|
|
|
|
rc = 0;
|
|
|
|
if (connect(sock, addr->ai_addr, addr->ai_addrlen) < 0) {
|
2016-03-07 21:36:03 +01:00
|
|
|
rc = -errno;
|
2012-09-24 13:11:07 +02:00
|
|
|
}
|
|
|
|
} while (rc == -EINTR);
|
|
|
|
|
2012-09-24 13:11:09 +02: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 08:45:18 +02:00
|
|
|
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
|
2012-09-24 13:11:09 +02:00
|
|
|
*in_progress = true;
|
2012-09-24 13:11:07 +02:00
|
|
|
} else if (rc < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to connect socket");
|
2012-09-24 13:11:07 +02:00
|
|
|
closesocket(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
static struct addrinfo *inet_parse_connect_saddr(InetSocketAddress *saddr,
|
|
|
|
Error **errp)
|
2012-09-24 13:11:07 +02:00
|
|
|
{
|
|
|
|
struct addrinfo ai, *res;
|
|
|
|
int rc;
|
2016-01-11 14:17:03 +01:00
|
|
|
Error *err = NULL;
|
2016-04-04 18:22:00 +02:00
|
|
|
static int useV4Mapped = 1;
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2012-09-24 13:11:07 +02:00
|
|
|
memset(&ai, 0, sizeof(ai));
|
2012-09-24 13:11:09 +02:00
|
|
|
|
2016-04-04 18:22:00 +02:00
|
|
|
ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
|
|
|
|
if (atomic_read(&useV4Mapped)) {
|
|
|
|
ai.ai_flags |= AI_V4MAPPED;
|
|
|
|
}
|
2016-01-11 14:17:03 +01:00
|
|
|
ai.ai_family = inet_ai_family_from_address(saddr, &err);
|
2009-09-10 10:58:40 +02:00
|
|
|
ai.ai_socktype = SOCK_STREAM;
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
2012-09-24 13:11:07 +02:00
|
|
|
return NULL;
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
if (saddr->host == NULL || saddr->port == NULL) {
|
|
|
|
error_setg(errp, "host and/or port not specified");
|
|
|
|
return NULL;
|
2012-09-24 13:11:07 +02:00
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
|
|
|
|
/* lookup */
|
2016-01-11 14:17:03 +01:00
|
|
|
rc = getaddrinfo(saddr->host, saddr->port, &ai, &res);
|
2016-04-04 18:22:00 +02:00
|
|
|
|
|
|
|
/* At least FreeBSD and OS-X 10.6 declare AI_V4MAPPED but
|
|
|
|
* then don't implement it in their getaddrinfo(). Detect
|
|
|
|
* this and retry without the flag since that's preferrable
|
|
|
|
* to a fatal error
|
|
|
|
*/
|
|
|
|
if (rc == EAI_BADFLAGS &&
|
|
|
|
(ai.ai_flags & AI_V4MAPPED)) {
|
|
|
|
atomic_set(&useV4Mapped, 0);
|
|
|
|
ai.ai_flags &= ~AI_V4MAPPED;
|
|
|
|
rc = getaddrinfo(saddr->host, saddr->port, &ai, &res);
|
|
|
|
}
|
2012-09-24 13:11:07 +02:00
|
|
|
if (rc != 0) {
|
2016-01-11 14:17:03 +01:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s",
|
|
|
|
saddr->host, saddr->port, gai_strerror(rc));
|
2012-09-24 13:11:07 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2012-09-24 13:11:08 +02:00
|
|
|
/**
|
|
|
|
* Create a socket and connect it to an address.
|
|
|
|
*
|
2016-01-11 14:17:03 +01:00
|
|
|
* @saddr: Inet socket address specification
|
2012-09-24 13:11:08 +02:00
|
|
|
* @errp: set on error
|
2012-09-24 13:11:09 +02:00
|
|
|
* @callback: callback function for non-blocking connect
|
|
|
|
* @opaque: opaque for callback function
|
2012-09-24 13:11:08 +02:00
|
|
|
*
|
|
|
|
* Returns: -1 on error, file descriptor on success.
|
2012-09-24 13:11:09 +02: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 13:11:08 +02:00
|
|
|
*/
|
2016-01-11 14:17:03 +01:00
|
|
|
static int inet_connect_saddr(InetSocketAddress *saddr, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
2012-09-24 13:11:07 +02:00
|
|
|
{
|
2014-05-19 18:57:37 +02:00
|
|
|
Error *local_err = NULL;
|
2012-09-24 13:11:07 +02:00
|
|
|
struct addrinfo *res, *e;
|
|
|
|
int sock = -1;
|
2012-09-24 13:11:09 +02:00
|
|
|
bool in_progress;
|
|
|
|
ConnectState *connect_state = NULL;
|
2012-09-24 13:11:07 +02:00
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
res = inet_parse_connect_saddr(saddr, errp);
|
2012-09-24 13:11:07 +02:00
|
|
|
if (!res) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-09-24 13:11:09 +02: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 21:46:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
for (e = res; e != NULL; e = e->ai_next) {
|
2014-05-19 18:57:37 +02:00
|
|
|
error_free(local_err);
|
|
|
|
local_err = NULL;
|
2012-09-24 13:11:09 +02:00
|
|
|
if (connect_state != NULL) {
|
|
|
|
connect_state->current_addr = e;
|
|
|
|
}
|
2014-05-19 18:57:37 +02:00
|
|
|
sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
|
|
|
|
if (sock >= 0) {
|
2012-09-24 13:11:07 +02:00
|
|
|
break;
|
2012-05-10 18:28:16 +02:00
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
2014-05-19 18:57:37 +02: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 14:11:56 +02:00
|
|
|
callback(sock, NULL, opaque);
|
2014-05-19 18:57:37 +02:00
|
|
|
}
|
|
|
|
}
|
2012-09-24 13:11:09 +02:00
|
|
|
g_free(connect_state);
|
2008-11-11 21:46:40 +01:00
|
|
|
freeaddrinfo(res);
|
2012-09-24 13:11:07 +02:00
|
|
|
return sock;
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:04 +01:00
|
|
|
static int inet_dgram_saddr(InetSocketAddress *sraddr,
|
|
|
|
InetSocketAddress *sladdr,
|
|
|
|
Error **errp)
|
2009-09-10 10:58:51 +02:00
|
|
|
{
|
|
|
|
struct addrinfo ai, *peer = NULL, *local = NULL;
|
|
|
|
const char *addr;
|
|
|
|
const char *port;
|
|
|
|
int sock = -1, rc;
|
2016-01-11 14:17:04 +01:00
|
|
|
Error *err = NULL;
|
2009-09-10 10:58:51 +02:00
|
|
|
|
|
|
|
/* lookup peer addr */
|
|
|
|
memset(&ai,0, sizeof(ai));
|
2015-05-21 14:33:29 +02:00
|
|
|
ai.ai_flags = AI_CANONNAME | AI_V4MAPPED | AI_ADDRCONFIG;
|
2016-01-11 14:17:04 +01:00
|
|
|
ai.ai_family = inet_ai_family_from_address(sraddr, &err);
|
2009-09-10 10:58:51 +02:00
|
|
|
ai.ai_socktype = SOCK_DGRAM;
|
|
|
|
|
2016-01-11 14:17:04 +01:00
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
2016-01-22 12:28:33 +01:00
|
|
|
goto err;
|
2016-01-11 14:17:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
addr = sraddr->host;
|
|
|
|
port = sraddr->port;
|
2009-09-10 10:58:51 +02:00
|
|
|
if (addr == NULL || strlen(addr) == 0) {
|
|
|
|
addr = "localhost";
|
|
|
|
}
|
|
|
|
if (port == NULL || strlen(port) == 0) {
|
2012-10-02 09:25:14 +02:00
|
|
|
error_setg(errp, "remote port not specified");
|
2016-01-22 12:28:33 +01:00
|
|
|
goto err;
|
2009-09-10 10:58:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
|
2012-10-02 09:25:14 +02:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
|
|
|
|
gai_strerror(rc));
|
2016-01-22 12:28:33 +01:00
|
|
|
goto err;
|
2009-09-10 10:58:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* lookup local addr */
|
|
|
|
memset(&ai,0, sizeof(ai));
|
|
|
|
ai.ai_flags = AI_PASSIVE;
|
|
|
|
ai.ai_family = peer->ai_family;
|
|
|
|
ai.ai_socktype = SOCK_DGRAM;
|
|
|
|
|
2016-01-11 14:17:04 +01:00
|
|
|
if (sladdr) {
|
|
|
|
addr = sladdr->host;
|
|
|
|
port = sladdr->port;
|
|
|
|
if (addr == NULL || strlen(addr) == 0) {
|
|
|
|
addr = NULL;
|
|
|
|
}
|
|
|
|
if (!port || strlen(port) == 0) {
|
|
|
|
port = "0";
|
|
|
|
}
|
|
|
|
} else {
|
2009-09-10 10:58:51 +02:00
|
|
|
addr = NULL;
|
|
|
|
port = "0";
|
2016-01-11 14:17:04 +01:00
|
|
|
}
|
2009-09-10 10:58:51 +02:00
|
|
|
|
|
|
|
if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
|
2012-10-02 09:25:14 +02:00
|
|
|
error_setg(errp, "address resolution failed for %s:%s: %s", addr, port,
|
|
|
|
gai_strerror(rc));
|
2012-09-01 09:40:26 +02:00
|
|
|
goto err;
|
2009-09-10 10:58:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* create socket */
|
2009-12-02 12:24:42 +01:00
|
|
|
sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
|
2009-09-10 10:58:51 +02:00
|
|
|
if (sock < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2009-09-10 10:58:51 +02:00
|
|
|
goto err;
|
|
|
|
}
|
2013-10-02 12:23:16 +02:00
|
|
|
socket_set_fast_reuse(sock);
|
2009-09-10 10:58:51 +02:00
|
|
|
|
|
|
|
/* bind socket */
|
|
|
|
if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to bind socket");
|
2009-09-10 10:58:51 +02:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* connect to peer */
|
|
|
|
if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to connect socket");
|
2009-09-10 10:58:51 +02: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 10:58:40 +02:00
|
|
|
/* compatibility wrapper */
|
2013-03-15 11:55:29 +01:00
|
|
|
InetSocketAddress *inet_parse(const char *str, Error **errp)
|
2009-09-10 10:58:40 +02:00
|
|
|
{
|
2012-09-19 13:51:46 +02:00
|
|
|
InetSocketAddress *addr;
|
2009-09-10 10:58:40 +02:00
|
|
|
const char *optstr, *h;
|
2015-01-30 20:37:55 +01:00
|
|
|
char host[65];
|
2009-09-10 10:58:40 +02:00
|
|
|
char port[33];
|
2012-09-19 13:51:46 +02:00
|
|
|
int to;
|
2009-09-10 10:58:40 +02:00
|
|
|
int pos;
|
|
|
|
|
2012-09-19 13:51:46 +02:00
|
|
|
addr = g_new0(InetSocketAddress, 1);
|
|
|
|
|
2009-09-10 10:58:40 +02:00
|
|
|
/* parse address */
|
|
|
|
if (str[0] == ':') {
|
|
|
|
/* no host given */
|
2012-09-19 13:51:46 +02:00
|
|
|
host[0] = '\0';
|
|
|
|
if (1 != sscanf(str, ":%32[^,]%n", port, &pos)) {
|
2012-09-19 13:22:21 +02:00
|
|
|
error_setg(errp, "error parsing port in address '%s'", str);
|
2012-09-19 13:51:46 +02:00
|
|
|
goto fail;
|
2009-09-10 10:58:40 +02:00
|
|
|
}
|
|
|
|
} else if (str[0] == '[') {
|
|
|
|
/* IPv6 addr */
|
2012-09-19 13:51:46 +02:00
|
|
|
if (2 != sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos)) {
|
2012-09-19 13:22:21 +02:00
|
|
|
error_setg(errp, "error parsing IPv6 address '%s'", str);
|
2012-09-19 13:51:46 +02:00
|
|
|
goto fail;
|
2009-09-10 10:58:40 +02:00
|
|
|
}
|
2012-09-19 13:51:46 +02:00
|
|
|
addr->ipv6 = addr->has_ipv6 = true;
|
2009-09-10 10:58:40 +02:00
|
|
|
} else {
|
2013-06-03 17:54:55 +02:00
|
|
|
/* hostname or IPv4 addr */
|
2012-09-19 13:51:46 +02:00
|
|
|
if (2 != sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos)) {
|
2012-09-19 13:22:21 +02:00
|
|
|
error_setg(errp, "error parsing address '%s'", str);
|
2012-09-19 13:51:46 +02:00
|
|
|
goto fail;
|
2009-09-10 10:58:40 +02:00
|
|
|
}
|
2013-06-03 17:54:55 +02:00
|
|
|
if (host[strspn(host, "0123456789.")] == '\0') {
|
|
|
|
addr->ipv4 = addr->has_ipv4 = true;
|
|
|
|
}
|
2009-09-10 10:58:40 +02:00
|
|
|
}
|
2012-09-19 13:51:46 +02:00
|
|
|
|
|
|
|
addr->host = g_strdup(host);
|
|
|
|
addr->port = g_strdup(port);
|
2009-09-10 10:58:40 +02:00
|
|
|
|
|
|
|
/* parse options */
|
|
|
|
optstr = str + pos;
|
|
|
|
h = strstr(optstr, ",to=");
|
2012-09-19 13:51:46 +02:00
|
|
|
if (h) {
|
2012-11-16 05:08:14 +01:00
|
|
|
h += 4;
|
|
|
|
if (sscanf(h, "%d%n", &to, &pos) != 1 ||
|
|
|
|
(h[pos] != '\0' && h[pos] != ',')) {
|
2012-09-19 13:51:46 +02: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;
|
|
|
|
}
|
|
|
|
|
2009-09-10 10:58:41 +02:00
|
|
|
int inet_listen(const char *str, char *ostr, int olen,
|
2012-05-10 18:28:26 +02:00
|
|
|
int socktype, int port_offset, Error **errp)
|
2009-09-10 10:58:41 +02:00
|
|
|
{
|
|
|
|
char *optstr;
|
|
|
|
int sock = -1;
|
2012-09-19 13:51:46 +02:00
|
|
|
InetSocketAddress *addr;
|
2009-09-10 10:58:41 +02:00
|
|
|
|
2012-09-19 13:51:46 +02:00
|
|
|
addr = inet_parse(str, errp);
|
|
|
|
if (addr != NULL) {
|
2016-01-11 14:17:02 +01:00
|
|
|
sock = inet_listen_saddr(addr, port_offset, true, errp);
|
2009-09-10 10:58:41 +02:00
|
|
|
if (sock != -1 && ostr) {
|
|
|
|
optstr = strchr(str, ',');
|
2016-01-11 14:17:02 +01:00
|
|
|
if (addr->ipv6) {
|
2009-09-10 10:58:41 +02:00
|
|
|
snprintf(ostr, olen, "[%s]:%s%s",
|
2016-01-11 14:17:02 +01:00
|
|
|
addr->host,
|
|
|
|
addr->port,
|
2009-09-10 10:58:41 +02:00
|
|
|
optstr ? optstr : "");
|
|
|
|
} else {
|
|
|
|
snprintf(ostr, olen, "%s:%s%s",
|
2016-01-11 14:17:02 +01:00
|
|
|
addr->host,
|
|
|
|
addr->port,
|
2009-09-10 10:58:41 +02:00
|
|
|
optstr ? optstr : "");
|
|
|
|
}
|
|
|
|
}
|
2016-01-11 14:17:02 +01:00
|
|
|
qapi_free_InetSocketAddress(addr);
|
2009-09-10 10:58:41 +02:00
|
|
|
}
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-09-24 13:11:08 +02: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 10:58:40 +02:00
|
|
|
{
|
|
|
|
int sock = -1;
|
2012-09-19 13:51:46 +02:00
|
|
|
InetSocketAddress *addr;
|
2009-09-10 10:58:40 +02:00
|
|
|
|
2012-09-19 13:51:46 +02:00
|
|
|
addr = inet_parse(str, errp);
|
|
|
|
if (addr != NULL) {
|
2016-01-11 14:17:03 +01:00
|
|
|
sock = inet_connect_saddr(addr, errp, NULL, NULL);
|
2012-09-19 13:51:46 +02:00
|
|
|
qapi_free_InetSocketAddress(addr);
|
2012-09-24 13:11:08 +02:00
|
|
|
}
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a non-blocking socket and connect it to an address.
|
2012-09-24 13:11:09 +02:00
|
|
|
* Calls the callback function with fd in case of success or -1 in case of
|
|
|
|
* error.
|
2012-09-24 13:11:08 +02:00
|
|
|
*
|
|
|
|
* @str: address string
|
2012-09-24 13:11:09 +02:00
|
|
|
* @callback: callback function that is called when connect completes,
|
|
|
|
* cannot be NULL.
|
|
|
|
* @opaque: opaque for callback function
|
2012-09-24 13:11:08 +02:00
|
|
|
* @errp: set in case of an error
|
|
|
|
*
|
2012-09-24 13:11:09 +02:00
|
|
|
* Returns: -1 on immediate error, file descriptor on success.
|
2012-09-24 13:11:08 +02:00
|
|
|
**/
|
2012-09-24 13:11:09 +02:00
|
|
|
int inet_nonblocking_connect(const char *str,
|
|
|
|
NonBlockingConnectHandler *callback,
|
|
|
|
void *opaque, Error **errp)
|
2012-09-24 13:11:08 +02:00
|
|
|
{
|
|
|
|
int sock = -1;
|
2012-09-19 13:51:46 +02:00
|
|
|
InetSocketAddress *addr;
|
2012-09-24 13:11:08 +02:00
|
|
|
|
2012-09-24 13:11:09 +02:00
|
|
|
g_assert(callback != NULL);
|
|
|
|
|
2012-09-19 13:51:46 +02:00
|
|
|
addr = inet_parse(str, errp);
|
|
|
|
if (addr != NULL) {
|
2016-01-11 14:17:03 +01:00
|
|
|
sock = inet_connect_saddr(addr, errp, callback, opaque);
|
2012-09-19 13:51:46 +02:00
|
|
|
qapi_free_InetSocketAddress(addr);
|
2012-05-10 18:28:16 +02:00
|
|
|
}
|
2009-09-10 10:58:40 +02:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2008-11-11 21:46:40 +01:00
|
|
|
#ifndef _WIN32
|
|
|
|
|
2016-01-11 14:17:02 +01:00
|
|
|
static int unix_listen_saddr(UnixSocketAddress *saddr,
|
|
|
|
bool update_addr,
|
|
|
|
Error **errp)
|
2008-11-11 21:46:40 +01:00
|
|
|
{
|
|
|
|
struct sockaddr_un un;
|
2009-09-10 10:58:38 +02:00
|
|
|
int sock, fd;
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2009-12-02 12:24:42 +01:00
|
|
|
sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
|
2008-11-11 21:46:40 +01:00
|
|
|
if (sock < 0) {
|
2015-01-26 12:12:24 +01:00
|
|
|
error_setg_errno(errp, errno, "Failed to create Unix socket");
|
2009-05-06 11:57:03 +02:00
|
|
|
return -1;
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(&un, 0, sizeof(un));
|
|
|
|
un.sun_family = AF_UNIX;
|
2016-01-11 14:17:02 +01:00
|
|
|
if (saddr->path && strlen(saddr->path)) {
|
|
|
|
snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
|
2008-11-11 21:46:40 +01:00
|
|
|
} else {
|
2015-01-26 12:12:24 +01: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 21:46:40 +01: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 12:12:24 +01: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);
|
2016-01-11 14:17:02 +01:00
|
|
|
if (update_addr) {
|
|
|
|
g_free(saddr->path);
|
|
|
|
saddr->path = g_strdup(un.sun_path);
|
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
|
2015-11-04 14:48:47 +01:00
|
|
|
if (unlink(un.sun_path) < 0 && errno != ENOENT) {
|
2015-05-05 17:07:19 +02:00
|
|
|
error_setg_errno(errp, errno,
|
|
|
|
"Failed to unlink socket %s", un.sun_path);
|
|
|
|
goto err;
|
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
|
2015-01-26 12:12:24 +01:00
|
|
|
error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path);
|
2008-11-11 21:46:40 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (listen(sock, 1) < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to listen on socket");
|
2008-11-11 21:46:40 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sock;
|
|
|
|
|
|
|
|
err:
|
|
|
|
closesocket(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
2008-11-11 21:46:40 +01:00
|
|
|
{
|
|
|
|
struct sockaddr_un un;
|
2012-10-03 13:37:46 +02:00
|
|
|
ConnectState *connect_state = NULL;
|
|
|
|
int sock, rc;
|
2008-11-11 21:46:40 +01:00
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
if (saddr->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-08 21:22:16 +01:00
|
|
|
error_setg(errp, "unix connect: no path specified");
|
2009-09-10 10:58:37 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-12-02 12:24:42 +01:00
|
|
|
sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
|
2008-11-11 21:46:40 +01:00
|
|
|
if (sock < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, errno, "Failed to create socket");
|
2009-05-06 11:57:03 +02:00
|
|
|
return -1;
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
2012-10-03 13:37:46 +02:00
|
|
|
if (callback != NULL) {
|
|
|
|
connect_state = g_malloc0(sizeof(*connect_state));
|
|
|
|
connect_state->callback = callback;
|
|
|
|
connect_state->opaque = opaque;
|
2013-03-27 10:10:43 +01:00
|
|
|
qemu_set_nonblock(sock);
|
2012-10-03 13:37:46 +02:00
|
|
|
}
|
2008-11-11 21:46:40 +01:00
|
|
|
|
|
|
|
memset(&un, 0, sizeof(un));
|
|
|
|
un.sun_family = AF_UNIX;
|
2016-01-11 14:17:03 +01:00
|
|
|
snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
|
2012-10-03 13:37:46 +02:00
|
|
|
|
|
|
|
/* connect to peer */
|
|
|
|
do {
|
|
|
|
rc = 0;
|
|
|
|
if (connect(sock, (struct sockaddr *) &un, sizeof(un)) < 0) {
|
2016-03-07 21:36:03 +01:00
|
|
|
rc = -errno;
|
2012-10-03 13:37:46 +02:00
|
|
|
}
|
|
|
|
} 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 08:45:18 +02:00
|
|
|
qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
|
2012-10-03 13:37:46 +02:00
|
|
|
return sock;
|
|
|
|
} else if (rc >= 0) {
|
|
|
|
/* non blocking socket immediate success, call callback */
|
|
|
|
if (callback != NULL) {
|
2014-10-08 14:11:56 +02:00
|
|
|
callback(sock, NULL, opaque);
|
2012-10-03 13:37:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc < 0) {
|
2014-09-25 08:49:31 +02:00
|
|
|
error_setg_errno(errp, -rc, "Failed to connect socket");
|
2011-11-11 10:40:07 +01:00
|
|
|
close(sock);
|
2012-10-03 13:37:46 +02:00
|
|
|
sock = -1;
|
2008-11-11 21:46:40 +01:00
|
|
|
}
|
|
|
|
|
2012-10-03 13:37:46 +02:00
|
|
|
g_free(connect_state);
|
2008-11-11 21:46:40 +01:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-10-18 08:44:00 +02:00
|
|
|
#else
|
|
|
|
|
2016-01-11 14:17:02 +01:00
|
|
|
static int unix_listen_saddr(UnixSocketAddress *saddr,
|
|
|
|
bool update_addr,
|
|
|
|
Error **errp)
|
2012-10-18 08:44:00 +02:00
|
|
|
{
|
2012-09-19 13:54:39 +02:00
|
|
|
error_setg(errp, "unix sockets are not available on windows");
|
2012-10-18 08:44:00 +02:00
|
|
|
errno = ENOTSUP;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
2012-10-18 08:44:00 +02:00
|
|
|
{
|
2012-09-19 13:54:39 +02:00
|
|
|
error_setg(errp, "unix sockets are not available on windows");
|
2012-10-18 08:44:00 +02:00
|
|
|
errno = ENOTSUP;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-09-10 10:58:37 +02:00
|
|
|
/* compatibility wrapper */
|
2012-10-02 09:35:32 +02:00
|
|
|
int unix_listen(const char *str, char *ostr, int olen, Error **errp)
|
2009-09-10 10:58:38 +02:00
|
|
|
{
|
|
|
|
char *path, *optstr;
|
|
|
|
int sock, len;
|
2016-01-11 14:17:02 +01:00
|
|
|
UnixSocketAddress *saddr;
|
2009-09-10 10:58:38 +02:00
|
|
|
|
2016-01-11 14:17:02 +01:00
|
|
|
saddr = g_new0(UnixSocketAddress, 1);
|
2009-09-10 10:58:38 +02:00
|
|
|
|
|
|
|
optstr = strchr(str, ',');
|
|
|
|
if (optstr) {
|
|
|
|
len = optstr - str;
|
|
|
|
if (len) {
|
2011-08-21 05:09:37 +02:00
|
|
|
path = g_malloc(len+1);
|
2009-09-10 10:58:38 +02:00
|
|
|
snprintf(path, len+1, "%.*s", len, str);
|
2016-01-11 14:17:02 +01:00
|
|
|
saddr->path = path;
|
2009-09-10 10:58:38 +02:00
|
|
|
}
|
|
|
|
} else {
|
2016-01-11 14:17:02 +01:00
|
|
|
saddr->path = g_strdup(str);
|
2009-09-10 10:58:38 +02:00
|
|
|
}
|
|
|
|
|
2016-01-11 14:17:02 +01:00
|
|
|
sock = unix_listen_saddr(saddr, true, errp);
|
2009-09-10 10:58:38 +02:00
|
|
|
|
|
|
|
if (sock != -1 && ostr)
|
2016-01-11 14:17:02 +01:00
|
|
|
snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : "");
|
|
|
|
qapi_free_UnixSocketAddress(saddr);
|
2009-09-10 10:58:38 +02:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-10-02 09:35:32 +02:00
|
|
|
int unix_connect(const char *path, Error **errp)
|
2009-09-10 10:58:37 +02:00
|
|
|
{
|
2016-01-11 14:17:03 +01:00
|
|
|
UnixSocketAddress *saddr;
|
2009-09-10 10:58:37 +02:00
|
|
|
int sock;
|
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
saddr = g_new0(UnixSocketAddress, 1);
|
|
|
|
saddr->path = g_strdup(path);
|
|
|
|
sock = unix_connect_saddr(saddr, errp, NULL, NULL);
|
|
|
|
qapi_free_UnixSocketAddress(saddr);
|
2012-10-03 13:37:46 +02:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int unix_nonblocking_connect(const char *path,
|
|
|
|
NonBlockingConnectHandler *callback,
|
|
|
|
void *opaque, Error **errp)
|
|
|
|
{
|
2016-01-11 14:17:03 +01:00
|
|
|
UnixSocketAddress *saddr;
|
2012-10-03 13:37:46 +02:00
|
|
|
int sock = -1;
|
|
|
|
|
|
|
|
g_assert(callback != NULL);
|
|
|
|
|
2016-01-11 14:17:03 +01:00
|
|
|
saddr = g_new0(UnixSocketAddress, 1);
|
|
|
|
saddr->path = g_strdup(path);
|
|
|
|
sock = unix_connect_saddr(saddr, errp, callback, opaque);
|
|
|
|
qapi_free_UnixSocketAddress(saddr);
|
2009-09-10 10:58:37 +02:00
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2012-10-23 21:31:53 +02:00
|
|
|
SocketAddress *socket_parse(const char *str, Error **errp)
|
|
|
|
{
|
2013-06-24 08:39:44 +02:00
|
|
|
SocketAddress *addr;
|
2012-10-23 21:31:53 +02:00
|
|
|
|
2013-06-24 08:39:44 +02:00
|
|
|
addr = g_new0(SocketAddress, 1);
|
2012-10-23 21:31:53 +02: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-08 21:22:16 +01:00
|
|
|
error_setg(errp, "invalid Unix socket address");
|
2012-10-23 21:31:53 +02:00
|
|
|
goto fail;
|
|
|
|
} else {
|
2015-10-26 23:34:55 +01:00
|
|
|
addr->type = SOCKET_ADDRESS_KIND_UNIX;
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
addr->u.q_unix.data = g_new(UnixSocketAddress, 1);
|
|
|
|
addr->u.q_unix.data->path = g_strdup(str + 5);
|
2012-10-23 21:31:53 +02:00
|
|
|
}
|
|
|
|
} 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-08 21:22:16 +01:00
|
|
|
error_setg(errp, "invalid file descriptor address");
|
2012-10-23 21:31:53 +02:00
|
|
|
goto fail;
|
|
|
|
} else {
|
2015-10-26 23:34:55 +01:00
|
|
|
addr->type = SOCKET_ADDRESS_KIND_FD;
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
addr->u.fd.data = g_new(String, 1);
|
|
|
|
addr->u.fd.data->str = g_strdup(str + 3);
|
2012-10-23 21:31:53 +02:00
|
|
|
}
|
|
|
|
} else {
|
2015-10-26 23:34:55 +01:00
|
|
|
addr->type = SOCKET_ADDRESS_KIND_INET;
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
addr->u.inet.data = inet_parse(str, errp);
|
|
|
|
if (addr->u.inet.data == NULL) {
|
2012-10-23 21:31:53 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
qapi_free_SocketAddress(addr);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int socket_connect(SocketAddress *addr, Error **errp,
|
|
|
|
NonBlockingConnectHandler *callback, void *opaque)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
2015-10-26 23:34:55 +01:00
|
|
|
switch (addr->type) {
|
2012-10-23 21:31:53 +02:00
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = inet_connect_saddr(addr->u.inet.data, errp, callback, opaque);
|
2012-10-23 21:31:53 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_UNIX:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = unix_connect_saddr(addr->u.q_unix.data, errp, callback, opaque);
|
2012-10-23 21:31:53 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_FD:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
|
2013-06-24 08:39:46 +02:00
|
|
|
if (fd >= 0 && callback) {
|
2013-03-27 10:10:45 +01:00
|
|
|
qemu_set_nonblock(fd);
|
2014-10-08 14:11:56 +02:00
|
|
|
callback(fd, NULL, opaque);
|
2012-10-23 21:31:53 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
int socket_listen(SocketAddress *addr, Error **errp)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
2015-10-26 23:34:55 +01:00
|
|
|
switch (addr->type) {
|
2012-10-23 21:31:53 +02:00
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp);
|
2012-10-23 21:31:53 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_UNIX:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = unix_listen_saddr(addr->u.q_unix.data, false, errp);
|
2012-10-23 21:31:53 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_FD:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
|
2012-10-23 21:31:53 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2016-06-16 21:28:52 +02:00
|
|
|
void socket_listen_cleanup(int fd, Error **errp)
|
|
|
|
{
|
|
|
|
SocketAddress *addr;
|
|
|
|
|
|
|
|
addr = socket_local_address(fd, errp);
|
|
|
|
|
|
|
|
if (addr->type == SOCKET_ADDRESS_KIND_UNIX
|
|
|
|
&& addr->u.q_unix.data->path) {
|
|
|
|
if (unlink(addr->u.q_unix.data->path) < 0 && errno != ENOENT) {
|
|
|
|
error_setg_errno(errp, errno,
|
|
|
|
"Failed to unlink socket %s",
|
|
|
|
addr->u.q_unix.data->path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(addr);
|
|
|
|
}
|
|
|
|
|
2013-02-27 14:10:47 +01:00
|
|
|
int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
2015-10-26 23:34:55 +01:00
|
|
|
switch (remote->type) {
|
2013-02-27 14:10:47 +01:00
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
fd = inet_dgram_saddr(remote->u.inet.data,
|
|
|
|
local ? local->u.inet.data : NULL, errp);
|
2013-02-27 14:10:47 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error_setg(errp, "socket type unsupported for datagram");
|
2013-06-24 08:39:56 +02:00
|
|
|
fd = -1;
|
2013-02-27 14:10:47 +01:00
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
2015-05-01 18:36:20 +02:00
|
|
|
|
|
|
|
|
|
|
|
static SocketAddress *
|
|
|
|
socket_sockaddr_to_address_inet(struct sockaddr_storage *sa,
|
|
|
|
socklen_t salen,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
char host[NI_MAXHOST];
|
|
|
|
char serv[NI_MAXSERV];
|
|
|
|
SocketAddress *addr;
|
2016-03-03 17:16:48 +01:00
|
|
|
InetSocketAddress *inet;
|
2015-05-01 18:36:20 +02:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = getnameinfo((struct sockaddr *)sa, salen,
|
|
|
|
host, sizeof(host),
|
|
|
|
serv, sizeof(serv),
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
|
|
|
if (ret != 0) {
|
|
|
|
error_setg(errp, "Cannot format numeric socket address: %s",
|
|
|
|
gai_strerror(ret));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr = g_new0(SocketAddress, 1);
|
2015-10-26 23:34:55 +01:00
|
|
|
addr->type = SOCKET_ADDRESS_KIND_INET;
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
inet = addr->u.inet.data = g_new0(InetSocketAddress, 1);
|
2016-03-03 17:16:48 +01:00
|
|
|
inet->host = g_strdup(host);
|
|
|
|
inet->port = g_strdup(serv);
|
2015-05-01 18:36:20 +02:00
|
|
|
if (sa->ss_family == AF_INET) {
|
2016-03-03 17:16:48 +01:00
|
|
|
inet->has_ipv4 = inet->ipv4 = true;
|
2015-05-01 18:36:20 +02:00
|
|
|
} else {
|
2016-03-03 17:16:48 +01:00
|
|
|
inet->has_ipv6 = inet->ipv6 = true;
|
2015-05-01 18:36:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef WIN32
|
|
|
|
static SocketAddress *
|
|
|
|
socket_sockaddr_to_address_unix(struct sockaddr_storage *sa,
|
|
|
|
socklen_t salen,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
SocketAddress *addr;
|
|
|
|
struct sockaddr_un *su = (struct sockaddr_un *)sa;
|
|
|
|
|
|
|
|
addr = g_new0(SocketAddress, 1);
|
2015-10-26 23:34:55 +01:00
|
|
|
addr->type = SOCKET_ADDRESS_KIND_UNIX;
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
|
2015-05-01 18:36:20 +02:00
|
|
|
if (su->sun_path[0]) {
|
qapi: Don't special-case simple union wrappers
Simple unions were carrying a special case that hid their 'data'
QMP member from the resulting C struct, via the hack method
QAPISchemaObjectTypeVariant.simple_union_type(). But by using
the work we started by unboxing flat union and alternate
branches, coupled with the ability to visit the members of an
implicit type, we can now expose the simple union's implicit
type in qapi-types.h:
| struct q_obj_ImageInfoSpecificQCow2_wrapper {
| ImageInfoSpecificQCow2 *data;
| };
|
| struct q_obj_ImageInfoSpecificVmdk_wrapper {
| ImageInfoSpecificVmdk *data;
| };
...
| struct ImageInfoSpecific {
| ImageInfoSpecificKind type;
| union { /* union tag is @type */
| void *data;
|- ImageInfoSpecificQCow2 *qcow2;
|- ImageInfoSpecificVmdk *vmdk;
|+ q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
|+ q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
| } u;
| };
Doing this removes asymmetry between QAPI's QMP side and its
C side (both sides now expose 'data'), and means that the
treatment of a simple union as sugar for a flat union is now
equivalent in both languages (previously the two approaches used
a different layer of dereferencing, where the simple union could
be converted to a flat union with equivalent C layout but
different {} on the wire, or to an equivalent QMP wire form
but with different C representation). Using the implicit type
also lets us get rid of the simple_union_type() hack.
Of course, now all clients of simple unions have to adjust from
using su->u.member to using su->u.member.data; while this touches
a number of files in the tree, some earlier cleanup patches
helped minimize the change to the initialization of a temporary
variable rather than every single member access. The generated
qapi-visit.c code is also affected by the layout change:
|@@ -7393,10 +7393,10 @@ void visit_type_ImageInfoSpecific_member
| }
| switch (obj->type) {
| case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
|- visit_type_ImageInfoSpecificQCow2(v, "data", &obj->u.qcow2, &err);
|+ visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
| break;
| case IMAGE_INFO_SPECIFIC_KIND_VMDK:
|- visit_type_ImageInfoSpecificVmdk(v, "data", &obj->u.vmdk, &err);
|+ visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
| break;
| default:
| abort();
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-13-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-03-17 23:48:37 +01:00
|
|
|
addr->u.q_unix.data->path = g_strndup(su->sun_path,
|
|
|
|
sizeof(su->sun_path));
|
2015-05-01 18:36:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
#endif /* WIN32 */
|
|
|
|
|
2015-02-27 17:19:33 +01:00
|
|
|
SocketAddress *
|
2015-05-01 18:36:20 +02:00
|
|
|
socket_sockaddr_to_address(struct sockaddr_storage *sa,
|
|
|
|
socklen_t salen,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
switch (sa->ss_family) {
|
|
|
|
case AF_INET:
|
|
|
|
case AF_INET6:
|
|
|
|
return socket_sockaddr_to_address_inet(sa, salen, errp);
|
|
|
|
|
|
|
|
#ifndef WIN32
|
|
|
|
case AF_UNIX:
|
|
|
|
return socket_sockaddr_to_address_unix(sa, salen, errp);
|
|
|
|
#endif /* WIN32 */
|
|
|
|
|
|
|
|
default:
|
|
|
|
error_setg(errp, "socket family %d unsupported",
|
|
|
|
sa->ss_family);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
SocketAddress *socket_local_address(int fd, Error **errp)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage ss;
|
|
|
|
socklen_t sslen = sizeof(ss);
|
|
|
|
|
|
|
|
if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) {
|
2016-03-07 21:36:03 +01:00
|
|
|
error_setg_errno(errp, errno, "%s",
|
2015-05-01 18:36:20 +02:00
|
|
|
"Unable to query local socket address");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return socket_sockaddr_to_address(&ss, sslen, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
SocketAddress *socket_remote_address(int fd, Error **errp)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage ss;
|
|
|
|
socklen_t sslen = sizeof(ss);
|
|
|
|
|
|
|
|
if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) {
|
2016-03-07 21:36:03 +01:00
|
|
|
error_setg_errno(errp, errno, "%s",
|
2015-05-01 18:36:20 +02:00
|
|
|
"Unable to query remote socket address");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return socket_sockaddr_to_address(&ss, sslen, errp);
|
|
|
|
}
|
2015-08-14 19:18:41 +02:00
|
|
|
|
|
|
|
|
|
|
|
void qapi_copy_SocketAddress(SocketAddress **p_dest,
|
|
|
|
SocketAddress *src)
|
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov;
|
|
|
|
Visitor *ov, *iv;
|
|
|
|
QObject *obj;
|
|
|
|
|
|
|
|
*p_dest = NULL;
|
|
|
|
|
|
|
|
qov = qmp_output_visitor_new();
|
|
|
|
ov = qmp_output_get_visitor(qov);
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_SocketAddress(ov, NULL, &src, &error_abort);
|
2015-08-14 19:18:41 +02:00
|
|
|
obj = qmp_output_get_qobject(qov);
|
|
|
|
qmp_output_visitor_cleanup(qov);
|
|
|
|
if (!obj) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
qmp-input-visitor: Favor new visit_free() function
Now that we have a polymorphic visit_free(), we no longer need
qmp_input_visitor_cleanup(); which in turn means we no longer
need to return a subtype from qmp_input_visitor_new() nor a
public upcast function.
Generated code changes to qmp-marshal.c look like:
|@@ -52,11 +52,10 @@ void qmp_marshal_add_fd(QDict *args, QOb
| {
| Error *err = NULL;
| AddfdInfo *retval;
|- QmpInputVisitor *qiv = qmp_input_visitor_new(QOBJECT(args), true);
| Visitor *v;
| q_obj_add_fd_arg arg = {0};
|
|- v = qmp_input_get_visitor(qiv);
|+ v = qmp_input_visitor_new(QOBJECT(args), true);
| visit_start_struct(v, NULL, NULL, 0, &err);
| if (err) {
| goto out;
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-8-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:38 +02:00
|
|
|
iv = qmp_input_visitor_new(obj, true);
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_SocketAddress(iv, NULL, p_dest, &error_abort);
|
qmp-input-visitor: Favor new visit_free() function
Now that we have a polymorphic visit_free(), we no longer need
qmp_input_visitor_cleanup(); which in turn means we no longer
need to return a subtype from qmp_input_visitor_new() nor a
public upcast function.
Generated code changes to qmp-marshal.c look like:
|@@ -52,11 +52,10 @@ void qmp_marshal_add_fd(QDict *args, QOb
| {
| Error *err = NULL;
| AddfdInfo *retval;
|- QmpInputVisitor *qiv = qmp_input_visitor_new(QOBJECT(args), true);
| Visitor *v;
| q_obj_add_fd_arg arg = {0};
|
|- v = qmp_input_get_visitor(qiv);
|+ v = qmp_input_visitor_new(QOBJECT(args), true);
| visit_start_struct(v, NULL, NULL, 0, &err);
| if (err) {
| goto out;
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-8-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:38 +02:00
|
|
|
visit_free(iv);
|
2015-08-14 19:18:41 +02:00
|
|
|
qobject_decref(obj);
|
|
|
|
}
|
2016-06-18 09:54:02 +02:00
|
|
|
|
|
|
|
char *socket_address_to_string(struct SocketAddress *addr, Error **errp)
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
InetSocketAddress *inet;
|
|
|
|
char host_port[INET6_ADDRSTRLEN + 5 + 4];
|
|
|
|
|
|
|
|
switch (addr->type) {
|
|
|
|
case SOCKET_ADDRESS_KIND_INET:
|
|
|
|
inet = addr->u.inet.data;
|
|
|
|
if (strchr(inet->host, ':') == NULL) {
|
|
|
|
snprintf(host_port, sizeof(host_port), "%s:%s", inet->host,
|
|
|
|
inet->port);
|
|
|
|
buf = g_strdup(host_port);
|
|
|
|
} else {
|
|
|
|
snprintf(host_port, sizeof(host_port), "[%s]:%s", inet->host,
|
|
|
|
inet->port);
|
|
|
|
buf = g_strdup(host_port);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_UNIX:
|
|
|
|
buf = g_strdup(addr->u.q_unix.data->path);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_ADDRESS_KIND_FD:
|
|
|
|
buf = g_strdup(addr->u.fd.data->str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error_setg(errp, "socket family %d unsupported",
|
|
|
|
addr->type);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
}
|