diff options
Diffstat (limited to 'io')
| -rw-r--r-- | io/Makefile.objs | 1 | ||||
| -rw-r--r-- | io/channel-socket.c | 44 | ||||
| -rw-r--r-- | io/channel-tls.c | 16 | ||||
| -rw-r--r-- | io/channel-websock.c | 8 | ||||
| -rw-r--r-- | io/dns-resolver.c | 276 | ||||
| -rw-r--r-- | io/task.c | 62 | ||||
| -rw-r--r-- | io/trace-events | 1 |
7 files changed, 346 insertions, 62 deletions
diff --git a/io/Makefile.objs b/io/Makefile.objs index 9d8337d89a..12983cca79 100644 --- a/io/Makefile.objs +++ b/io/Makefile.objs @@ -7,4 +7,5 @@ io-obj-y += channel-tls.o io-obj-y += channel-watch.o io-obj-y += channel-websock.o io-obj-y += channel-util.o +io-obj-y += dns-resolver.o io-obj-y += task.o diff --git a/io/channel-socket.c b/io/channel-socket.c index d7e03f6266..f385233f18 100644 --- a/io/channel-socket.c +++ b/io/channel-socket.c @@ -156,20 +156,16 @@ int qio_channel_socket_connect_sync(QIOChannelSocket *ioc, } -static int qio_channel_socket_connect_worker(QIOTask *task, - Error **errp, - gpointer opaque) +static void qio_channel_socket_connect_worker(QIOTask *task, + gpointer opaque) { QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); SocketAddress *addr = opaque; - int ret; + Error *err = NULL; - ret = qio_channel_socket_connect_sync(ioc, - addr, - errp); + qio_channel_socket_connect_sync(ioc, addr, &err); - object_unref(OBJECT(ioc)); - return ret; + qio_task_set_error(task, err); } @@ -219,20 +215,16 @@ int qio_channel_socket_listen_sync(QIOChannelSocket *ioc, } -static int qio_channel_socket_listen_worker(QIOTask *task, - Error **errp, - gpointer opaque) +static void qio_channel_socket_listen_worker(QIOTask *task, + gpointer opaque) { QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); SocketAddress *addr = opaque; - int ret; + Error *err = NULL; - ret = qio_channel_socket_listen_sync(ioc, - addr, - errp); + qio_channel_socket_listen_sync(ioc, addr, &err); - object_unref(OBJECT(ioc)); - return ret; + qio_task_set_error(task, err); } @@ -295,22 +287,18 @@ static void qio_channel_socket_dgram_worker_free(gpointer opaque) g_free(data); } -static int qio_channel_socket_dgram_worker(QIOTask *task, - Error **errp, - gpointer opaque) +static void qio_channel_socket_dgram_worker(QIOTask *task, + gpointer opaque) { QIOChannelSocket *ioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task)); struct QIOChannelSocketDGramWorkerData *data = opaque; - int ret; + Error *err = NULL; /* socket_dgram() blocks in DNS lookups, so we must use a thread */ - ret = qio_channel_socket_dgram_sync(ioc, - data->localAddr, - data->remoteAddr, - errp); + qio_channel_socket_dgram_sync(ioc, data->localAddr, + data->remoteAddr, &err); - object_unref(OBJECT(ioc)); - return ret; + qio_task_set_error(task, err); } diff --git a/io/channel-tls.c b/io/channel-tls.c index d24dc8c613..f25ab0ae53 100644 --- a/io/channel-tls.c +++ b/io/channel-tls.c @@ -153,8 +153,9 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, if (qcrypto_tls_session_handshake(ioc->session, &err) < 0) { trace_qio_channel_tls_handshake_fail(ioc); - qio_task_abort(task, err); - goto cleanup; + qio_task_set_error(task, err); + qio_task_complete(task); + return; } status = qcrypto_tls_session_get_handshake_status(ioc->session); @@ -163,10 +164,10 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, if (qcrypto_tls_session_check_credentials(ioc->session, &err) < 0) { trace_qio_channel_tls_credentials_deny(ioc); - qio_task_abort(task, err); - goto cleanup; + qio_task_set_error(task, err); + } else { + trace_qio_channel_tls_credentials_allow(ioc); } - trace_qio_channel_tls_credentials_allow(ioc); qio_task_complete(task); } else { GIOCondition condition; @@ -183,9 +184,6 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, task, NULL); } - - cleanup: - error_free(err); } @@ -200,8 +198,6 @@ static gboolean qio_channel_tls_handshake_io(QIOChannel *ioc, qio_channel_tls_handshake_task( tioc, task); - object_unref(OBJECT(tioc)); - return FALSE; } diff --git a/io/channel-websock.c b/io/channel-websock.c index f45bced82a..e47279a1ae 100644 --- a/io/channel-websock.c +++ b/io/channel-websock.c @@ -279,8 +279,8 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc, if (ret < 0) { trace_qio_channel_websock_handshake_fail(ioc); - qio_task_abort(task, err); - error_free(err); + qio_task_set_error(task, err); + qio_task_complete(task); return FALSE; } @@ -307,8 +307,8 @@ static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc, ret = qio_channel_websock_handshake_read(wioc, &err); if (ret < 0) { trace_qio_channel_websock_handshake_fail(ioc); - qio_task_abort(task, err); - error_free(err); + qio_task_set_error(task, err); + qio_task_complete(task); return FALSE; } if (ret == 0) { diff --git a/io/dns-resolver.c b/io/dns-resolver.c new file mode 100644 index 0000000000..0ac6b23c02 --- /dev/null +++ b/io/dns-resolver.c @@ -0,0 +1,276 @@ +/* + * QEMU DNS resolver + * + * Copyright (c) 2016 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "qemu/osdep.h" +#include "io/dns-resolver.h" +#include "qapi/clone-visitor.h" +#include "qemu/sockets.h" +#include "qapi/error.h" +#include "qemu/cutils.h" + +#ifndef AI_NUMERICSERV +# define AI_NUMERICSERV 0 +#endif + +static QIODNSResolver *instance; +static GOnce instance_init = G_ONCE_INIT; + +static gpointer qio_dns_resolve_init_instance(gpointer unused G_GNUC_UNUSED) +{ + instance = QIO_DNS_RESOLVER(object_new(TYPE_QIO_DNS_RESOLVER)); + return NULL; +} + +QIODNSResolver *qio_dns_resolver_get_instance(void) +{ + g_once(&instance_init, qio_dns_resolve_init_instance, NULL); + return instance; +} + +static int qio_dns_resolver_lookup_sync_inet(QIODNSResolver *resolver, + SocketAddress *addr, + size_t *naddrs, + SocketAddress ***addrs, + Error **errp) +{ + struct addrinfo ai, *res, *e; + InetSocketAddress *iaddr = addr->u.inet.data; + char port[33]; + char uaddr[INET6_ADDRSTRLEN + 1]; + char uport[33]; + int rc; + Error *err = NULL; + size_t i; + + *naddrs = 0; + *addrs = NULL; + + memset(&ai, 0, sizeof(ai)); + ai.ai_flags = AI_PASSIVE; + if (iaddr->has_numeric && iaddr->numeric) { + ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV; + } + ai.ai_family = inet_ai_family_from_address(iaddr, &err); + ai.ai_socktype = SOCK_STREAM; + + if (err) { + error_propagate(errp, err); + return -1; + } + + if (iaddr->host == NULL) { + error_setg(errp, "host not specified"); + return -1; + } + if (iaddr->port != NULL) { + pstrcpy(port, sizeof(port), iaddr->port); + } else { + port[0] = '\0'; + } + + rc = getaddrinfo(strlen(iaddr->host) ? iaddr->host : NULL, + strlen(port) ? port : NULL, &ai, &res); + if (rc != 0) { + error_setg(errp, "address resolution failed for %s:%s: %s", + iaddr->host, port, gai_strerror(rc)); + return -1; + } + + for (e = res; e != NULL; e = e->ai_next) { + (*naddrs)++; + } + + *addrs = g_new0(SocketAddress *, *naddrs); + + /* create socket + bind */ + for (i = 0, e = res; e != NULL; i++, e = e->ai_next) { + SocketAddress *newaddr = g_new0(SocketAddress, 1); + InetSocketAddress *newiaddr = g_new0(InetSocketAddress, 1); + newaddr->u.inet.data = newiaddr; + newaddr->type = SOCKET_ADDRESS_KIND_INET; + + getnameinfo((struct sockaddr *)e->ai_addr, e->ai_addrlen, + uaddr, INET6_ADDRSTRLEN, uport, 32, + NI_NUMERICHOST | NI_NUMERICSERV); + + *newiaddr = (InetSocketAddress){ + .host = g_strdup(uaddr), + .port = g_strdup(uport), + .has_numeric = true, + .numeric = true, + .has_to = iaddr->has_to, + .to = iaddr->to, + .has_ipv4 = false, + .has_ipv6 = false, + }; + + (*addrs)[i] = newaddr; + } + freeaddrinfo(res); + return 0; +} + + +static int qio_dns_resolver_lookup_sync_nop(QIODNSResolver *resolver, + SocketAddress *addr, + size_t *naddrs, + SocketAddress ***addrs, + Error **errp) +{ + *naddrs = 1; + *addrs = g_new0(SocketAddress *, 1); + (*addrs)[0] = QAPI_CLONE(SocketAddress, addr); + + return 0; +} + + +int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver, + SocketAddress *addr, + size_t *naddrs, + SocketAddress ***addrs, + Error **errp) +{ + switch (addr->type) { + case SOCKET_ADDRESS_KIND_INET: + return qio_dns_resolver_lookup_sync_inet(resolver, + addr, + naddrs, + addrs, + errp); + + case SOCKET_ADDRESS_KIND_UNIX: + case SOCKET_ADDRESS_KIND_VSOCK: + return qio_dns_resolver_lookup_sync_nop(resolver, + addr, + naddrs, + addrs, + errp); + + default: + error_setg(errp, "Unknown socket address kind"); + return -1; + } +} + + +struct QIODNSResolverLookupData { + SocketAddress *addr; + SocketAddress **addrs; + size_t naddrs; +}; + + +static void qio_dns_resolver_lookup_data_free(gpointer opaque) +{ + struct QIODNSResolverLookupData *data = opaque; + size_t i; + + qapi_free_SocketAddress(data->addr); + for (i = 0; i < data->naddrs; i++) { + qapi_free_SocketAddress(data->addrs[i]); + } + + g_free(data->addrs); + g_free(data); +} + + +static void qio_dns_resolver_lookup_worker(QIOTask *task, + gpointer opaque) +{ + QIODNSResolver *resolver = QIO_DNS_RESOLVER(qio_task_get_source(task)); + struct QIODNSResolverLookupData *data = opaque; + Error *err = NULL; + + qio_dns_resolver_lookup_sync(resolver, + data->addr, + &data->naddrs, + &data->addrs, + &err); + if (err) { + qio_task_set_error(task, err); + } else { + qio_task_set_result_pointer(task, opaque, NULL); + } + + object_unref(OBJECT(resolver)); +} + + +void qio_dns_resolver_lookup_async(QIODNSResolver *resolver, + SocketAddress *addr, + QIOTaskFunc func, + gpointer opaque, + GDestroyNotify notify) +{ + QIOTask *task; + struct QIODNSResolverLookupData *data = + g_new0(struct QIODNSResolverLookupData, 1); + + data->addr = QAPI_CLONE(SocketAddress, addr); + + task = qio_task_new(OBJECT(resolver), func, opaque, notify); + + qio_task_run_in_thread(task, + qio_dns_resolver_lookup_worker, + data, + qio_dns_resolver_lookup_data_free); +} + + +void qio_dns_resolver_lookup_result(QIODNSResolver *resolver, + QIOTask *task, + size_t *naddrs, + SocketAddress ***addrs) +{ + struct QIODNSResolverLookupData *data = + qio_task_get_result_pointer(task); + size_t i; + + *naddrs = 0; + *addrs = NULL; + if (!data) { + return; + } + + *naddrs = data->naddrs; + *addrs = g_new0(SocketAddress *, data->naddrs); + for (i = 0; i < data->naddrs; i++) { + (*addrs)[i] = QAPI_CLONE(SocketAddress, data->addrs[i]); + } +} + + +static const TypeInfo qio_dns_resolver_info = { + .parent = TYPE_OBJECT, + .name = TYPE_QIO_DNS_RESOLVER, + .instance_size = sizeof(QIODNSResolver), + .class_size = sizeof(QIODNSResolverClass), +}; + + +static void qio_dns_resolver_register_types(void) +{ + type_register_static(&qio_dns_resolver_info); +} + + +type_init(qio_dns_resolver_register_types); diff --git a/io/task.c b/io/task.c index c7f97a9b16..60bf1a94d5 100644 --- a/io/task.c +++ b/io/task.c @@ -29,6 +29,9 @@ struct QIOTask { QIOTaskFunc func; gpointer opaque; GDestroyNotify destroy; + Error *err; + gpointer result; + GDestroyNotify destroyResult; }; @@ -57,6 +60,12 @@ static void qio_task_free(QIOTask *task) if (task->destroy) { task->destroy(task->opaque); } + if (task->destroyResult) { + task->destroyResult(task->result); + } + if (task->err) { + error_free(task->err); + } object_unref(task->source); g_free(task); @@ -68,8 +77,6 @@ struct QIOTaskThreadData { QIOTaskWorker worker; gpointer opaque; GDestroyNotify destroy; - Error *err; - int ret; }; @@ -78,13 +85,8 @@ static gboolean gio_task_thread_result(gpointer opaque) struct QIOTaskThreadData *data = opaque; trace_qio_task_thread_result(data->task); - if (data->ret == 0) { - qio_task_complete(data->task); - } else { - qio_task_abort(data->task, data->err); - } + qio_task_complete(data->task); - error_free(data->err); if (data->destroy) { data->destroy(data->opaque); } @@ -100,10 +102,7 @@ static gpointer qio_task_thread_worker(gpointer opaque) struct QIOTaskThreadData *data = opaque; trace_qio_task_thread_run(data->task); - data->ret = data->worker(data->task, &data->err, data->opaque); - if (data->ret < 0 && data->err == NULL) { - error_setg(&data->err, "Task worker failed but did not set an error"); - } + data->worker(data->task, data->opaque); /* We're running in the background thread, and must only * ever report the task results in the main event loop @@ -140,22 +139,47 @@ void qio_task_run_in_thread(QIOTask *task, void qio_task_complete(QIOTask *task) { - task->func(task->source, NULL, task->opaque); + task->func(task, task->opaque); trace_qio_task_complete(task); qio_task_free(task); } -void qio_task_abort(QIOTask *task, - Error *err) + +void qio_task_set_error(QIOTask *task, + Error *err) { - task->func(task->source, err, task->opaque); - trace_qio_task_abort(task); - qio_task_free(task); + error_propagate(&task->err, err); +} + + +bool qio_task_propagate_error(QIOTask *task, + Error **errp) +{ + if (task->err) { + error_propagate(errp, task->err); + return true; + } + + return false; +} + + +void qio_task_set_result_pointer(QIOTask *task, + gpointer result, + GDestroyNotify destroy) +{ + task->result = result; + task->destroyResult = destroy; +} + + +gpointer qio_task_get_result_pointer(QIOTask *task) +{ + return task->result; } Object *qio_task_get_source(QIOTask *task) { - object_ref(task->source); return task->source; } diff --git a/io/trace-events b/io/trace-events index e31b596ca1..ff993bef45 100644 --- a/io/trace-events +++ b/io/trace-events @@ -3,7 +3,6 @@ # io/task.c qio_task_new(void *task, void *source, void *func, void *opaque) "Task new task=%p source=%p func=%p opaque=%p" qio_task_complete(void *task) "Task complete task=%p" -qio_task_abort(void *task) "Task abort task=%p" qio_task_thread_start(void *task, void *worker, void *opaque) "Task thread start task=%p worker=%p opaque=%p" qio_task_thread_run(void *task) "Task thread run task=%p" qio_task_thread_exit(void *task) "Task thread exit task=%p" |