Skip to contentSkip to conversation

io: enable DNS resolving separately of socket create

PATCH Superseded Daniel P. Berrange 2 participants 22 messages Jan 5, 2017 – Jan 6, 2017

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover io: enable DNS resolving separately of socket create

Currently DNS resolution of SocketAddress structs is done as part of the socket connect/listen process. This is very inflexible as it assumes that a single SocketAddress struct will only ever require a single socket to be opened. While true for connect(), it is not the case for listen() in two scenarios

- A name may resolve to both an IPv4 and IPv6 address. Currently we workaround that by clearing the IPV6_V6ONLY flag.

- A name may resolve to multiple IP addresses of the same protocol. eg "myhostname" may return "192.168.122.1" and "10.0.0.2" when the host has multiple NICs, or multiple addresses per NIC.

The only way to deal with the latter problem is to open multiple sockets and that requires the ability to separate DNS resolution from socket creation.

This series thus enhances the I/O framework in QEMU to introduce the "QIODNSResolver" concept. This (singleton) object allows the caller to feed in a single SocketAddress struct, perform DNS resolution, and get back out one or more new SocketAddress structs for the results. The API allows both synchronous and asynchrounous DNS lookups, the latter done by spawning a thread to do the getaddrinfo call via the QIOTask framework.

In this series the InetSocketAddress struct gains a new field to let the caller indicate that the address is providing a numeric host value, thus skipping DNS altogether.

The QIOTask object had some refactoring to allow results to be associated with it explicitly, so that the asynchronous DNS results can be passed around. This triggered the code churn across other files in QEMU using QIOTask.

This series will be utilized by a second series that will be sent that updates the VNC server code to use this new feature.

Daniel P. Berrange (8):
sockets: add ability to disable DNS resolution for InetSocketAddress
io: stop incrementing reference in qio_task_get_source
io: fix typo in docs for QIOTask
io: add ability to associate an opaque "result" with with a task
io: add ability to associate an error with a task
io: change the QIOTask callback signature
io: remove Error parameter from QIOTask thread worker
io: introduce a DNS resolver API

 include/io/dns-resolver.h      | 224 ++++++++++++++++++++++++++++++++++
 include/io/task.h              | 151 ++++++++++++++++-------
 include/qemu/sockets.h         |   2 +
 io/Makefile.objs               |   1 +
 io/channel-socket.c            |  50 ++++----
 io/channel-tls.c               |  16 +--
 io/channel-websock.c           |   8 +-
 io/dns-resolver.c              | 265 +++++++++++++++++++++++++++++++++++++++++
 io/task.c                      |  62 +++++++---
 io/trace-events                |   1 -
 migration/socket.c             |  11 +-
 migration/tls.c                |  19 +--
 nbd/common.c                   |   8 +-
 nbd/nbd-internal.h             |   3 +-
 qapi-schema.json               |   5 +
 qemu-char.c                    |  18 +--
 tests/test-io-channel-socket.c |   5 +-
 tests/test-io-channel-tls.c    |   5 +-
 tests/test-io-task.c           |  31 ++---
 ui/vnc-auth-vencrypt.c         |   7 +-
 ui/vnc-ws.c                    |  14 ++-
 util/qemu-sockets.c            |   7 +-
 22 files changed, 745 insertions(+), 168 deletions(-)
 create mode 100644 include/io/dns-resolver.h
 create mode 100644 io/dns-resolver.c
Signature · 1 line
2.9.3
#1 lore raw

PATCH 1/8 sockets: add ability to disable DNS resolution for InetSocketAddress

Add a 'numeric' flag to the InetSocketAddress struct to allow the caller to indicate that DNS should be skipped for the host/port fields. This is useful if the caller knows the address is already numeric and wants to guarantee no (potentially blocking) DNS lookups are attempted.

---
 qapi-schema.json    | 5 +++++
 util/qemu-sockets.c | 3 +++
 2 files changed, 8 insertions(+)
qapi-schema.json +5 -0
index a0d3b5d..d605c1e 100644
@@ -3070,6 +3070,10 @@
 #
 # @port: port part of the address, or lowest port if @to is present
 #
+# @numeric: #optional true if the host/port are guaranteed to be numeric,
+#           false if name resolution should be attempted. Defaults to false.
+#           Since 2.8
+#
 # @to: highest port to try
 #
 # @ipv4: whether to accept IPv4 addresses, default try both IPv4 and IPv6
@@ -3084,6 +3088,7 @@
   'data': {
     'host': 'str',
     'port': 'str',
+    'numeric':  'bool',
     '*to': 'uint16',
     '*ipv4': 'bool',
     '*ipv6': 'bool' } }
util/qemu-sockets.c +3 -0
index fe1d07a..6f1c10a 100644
@@ -141,6 +141,9 @@ static int inet_listen_saddr(InetSocketAddress *saddr,
 
     memset(&ai,0, sizeof(ai));
     ai.ai_flags = AI_PASSIVE;
+    if (saddr->numeric) {
+        ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV;
+    }
     ai.ai_family = inet_ai_family_from_address(saddr, &err);
     ai.ai_socktype = SOCK_STREAM;
 
Signature · 1 line
2.9.3
#4 lore raw

PATCH 2/8 io: stop incrementing reference in qio_task_get_source

In reply to Daniel P. Berrange

Incrementing the reference in qio_task_get_source is not neccessary, since we're not running concurrently with any other code touching the QIOTask. This minimizes chances of further memory leaks.

---
 include/io/task.h    | 7 ++++---
 io/channel-socket.c  | 3 ---
 io/channel-tls.c     | 2 --
 io/task.c            | 1 -
 tests/test-io-task.c | 1 -
 5 files changed, 4 insertions(+), 10 deletions(-)
include/io/task.h +4 -3
index 42028cb..c268eb0 100644
@@ -244,9 +244,10 @@ void qio_task_abort(QIOTask *task,
  * @task: the task struct
  *
  * Get the source object associated with the background
- * task. This returns a new reference to the object,
- * which the caller must released with object_unref()
- * when no longer required.
+ * task. The caller does not own a reference on the
+ * returned Object, and so should call object_ref()
+ * if it wants to keep the object pointer outside the
+ * lifetime of the QIOTask object.
  *
  * Returns: the source object
  */
io/channel-socket.c +0 -3
index d7e03f6..45df819 100644
@@ -168,7 +168,6 @@ static int qio_channel_socket_connect_worker(QIOTask *task,
                                           addr,
                                           errp);
 
-    object_unref(OBJECT(ioc));
     return ret;
 }
 
@@ -231,7 +230,6 @@ static int qio_channel_socket_listen_worker(QIOTask *task,
                                          addr,
                                          errp);
 
-    object_unref(OBJECT(ioc));
     return ret;
 }
 
@@ -309,7 +307,6 @@ static int qio_channel_socket_dgram_worker(QIOTask *task,
                                         data->remoteAddr,
                                         errp);
 
-    object_unref(OBJECT(ioc));
     return ret;
 }
 
io/channel-tls.c +0 -2
index d24dc8c..cf3bcca 100644
@@ -200,8 +200,6 @@ static gboolean qio_channel_tls_handshake_io(QIOChannel *ioc,
     qio_channel_tls_handshake_task(
        tioc, task);
 
-    object_unref(OBJECT(tioc));
-
     return FALSE;
 }
 
io/task.c +0 -1
index c7f97a9..a763990 100644
@@ -156,6 +156,5 @@ void qio_task_abort(QIOTask *task,
 
 Object *qio_task_get_source(QIOTask *task)
 {
-    object_ref(task->source);
     return task->source;
 }
tests/test-io-task.c +0 -1
index e091c12..024eb58 100644
@@ -76,7 +76,6 @@ static void test_task_complete(void)
     g_assert(obj == src);
 
     object_unref(obj);
-    object_unref(src);
 
     g_assert(data.source == obj);
     g_assert(data.err == NULL);
Signature · 1 line
2.9.3
#6 lore raw

PATCH 3/8 io: fix typo in docs for QIOTask

In reply to Daniel P. Berrange

The GDestroyNotify parameter is already a pointer, so does not need a '*' suffix on the type.

---
 include/io/task.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
include/io/task.h +3 -3
index c268eb0..1407747 100644
@@ -49,7 +49,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *  void myobject_operation(QMyObject *obj,
  *                          QIOTaskFunc *func,
  *                          gpointer opaque,
- *                          GDestroyNotify *notify);
+ *                          GDestroyNotify notify);
  *   </programlisting>
  * </example>
  *
@@ -67,7 +67,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *    void myobject_operation(QMyObject *obj,
  *                            QIOTaskFunc *func,
  *                            gpointer opaque,
- *                            GDestroyNotify *notify)
+ *                            GDestroyNotify notify)
  *    {
  *      QIOTask *task;
  *
@@ -154,7 +154,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *                               SocketAddress *addr,
  *                               QIOTaskFunc *func,
  *                               gpointer opaque,
- *                               GDestroyNotify *notify)
+ *                               GDestroyNotify notify)
  *    {
  *      QIOTask *task;
  *      SocketAddress *addrCopy;
Signature · 1 line
2.9.3
#8 lore raw

PATCH 4/8 io: add ability to associate an opaque "result" with with a task

In reply to Daniel P. Berrange

Currently there is no data associated with a successful task completion. This adds an opaque pointer to the task to store an arbitrary result.

---
 include/io/task.h | 27 +++++++++++++++++++++++++++
 io/task.c         | 20 ++++++++++++++++++++
 2 files changed, 47 insertions(+)
include/io/task.h +27 -0
index 1407747..ece1372 100644
@@ -240,6 +240,33 @@ void qio_task_abort(QIOTask *task,
 
 
 /**
+ * qio_task_set_result_pointer:
+ * @task: the task struct
+ * @result: pointer to the result data
+ *
+ * Associate an opaque result with the task,
+ * which can later be retrieved with the
+ * qio_task_get_result_pointer() method
+ *
+ */
+void qio_task_set_result_pointer(QIOTask *task,
+                                 gpointer result,
+                                 GDestroyNotify notify);
+
+
+/**
+ * qio_task_get_result_pointer:
+ * @task: the task struct
+ *
+ * Retrieve the opaque result data associated
+ * with the task, if any.
+ *
+ * Returns: the task result, or NULL
+ */
+gpointer qio_task_get_result_pointer(QIOTask *task);
+
+
+/**
  * qio_task_get_source:
  * @task: the task struct
  *
io/task.c +20 -0
index a763990..675e196 100644
@@ -29,6 +29,8 @@ struct QIOTask {
     QIOTaskFunc func;
     gpointer opaque;
     GDestroyNotify destroy;
+    gpointer result;
+    GDestroyNotify destroyResult;
 };
 
 
@@ -57,6 +59,9 @@ static void qio_task_free(QIOTask *task)
     if (task->destroy) {
         task->destroy(task->opaque);
     }
+    if (task->destroyResult) {
+        task->destroyResult(task->result);
+    }
     object_unref(task->source);
 
     g_free(task);
@@ -154,6 +159,21 @@ void qio_task_abort(QIOTask *task,
 }
 
 
+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)
 {
     return task->source;
Signature · 1 line
2.9.3
#11 lore raw

PATCH 5/8 io: add ability to associate an error with a task

In reply to Daniel P. Berrange

Currently when a task fails, the error is never explicitly associated with the task object, it is just passed along through the completion callback. This adds ability to explicitly associate an error with the task.

---
 include/io/task.h | 29 +++++++++++++++++++++++++++++
 io/task.c         | 23 +++++++++++++++++++++++
 2 files changed, 52 insertions(+)
include/io/task.h +29 -0
index ece1372..244c1a1 100644
@@ -240,6 +240,35 @@ void qio_task_abort(QIOTask *task,
 
 
 /**
+ * qio_task_set_error:
+ * @task: the task struct
+ * @err: pointer to the error
+ *
+ * Associate an error with the task, which can later
+ * be retrieved with the qio_task_propagate_error()
+ * method. This method takes ownership of @err, so
+ * it is not valid to access it after this call
+ * completes.
+ */
+void qio_task_set_error(QIOTask *task,
+                        Error *err);
+
+
+/**
+ * qio_task_propagate_error:
+ * @task: the task struct
+ * @errp: pointer to a NULL-initialized error object
+ *
+ * Propagate the error associated with @task
+ * into @errp.
+ *
+ * Returns: true if an error was propagated, false otherwise
+ */
+gboolean qio_task_propagate_error(QIOTask *task,
+                                  Error **errp);
+
+
+/**
  * qio_task_set_result_pointer:
  * @task: the task struct
  * @result: pointer to the result data
io/task.c +23 -0
index 675e196..1136c75 100644
@@ -29,6 +29,7 @@ struct QIOTask {
     QIOTaskFunc func;
     gpointer opaque;
     GDestroyNotify destroy;
+    Error *err;
     gpointer result;
     GDestroyNotify destroyResult;
 };
@@ -62,6 +63,9 @@ static void qio_task_free(QIOTask *task)
     if (task->destroyResult) {
         task->destroyResult(task->result);
     }
+    if (task->err) {
+        error_free(task->err);
+    }
     object_unref(task->source);
 
     g_free(task);
@@ -159,6 +163,25 @@ void qio_task_abort(QIOTask *task,
 }
 
 
+void qio_task_set_error(QIOTask *task,
+                        Error *err)
+{
+    error_propagate(&task->err, err);
+}
+
+
+gboolean 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)
Signature · 1 line
2.9.3
#14 lore raw

PATCH 6/8 io: change the QIOTask callback signature

In reply to Daniel P. Berrange

Currently the QIOTaskFunc signature takes an Object * for the source, and an Error * for any error. We also need to be able to provide a result pointer. Rather than continue to add parameters to QIOTaskFunc, remove the existing ones and simply pass the QIOTask object instead. This has methods to access all the other data items required in the callback impl.

---
 include/io/task.h              | 73 ++++++++++++++++++++++++------------------
 io/channel-tls.c               | 14 ++++----
 io/channel-websock.c           |  8 ++---
 io/task.c                      | 18 +++--------
 io/trace-events                |  1 -
 migration/socket.c             | 11 ++++---
 migration/tls.c                | 19 +++++------
 nbd/common.c                   |  8 ++---
 nbd/nbd-internal.h             |  3 +-
 qemu-char.c                    | 18 ++++++-----
 tests/test-io-channel-socket.c |  5 ++-
 tests/test-io-channel-tls.c    |  5 ++-
 tests/test-io-task.c           | 18 +++++------
 ui/vnc-auth-vencrypt.c         |  7 ++--
 ui/vnc-ws.c                    | 14 ++++----
 15 files changed, 110 insertions(+), 112 deletions(-)
include/io/task.h +42 -31
index 244c1a1..7b5bc43 100644
@@ -26,8 +26,7 @@
 
 typedef struct QIOTask QIOTask;
 
-typedef void (*QIOTaskFunc)(Object *source,
-                            Error *err,
+typedef void (*QIOTaskFunc)(QIOTask *task,
                             gpointer opaque);
 
 typedef int (*QIOTaskWorker)(QIOTask *task,
@@ -44,7 +43,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  * a public API which accepts a task callback:
  *
  * <example>
- *   <title>Task callback function signature</title>
+ *   <title>Task function signature</title>
  *   <programlisting>
  *  void myobject_operation(QMyObject *obj,
  *                          QIOTaskFunc *func,
@@ -57,12 +56,36 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  * is data to pass to it. The optional 'notify' function is used
  * to free 'opaque' when no longer needed.
  *
- * Now, lets say the implementation of this method wants to set
- * a timer to run once a second checking for completion of some
- * activity. It would do something like
+ * When the operation completes, the 'func' callback will be
+ * invoked, allowing the calling code to determine the result
+ * of the operation. An example QIOTaskFunc impl may look
+ * like
  *
  * <example>
- *   <title>Task callback function implementation</title>
+ *   <title>Task callback implementation</title>
+ *   <programlisting>
+ *  static void myobject_operation_notify(QIOTask *task,
+ *                                        gpointer opaque)
+ *  {
+ *      Error *err = NULL;
+ *      if (qio_task_propagate_error(task, &err)) {
+ *          ...deal with the failure...
+ *          error_free(err);
+ *      } else {
+ *          QMyObject *src = QMY_OBJECT(qio_task_get_source(task));
+ *          ...deal with the completion...
+ *      }
+ *  }
+ *   </programlisting>
+ * </example>
+ *
+ * Now, lets say the implementation of the method using the
+ * task wants to set a timer to run once a second checking
+ * for completion of some  activity. It would do something
+ * like
+ *
+ * <example>
+ *   <title>Task function implementation</title>
  *   <programlisting>
  *    void myobject_operation(QMyObject *obj,
  *                            QIOTaskFunc *func,
@@ -102,8 +125,8 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *
  *      ...check something important...
  *       if (err) {
- *           qio_task_abort(task, err);
- *           error_free(task);
+ *           qio_task_set_error(task, err);
+ *           qio_task_complete(task);
  *           return FALSE;
  *       } else if (...work is completed ...) {
  *           qio_task_complete(task);
@@ -115,6 +138,10 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *   </programlisting>
  * </example>
  *
+ * The 'qio_task_complete' call in this method will trigger
+ * the callback func 'myobject_operation_notify' shown
+ * earlier to deal with the results.
+ *
  * Once this function returns false, object_unref will be called
  * automatically on the task causing it to be released and the
  * ref on QMyObject dropped too.
@@ -187,8 +214,8 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  * 'err' attribute in the task object to determine if
  * the operation was successful or not.
  *
- * The returned task will be released when one of
- * qio_task_abort() or qio_task_complete() are invoked.
+ * The returned task will be released when qio_task_complete()
+ * is invoked.
  *
  * Returns: the task struct
  */
@@ -204,10 +231,8 @@ QIOTask *qio_task_new(Object *source,
  * @opaque: opaque data to pass to @worker
  * @destroy: function to free @opaque
  *
- * Run a task in a background thread. If @worker
- * returns 0 it will call qio_task_complete() in
- * the main event thread context. If @worker
- * returns -1 it will call qio_task_abort() in
+ * Run a task in a background thread. When @worker
+ * returns it will call qio_task_complete() in
  * the main event thread context.
  */
 void qio_task_run_in_thread(QIOTask *task,
@@ -219,25 +244,11 @@ void qio_task_run_in_thread(QIOTask *task,
  * qio_task_complete:
  * @task: the task struct
  *
- * Mark the operation as successfully completed
- * and free the memory for @task.
+ * Invoke the completion callback for @task and
+ * then free its memory.
  */
 void qio_task_complete(QIOTask *task);
 
-/**
- * qio_task_abort:
- * @task: the task struct
- * @err: the error to record for the operation
- *
- * Mark the operation as failed, with @err providing
- * details about the failure. The @err may be freed
- * afer the function returns, as the notification
- * callback is invoked synchronously. The @task will
- * be freed when this call completes.
- */
-void qio_task_abort(QIOTask *task,
-                    Error *err);
-
 
 /**
  * qio_task_set_error:
io/channel-tls.c +6 -8
index cf3bcca..f25ab0a 100644
@@ -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);
 }
 
 
io/channel-websock.c +4 -4
index f45bced..e47279a 100644
@@ -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) {
io/task.c +4 -14
index 1136c75..7da6bdd 100644
@@ -87,13 +87,11 @@ 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);
+    if (data->err) {
+        qio_task_set_error(data->task, data->err);
     }
+    qio_task_complete(data->task);
 
-    error_free(data->err);
     if (data->destroy) {
         data->destroy(data->opaque);
     }
@@ -149,19 +147,11 @@ 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)
-{
-    task->func(task->source, err, task->opaque);
-    trace_qio_task_abort(task);
-    qio_task_free(task);
-}
-
 
 void qio_task_set_error(QIOTask *task,
                         Error *err)
io/trace-events +0 -1
index e31b596..ff993be 100644
@@ -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"
migration/socket.c +6 -5
index 11f80b1..13966f1 100644
@@ -70,22 +70,23 @@ static void socket_connect_data_free(void *opaque)
     g_free(data);
 }
 
-static void socket_outgoing_migration(Object *src,
-                                      Error *err,
+static void socket_outgoing_migration(QIOTask *task,
                                       gpointer opaque)
 {
     struct SocketConnectData *data = opaque;
-    QIOChannel *sioc = QIO_CHANNEL(src);
+    QIOChannel *sioc = QIO_CHANNEL(qio_task_get_source(task));
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         trace_migration_socket_outgoing_error(error_get_pretty(err));
         data->s->to_dst_file = NULL;
         migrate_fd_error(data->s, err);
+        error_free(err);
     } else {
         trace_migration_socket_outgoing_connected(data->hostname);
         migration_channel_connect(data->s, sioc, data->hostname);
     }
-    object_unref(src);
+    object_unref(OBJECT(sioc));
 }
 
 static void socket_start_outgoing_migration(MigrationState *s,
migration/tls.c +10 -9
index 49ca9a8..203c11d 100644
@@ -61,15 +61,15 @@ migration_tls_get_creds(MigrationState *s,
 }
 
 
-static void migration_tls_incoming_handshake(Object *src,
-                                             Error *err,
+static void migration_tls_incoming_handshake(QIOTask *task,
                                              gpointer opaque)
 {
-    QIOChannel *ioc = QIO_CHANNEL(src);
+    QIOChannel *ioc = QIO_CHANNEL(qio_task_get_source(task));
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         trace_migration_tls_incoming_handshake_error(error_get_pretty(err));
-        error_report("%s", error_get_pretty(err));
+        error_report_err(err);
     } else {
         trace_migration_tls_incoming_handshake_complete();
         migration_channel_process_incoming(migrate_get_current(), ioc);
@@ -107,17 +107,18 @@ void migration_tls_channel_process_incoming(MigrationState *s,
 }
 
 
-static void migration_tls_outgoing_handshake(Object *src,
-                                             Error *err,
+static void migration_tls_outgoing_handshake(QIOTask *task,
                                              gpointer opaque)
 {
     MigrationState *s = opaque;
-    QIOChannel *ioc = QIO_CHANNEL(src);
+    QIOChannel *ioc = QIO_CHANNEL(qio_task_get_source(task));
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         trace_migration_tls_outgoing_handshake_error(error_get_pretty(err));
         s->to_dst_file = NULL;
         migrate_fd_error(s, err);
+        error_free(err);
     } else {
         trace_migration_tls_outgoing_handshake_complete();
         migration_channel_connect(s, ioc, NULL);
nbd/common.c +3 -5
index b583a4f..a5f39ea 100644
@@ -78,15 +78,13 @@ ssize_t nbd_wr_syncv(QIOChannel *ioc,
 }
 
 
-void nbd_tls_handshake(Object *src,
-                       Error *err,
+void nbd_tls_handshake(QIOTask *task,
                        void *opaque)
 {
     struct NBDTLSHandshakeData *data = opaque;
 
-    if (err) {
-        TRACE("TLS failed %s", error_get_pretty(err));
-        data->error = error_copy(err);
+    if (qio_task_propagate_error(task, &data->error)) {
+        TRACE("TLS failed %s", error_get_pretty(data->error));
     }
     data->complete = true;
     g_main_loop_quit(data->loop);
nbd/nbd-internal.h +1 -2
index eee20ab..f43d990 100644
@@ -120,8 +120,7 @@ struct NBDTLSHandshakeData {
 };
 
 
-void nbd_tls_handshake(Object *src,
-                       Error *err,
+void nbd_tls_handshake(QIOTask *task,
                        void *opaque);
 
 #endif
qemu-char.c +10 -8
index 2c9940c..502d50a 100644
@@ -3272,14 +3272,13 @@ static void tcp_chr_telnet_init(CharDriverState *chr)
 }
 
 
-static void tcp_chr_tls_handshake(Object *source,
-                                  Error *err,
+static void tcp_chr_tls_handshake(QIOTask *task,
                                   gpointer user_data)
 {
     CharDriverState *chr = user_data;
     TCPCharDriver *s = chr->opaque;
 
-    if (err) {
+    if (qio_task_propagate_error(task, NULL)) {
         tcp_chr_disconnect(chr);
     } else {
         if (s->do_telnetopt) {
@@ -3487,20 +3486,23 @@ static void tcp_chr_free(CharDriverState *chr)
 }
 
 
-static void qemu_chr_socket_connected(Object *src, Error *err, void *opaque)
+static void qemu_chr_socket_connected(QIOTask *task, void *opaque)
 {
-    QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(src);
+    QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(qio_task_get_source(task));
     CharDriverState *chr = opaque;
     TCPCharDriver *s = chr->opaque;
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         check_report_connect_error(chr, err);
-        object_unref(src);
-        return;
+        error_free(err);
+        goto cleanup;
     }
 
     s->connect_err_reported = false;
     tcp_chr_new_client(chr, sioc);
+
+ cleanup:
     object_unref(OBJECT(sioc));
 }
 
tests/test-io-channel-socket.c +2 -3
index aa88c3c..aaa9116 100644
@@ -156,12 +156,11 @@ struct TestIOChannelData {
 };
 
 
-static void test_io_channel_complete(Object *src,
-                                     Error *err,
+static void test_io_channel_complete(QIOTask *task,
                                      gpointer opaque)
 {
     struct TestIOChannelData *data = opaque;
-    data->err = err != NULL;
+    data->err = qio_task_propagate_error(task, NULL);
     g_main_loop_quit(data->loop);
 }
 
tests/test-io-channel-tls.c +2 -3
index bd3ae2b..8eaa208 100644
@@ -53,14 +53,13 @@ struct QIOChannelTLSHandshakeData {
     bool failed;
 };
 
-static void test_tls_handshake_done(Object *source,
-                                    Error *err,
+static void test_tls_handshake_done(QIOTask *task,
                                     gpointer opaque)
 {
     struct QIOChannelTLSHandshakeData *data = opaque;
 
     data->finished = true;
-    data->failed = err != NULL;
+    data->failed = qio_task_propagate_error(task, NULL);
 }
 
 
tests/test-io-task.c +8 -10
index 024eb58..84144c9 100644
@@ -50,14 +50,13 @@ struct TestTaskData {
 };
 
 
-static void task_callback(Object *source,
-                          Error *err,
+static void task_callback(QIOTask *task,
                           gpointer opaque)
 {
     struct TestTaskData *data = opaque;
 
-    data->source = source;
-    data->err = err;
+    data->source = qio_task_get_source(task);
+    qio_task_propagate_error(task, &data->err);
 }
 
 
@@ -120,9 +119,9 @@ static void test_task_failure(void)
 
     error_setg(&err, "Some error");
 
-    qio_task_abort(task, err);
+    qio_task_set_error(task, err);
+    qio_task_complete(task);
 
-    error_free(err);
     object_unref(obj);
 
     g_assert(data.source == obj);
@@ -158,14 +157,13 @@ static int test_task_thread_worker(QIOTask *task,
 }
 
 
-static void test_task_thread_callback(Object *source,
-                                      Error *err,
+static void test_task_thread_callback(QIOTask *task,
                                       gpointer opaque)
 {
     struct TestThreadWorkerData *data = opaque;
 
-    data->source = source;
-    data->err = err;
+    data->source = qio_task_get_source(task);
+    qio_task_propagate_error(task, &data->err);
 
     data->complete = g_thread_self();
 
ui/vnc-auth-vencrypt.c +4 -3
index c0c29a5..ffaab57 100644
@@ -65,16 +65,17 @@ static void start_auth_vencrypt_subauth(VncState *vs)
     }
 }
 
-static void vnc_tls_handshake_done(Object *source,
-                                   Error *err,
+static void vnc_tls_handshake_done(QIOTask *task,
                                    gpointer user_data)
 {
     VncState *vs = user_data;
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         VNC_DEBUG("Handshake failed %s\n",
                   error_get_pretty(err));
         vnc_client_error(vs);
+        error_free(err);
     } else {
         vs->ioc_tag = qio_channel_add_watch(
             vs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL);
ui/vnc-ws.c +8 -6
index bffb484..f530cd5 100644
@@ -24,15 +24,16 @@
 #include "io/channel-websock.h"
 #include "qemu/bswap.h"
 
-static void vncws_tls_handshake_done(Object *source,
-                                     Error *err,
+static void vncws_tls_handshake_done(QIOTask *task,
                                      gpointer user_data)
 {
     VncState *vs = user_data;
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         VNC_DEBUG("Handshake failed %s\n", error_get_pretty(err));
         vnc_client_error(vs);
+        error_free(err);
     } else {
         VNC_DEBUG("TLS handshake complete, starting websocket handshake\n");
         vs->ioc_tag = qio_channel_add_watch(
@@ -83,15 +84,16 @@ gboolean vncws_tls_handshake_io(QIOChannel *ioc G_GNUC_UNUSED,
 }
 
 
-static void vncws_handshake_done(Object *source,
-                                 Error *err,
+static void vncws_handshake_done(QIOTask *task,
                                  gpointer user_data)
 {
     VncState *vs = user_data;
+    Error *err = NULL;
 
-    if (err) {
+    if (qio_task_propagate_error(task, &err)) {
         VNC_DEBUG("Websock handshake failed %s\n", error_get_pretty(err));
         vnc_client_error(vs);
+        error_free(err);
     } else {
         VNC_DEBUG("Websock handshake complete, starting VNC protocol\n");
         vnc_start_protocol(vs);
Signature · 1 line
2.9.3
#17 lore raw

PATCH 7/8 io: remove Error parameter from QIOTask thread worker

In reply to Daniel P. Berrange

Now that task objects have a directly associated error, there's no need for an an Error **errp parameter to the QIOTask thread worker function. It already has a QIOTask object, so can directly set the error on it.

---
 include/io/task.h    | 19 +++++++++----------
 io/channel-socket.c  | 47 ++++++++++++++++++++++-------------------------
 io/task.c            | 10 +---------
 tests/test-io-task.c | 12 +++++-------
 4 files changed, 37 insertions(+), 51 deletions(-)
include/io/task.h +9 -10
index 7b5bc43..dca57dc 100644
@@ -29,9 +29,8 @@ typedef struct QIOTask QIOTask;
 typedef void (*QIOTaskFunc)(QIOTask *task,
                             gpointer opaque);
 
-typedef int (*QIOTaskWorker)(QIOTask *task,
-                             Error **errp,
-                             gpointer opaque);
+typedef void (*QIOTaskWorker)(QIOTask *task,
+                              gpointer opaque);
 
 /**
  * QIOTask:
@@ -163,18 +162,18 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  * socket listen using QIOTask would require:
  *
  * <example>
- *    static int myobject_listen_worker(QIOTask *task,
- *                                      Error **errp,
- *                                      gpointer opaque)
+ *    static void myobject_listen_worker(QIOTask *task,
+ *                                       gpointer opaque)
  *    {
  *       QMyObject obj = QMY_OBJECT(qio_task_get_source(task));
  *       SocketAddress *addr = opaque;
+ *       Error *err = NULL;
  *
- *       obj->fd = socket_listen(addr, errp);
- *       if (obj->fd < 0) {
- *          return -1;
+ *       obj->fd = socket_listen(addr, &err);
+ *
+ *       if (err) {
+ *           qio_task_set_error(task, err);
  *       }
- *       return 0;
  *    }
  *
  *    void myobject_listen_async(QMyObject *obj,
io/channel-socket.c +22 -25

81 lines not on this page · raw message

io/task.c +1 -9
index 7da6bdd..448ec67 100644
@@ -77,8 +77,6 @@ struct QIOTaskThreadData {
     QIOTaskWorker worker;
     gpointer opaque;
     GDestroyNotify destroy;
-    Error *err;
-    int ret;
 };
 
 
@@ -87,9 +85,6 @@ static gboolean gio_task_thread_result(gpointer opaque)
     struct QIOTaskThreadData *data = opaque;
 
     trace_qio_task_thread_result(data->task);
-    if (data->err) {
-        qio_task_set_error(data->task, data->err);
-    }
     qio_task_complete(data->task);
 
     if (data->destroy) {
@@ -107,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
tests/test-io-task.c +5 -7
index 84144c9..ff62272 100644
@@ -140,20 +140,18 @@ struct TestThreadWorkerData {
     GMainLoop *loop;
 };
 
-static int test_task_thread_worker(QIOTask *task,
-                                   Error **errp,
-                                   gpointer opaque)
+static void test_task_thread_worker(QIOTask *task,
+                                    gpointer opaque)
 {
     struct TestThreadWorkerData *data = opaque;
 
     data->worker = g_thread_self();
 
     if (data->fail) {
-        error_setg(errp, "Testing fail");
-        return -1;
+        Error *err = NULL;
+        error_setg(&err, "Testing fail");
+        qio_task_set_error(task, err);
     }
-
-    return 0;
 }
 
 
Signature · 1 line
2.9.3
#19 lore raw

PATCH 8/8 io: introduce a DNS resolver API

In reply to Daniel P. Berrange

Currently DNS resolution is done automatically as part of the creation of a QIOChannelSocket object instance. This works ok for network clients where you just end up a single network socket, but for servers, the results of DNS resolution may require creation of multiple sockets.

Introducing a DNS resolver API allows DNS resolution to be separated from the socket object creation. This will make it practical to create multiple QIOChannelSocket instances for servers.

---
 include/io/dns-resolver.h | 224 +++++++++++++++++++++++++++++++++++++++
 include/qemu/sockets.h    |   2 +
 io/Makefile.objs          |   1 +
 io/dns-resolver.c         | 265 ++++++++++++++++++++++++++++++++++++++++++++++
 util/qemu-sockets.c       |   4 +-
 5 files changed, 494 insertions(+), 2 deletions(-)
 create mode 100644 include/io/dns-resolver.h
 create mode 100644 io/dns-resolver.c
include/io/dns-resolver.h new file +224 -0
new file mode 100644
index 0000000..5121e65
@@ -0,0 +1,224 @@
+/*
+ * 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/>.
+ *
+ */
+
+#ifndef QIO_DNS_RESOLVER_H
+#define QIO_DNS_RESOLVER_H
+
+#include "qemu-common.h"
+#include "qom/object.h"
+#include "io/task.h"
+
+#define TYPE_QIO_DNS_RESOLVER "qio-dns-resolver"
+#define QIO_DNS_RESOLVER(obj)                                    \
+    OBJECT_CHECK(QIODNSResolver, (obj), TYPE_QIO_DNS_RESOLVER)
+#define QIO_DNS_RESOLVER_CLASS(klass)                                    \
+    OBJECT_CLASS_CHECK(QIODNSResolverClass, klass, TYPE_QIO_DNS_RESOLVER)
+#define QIO_DNS_RESOLVER_GET_CLASS(obj)                                  \
+    OBJECT_GET_CLASS(QIODNSResolverClass, obj, TYPE_QIO_DNS_RESOLVER)
+
+typedef struct QIODNSResolver QIODNSResolver;
+typedef struct QIODNSResolverClass QIODNSResolverClass;
+
+/**
+ * QIODNSResolver:
+ *
+ * The QIODNSResolver class provides a framework for doing
+ * DNS resolution on SocketAddress objects, independently
+ * of socket creation.
+ *
+ * <example>
+ *   <title>Resolving addresses synchronously</title>
+ *   <programlisting>
+ *    int mylisten(SocketAddress *addr, Error **errp) {
+ *      QIODNSResolver *resolver = qio_dns_resolver_get_instance();
+ *      SocketAddress **rawaddrs = NULL;
+ *      size_t nrawaddrs = 0;
+ *      Error *err = NULL;
+ *      QIOChannel **socks = NULL;
+ *      size_t nsocks = 0;
+ *
+ *      if (qio_dns_resolver_lookup_sync(dns, addr, &nrawaddrs,
+ *                                       &rawaddrs, &err) < 0) {
+ *          error_propagate(errp, err);
+ *          return -1;
+ *      }
+ *
+ *      for (i = 0; i < nrawaddrs; i++) {
+ *         QIOChannel *sock = qio_channel_new();
+ *         Error *local_err = NULL;
+ *         qio_channel_listen_sync(sock, rawaddrs[i], &local_err);
+ *         if (local_err && !err) {
+ *            error_propagate(err, local_err);
+ *         } else {
+ *            socks = g_renew(QIOChannelSocket *, socks, nsocks + 1);
+ *            socks[nsocks++] = sock;
+ *         }
+ *      }
+ *
+ *      if (nsocks == 0) {
+ *         error_propagate(errp, err);
+ *      } else {
+ *         error_free(err);
+ *      }
+ *   }
+ *   </programlisting>
+ * </example>
+ *
+ * <example>
+ *   <title>Resolving addresses asynchronously</title>
+ *   <programlisting>
+ *    typedef struct MyListenData {
+ *       Error *err;
+ *       QIOChannelSocket **socks;
+ *       size_t nsocks;
+ *    } MyListenData;
+ *
+ *    void mylistenresult(QIOTask *task, void *opaque) {
+ *      MyListenData *data = opaque;
+ *      QIODNSResolver *resolver =
+ *         QIO_DNS_RESOLVER(qio_task_get_source(task);
+ *      SocketAddress **rawaddrs = NULL;
+ *      size_t nrawaddrs = 0;
+ *      Error *err = NULL;
+ *
+ *      if (qio_task_propagate_error(task, &data->err)) {
+ *         return;
+ *      }
+ *
+ *      qio_dns_resolver_lookup_result(resolver, task,
+ *                                     &nrawaddrs, &rawaddrs);
+ *
+ *      for (i = 0; i < nrawaddrs; i++) {
+ *         QIOChannel *sock = qio_channel_new();
+ *         Error *local_err = NULL;
+ *         qio_channel_listen_sync(sock, rawaddrs[i], &local_err);
+ *         if (local_err && !err) {
+ *            error_propagate(err, local_err);
+ *         } else {
+ *            socks = g_renew(QIOChannelSocket *, socks, nsocks + 1);
+ *            socks[nsocks++] = sock;
+ *         }
+ *      }
+ *
+ *      if (nsocks == 0) {
+ *         error_propagate(&data->err, err);
+ *      } else {
+ *         error_free(err);
+ *      }
+ *    }
+ *
+ *    void mylisten(SocketAddress *addr, MyListenData *data) {
+ *      QIODNSResolver *resolver = qio_dns_resolver_get_instance();
+ *      qio_dns_resolver_lookup_async(dns, addr,
+ *                                    mylistenresult, data, NULL);
+ *    }
+ *   </programlisting>
+ * </example>
+ */
+struct QIODNSResolver {
+    Object parent;
+};
+
+struct QIODNSResolverClass {
+    ObjectClass parent;
+};
+
+
+/**
+ * qio_dns_resolver_get_instance:
+ *
+ * Get the singleton dns resolver instance. The caller
+ * does not own a reference on the returned object.
+ *
+ * Returns: the single dns resolver instance
+ */
+QIODNSResolver *qio_dns_resolver_get_instance(void);
+
+/**
+ * qio_dns_resolver_lookup_sync:
+ * @resolver: the DNS resolver instance
+ * @addr: the address to resolve
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ * @errp: pointer to NULL initialized error object
+ *
+ * This will attempt to resolve the address provided
+ * in @addr. If resolution succeeds, @addrs will be filled
+ * with all the resolved addresses. @naddrs will specify
+ * the number of entries allocated in @addrs. The caller
+ * is responsible for freeing each entry in @addrs, as
+ * well as @addrs itself.
+ *
+ * DNS resolution will be done synchronously so execution
+ * of the caller may be blocked for an arbitrary length
+ * of time.
+ *
+ * Returns: 0 if resolution was successful, -1 on error
+ */
+int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver,
+                                 SocketAddress *addr,
+                                 size_t *naddrs,
+                                 SocketAddress ***addrs,
+                                 Error **errp);
+
+/**
+ * qio_dns_resolver_lookup_sync:
+ * @resolver: the DNS resolver instance
+ * @addr: the address to resolve
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ * @errp: pointer to NULL initialized error object
+ *
+ * This will attempt to resolve the address provided
+ * in @addr. The callback @func will be invoked when
+ * resolution has either completed or failed. On
+ * success, the @func should call the method
+ * qio_dns_resolver_lookup_result() to obtain the
+ * results.
+ *
+ * DNS resolution will be done asynchronously so execution
+ * of the caller will not be blocked.
+ */
+void qio_dns_resolver_lookup_async(QIODNSResolver *resolver,
+                                   SocketAddress *addr,
+                                   QIOTaskFunc func,
+                                   gpointer opaque,
+                                   GDestroyNotify notify);
+
+/**
+ * qio_dns_resolver_lookup_result:
+ * @resolver: the DNS resolver instance
+ * @task: the task object to get results for
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ *
+ * This method should be called from the callback passed
+ * to qio_dns_resolver_lookup_async() in order to obtain
+ * results.  @addrs will be filled with all the resolved
+ * addresses. @naddrs will specify the number of entries
+ * allocated in @addrs. The caller is responsible for
+ * freeing each entry in @addrs, as well as @addrs itself.
+ */
+void qio_dns_resolver_lookup_result(QIODNSResolver *resolver,
+                                    QIOTask *task,
+                                    size_t *naddrs,
+                                    SocketAddress ***addrs);
+
+#endif /* QIO_DNS_RESOLVER_H */
include/qemu/sockets.h +2 -0
index 5589e68..5f1bab9 100644
@@ -32,6 +32,8 @@ int socket_set_fast_reuse(int fd);
  */
 typedef void NonBlockingConnectHandler(int fd, Error *err, void *opaque);
 
+int inet_ai_family_from_address(InetSocketAddress *addr,
+                                Error **errp);
 InetSocketAddress *inet_parse(const char *str, Error **errp);
 int inet_connect(const char *str, Error **errp);
 int inet_connect_saddr(InetSocketAddress *saddr, Error **errp,
io/Makefile.objs +1 -0
index 9d8337d..12983cc 100644
@@ -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
io/dns-resolver.c new file +265 -0

265 lines not on this page · raw message

util/qemu-sockets.c +2 -2
index 6f1c10a..ed31a1d 100644
@@ -110,8 +110,8 @@ NetworkAddressFamily inet_netfamily(int family)
  * outside scope of this method and not currently handled by
  * callers at all.
  */
-static int inet_ai_family_from_address(InetSocketAddress *addr,
-                                       Error **errp)
+int inet_ai_family_from_address(InetSocketAddress *addr,
+                                Error **errp)
 {
     if (addr->has_ipv6 && addr->has_ipv4 &&
         !addr->ipv6 && !addr->ipv4) {
Signature · 1 line
2.9.3
#2 lore raw

Re: [Qemu-devel] [PATCH 1/8] sockets: add ability to disable DNS resolution for InetSocketAddress

In reply to Daniel P. Berrange
Quoted 17 lines · Daniel P. Berrange

Add a 'numeric' flag to the InetSocketAddress struct to allow the caller to indicate that DNS should be skipped for the host/port fields. This is useful if the caller knows the address is already numeric and wants to guarantee no (potentially blocking) DNS lookups are attempted.

---
 qapi-schema.json    | 5 +++++
 util/qemu-sockets.c | 3 +++
 2 files changed, 8 insertions(+)
qapi-schema.json +0 -0
index a0d3b5d..d605c1e 100644

qapi-schema.json line 3075

Quoted 6 lines
qapi-schema.json +3 -0
@@ -3070,6 +3070,10 @@
 #
 # @port: port part of the address, or lowest port if @to is present
 #
+# @numeric: #optional true if the host/port are guaranteed to be numeric,
+#           false if name resolution should be attempted. Defaults to false.
+#           Since 2.8

2.9, actually. I'm also not sure if Marc-Andre's work requires () brackets around the since designation on a per-member listing.

qapi-schema.json line 3091

Quoted 5 lines
qapi-schema.json +1 -0
@@ -3084,6 +3088,7 @@
   'data': {
     'host': 'str',
     'port': 'str',
+    'numeric':  'bool',

In order to be optional, it must be spelled '*numeric'.

qapi-schema.json line 3094

Quoted 3 lines
qapi-schema.json +0 -0
     '*to': 'uint16',
     '*ipv4': 'bool',
     '*ipv6': 'bool' } }

Thinking out loud: Do we even need a 'numeric' field? If we could create an alternate type that distinguishes between a 'str' (name, DNS resolution required) and an 'int' (numeric, skip DNS), then we don't need a field. Except that an 'int' for IPv4 addresses is awkward, and an 'int' for IPv6 addresses in insufficient - so even when the address is numeric, you STILL have to pass it in as 'str'. Okay, experiment failed, your interface seems like the correct thing to do.

util/qemu-sockets.c static int inet_listen_saddr(InetSocketAddress *saddr, · line 144

Quoted 9 lines
util/qemu-sockets.c +1 -0
index fe1d07a..6f1c10a 100644
@@ -141,6 +141,9 @@ static int inet_listen_saddr(InetSocketAddress *saddr,
 
     memset(&ai,0, sizeof(ai));
     ai.ai_flags = AI_PASSIVE;
+    if (saddr->numeric) {

if (saddr->has_numeric && saddr->numeric)

Quoted 6 lines
util/qemu-sockets.c +2 -0
+        ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV;
+    }
     ai.ai_family = inet_ai_family_from_address(saddr, &err);
     ai.ai_socktype = SOCK_STREAM;
 
Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
Reviewed-by on v1 2/8
#5 lore raw

Re: [Qemu-devel] [PATCH 2/8] io: stop incrementing reference in qio_task_get_source

In reply to Daniel P. Berrange
Quoted 2 lines · Daniel P. Berrange

Incrementing the reference in qio_task_get_source is not neccessary, since we're not running concurrently

s/neccessary/necessary/

Quoted 12 lines

with any other code touching the QIOTask. This
minimizes chances of further memory leaks.

---
 include/io/task.h    | 7 ++++---
 io/channel-socket.c  | 3 ---
 io/channel-tls.c     | 2 --
 io/task.c            | 1 -
 tests/test-io-task.c | 1 -
 5 files changed, 4 insertions(+), 10 deletions(-)
Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#3 lore raw

Re: [Qemu-devel] [PATCH 1/8] sockets: add ability to disable DNS resolution for InetSocketAddress

In reply to Eric Blake
Quoted 28 lines · Eric Blake
Quoted 17 lines · Daniel P. Berrange

Add a 'numeric' flag to the InetSocketAddress struct to allow the caller to indicate that DNS should be skipped for the host/port fields. This is useful if the caller knows the address is already numeric and wants to guarantee no (potentially blocking) DNS lookups are attempted.

---
 qapi-schema.json    | 5 +++++
 util/qemu-sockets.c | 3 +++
 2 files changed, 8 insertions(+)
qapi-schema.json +0 -0
index a0d3b5d..d605c1e 100644

qapi-schema.json line 3075

Quoted 6 lines
qapi-schema.json +3 -0
@@ -3070,6 +3070,10 @@
 #
 # @port: port part of the address, or lowest port if @to is present
 #
+# @numeric: #optional true if the host/port are guaranteed to be numeric,
+#           false if name resolution should be attempted. Defaults to false.
+#           Since 2.8

2.9, actually. I'm also not sure if Marc-Andre's work requires () brackets around the since designation on a per-member listing.

Quoted 7 lines

qapi-schema.json line 3091

Quoted 5 lines
qapi-schema.json +1 -0
@@ -3084,6 +3088,7 @@
   'data': {
     'host': 'str',
     'port': 'str',
+    'numeric':  'bool',

In order to be optional, it must be spelled '*numeric'.

Sigh, yes.

Quoted 11 lines

qapi-schema.json line 3094

Quoted 3 lines
qapi-schema.json +0 -0
     '*to': 'uint16',
     '*ipv4': 'bool',
     '*ipv6': 'bool' } }

Thinking out loud: Do we even need a 'numeric' field? If we could create an alternate type that distinguishes between a 'str' (name, DNS resolution required) and an 'int' (numeric, skip DNS), then we don't need a field. Except that an 'int' for IPv4 addresses is awkward, and an 'int' for IPv6 addresses in insufficient - so even when the address is numeric, you STILL have to pass it in as 'str'. Okay, experiment failed, your interface seems like the correct thing to do.

Basically think of this 'numeric' flag as being the same as the AI_NUMERIC flag to getaddrinfo. You're still using the string format as input so that you can reuse existing code for converting from user friendly string format to raw byte format.

Regards,
Daniel

Signature · 3 lines
|: http://berrange.com      -o-    http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org              -o-             http://virt-manager.org :|
|: http://entangle-photo.org       -o-    http://search.cpan.org/~danberr/ :|
Reviewed-by on v1 3/8
#7 lore raw

Re: [Qemu-devel] [PATCH 3/8] io: fix typo in docs for QIOTask

In reply to Daniel P. Berrange

include/io/task.h

Quoted 9 lines · Daniel P. Berrange

The GDestroyNotify parameter is already a pointer, so does not need a '*' suffix on the type.

---
 include/io/task.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
include/io/task.h +0 -0
Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
Reviewed-by on v1 4/8
#9 lore raw

Re: [Qemu-devel] [PATCH 4/8] io: add ability to associate an opaque "result" with with a task

In reply to Daniel P. Berrange
Quoted 10 lines · Daniel P. Berrange

Currently there is no data associated with a successful task completion. This adds an opaque pointer to the task to store an arbitrary result.

---
 include/io/task.h | 27 +++++++++++++++++++++++++++
 io/task.c         | 20 ++++++++++++++++++++
 2 files changed, 47 insertions(+)

I suppose a different approach would have been changing QIOTaskFunc() to have a void* return, but that would be more invasive. Grabbing the result separately from the task completing is a bit weird, but looks like it will work.

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#12 lore raw

Re: [Qemu-devel] [PATCH 5/8] io: add ability to associate an error with a task

In reply to Daniel P. Berrange
Quoted 3 lines · Daniel P. Berrange

Currently when a task fails, the error is never explicitly associated with the task object, it is just passed along through the completion callback. This adds ability to

s/adds/adds the/

Quoted 18 lines

explicitly associate an error with the task.

---
 include/io/task.h | 29 +++++++++++++++++++++++++++++
 io/task.c         | 23 +++++++++++++++++++++++
 2 files changed, 52 insertions(+)
include/io/task.h +2 -0
index ece1372..244c1a1 100644
@@ -240,6 +240,35 @@ void qio_task_abort(QIOTask *task,
 
 
 /**
+ * qio_task_set_error:
+ * @task: the task struct

include/io/task.h void qio_task_abort(QIOTask *task, · line 254

Quoted 10 lines
include/io/task.h +10 -0
+ * @err: pointer to the error
+ *
+ * Associate an error with the task, which can later
+ * be retrieved with the qio_task_propagate_error()
+ * method. This method takes ownership of @err, so
+ * it is not valid to access it after this call
+ * completes.
+ */
+void qio_task_set_error(QIOTask *task,
+                        Error *err);

Is it valid for @err to be NULL (or put another way, may callers blindly call this function whether or not an error has occurred)?...

include/io/task.h void qio_task_abort(QIOTask *task, · line 267

Quoted 13 lines
include/io/task.h +13 -0
+
+
+/**
+ * qio_task_propagate_error:
+ * @task: the task struct
+ * @errp: pointer to a NULL-initialized error object
+ *
+ * Propagate the error associated with @task
+ * into @errp.
+ *
+ * Returns: true if an error was propagated, false otherwise
+ */
+gboolean qio_task_propagate_error(QIOTask *task,

Must this return 'gboolean' (in which case the docs should mention TRUE/FALSE rather than true/false)? Or can we make it return the nicer 'bool'?

Quoted 30 lines
include/io/task.h +4 -0
+                                  Error **errp);
+
+
+/**
  * qio_task_set_result_pointer:
  * @task: the task struct
  * @result: pointer to the result data
io/task.c +4 -0
index 675e196..1136c75 100644
@@ -29,6 +29,7 @@ struct QIOTask {
     QIOTaskFunc func;
     gpointer opaque;
     GDestroyNotify destroy;
+    Error *err;
     gpointer result;
     GDestroyNotify destroyResult;
 };
@@ -62,6 +63,9 @@ static void qio_task_free(QIOTask *task)
     if (task->destroyResult) {
         task->destroyResult(task->result);
     }
+    if (task->err) {
+        error_free(task->err);
+    }
     object_unref(task->source);
 
     g_free(task);

io/task.c void qio_task_abort(QIOTask *task, · line 169

Quoted 7 lines
io/task.c +4 -0
@@ -159,6 +163,25 @@ void qio_task_abort(QIOTask *task,
 }
 
 
+void qio_task_set_error(QIOTask *task,
+                        Error *err)
+{
+    error_propagate(&task->err, err);

...As written, qio_task_set_error(task, NULL) is thus valid as a no-op; and in turn, qio_task_set_error(task, err) is unconditionally valid a cleanup path regardless of whether the cleanup was reached on success (err is still NULL) or failure (err is set). But it's worth documenting.

In fact, error_propagate() can be called more than once (first call wins, all later calls silently drop the subsequent error in favor of a first one already present), and therefore qio_task_set_error() gains that same property. Worth documenting?

io/task.c void qio_task_abort(QIOTask *task, · line 181

Quoted 12 lines
io/task.c +12 -0
+}
+
+
+gboolean qio_task_propagate_error(QIOTask *task,
+                                  Error **errp)
+{
+    if (task->err) {
+        error_propagate(errp, task->err);
+        return TRUE;
+    }
+
+    return FALSE;

Again, I think a 'bool' return (and true/false) is nicer.

io/task.c void qio_task_abort(QIOTask *task, · line 187

Quoted 7 lines
io/task.c +3 -0
+}
+
+
 void qio_task_set_result_pointer(QIOTask *task,
                                  gpointer result,
                                  GDestroyNotify destroy)

The idea makes sense, though.

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
Reviewed-by on v1 6/8
#15 lore raw

Re: [Qemu-devel] [PATCH 6/8] io: change the QIOTask callback signature

In reply to Daniel P. Berrange
Quoted 7 lines · Daniel P. Berrange

Currently the QIOTaskFunc signature takes an Object * for the source, and an Error * for any error. We also need to be able to provide a result pointer. Rather than continue to add parameters to QIOTaskFunc, remove the existing ones and simply pass the QIOTask object instead. This has methods to access all the other data items required in the callback impl.

Hmmm. If you're going to change the callback signature after all, then is it worth considering having the callback return void* instead of the clunky way of passing the result pointer around, with existing callers updated to return NULL if they have nothing better to do? Accessing the error pointer through the QIOTask object seems okay, it's just the return type that feels clunky.

But that's bike-shedding, so I'll review as written.

Quoted 34 lines
---
 include/io/task.h              | 73 ++++++++++++++++++++++++------------------
 io/channel-tls.c               | 14 ++++----
 io/channel-websock.c           |  8 ++---
 io/task.c                      | 18 +++--------
 io/trace-events                |  1 -
 migration/socket.c             | 11 ++++---
 migration/tls.c                | 19 +++++------
 nbd/common.c                   |  8 ++---
 nbd/nbd-internal.h             |  3 +-
 qemu-char.c                    | 18 ++++++-----
 tests/test-io-channel-socket.c |  5 ++-
 tests/test-io-channel-tls.c    |  5 ++-
 tests/test-io-task.c           | 18 +++++------
 ui/vnc-auth-vencrypt.c         |  7 ++--
 ui/vnc-ws.c                    | 14 ++++----
 15 files changed, 110 insertions(+), 112 deletions(-)
include/io/task.h +1 -2
index 244c1a1..7b5bc43 100644
@@ -26,8 +26,7 @@
 
 typedef struct QIOTask QIOTask;
 
-typedef void (*QIOTaskFunc)(Object *source,
-                            Error *err,
+typedef void (*QIOTaskFunc)(QIOTask *task,
                             gpointer opaque);
 
 
Quoted 7 lines

*
- * Now, lets say the implementation of this method wants to set
- * a timer to run once a second checking for completion of some
- * activity. It would do something like
+ * When the operation completes, the 'func' callback will be
+ * invoked, allowing the calling code to determine the result
+ * of the operation. An example QIOTaskFunc impl may look

Worth spelling out 'implementation' in the docs?

Quoted 16 lines

+ * like
*
* <example>

- *   <title>Task callback function implementation</title>
+ *   <title>Task callback implementation</title>
+ *   <programlisting>

+ * static void myobject_operation_notify(QIOTask *task,
+ * gpointer opaque)
+ * {
+ * Error *err = NULL;
+ * if (qio_task_propagate_error(task, &err)) {
+ * ...deal with the failure...
+ * error_free(err);
+ * } else {
+ * QMyObject *src = QMY_OBJECT(qio_task_get_source(task));
+ * ...deal with the completion...

Quoted 8 lines

+ * }
+ * }
+ * </programlisting>
+ * </example>
+ *
+ * Now, lets say the implementation of the method using the
+ * task wants to set a timer to run once a second checking
+ * for completion of some activity. It would do something

Why two spaces after 'some'?

Quoted 8 lines

+ * like
+ *
+ * <example>
+ * <title>Task function implementation</title>
* <programlisting>
* void myobject_operation(QMyObject *obj,
* QIOTaskFunc *func,

include/io/task.h typedef int (*QIOTaskWorker)(QIOTask *task, · line 129

Quoted 7 lines
include/io/task.h +2 -2
@@ -102,8 +125,8 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *
  *      ...check something important...
  *       if (err) {
- *           qio_task_abort(task, err);
- *           error_free(task);
+ *           qio_task_set_error(task, err);
+ *           qio_task_complete(task);

Interesting - by storing the error object directly in the task, you no longer have to special-case task abort vs. complete (rather, the notifier checks whether the task completed successfully or in error).

Quoted 47 lines
include/io/task.h +10 -8
  *           return FALSE;
  *       } else if (...work is completed ...) {
  *           qio_task_complete(task);
@@ -115,6 +138,10 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  *   </programlisting>
  * </example>
  *
+ * The 'qio_task_complete' call in this method will trigger
+ * the callback func 'myobject_operation_notify' shown
+ * earlier to deal with the results.
+ *
  * Once this function returns false, object_unref will be called
  * automatically on the task causing it to be released and the
  * ref on QMyObject dropped too.
@@ -187,8 +214,8 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  * 'err' attribute in the task object to determine if
  * the operation was successful or not.
  *
- * The returned task will be released when one of
- * qio_task_abort() or qio_task_complete() are invoked.
+ * The returned task will be released when qio_task_complete()
+ * is invoked.
  *
  * Returns: the task struct
  */
@@ -204,10 +231,8 @@ QIOTask *qio_task_new(Object *source,
  * @opaque: opaque data to pass to @worker
  * @destroy: function to free @opaque
  *
- * Run a task in a background thread. If @worker
- * returns 0 it will call qio_task_complete() in
- * the main event thread context. If @worker
- * returns -1 it will call qio_task_abort() in
+ * Run a task in a background thread. When @worker
+ * returns it will call qio_task_complete() in
  * the main event thread context.
  */
 void qio_task_run_in_thread(QIOTask *task,
@@ -219,25 +244,11 @@ void qio_task_run_in_thread(QIOTask *task,
  * qio_task_complete:
  * @task: the task struct
  *
- * Mark the operation as successfully completed
- * and free the memory for @task.
+ * Invoke the completion callback for @task and
+ * then free its memory.
  */

include/io/task.h void qio_task_run_in_thread(QIOTask *task, · line 234

Quoted 10 lines
include/io/task.h +0 -8
 void qio_task_complete(QIOTask *task);
 
-/**
- * qio_task_abort:
- * @task: the task struct
- * @err: the error to record for the operation
- *
- * Mark the operation as failed, with @err providing
- * details about the failure. The @err may be freed
- * afer the function returns, as the notification

And you're eliminating a typo :)

Quoted 16 lines
include/io/task.h +0 -6
- * callback is invoked synchronously. The @task will
- * be freed when this call completes.
- */
-void qio_task_abort(QIOTask *task,
-                    Error *err);
-
 
 /**
  * qio_task_set_error:
io/channel-tls.c +1 -1
index cf3bcca..f25ab0a 100644
--- a/io/channel-tls.c
 
+++ b/tests/test-io-channel-socket.c
@@ -156,12 +156,11 @@ struct TestIOChannelData {
 };

io/channel-tls.c struct TestIOChannelData { · line 163

Quoted 10 lines
io/channel-tls.c +2 -3
 
 
-static void test_io_channel_complete(Object *src,
-                                     Error *err,
+static void test_io_channel_complete(QIOTask *task,
                                      gpointer opaque)
 {
     struct TestIOChannelData *data = opaque;
-    data->err = err != NULL;
+    data->err = qio_task_propagate_error(task, NULL);

Cool way to ignore and free task->err while still tracking if it had captured an error. I had to go re-read patch 5/8 to make sure this did the right thing.

I'm still not sure if there is a better signature to be using, but as written, your conversion to your choice of signature looks correct (modulo nits I pointed out above), so you can add:

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
Reviewed-by on v1 7/8
#18 lore raw

Re: [Qemu-devel] [PATCH 7/8] io: remove Error parameter from QIOTask thread worker

In reply to Daniel P. Berrange
Quoted 18 lines · Daniel P. Berrange

Now that task objects have a directly associated error, there's no need for an an Error **errp parameter to the QIOTask thread worker function. It already has a QIOTask object, so can directly set the error on it.

---
 include/io/task.h    | 19 +++++++++----------
 io/channel-socket.c  | 47 ++++++++++++++++++++++-------------------------
 io/task.c            | 10 +---------
 tests/test-io-task.c | 12 +++++-------
 4 files changed, 37 insertions(+), 51 deletions(-)
include/io/task.h +0 -0
index 7b5bc43..dca57dc 100644

include/io/task.h typedef struct QIOTask QIOTask; · line 33

Quoted 8 lines
include/io/task.h +2 -3
@@ -29,9 +29,8 @@ typedef struct QIOTask QIOTask;
 typedef void (*QIOTaskFunc)(QIOTask *task,
                             gpointer opaque);
 
-typedef int (*QIOTaskWorker)(QIOTask *task,
-                             Error **errp,
-                             gpointer opaque);
+typedef void (*QIOTaskWorker)(QIOTask *task,
+                              gpointer opaque);

Hmm, so you're getting rid of the return type here, because the QIOTask now holds everything. I'm still not sure whether a void* return would be easier, but I'm not going to reject your patch because of my bikeshedding.

Quoted 14 lines
include/io/task.h +2 -3
 /**
  * QIOTask:
@@ -163,18 +162,18 @@ typedef int (*QIOTaskWorker)(QIOTask *task,
  * socket listen using QIOTask would require:
  *
  * <example>
- *    static int myobject_listen_worker(QIOTask *task,
- *                                      Error **errp,
- *                                      gpointer opaque)
+ *    static void myobject_listen_worker(QIOTask *task,
+ *                                       gpointer opaque)
  *    {
  *       QMyObject obj = QMY_OBJECT(qio_task_get_source(task));

include/io/task.h typedef int (*QIOTaskWorker)(QIOTask *task, · line 175

Quoted 10 lines
include/io/task.h +5 -3
  *       SocketAddress *addr = opaque;
+ *       Error *err = NULL;
  *
- *       obj->fd = socket_listen(addr, errp);
- *       if (obj->fd < 0) {
- *          return -1;
+ *       obj->fd = socket_listen(addr, &err);
+ *
+ *       if (err) {
+ *           qio_task_set_error(task, err);

I argued earlier that you can call this unconditionally, dropping the 'if (err)'. Both here in the doc example...

Quoted 14 lines
include/io/task.h +3 -4
+++ b/io/channel-socket.c
@@ -156,19 +156,18 @@ 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;

include/io/task.h int qio_channel_socket_connect_sync(QIOChannelSocket *ioc, · line 169

Quoted 10 lines
include/io/task.h +4 -4
+    Error *err = NULL;
 
-    ret = qio_channel_socket_connect_sync(ioc,
-                                          addr,
-                                          errp);
+    qio_channel_socket_connect_sync(ioc, addr, &err);
 
-    return ret;
+    if (err) {
+        qio_task_set_error(task, err);

...and in the actual code. But I guess leaving it in doesn't hurt much, either.

include/io/task.h static gpointer qio_task_thread_worker(gpointer opaque) · line 105

Quoted 9 lines
include/io/task.h +1 -4
@@ -107,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);

I like that your choice of making the error part of the QIOTask simplifies the workers.

Up to you whether to simplify the conditionals.

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#20 lore raw

Re: [Qemu-devel] [PATCH 8/8] io: introduce a DNS resolver API

In reply to Daniel P. Berrange
Quoted 29 lines · Daniel P. Berrange

Currently DNS resolution is done automatically as part of the creation of a QIOChannelSocket object instance. This works ok for network clients where you just end up a single network socket, but for servers, the results of DNS resolution may require creation of multiple sockets.

Introducing a DNS resolver API allows DNS resolution to be separated from the socket object creation. This will make it practical to create multiple QIOChannelSocket instances for servers.

---
 include/io/dns-resolver.h | 224 +++++++++++++++++++++++++++++++++++++++
 include/qemu/sockets.h    |   2 +
 io/Makefile.objs          |   1 +
 io/dns-resolver.c         | 265 ++++++++++++++++++++++++++++++++++++++++++++++
 util/qemu-sockets.c       |   4 +-
 5 files changed, 494 insertions(+), 2 deletions(-)
 create mode 100644 include/io/dns-resolver.h
 create mode 100644 io/dns-resolver.c
include/io/dns-resolver.h new file +0 -0
new file mode 100644
index 0000000..5121e65

include/io/dns-resolver.h line 4

Quoted 4 lines
include/io/dns-resolver.h new file +4 -0
@@ -0,0 +1,224 @@
+/*
+ * QEMU DNS resolver
+ *
+ * Copyright (c) 2016 Red Hat, Inc.

Want to add 2017?

Quoted 12 lines
include/io/dns-resolver.h new file +12 -0
+
+/**
+ * QIODNSResolver:
+ *
+ * The QIODNSResolver class provides a framework for doing
+ * DNS resolution on SocketAddress objects, independently
+ * of socket creation.
+ *
+ * <example>
+ *   <title>Resolving addresses synchronously</title>
+ *   <programlisting>
+ *    int mylisten(SocketAddress *addr, Error **errp) {

include/io/dns-resolver.h line 59

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+ *      QIODNSResolver *resolver = qio_dns_resolver_get_instance();
+ *      SocketAddress **rawaddrs = NULL;
+ *      size_t nrawaddrs = 0;
+ *      Error *err = NULL;
+ *      QIOChannel **socks = NULL;
+ *      size_t nsocks = 0;
+ *
+ *      if (qio_dns_resolver_lookup_sync(dns, addr, &nrawaddrs,
+ *                                       &rawaddrs, &err) < 0) {
+ *          error_propagate(errp, err);

You aren't using the local err here; why not just call qio_dns_resolver_lookup_sync(, errp) directly, then you don't need to propagate?

Is it guaranteed that 'err' is set only when qio_dns_resolver_lookup_sync() returns negative, and conversely that nrawaddrs is > 0 when it succeeded? It matters later...[3]

include/io/dns-resolver.h line 65

Quoted 6 lines
include/io/dns-resolver.h new file +6 -0
+ *          return -1;
+ *      }
+ *
+ *      for (i = 0; i < nrawaddrs; i++) {
+ *         QIOChannel *sock = qio_channel_new();
+ *         Error *local_err = NULL;

It looks weird that you are declaring two different local Error* variables. But I read further down, and finally figured out why...[1]

include/io/dns-resolver.h line 68

Quoted 3 lines
include/io/dns-resolver.h new file +3 -0
+ *         qio_channel_listen_sync(sock, rawaddrs[i], &local_err);
+ *         if (local_err && !err) {
+ *            error_propagate(err, local_err);

Won't compile as written; you need error_propagate(&err, local_err);

error_propagate() is safe to call more than once (first error wins), so you could simplify this to 'if (local_err) {'. In fact, if you don't rewrite the condition, then on the second error, you end up falling through to the else...[2]

include/io/dns-resolver.h line 37

Quoted 2 lines
include/io/dns-resolver.h new file +2 -0
+ *         } else {
+ *            socks = g_renew(QIOChannelSocket *, socks, nsocks + 1);

[2]...and allocating a slot in spite of the failure, plus leaking local_err at the end of the loop. Oops.

As long as nsocks is not going to be arbitrarily huge, it shouldn't matter that this particular style of array growth is O(n^2) in complexity (quadratic complexity is fine on small lists, but for large lists, you need to realloc in geometrically-larger increments to keep things amortized to linear costs that otherwise explode due to copying old-to-new array on each iteration).

include/io/dns-resolver.h line 76

Quoted 6 lines
include/io/dns-resolver.h new file +6 -0
+ *            socks[nsocks++] = sock;
+ *         }
+ *      }
+ *
+ *      if (nsocks == 0) {
+ *         error_propagate(errp, err);

[3]...if the DNS lookup can succeed with nrawaddrs == 0, then you have nsocks == 0 but no err set. Is that a problem? Or is nrawaddrs always greater than 0 on success, such that nsocks == 0 always implies that we failed to open every single socket and thus have err set?

include/io/dns-resolver.h line 45

Quoted 2 lines
include/io/dns-resolver.h new file +2 -0
+ *      } else {
+ *         error_free(err);

[1]...and this is why you have two error variables. You've chosen to explicitly succeed if you get at least one socket open, even in the case where resolution returns multiple possible addresses and some of them fail.

Quoted 25 lines
include/io/dns-resolver.h new file +25 -0
+ *      }
+ *   }
+ *   </programlisting>
+ * </example>
+ *
+ * <example>
+ *   <title>Resolving addresses asynchronously</title>
+ *   <programlisting>
+ *    typedef struct MyListenData {
+ *       Error *err;
+ *       QIOChannelSocket **socks;
+ *       size_t nsocks;
+ *    } MyListenData;
+ *
+ *    void mylistenresult(QIOTask *task, void *opaque) {
+ *      MyListenData *data = opaque;
+ *      QIODNSResolver *resolver =
+ *         QIO_DNS_RESOLVER(qio_task_get_source(task);
+ *      SocketAddress **rawaddrs = NULL;
+ *      size_t nrawaddrs = 0;
+ *      Error *err = NULL;
+ *
+ *      if (qio_task_propagate_error(task, &data->err)) {
+ *         return;
+ *      }

include/io/dns-resolver.h line 113

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+ *
+ *      qio_dns_resolver_lookup_result(resolver, task,
+ *                                     &nrawaddrs, &rawaddrs);
+ *
+ *      for (i = 0; i < nrawaddrs; i++) {
+ *         QIOChannel *sock = qio_channel_new();
+ *         Error *local_err = NULL;
+ *         qio_channel_listen_sync(sock, rawaddrs[i], &local_err);
+ *         if (local_err && !err) {
+ *            error_propagate(err, local_err);

Same problem as in the last example, where you don't handle double-failure correctly, and where the code won't compile without &.

Quoted 11 lines
include/io/dns-resolver.h new file +11 -0
+ *         } else {
+ *            socks = g_renew(QIOChannelSocket *, socks, nsocks + 1);
+ *            socks[nsocks++] = sock;
+ *         }
+ *      }
+ *
+ *      if (nsocks == 0) {
+ *         error_propagate(&data->err, err);
+ *      } else {
+ *         error_free(err);
+ *      }

include/io/dns-resolver.h line 134

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+ *    }
+ *
+ *    void mylisten(SocketAddress *addr, MyListenData *data) {
+ *      QIODNSResolver *resolver = qio_dns_resolver_get_instance();
+ *      qio_dns_resolver_lookup_async(dns, addr,
+ *                                    mylistenresult, data, NULL);
+ *    }
+ *   </programlisting>
+ * </example>
+ */

The examples are much appreciated; looking forward to v2.

Quoted 4 lines
include/io/dns-resolver.h new file +4 -0
+/**
+ * qio_dns_resolver_lookup_sync:
+ * @resolver: the DNS resolver instance
+ * @addr: the address to resolve

include/io/dns-resolver.h line 167

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ * @errp: pointer to NULL initialized error object
+ *
+ * This will attempt to resolve the address provided
+ * in @addr. If resolution succeeds, @addrs will be filled
+ * with all the resolved addresses. @naddrs will specify
+ * the number of entries allocated in @addrs. The caller
+ * is responsible for freeing each entry in @addrs, as
+ * well as @addrs itself.

Where in your example code above do you free the memory? Or is that a leak you need to plug?

Are we guaranteed that naddrs > 0 on success? (point [3] above)

Quoted 5 lines
include/io/dns-resolver.h new file +5 -0
+ *
+ * DNS resolution will be done synchronously so execution
+ * of the caller may be blocked for an arbitrary length
+ * of time.
+ *

include/io/dns-resolver.h line 182

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+ * Returns: 0 if resolution was successful, -1 on error
+ */
+int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver,
+                                 SocketAddress *addr,
+                                 size_t *naddrs,
+                                 SocketAddress ***addrs,
+                                 Error **errp);
+
+/**
+ * qio_dns_resolver_lookup_sync:

s/sync/async/

include/io/dns-resolver.h line 160

Quoted 5 lines
include/io/dns-resolver.h new file +5 -0
+ * @resolver: the DNS resolver instance
+ * @addr: the address to resolve
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ * @errp: pointer to NULL initialized error object

Wrong parameters; naddr/addrs/errp should be replaced with func/opaque/notify.

Quoted 20 lines
include/io/dns-resolver.h new file +20 -0
+ *
+ * This will attempt to resolve the address provided
+ * in @addr. The callback @func will be invoked when
+ * resolution has either completed or failed. On
+ * success, the @func should call the method
+ * qio_dns_resolver_lookup_result() to obtain the
+ * results.
+ *
+ * DNS resolution will be done asynchronously so execution
+ * of the caller will not be blocked.
+ */
+void qio_dns_resolver_lookup_async(QIODNSResolver *resolver,
+                                   SocketAddress *addr,
+                                   QIOTaskFunc func,
+                                   gpointer opaque,
+                                   GDestroyNotify notify);
+
+/**
+ * qio_dns_resolver_lookup_result:
+ * @resolver: the DNS resolver instance

include/io/dns-resolver.h line 217

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+ * @task: the task object to get results for
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ *
+ * This method should be called from the callback passed
+ * to qio_dns_resolver_lookup_async() in order to obtain
+ * results.  @addrs will be filled with all the resolved
+ * addresses. @naddrs will specify the number of entries
+ * allocated in @addrs. The caller is responsible for
+ * freeing each entry in @addrs, as well as @addrs itself.

Again, the free seems to be missing in the example above.

include/io/dns-resolver.h line 224

Quoted 7 lines
include/io/dns-resolver.h new file +7 -0
+ */
+void qio_dns_resolver_lookup_result(QIODNSResolver *resolver,
+                                    QIOTask *task,
+                                    size_t *naddrs,
+                                    SocketAddress ***addrs);
+
+#endif /* QIO_DNS_RESOLVER_H */

Overall the interface looks reasonable.

include/io/dns-resolver.h line 4

Quoted 6 lines
include/io/dns-resolver.h new file +5 -0
+++ b/io/dns-resolver.c
@@ -0,0 +1,265 @@
+/*
+ * QEMU DNS resolver
+ *
+ * Copyright (c) 2016 Red Hat, Inc.

and 2017?

Quoted 11 lines
include/io/dns-resolver.h new file +11 -0
+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];

include/io/dns-resolver.h line 25

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+    int rc;
+    Error *err = NULL;
+    size_t i;
+
+    *naddrs = 0;
+    *addrs = NULL;
+
+    memset(&ai, 0, sizeof(ai));
+    ai.ai_flags = AI_PASSIVE;
+    if (iaddr->numeric) {

'iaddr->has_numeric && iaddr->numeric', unless you make sure that all possible initialization paths have a sane value of iaddr->numeric==false even when iaddr->has_numeric is false (qapi guarantees 0 initialization, but I'm not sure if all SocketAddress come from qapi).

Quoted 5 lines
include/io/dns-resolver.h new file +5 -0
+    /* 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;

include/io/dns-resolver.h line 40

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+        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),
+            .numeric = true,

Also need .has_numeric = true

Quoted 12 lines
include/io/dns-resolver.h new file +12 -0
+            .has_to = iaddr->has_to,
+            .to = iaddr->to,
+            .has_ipv4 = false,
+            .has_ipv6 = false,
+        };
+
+        (*addrs)[i] = newaddr;
+    }
+    freeaddrinfo(res);
+    return 0;
+}
+

include/io/dns-resolver.h line 62

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+
+static int qio_dns_resolver_lookup_sync_unix(QIODNSResolver *resolver,
+                                             SocketAddress *addr,
+                                             size_t *naddrs,
+                                             SocketAddress ***addrs,
+                                             Error **errp)
+{
+    *naddrs = 1;
+    *addrs = g_new0(SocketAddress *, 1);
+    (*addrs)[0] = QAPI_CLONE(SocketAddress, addr);

Cool - I'm glad to see more use of my clone visitor :)

Quoted 17 lines
include/io/dns-resolver.h new file +17 -0
+
+    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,

include/io/dns-resolver.h line 89

Quoted 10 lines
include/io/dns-resolver.h new file +10 -0
+                                                 errp);
+
+    case SOCKET_ADDRESS_KIND_UNIX:
+        return qio_dns_resolver_lookup_sync_unix(resolver,
+                                                 addr,
+                                                 naddrs,
+                                                 addrs,
+                                                 errp);
+
+    default:

Do we need to play with Stefan's vsock stuff?

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#10 lore raw

Re: [Qemu-devel] [PATCH 4/8] io: add ability to associate an opaque "result" with with a task

In reply to Eric Blake
Quoted 12 lines · Eric Blake
Quoted 10 lines · Daniel P. Berrange

Currently there is no data associated with a successful task completion. This adds an opaque pointer to the task to store an arbitrary result.

---
 include/io/task.h | 27 +++++++++++++++++++++++++++
 io/task.c         | 20 ++++++++++++++++++++
 2 files changed, 47 insertions(+)
Quoted 4 lines

I suppose a different approach would have been changing QIOTaskFunc() to have a void* return, but that would be more invasive. Grabbing the result separately from the task completing is a bit weird, but looks like it will work.

FYI, the design I've chosen here closely matches that used by GLib in its own GTask / GAsyncResult, on which the QIOTask was modelled. The idea is that in future when we eventually bump to a newer glib, we can switch over to GTask easily.

Regards,
Daniel

Signature · 3 lines
|: http://berrange.com      -o-    http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org              -o-             http://virt-manager.org :|
|: http://entangle-photo.org       -o-    http://search.cpan.org/~danberr/ :|
#13 lore raw

Re: [Qemu-devel] [PATCH 5/8] io: add ability to associate an error with a task

In reply to Eric Blake
Quoted 48 lines · Eric Blake
Quoted 3 lines · Daniel P. Berrange

Currently when a task fails, the error is never explicitly associated with the task object, it is just passed along through the completion callback. This adds ability to

s/adds/adds the/

Quoted 18 lines

explicitly associate an error with the task.

---
 include/io/task.h | 29 +++++++++++++++++++++++++++++
 io/task.c         | 23 +++++++++++++++++++++++
 2 files changed, 52 insertions(+)
include/io/task.h +2 -0
index ece1372..244c1a1 100644
@@ -240,6 +240,35 @@ void qio_task_abort(QIOTask *task,
 
 
 /**
+ * qio_task_set_error:
+ * @task: the task struct

include/io/task.h void qio_task_abort(QIOTask *task, · line 254

Quoted 10 lines
include/io/task.h +10 -0
+ * @err: pointer to the error
+ *
+ * Associate an error with the task, which can later
+ * be retrieved with the qio_task_propagate_error()
+ * method. This method takes ownership of @err, so
+ * it is not valid to access it after this call
+ * completes.
+ */
+void qio_task_set_error(QIOTask *task,
+                        Error *err);

Is it valid for @err to be NULL (or put another way, may callers blindly call this function whether or not an error has occurred)?...

Quoted 9 lines
include/io/task.h +9 -0
+
+
+/**
+ * qio_task_propagate_error:
+ * @task: the task struct
+ * @errp: pointer to a NULL-initialized error object
+ *
+ * Propagate the error associated with @task
+ * into @errp.
Quoted 8 lines

include/io/task.h void qio_task_abort(QIOTask *task, · line 267

Quoted 4 lines
include/io/task.h +4 -0
+ *
+ * Returns: true if an error was propagated, false otherwise
+ */
+gboolean qio_task_propagate_error(QIOTask *task,

Must this return 'gboolean' (in which case the docs should mention TRUE/FALSE rather than true/false)? Or can we make it return the nicer 'bool'?

bool is fine - gboolean is just from my habit of using glib

Quoted 14 lines

include/io/task.h void qio_task_abort(QIOTask *task, · line 169

Quoted 8 lines
include/io/task.h +4 -0
@@ -159,6 +163,25 @@ void qio_task_abort(QIOTask *task,
 }
 
 
+void qio_task_set_error(QIOTask *task,
+                        Error *err)
+{
+    error_propagate(&task->err, err);

...As written, qio_task_set_error(task, NULL) is thus valid as a no-op; and in turn, qio_task_set_error(task, err) is unconditionally valid a cleanup path regardless of whether the cleanup was reached on success (err is still NULL) or failure (err is set). But it's worth documenting.

Quoted 4 lines

In fact, error_propagate() can be called more than once (first call wins, all later calls silently drop the subsequent error in favor of a first one already present), and therefore qio_task_set_error() gains that same property. Worth documenting?

Ok, will expand docs.

Regards,
Daniel

Signature · 3 lines
|: http://berrange.com      -o-    http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org              -o-             http://virt-manager.org :|
|: http://entangle-photo.org       -o-    http://search.cpan.org/~danberr/ :|
#16 lore raw

Re: [Qemu-devel] [PATCH 6/8] io: change the QIOTask callback signature

In reply to Eric Blake
Quoted 9 lines · Eric Blake
Quoted 7 lines · Daniel P. Berrange

Currently the QIOTaskFunc signature takes an Object * for the source, and an Error * for any error. We also need to be able to provide a result pointer. Rather than continue to add parameters to QIOTaskFunc, remove the existing ones and simply pass the QIOTask object instead. This has methods to access all the other data items required in the callback impl.

Quoted 8 lines

Hmmm. If you're going to change the callback signature after all, then is it worth considering having the callback return void* instead of the clunky way of passing the result pointer around, with existing callers updated to return NULL if they have nothing better to do? Accessing the error pointer through the QIOTask object seems okay, it's just the return type that feels clunky.

But that's bike-shedding, so I'll review as written.

Per my comments in previous patch, the approach taken here was chosen to align with GLib's GTask/GAsyncResult design more closely.

Regards,
Daniel

Signature · 3 lines
|: http://berrange.com      -o-    http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org              -o-             http://virt-manager.org :|
|: http://entangle-photo.org       -o-    http://search.cpan.org/~danberr/ :|
#21 lore raw

Re: [Qemu-devel] [PATCH 8/8] io: introduce a DNS resolver API

In reply to Eric Blake
Quoted 16 lines · Eric Blake
Quoted 10 lines · Daniel P. Berrange

+ * <example>
+ * <title>Resolving addresses synchronously</title>
+ * <programlisting>
+ * int mylisten(SocketAddress *addr, Error **errp) {

+ *      QIODNSResolver *resolver = qio_dns_resolver_get_instance();
+ *      SocketAddress **rawaddrs = NULL;
+ *      size_t nrawaddrs = 0;
+ *      Error *err = NULL;
+ *      QIOChannel **socks = NULL;
+ *      size_t nsocks = 0;
Quoted 4 lines

+ *
+ * if (qio_dns_resolver_lookup_sync(dns, addr, &nrawaddrs,
+ * &rawaddrs, &err) < 0) {
+ * error_propagate(errp, err);

Quoted 3 lines

You aren't using the local err here; why not just call qio_dns_resolver_lookup_sync(, errp) directly, then you don't need to propagate?

Yep

Quoted 3 lines

Is it guaranteed that 'err' is set only when qio_dns_resolver_lookup_sync() returns negative, and conversely that nrawaddrs is > 0 when it succeeded? It matters later...[3]

getaddrinfo() returns an error code of EAI_NODATA if the dns name has no corresponding records, so we should be guaranteed > 0 for nrawaddrs on success.

Quoted 10 lines
Quoted 7 lines

+ * return -1;
+ * }
+ *
+ * for (i = 0; i < nrawaddrs; i++) {
+ * QIOChannel *sock = qio_channel_new();
+ * Error *local_err = NULL;

It looks weird that you are declaring two different local Error* variables. But I read further down, and finally figured out why...[1]

Yeah, the peculiarty of getaddrinfo where you should only report an error if every address failed.

Quoted 12 lines
Quoted 4 lines

+ * qio_channel_listen_sync(sock, rawaddrs[i], &local_err);
+ * if (local_err && !err) {
+ * error_propagate(err, local_err);

Won't compile as written; you need error_propagate(&err, local_err);

error_propagate() is safe to call more than once (first error wins), so you could simplify this to 'if (local_err) {'. In fact, if you don't rewrite the condition, then on the second error, you end up falling through to the else...[2]

Quoted 5 lines
Quoted 2 lines

+ * } else {
+ * socks = g_renew(QIOChannelSocket *, socks, nsocks + 1);

[2]...and allocating a slot in spite of the failure, plus leaking local_err at the end of the loop. Oops.

Oh, nice spot.

Quoted 6 lines

As long as nsocks is not going to be arbitrarily huge, it shouldn't matter that this particular style of array growth is O(n^2) in complexity (quadratic complexity is fine on small lists, but for large lists, you need to realloc in geometrically-larger increments to keep things amortized to linear costs that otherwise explode due to copying old-to-new array on each iteration).

Yeah, realistically 99% of the time there will be 2 results (ipv4 and ipv6). Only in niche cases where there's a host with multiple public IPs will we have more addressses and even then it'll be less than
10. So the complexity is not an issue here IMHO - the actual dns network lookup time will dwarf any inefficiency.

Quoted 6 lines
Quoted 2 lines

+ * } else {
+ * error_free(err);

[1]...and this is why you have two error variables. You've chosen to explicitly succeed if you get at least one socket open, even in the case where resolution returns multiple possible addresses and some of them fail.

Yep, glibc recommended behaviour for listening with getaddrinfo().

Quoted 15 lines
Quoted 6 lines

+/**
+ * qio_dns_resolver_lookup_sync:
+ * @resolver: the DNS resolver instance
+ * @addr: the address to resolve
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses

Quoted 8 lines

+ * @errp: pointer to NULL initialized error object
+ *
+ * This will attempt to resolve the address provided
+ * in @addr. If resolution succeeds, @addrs will be filled
+ * with all the resolved addresses. @naddrs will specify
+ * the number of entries allocated in @addrs. The caller
+ * is responsible for freeing each entry in @addrs, as
+ * well as @addrs itself.

Quoted 2 lines

Where in your example code above do you free the memory? Or is that a leak you need to plug?

Opps, yes, a leak

Quoted 1 line

Are we guaranteed that naddrs > 0 on success? (point [3] above)

Yes and will document it.

Quoted 52 lines
Quoted 8 lines

+ *
+ * DNS resolution will be done synchronously so execution
+ * of the caller may be blocked for an arbitrary length
+ * of time.
+ *
+ * Returns: 0 if resolution was successful, -1 on error
+ */

include/io/dns-resolver.h line 182

Quoted 8 lines
include/io/dns-resolver.h new file +8 -0
+int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver,
+                                 SocketAddress *addr,
+                                 size_t *naddrs,
+                                 SocketAddress ***addrs,
+                                 Error **errp);
+
+/**
+ * qio_dns_resolver_lookup_sync:

s/sync/async/

Quoted 5 lines

+ * @resolver: the DNS resolver instance
+ * @addr: the address to resolve
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ * @errp: pointer to NULL initialized error object

Wrong parameters; naddr/addrs/errp should be replaced with func/opaque/notify.

Quoted 24 lines

+ *
+ * This will attempt to resolve the address provided
+ * in @addr. The callback @func will be invoked when
+ * resolution has either completed or failed. On
+ * success, the @func should call the method
+ * qio_dns_resolver_lookup_result() to obtain the
+ * results.
+ *
+ * DNS resolution will be done asynchronously so execution
+ * of the caller will not be blocked.
+ */

include/io/dns-resolver.h new file +13 -0
+void qio_dns_resolver_lookup_async(QIODNSResolver *resolver,
+                                   SocketAddress *addr,
+                                   QIOTaskFunc func,
+                                   gpointer opaque,
+                                   GDestroyNotify notify);
+
+/**
+ * qio_dns_resolver_lookup_result:
+ * @resolver: the DNS resolver instance
+ * @task: the task object to get results for
+ * @naddr: pointer to hold number of resolved addresses
+ * @addrs: pointer to hold resolved addresses
+ *
Quoted 8 lines
Quoted 6 lines

+ * This method should be called from the callback passed
+ * to qio_dns_resolver_lookup_async() in order to obtain
+ * results. @addrs will be filled with all the resolved
+ * addresses. @naddrs will specify the number of entries
+ * allocated in @addrs. The caller is responsible for
+ * freeing each entry in @addrs, as well as @addrs itself.

Again, the free seems to be missing in the example above.

Yep, will fix.

Quoted 18 lines
Quoted 18 lines
io/dns-resolver.c new file +18 -0
+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;
+
Quoted 8 lines

io/dns-resolver.c line 56

Quoted 3 lines
io/dns-resolver.c new file +3 -0
+    memset(&ai, 0, sizeof(ai));
+    ai.ai_flags = AI_PASSIVE;
+    if (iaddr->numeric) {

'iaddr->has_numeric && iaddr->numeric', unless you make sure that all possible initialization paths have a sane value of iaddr->numeric==false even when iaddr->has_numeric is false (qapi guarantees 0 initialization, but I'm not sure if all SocketAddress come from qapi).

Yeah, makes sense to be explicit about it anyway

Quoted 64 lines
Quoted 5 lines
io/dns-resolver.c new file +5 -0
+    /* 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;

io/dns-resolver.c line 105

Quoted 10 lines
io/dns-resolver.c new file +10 -0
+        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),
+            .numeric = true,

Also need .has_numeric = true

Quoted 12 lines
io/dns-resolver.c new file +12 -0
+            .has_to = iaddr->has_to,
+            .to = iaddr->to,
+            .has_ipv4 = false,
+            .has_ipv6 = false,
+        };
+
+        (*addrs)[i] = newaddr;
+    }
+    freeaddrinfo(res);
+    return 0;
+}
+

io/dns-resolver.c line 127

Quoted 10 lines
io/dns-resolver.c new file +10 -0
+
+static int qio_dns_resolver_lookup_sync_unix(QIODNSResolver *resolver,
+                                             SocketAddress *addr,
+                                             size_t *naddrs,
+                                             SocketAddress ***addrs,
+                                             Error **errp)
+{
+    *naddrs = 1;
+    *addrs = g_new0(SocketAddress *, 1);
+    (*addrs)[0] = QAPI_CLONE(SocketAddress, addr);

Cool - I'm glad to see more use of my clone visitor :)

Quoted 21 lines
io/dns-resolver.c new file +21 -0
+
+    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:
+        return qio_dns_resolver_lookup_sync_unix(resolver,
Quoted 8 lines

io/dns-resolver.c line 154

Quoted 6 lines
io/dns-resolver.c new file +6 -0
+                                                 addr,
+                                                 naddrs,
+                                                 addrs,
+                                                 errp);
+
+    default:

Do we need to play with Stefan's vsock stuff?

Oh yes, I didn't realize that was merged. It should be just cloned as we do for unix sock.

Regards,
Daniel

Signature · 3 lines
|: http://berrange.com      -o-    http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org              -o-             http://virt-manager.org :|
|: http://entangle-photo.org       -o-    http://search.cpan.org/~danberr/ :|