#include <linux/vm_sockets.h>
#endif /* CONFIG_AF_VSOCK */
+#include "qemu-common.h"
#include "monitor/monitor.h"
+#include "qapi/clone-visitor.h"
#include "qapi/error.h"
+#include "qapi/qapi-visit-sockets.h"
#include "qemu/sockets.h"
#include "qemu/main-loop.h"
-#include "qapi/clone-visitor.h"
#include "qapi/qobject-input-visitor.h"
#include "qapi/qobject-output-visitor.h"
-#include "qapi-visit.h"
#include "qemu/cutils.h"
+#include "trace.h"
#ifndef AI_ADDRCONFIG
# define AI_ADDRCONFIG 0
return NETWORK_ADDRESS_FAMILY_UNKNOWN;
}
+bool fd_is_socket(int fd)
+{
+ int optval;
+ socklen_t optlen = sizeof(optval);
+ return !qemu_getsockopt(fd, SOL_SOCKET, SO_TYPE, &optval, &optlen);
+}
+
+
/*
* Matrix we're trying to apply
*
* f t PF_INET6
* t - PF_INET
* t f PF_INET
- * t t PF_INET6
+ * t t PF_INET6/PF_UNSPEC
*
* NB, this matrix is only about getting the necessary results
* 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.
+ * apply the logic the end user wants.
+ *
+ * In the first and last cases, we must set IPV6_V6ONLY=0
+ * when binding, to allow a single listener to potentially
+ * accept both IPv4+6 addresses.
*/
int inet_ai_family_from_address(InetSocketAddress *addr,
Error **errp)
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)) {
+ /*
+ * Some backends can only do a single listener. In that case
+ * we want empty hostname to resolve to "::" and then use the
+ * flag IPV6_V6ONLY==0 to get both protocols on 1 socket. This
+ * doesn't work for addresses other than "", so they're just
+ * inevitably broken until multiple listeners can be used,
+ * and thus we honour getaddrinfo automatic protocol detection
+ * Once all backends do multi-listener, remove the PF_INET6
+ * branch entirely.
+ */
+ if (!addr->host || g_str_equal(addr->host, "")) {
+ return PF_INET6;
+ } else {
+ return PF_UNSPEC;
+ }
+ }
if ((addr->has_ipv6 && addr->ipv6) || (addr->has_ipv4 && !addr->ipv4)) {
return PF_INET6;
}
return PF_UNSPEC;
}
+static int create_fast_reuse_socket(struct addrinfo *e)
+{
+ int slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
+ if (slisten < 0) {
+ return -1;
+ }
+ socket_set_fast_reuse(slisten);
+ return slisten;
+}
+
+static int try_bind(int socket, InetSocketAddress *saddr, struct addrinfo *e)
+{
+#ifndef IPV6_V6ONLY
+ return bind(socket, e->ai_addr, e->ai_addrlen);
+#else
+ /*
+ * Deals with first & last cases in matrix in comment
+ * for inet_ai_family_from_address().
+ */
+ int v6only =
+ ((!saddr->has_ipv4 && !saddr->has_ipv6) ||
+ (saddr->has_ipv4 && saddr->ipv4 &&
+ saddr->has_ipv6 && saddr->ipv6)) ? 0 : 1;
+ int stat;
+
+ rebind:
+ if (e->ai_family == PF_INET6) {
+ qemu_setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, &v6only,
+ sizeof(v6only));
+ }
+
+ stat = bind(socket, e->ai_addr, e->ai_addrlen);
+ if (!stat) {
+ return 0;
+ }
+
+ /* If we got EADDRINUSE from an IPv6 bind & v6only is unset,
+ * it could be that the IPv4 port is already claimed, so retry
+ * with v6only set
+ */
+ if (e->ai_family == PF_INET6 && errno == EADDRINUSE && !v6only) {
+ v6only = 1;
+ goto rebind;
+ }
+ return stat;
+#endif
+}
+
static int inet_listen_saddr(InetSocketAddress *saddr,
int port_offset,
- bool update_addr,
+ int num,
Error **errp)
{
struct addrinfo ai,*res,*e;
char port[33];
char uaddr[INET6_ADDRSTRLEN+1];
char uport[33];
- int slisten, rc, port_min, port_max, p;
+ int rc, port_min, port_max, p;
+ int slisten = -1;
+ int saved_errno = 0;
+ bool socket_created = false;
Error *err = NULL;
+ if (saddr->keep_alive) {
+ error_setg(errp, "keep-alive option is not supported for passive "
+ "sockets");
+ return -1;
+ }
+
memset(&ai,0, sizeof(ai));
ai.ai_flags = AI_PASSIVE;
if (saddr->has_numeric && saddr->numeric) {
return -1;
}
- /* create socket + bind */
+ /* create socket + bind/listen */
for (e = res; e != NULL; e = e->ai_next) {
getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
- uaddr,INET6_ADDRSTRLEN,uport,32,
- NI_NUMERICHOST | NI_NUMERICSERV);
- slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
- if (slisten < 0) {
- if (!e->ai_next) {
- error_setg_errno(errp, errno, "Failed to create socket");
- }
- continue;
- }
-
- socket_set_fast_reuse(slisten);
-#ifdef IPV6_V6ONLY
- if (e->ai_family == PF_INET6) {
- /* listen on both ipv4 and ipv6 */
- const int off = 0;
- qemu_setsockopt(slisten, IPPROTO_IPV6, IPV6_V6ONLY, &off,
- sizeof(off));
- }
-#endif
+ uaddr,INET6_ADDRSTRLEN,uport,32,
+ NI_NUMERICHOST | NI_NUMERICSERV);
port_min = inet_getport(e);
port_max = saddr->has_to ? saddr->to + port_offset : port_min;
for (p = port_min; p <= port_max; p++) {
inet_setport(e, p);
- if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
- goto listen;
+
+ slisten = create_fast_reuse_socket(e);
+ if (slisten < 0) {
+ /* First time we expect we might fail to create the socket
+ * eg if 'e' has AF_INET6 but ipv6 kmod is not loaded.
+ * Later iterations should always succeed if first iteration
+ * worked though, so treat that as fatal.
+ */
+ if (p == port_min) {
+ continue;
+ } else {
+ error_setg_errno(errp, errno,
+ "Failed to recreate failed listening socket");
+ goto listen_failed;
+ }
}
- if (p == port_max) {
- if (!e->ai_next) {
+ socket_created = true;
+
+ rc = try_bind(slisten, saddr, e);
+ if (rc < 0) {
+ if (errno != EADDRINUSE) {
error_setg_errno(errp, errno, "Failed to bind socket");
+ goto listen_failed;
+ }
+ } else {
+ if (!listen(slisten, num)) {
+ goto listen_ok;
+ }
+ if (errno != EADDRINUSE) {
+ error_setg_errno(errp, errno, "Failed to listen on socket");
+ goto listen_failed;
}
}
+ /* Someone else managed to bind to the same port and beat us
+ * to listen on it! Socket semantics does not allow us to
+ * recover from this situation, so we need to recreate the
+ * socket to allow bind attempts for subsequent ports:
+ */
+ closesocket(slisten);
+ slisten = -1;
}
+ }
+ error_setg_errno(errp, errno,
+ socket_created ?
+ "Failed to find an available port" :
+ "Failed to create a socket");
+listen_failed:
+ saved_errno = errno;
+ if (slisten >= 0) {
closesocket(slisten);
}
freeaddrinfo(res);
+ errno = saved_errno;
return -1;
-listen:
- if (listen(slisten,1) != 0) {
- error_setg_errno(errp, errno, "Failed to listen on socket");
- closesocket(slisten);
- freeaddrinfo(res);
- return -1;
- }
- 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;
- }
+listen_ok:
freeaddrinfo(res);
return slisten;
}
((rc) == -EINPROGRESS)
#endif
-/* 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,
- ConnectState *connect_state, Error **errp);
+static int inet_connect_addr(struct addrinfo *addr, Error **errp);
-static void wait_for_connect(void *opaque)
-{
- ConnectState *s = opaque;
- int val = 0, rc = 0;
- socklen_t valsize = sizeof(val);
- bool in_progress;
- Error *err = NULL;
-
- qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
-
- do {
- rc = qemu_getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &val, &valsize);
- } while (rc == -1 && errno == EINTR);
-
- /* update rc to contain error */
- if (!rc && val) {
- rc = -1;
- errno = val;
- }
-
- /* connect error */
- if (rc < 0) {
- error_setg_errno(&err, errno, "Error connecting to socket");
- closesocket(s->fd);
- s->fd = rc;
- }
-
- /* try to connect to the next address on the list */
- if (s->current_addr) {
- while (s->current_addr->ai_next != NULL && s->fd < 0) {
- s->current_addr = s->current_addr->ai_next;
- s->fd = inet_connect_addr(s->current_addr, &in_progress, s, NULL);
- if (s->fd < 0) {
- error_free(err);
- err = NULL;
- error_setg_errno(&err, errno, "Unable to start socket connect");
- }
- /* connect in progress */
- if (in_progress) {
- goto out;
- }
- }
-
- freeaddrinfo(s->addr_list);
- }
-
- if (s->callback) {
- s->callback(s->fd, err, s->opaque);
- }
- g_free(s);
-out:
- error_free(err);
-}
-
-static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,
- ConnectState *connect_state, Error **errp)
+static int inet_connect_addr(struct addrinfo *addr, Error **errp)
{
int sock, rc;
- *in_progress = false;
-
sock = qemu_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
if (sock < 0) {
error_setg_errno(errp, errno, "Failed to create socket");
return -1;
}
socket_set_fast_reuse(sock);
- if (connect_state != NULL) {
- qemu_set_nonblock(sock);
- }
+
/* connect to peer */
do {
rc = 0;
}
} while (rc == -EINTR);
- if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
- connect_state->fd = sock;
- qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
- *in_progress = true;
- } else if (rc < 0) {
+ if (rc < 0) {
error_setg_errno(errp, errno, "Failed to connect socket");
closesocket(sock);
return -1;
}
+
return sock;
}
*
* @saddr: Inet socket address specification
* @errp: set on error
- * @callback: callback function for non-blocking connect
- * @opaque: opaque for callback function
*
* Returns: -1 on error, file descriptor on success.
- *
- * 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.
*/
-int inet_connect_saddr(InetSocketAddress *saddr,
- NonBlockingConnectHandler *callback, void *opaque,
- Error **errp)
+int inet_connect_saddr(InetSocketAddress *saddr, Error **errp)
{
Error *local_err = NULL;
struct addrinfo *res, *e;
int sock = -1;
- bool in_progress;
- ConnectState *connect_state = NULL;
res = inet_parse_connect_saddr(saddr, errp);
if (!res) {
return -1;
}
- if (callback != NULL) {
- connect_state = g_malloc0(sizeof(*connect_state));
- connect_state->addr_list = res;
- connect_state->callback = callback;
- connect_state->opaque = opaque;
- }
-
for (e = res; e != NULL; e = e->ai_next) {
error_free(local_err);
local_err = NULL;
- if (connect_state != NULL) {
- connect_state->current_addr = e;
- }
- sock = inet_connect_addr(e, &in_progress, connect_state, &local_err);
+ sock = inet_connect_addr(e, &local_err);
if (sock >= 0) {
break;
}
}
+ freeaddrinfo(res);
+
if (sock < 0) {
error_propagate(errp, local_err);
- } else if (in_progress) {
- /* wait_for_connect() will do the rest */
return sock;
- } else {
- if (callback) {
- callback(sock, NULL, opaque);
+ }
+
+ if (saddr->keep_alive) {
+ int val = 1;
+ int ret = qemu_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
+ &val, sizeof(val));
+
+ if (ret < 0) {
+ error_setg_errno(errp, errno, "Unable to set KEEPALIVE");
+ close(sock);
+ return -1;
}
}
- g_free(connect_state);
- freeaddrinfo(res);
+
return sock;
}
}
/* compatibility wrapper */
-InetSocketAddress *inet_parse(const char *str, Error **errp)
+static int inet_parse_flag(const char *flagname, const char *optstr, bool *val,
+ Error **errp)
+{
+ char *end;
+ size_t len;
+
+ end = strstr(optstr, ",");
+ if (end) {
+ if (end[1] == ',') { /* Reject 'ipv6=on,,foo' */
+ error_setg(errp, "error parsing '%s' flag '%s'", flagname, optstr);
+ return -1;
+ }
+ len = end - optstr;
+ } else {
+ len = strlen(optstr);
+ }
+ if (len == 0 || (len == 3 && strncmp(optstr, "=on", len) == 0)) {
+ *val = true;
+ } else if (len == 4 && strncmp(optstr, "=off", len) == 0) {
+ *val = false;
+ } else {
+ error_setg(errp, "error parsing '%s' flag '%s'", flagname, optstr);
+ return -1;
+ }
+ return 0;
+}
+
+int inet_parse(InetSocketAddress *addr, const char *str, Error **errp)
{
- InetSocketAddress *addr;
const char *optstr, *h;
char host[65];
char port[33];
int to;
int pos;
+ char *begin;
- addr = g_new0(InetSocketAddress, 1);
+ memset(addr, 0, sizeof(*addr));
/* parse address */
if (str[0] == ':') {
host[0] = '\0';
if (sscanf(str, ":%32[^,]%n", port, &pos) != 1) {
error_setg(errp, "error parsing port in address '%s'", str);
- goto fail;
+ return -1;
}
} else if (str[0] == '[') {
/* IPv6 addr */
if (sscanf(str, "[%64[^]]]:%32[^,]%n", host, port, &pos) != 2) {
error_setg(errp, "error parsing IPv6 address '%s'", str);
- goto fail;
+ return -1;
}
- addr->ipv6 = addr->has_ipv6 = true;
} else {
/* hostname or IPv4 addr */
if (sscanf(str, "%64[^:]:%32[^,]%n", host, port, &pos) != 2) {
error_setg(errp, "error parsing address '%s'", str);
- goto fail;
- }
- if (host[strspn(host, "0123456789.")] == '\0') {
- addr->ipv4 = addr->has_ipv4 = true;
+ return -1;
}
}
if (sscanf(h, "%d%n", &to, &pos) != 1 ||
(h[pos] != '\0' && h[pos] != ',')) {
error_setg(errp, "error parsing to= argument");
- goto fail;
+ return -1;
}
addr->has_to = true;
addr->to = to;
}
- if (strstr(optstr, ",ipv4")) {
- addr->ipv4 = addr->has_ipv4 = true;
+ begin = strstr(optstr, ",ipv4");
+ if (begin) {
+ if (inet_parse_flag("ipv4", begin + 5, &addr->ipv4, errp) < 0) {
+ return -1;
+ }
+ addr->has_ipv4 = true;
}
- if (strstr(optstr, ",ipv6")) {
- addr->ipv6 = addr->has_ipv6 = true;
+ begin = strstr(optstr, ",ipv6");
+ if (begin) {
+ if (inet_parse_flag("ipv6", begin + 5, &addr->ipv6, errp) < 0) {
+ return -1;
+ }
+ addr->has_ipv6 = true;
}
- return addr;
-
-fail:
- qapi_free_InetSocketAddress(addr);
- return NULL;
+ begin = strstr(optstr, ",keep-alive");
+ if (begin) {
+ if (inet_parse_flag("keep-alive", begin + strlen(",keep-alive"),
+ &addr->keep_alive, errp) < 0)
+ {
+ return -1;
+ }
+ addr->has_keep_alive = true;
+ }
+ return 0;
}
int inet_connect(const char *str, Error **errp)
{
int sock = -1;
- InetSocketAddress *addr;
+ InetSocketAddress *addr = g_new(InetSocketAddress, 1);
- addr = inet_parse(str, errp);
- if (addr != NULL) {
- sock = inet_connect_saddr(addr, NULL, NULL, errp);
- qapi_free_InetSocketAddress(addr);
+ if (!inet_parse(addr, str, errp)) {
+ sock = inet_connect_saddr(addr, errp);
}
+ qapi_free_InetSocketAddress(addr);
return sock;
}
return true;
}
-static int vsock_connect_addr(const struct sockaddr_vm *svm, bool *in_progress,
- ConnectState *connect_state, Error **errp)
+static int vsock_connect_addr(const struct sockaddr_vm *svm, Error **errp)
{
int sock, rc;
- *in_progress = false;
-
sock = qemu_socket(AF_VSOCK, SOCK_STREAM, 0);
if (sock < 0) {
error_setg_errno(errp, errno, "Failed to create socket");
return -1;
}
- if (connect_state != NULL) {
- qemu_set_nonblock(sock);
- }
+
/* connect to peer */
do {
rc = 0;
}
} while (rc == -EINTR);
- if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
- connect_state->fd = sock;
- qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
- *in_progress = true;
- } else if (rc < 0) {
+ if (rc < 0) {
error_setg_errno(errp, errno, "Failed to connect socket");
closesocket(sock);
return -1;
}
+
return sock;
}
-static int vsock_connect_saddr(VsockSocketAddress *vaddr,
- NonBlockingConnectHandler *callback,
- void *opaque,
- Error **errp)
+static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp)
{
struct sockaddr_vm svm;
int sock = -1;
- bool in_progress;
- ConnectState *connect_state = NULL;
if (!vsock_parse_vaddr_to_sockaddr(vaddr, &svm, errp)) {
return -1;
}
- if (callback != NULL) {
- connect_state = g_malloc0(sizeof(*connect_state));
- connect_state->callback = callback;
- connect_state->opaque = opaque;
- }
+ sock = vsock_connect_addr(&svm, errp);
- sock = vsock_connect_addr(&svm, &in_progress, connect_state, errp);
- if (sock < 0) {
- /* do nothing */
- } else if (in_progress) {
- /* wait_for_connect() will do the rest */
- return sock;
- } else {
- if (callback) {
- callback(sock, NULL, opaque);
- }
- }
- g_free(connect_state);
return sock;
}
static int vsock_listen_saddr(VsockSocketAddress *vaddr,
+ int num,
Error **errp)
{
struct sockaddr_vm svm;
return -1;
}
- if (listen(slisten, 1) != 0) {
+ if (listen(slisten, num) != 0) {
error_setg_errno(errp, errno, "Failed to listen on socket");
closesocket(slisten);
return -1;
return slisten;
}
-static VsockSocketAddress *vsock_parse(const char *str, Error **errp)
+static int vsock_parse(VsockSocketAddress *addr, const char *str,
+ Error **errp)
{
- VsockSocketAddress *addr = NULL;
char cid[33];
char port[33];
int n;
if (sscanf(str, "%32[^:]:%32[^,]%n", cid, port, &n) != 2) {
error_setg(errp, "error parsing address '%s'", str);
- return NULL;
+ return -1;
}
if (str[n] != '\0') {
error_setg(errp, "trailing characters in address '%s'", str);
- return NULL;
+ return -1;
}
- addr = g_new0(VsockSocketAddress, 1);
addr->cid = g_strdup(cid);
addr->port = g_strdup(port);
- return addr;
+ return 0;
}
#else
static void vsock_unsupported(Error **errp)
error_setg(errp, "socket family AF_VSOCK unsupported");
}
-static int vsock_connect_saddr(VsockSocketAddress *vaddr,
- NonBlockingConnectHandler *callback,
- void *opaque, Error **errp)
+static int vsock_connect_saddr(VsockSocketAddress *vaddr, Error **errp)
{
vsock_unsupported(errp);
return -1;
}
static int vsock_listen_saddr(VsockSocketAddress *vaddr,
+ int num,
Error **errp)
{
vsock_unsupported(errp);
return -1;
}
-static VsockSocketAddress *vsock_parse(const char *str, Error **errp)
+static int vsock_parse(VsockSocketAddress *addr, const char *str,
+ Error **errp)
{
vsock_unsupported(errp);
- return NULL;
+ return -1;
}
#endif /* CONFIG_AF_VSOCK */
#ifndef _WIN32
static int unix_listen_saddr(UnixSocketAddress *saddr,
- bool update_addr,
+ int num,
Error **errp)
{
struct sockaddr_un un;
int sock, fd;
+ char *pathbuf = NULL;
+ const char *path;
+ size_t pathlen;
sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
return -1;
}
- memset(&un, 0, sizeof(un));
- un.sun_family = AF_UNIX;
- if (saddr->path && strlen(saddr->path)) {
- snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
+ if (saddr->path && saddr->path[0]) {
+ path = saddr->path;
} else {
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;
- }
+ path = pathbuf = g_strdup_printf("%s/qemu-socket-XXXXXX", tmpdir);
+ }
+
+ pathlen = strlen(path);
+ if (pathlen > sizeof(un.sun_path)) {
+ error_setg(errp, "UNIX socket path '%s' is too long", path);
+ error_append_hint(errp, "Path must be less than %zu bytes\n",
+ sizeof(un.sun_path));
+ goto err;
+ }
+ if (pathbuf != NULL) {
/*
* This dummy fd usage silences the mktemp() unsecure warning.
* Using mkstemp() doesn't make things more secure here
* to unlink first and thus re-open the race window. The
* worst case possible is bind() failing, i.e. a DoS attack.
*/
- fd = mkstemp(un.sun_path);
+ fd = mkstemp(pathbuf);
if (fd < 0) {
error_setg_errno(errp, errno,
- "Failed to make a temporary socket name in %s", tmpdir);
+ "Failed to make a temporary socket %s", pathbuf);
goto err;
}
close(fd);
- if (update_addr) {
- g_free(saddr->path);
- saddr->path = g_strdup(un.sun_path);
- }
}
- if (unlink(un.sun_path) < 0 && errno != ENOENT) {
+ if (unlink(path) < 0 && errno != ENOENT) {
error_setg_errno(errp, errno,
- "Failed to unlink socket %s", un.sun_path);
+ "Failed to unlink socket %s", path);
goto err;
}
+
+ memset(&un, 0, sizeof(un));
+ un.sun_family = AF_UNIX;
+ memcpy(un.sun_path, path, pathlen);
+
if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
- error_setg_errno(errp, errno, "Failed to bind socket to %s", un.sun_path);
+ error_setg_errno(errp, errno, "Failed to bind socket to %s", path);
goto err;
}
- if (listen(sock, 1) < 0) {
+ if (listen(sock, num) < 0) {
error_setg_errno(errp, errno, "Failed to listen on socket");
goto err;
}
+ g_free(pathbuf);
return sock;
err:
+ g_free(pathbuf);
closesocket(sock);
return -1;
}
-static int unix_connect_saddr(UnixSocketAddress *saddr,
- NonBlockingConnectHandler *callback, void *opaque,
- Error **errp)
+static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp)
{
struct sockaddr_un un;
- ConnectState *connect_state = NULL;
int sock, rc;
+ size_t pathlen;
if (saddr->path == NULL) {
error_setg(errp, "unix connect: no path specified");
error_setg_errno(errp, errno, "Failed to create socket");
return -1;
}
- if (callback != NULL) {
- connect_state = g_malloc0(sizeof(*connect_state));
- connect_state->callback = callback;
- connect_state->opaque = opaque;
- qemu_set_nonblock(sock);
+
+ pathlen = strlen(saddr->path);
+ if (pathlen > sizeof(un.sun_path)) {
+ error_setg(errp, "UNIX socket path '%s' is too long", saddr->path);
+ error_append_hint(errp, "Path must be less than %zu bytes\n",
+ sizeof(un.sun_path));
+ goto err;
}
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
- snprintf(un.sun_path, sizeof(un.sun_path), "%s", saddr->path);
+ memcpy(un.sun_path, saddr->path, pathlen);
/* connect to peer */
do {
}
} while (rc == -EINTR);
- if (connect_state != NULL && QEMU_SOCKET_RC_INPROGRESS(rc)) {
- connect_state->fd = sock;
- qemu_set_fd_handler(sock, NULL, wait_for_connect, connect_state);
- return sock;
- } else if (rc >= 0) {
- /* non blocking socket immediate success, call callback */
- if (callback != NULL) {
- callback(sock, NULL, opaque);
- }
- }
-
if (rc < 0) {
- error_setg_errno(errp, -rc, "Failed to connect socket");
- close(sock);
- sock = -1;
+ error_setg_errno(errp, -rc, "Failed to connect socket %s",
+ saddr->path);
+ goto err;
}
- g_free(connect_state);
return sock;
+
+ err:
+ close(sock);
+ return -1;
}
#else
static int unix_listen_saddr(UnixSocketAddress *saddr,
- bool update_addr,
+ int num,
Error **errp)
{
error_setg(errp, "unix sockets are not available on windows");
return -1;
}
-static int unix_connect_saddr(UnixSocketAddress *saddr,
- NonBlockingConnectHandler *callback, void *opaque,
- Error **errp)
+static int unix_connect_saddr(UnixSocketAddress *saddr, Error **errp)
{
error_setg(errp, "unix sockets are not available on windows");
errno = ENOTSUP;
#endif
/* compatibility wrapper */
-int unix_listen(const char *str, char *ostr, int olen, Error **errp)
+int unix_listen(const char *str, Error **errp)
{
- char *path, *optstr;
- int sock, len;
UnixSocketAddress *saddr;
+ int sock;
saddr = g_new0(UnixSocketAddress, 1);
-
- optstr = strchr(str, ',');
- if (optstr) {
- len = optstr - str;
- if (len) {
- path = g_malloc(len+1);
- snprintf(path, len+1, "%.*s", len, str);
- saddr->path = path;
- }
- } else {
- saddr->path = g_strdup(str);
- }
-
- sock = unix_listen_saddr(saddr, true, errp);
-
- if (sock != -1 && ostr) {
- snprintf(ostr, olen, "%s%s", saddr->path, optstr ? optstr : "");
- }
-
+ saddr->path = g_strdup(str);
+ sock = unix_listen_saddr(saddr, 1, errp);
qapi_free_UnixSocketAddress(saddr);
return sock;
}
saddr = g_new0(UnixSocketAddress, 1);
saddr->path = g_strdup(path);
- sock = unix_connect_saddr(saddr, NULL, NULL, errp);
+ sock = unix_connect_saddr(saddr, errp);
qapi_free_UnixSocketAddress(saddr);
return sock;
}
error_setg(errp, "invalid Unix socket address");
goto fail;
} else {
- addr->type = SOCKET_ADDRESS_KIND_UNIX;
- addr->u.q_unix.data = g_new(UnixSocketAddress, 1);
- addr->u.q_unix.data->path = g_strdup(str + 5);
+ addr->type = SOCKET_ADDRESS_TYPE_UNIX;
+ addr->u.q_unix.path = g_strdup(str + 5);
}
} else if (strstart(str, "fd:", NULL)) {
if (str[3] == '\0') {
error_setg(errp, "invalid file descriptor address");
goto fail;
} else {
- addr->type = SOCKET_ADDRESS_KIND_FD;
- addr->u.fd.data = g_new(String, 1);
- addr->u.fd.data->str = g_strdup(str + 3);
+ addr->type = SOCKET_ADDRESS_TYPE_FD;
+ addr->u.fd.str = g_strdup(str + 3);
}
} else if (strstart(str, "vsock:", NULL)) {
- addr->type = SOCKET_ADDRESS_KIND_VSOCK;
- addr->u.vsock.data = vsock_parse(str + strlen("vsock:"), errp);
- if (addr->u.vsock.data == NULL) {
+ addr->type = SOCKET_ADDRESS_TYPE_VSOCK;
+ if (vsock_parse(&addr->u.vsock, str + strlen("vsock:"), errp)) {
goto fail;
}
} else {
- addr->type = SOCKET_ADDRESS_KIND_INET;
- addr->u.inet.data = inet_parse(str, errp);
- if (addr->u.inet.data == NULL) {
+ addr->type = SOCKET_ADDRESS_TYPE_INET;
+ if (inet_parse(&addr->u.inet, str, errp)) {
goto fail;
}
}
return NULL;
}
-int socket_connect(SocketAddress *addr, NonBlockingConnectHandler *callback,
- void *opaque, Error **errp)
+static int socket_get_fd(const char *fdstr, int num, Error **errp)
+{
+ int fd;
+ if (num != 1) {
+ error_setg_errno(errp, EINVAL, "socket_get_fd: too many connections");
+ return -1;
+ }
+ if (cur_mon) {
+ fd = monitor_get_fd(cur_mon, fdstr, errp);
+ if (fd < 0) {
+ return -1;
+ }
+ } else {
+ if (qemu_strtoi(fdstr, NULL, 10, &fd) < 0) {
+ error_setg_errno(errp, errno,
+ "Unable to parse FD number %s",
+ fdstr);
+ return -1;
+ }
+ }
+ if (!fd_is_socket(fd)) {
+ error_setg(errp, "File descriptor '%s' is not a socket", fdstr);
+ close(fd);
+ return -1;
+ }
+ return fd;
+}
+
+int socket_connect(SocketAddress *addr, Error **errp)
{
int fd;
switch (addr->type) {
- case SOCKET_ADDRESS_KIND_INET:
- fd = inet_connect_saddr(addr->u.inet.data, callback, opaque, errp);
+ case SOCKET_ADDRESS_TYPE_INET:
+ fd = inet_connect_saddr(&addr->u.inet, errp);
break;
- case SOCKET_ADDRESS_KIND_UNIX:
- fd = unix_connect_saddr(addr->u.q_unix.data, callback, opaque, errp);
+ case SOCKET_ADDRESS_TYPE_UNIX:
+ fd = unix_connect_saddr(&addr->u.q_unix, errp);
break;
- case SOCKET_ADDRESS_KIND_FD:
- fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
- if (fd >= 0 && callback) {
- qemu_set_nonblock(fd);
- callback(fd, NULL, opaque);
- }
+ case SOCKET_ADDRESS_TYPE_FD:
+ fd = socket_get_fd(addr->u.fd.str, 1, errp);
break;
- case SOCKET_ADDRESS_KIND_VSOCK:
- fd = vsock_connect_saddr(addr->u.vsock.data, callback, opaque, errp);
+ case SOCKET_ADDRESS_TYPE_VSOCK:
+ fd = vsock_connect_saddr(&addr->u.vsock, errp);
break;
default:
return fd;
}
-int socket_listen(SocketAddress *addr, Error **errp)
+int socket_listen(SocketAddress *addr, int num, Error **errp)
{
int fd;
+ trace_socket_listen(num);
switch (addr->type) {
- case SOCKET_ADDRESS_KIND_INET:
- fd = inet_listen_saddr(addr->u.inet.data, 0, false, errp);
+ case SOCKET_ADDRESS_TYPE_INET:
+ fd = inet_listen_saddr(&addr->u.inet, 0, num, errp);
break;
- case SOCKET_ADDRESS_KIND_UNIX:
- fd = unix_listen_saddr(addr->u.q_unix.data, false, errp);
+ case SOCKET_ADDRESS_TYPE_UNIX:
+ fd = unix_listen_saddr(&addr->u.q_unix, num, errp);
break;
- case SOCKET_ADDRESS_KIND_FD:
- fd = monitor_get_fd(cur_mon, addr->u.fd.data->str, errp);
+ case SOCKET_ADDRESS_TYPE_FD:
+ fd = socket_get_fd(addr->u.fd.str, num, errp);
break;
- case SOCKET_ADDRESS_KIND_VSOCK:
- fd = vsock_listen_saddr(addr->u.vsock.data, errp);
+ case SOCKET_ADDRESS_TYPE_VSOCK:
+ fd = vsock_listen_saddr(&addr->u.vsock, num, errp);
break;
default:
SocketAddress *addr;
addr = socket_local_address(fd, errp);
+ if (!addr) {
+ return;
+ }
- if (addr->type == SOCKET_ADDRESS_KIND_UNIX
- && addr->u.q_unix.data->path) {
- if (unlink(addr->u.q_unix.data->path) < 0 && errno != ENOENT) {
+ if (addr->type == SOCKET_ADDRESS_TYPE_UNIX
+ && addr->u.q_unix.path) {
+ if (unlink(addr->u.q_unix.path) < 0 && errno != ENOENT) {
error_setg_errno(errp, errno,
"Failed to unlink socket %s",
- addr->u.q_unix.data->path);
+ addr->u.q_unix.path);
}
}
int fd;
/*
- * TODO SOCKET_ADDRESS_KIND_FD when fd is AF_INET or AF_INET6
+ * TODO SOCKET_ADDRESS_TYPE_FD when fd is AF_INET or AF_INET6
* (although other address families can do SOCK_DGRAM, too)
*/
switch (remote->type) {
- case SOCKET_ADDRESS_KIND_INET:
- fd = inet_dgram_saddr(remote->u.inet.data,
- local ? local->u.inet.data : NULL, errp);
+ case SOCKET_ADDRESS_TYPE_INET:
+ fd = inet_dgram_saddr(&remote->u.inet,
+ local ? &local->u.inet : NULL, errp);
break;
default:
}
addr = g_new0(SocketAddress, 1);
- addr->type = SOCKET_ADDRESS_KIND_INET;
- inet = addr->u.inet.data = g_new0(InetSocketAddress, 1);
+ addr->type = SOCKET_ADDRESS_TYPE_INET;
+ inet = &addr->u.inet;
inet->host = g_strdup(host);
inet->port = g_strdup(serv);
if (sa->ss_family == AF_INET) {
struct sockaddr_un *su = (struct sockaddr_un *)sa;
addr = g_new0(SocketAddress, 1);
- addr->type = SOCKET_ADDRESS_KIND_UNIX;
- addr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
+ addr->type = SOCKET_ADDRESS_TYPE_UNIX;
if (su->sun_path[0]) {
- addr->u.q_unix.data->path = g_strndup(su->sun_path,
- sizeof(su->sun_path));
+ addr->u.q_unix.path = g_strndup(su->sun_path, sizeof(su->sun_path));
}
return addr;
struct sockaddr_vm *svm = (struct sockaddr_vm *)sa;
addr = g_new0(SocketAddress, 1);
- addr->type = SOCKET_ADDRESS_KIND_VSOCK;
- addr->u.vsock.data = vaddr = g_new0(VsockSocketAddress, 1);
+ addr->type = SOCKET_ADDRESS_TYPE_VSOCK;
+ vaddr = &addr->u.vsock;
vaddr->cid = g_strdup_printf("%u", svm->svm_cid);
vaddr->port = g_strdup_printf("%u", svm->svm_port);
return socket_sockaddr_to_address(&ss, sslen, errp);
}
-char *socket_address_to_string(struct SocketAddress *addr, Error **errp)
-{
- char *buf;
- InetSocketAddress *inet;
- switch (addr->type) {
- case SOCKET_ADDRESS_KIND_INET:
- inet = addr->u.inet.data;
- if (strchr(inet->host, ':') == NULL) {
- buf = g_strdup_printf("%s:%s", inet->host, inet->port);
- } else {
- buf = g_strdup_printf("[%s]:%s", inet->host, inet->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;
-
- case SOCKET_ADDRESS_KIND_VSOCK:
- buf = g_strdup_printf("%s:%s",
- addr->u.vsock.data->cid,
- addr->u.vsock.data->port);
- break;
+SocketAddress *socket_address_flatten(SocketAddressLegacy *addr_legacy)
+{
+ SocketAddress *addr;
- default:
- abort();
+ if (!addr_legacy) {
+ return NULL;
}
- return buf;
-}
-SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat)
-{
- SocketAddress *addr = g_new(SocketAddress, 1);
+ addr = g_new(SocketAddress, 1);
- switch (addr_flat->type) {
- case SOCKET_ADDRESS_FLAT_TYPE_INET:
- addr->type = SOCKET_ADDRESS_KIND_INET;
- addr->u.inet.data = QAPI_CLONE(InetSocketAddress,
- &addr_flat->u.inet);
+ switch (addr_legacy->type) {
+ case SOCKET_ADDRESS_LEGACY_KIND_INET:
+ addr->type = SOCKET_ADDRESS_TYPE_INET;
+ QAPI_CLONE_MEMBERS(InetSocketAddress, &addr->u.inet,
+ addr_legacy->u.inet.data);
break;
- case SOCKET_ADDRESS_FLAT_TYPE_UNIX:
- addr->type = SOCKET_ADDRESS_KIND_UNIX;
- addr->u.q_unix.data = QAPI_CLONE(UnixSocketAddress,
- &addr_flat->u.q_unix);
+ case SOCKET_ADDRESS_LEGACY_KIND_UNIX:
+ addr->type = SOCKET_ADDRESS_TYPE_UNIX;
+ QAPI_CLONE_MEMBERS(UnixSocketAddress, &addr->u.q_unix,
+ addr_legacy->u.q_unix.data);
break;
- case SOCKET_ADDRESS_FLAT_TYPE_VSOCK:
- addr->type = SOCKET_ADDRESS_KIND_VSOCK;
- addr->u.vsock.data = QAPI_CLONE(VsockSocketAddress,
- &addr_flat->u.vsock);
+ case SOCKET_ADDRESS_LEGACY_KIND_VSOCK:
+ addr->type = SOCKET_ADDRESS_TYPE_VSOCK;
+ QAPI_CLONE_MEMBERS(VsockSocketAddress, &addr->u.vsock,
+ addr_legacy->u.vsock.data);
break;
- case SOCKET_ADDRESS_FLAT_TYPE_FD:
- addr->type = SOCKET_ADDRESS_KIND_FD;
- addr->u.fd.data = QAPI_CLONE(String, &addr_flat->u.fd);
+ case SOCKET_ADDRESS_LEGACY_KIND_FD:
+ addr->type = SOCKET_ADDRESS_TYPE_FD;
+ QAPI_CLONE_MEMBERS(String, &addr->u.fd, addr_legacy->u.fd.data);
break;
default:
abort();
projects / mirror_qemu.git / blobdiff