Merge remote-tracking branch 'origin/master' into HEAD

Resolve conflicts around apb.

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>

2 files changed, 308 insertions, 0 deletions

diff --git a/io/Makefile.objs b/io/Makefile.objs
index 12983cca79..9a20fce4ed 100644
--- a/io/Makefile.objs
+++ b/io/Makefile.objs
@@ -8,4 +8,5 @@ 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 += net-listener.o
 io-obj-y += task.o
diff --git a/io/net-listener.c b/io/net-listener.c
new file mode 100644
index 0000000000..77a4e2831c
--- /dev/null
+++ b/io/net-listener.c
@@ -0,0 +1,307 @@
+/*
+ * QEMU network listener
+ *
+ * Copyright (c) 2016-2017 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "io/net-listener.h"
+#include "io/dns-resolver.h"
+#include "qapi/error.h"
+
+QIONetListener *qio_net_listener_new(void)
+{
+    QIONetListener *ret;
+
+    ret = QIO_NET_LISTENER(object_new(TYPE_QIO_NET_LISTENER));
+
+    return ret;
+}
+
+void qio_net_listener_set_name(QIONetListener *listener,
+                               const char *name)
+{
+    g_free(listener->name);
+    listener->name = g_strdup(name);
+}
+
+
+static gboolean qio_net_listener_channel_func(QIOChannel *ioc,
+                                              GIOCondition condition,
+                                              gpointer opaque)
+{
+    QIONetListener *listener = QIO_NET_LISTENER(opaque);
+    QIOChannelSocket *sioc;
+
+    sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
+                                     NULL);
+    if (!sioc) {
+        return TRUE;
+    }
+
+    if (listener->io_func) {
+        listener->io_func(listener, sioc, listener->io_data);
+    }
+
+    object_unref(OBJECT(sioc));
+
+    return TRUE;
+}
+
+
+int qio_net_listener_open_sync(QIONetListener *listener,
+                               SocketAddress *addr,
+                               Error **errp)
+{
+    QIODNSResolver *resolver = qio_dns_resolver_get_instance();
+    SocketAddress **resaddrs;
+    size_t nresaddrs;
+    size_t i;
+    Error *err = NULL;
+    bool success = false;
+
+    if (qio_dns_resolver_lookup_sync(resolver,
+                                     addr,
+                                     &nresaddrs,
+                                     &resaddrs,
+                                     errp) < 0) {
+        return -1;
+    }
+
+    for (i = 0; i < nresaddrs; i++) {
+        QIOChannelSocket *sioc = qio_channel_socket_new();
+
+        if (qio_channel_socket_listen_sync(sioc, resaddrs[i],
+                                           err ? NULL : &err) == 0) {
+            success = true;
+
+            qio_net_listener_add(listener, sioc);
+        }
+
+        qapi_free_SocketAddress(resaddrs[i]);
+        object_unref(OBJECT(sioc));
+    }
+    g_free(resaddrs);
+
+    if (success) {
+        error_free(err);
+        return 0;
+    } else {
+        error_propagate(errp, err);
+        return -1;
+    }
+}
+
+
+void qio_net_listener_add(QIONetListener *listener,
+                          QIOChannelSocket *sioc)
+{
+    if (listener->name) {
+        char *name = g_strdup_printf("%s-listen", listener->name);
+        qio_channel_set_name(QIO_CHANNEL(sioc), name);
+        g_free(name);
+    }
+
+    listener->sioc = g_renew(QIOChannelSocket *, listener->sioc,
+                             listener->nsioc + 1);
+    listener->io_tag = g_renew(gulong, listener->io_tag, listener->nsioc + 1);
+    listener->sioc[listener->nsioc] = sioc;
+    listener->io_tag[listener->nsioc] = 0;
+
+    object_ref(OBJECT(sioc));
+    listener->connected = true;
+
+    if (listener->io_func != NULL) {
+        object_ref(OBJECT(listener));
+        listener->io_tag[listener->nsioc] = qio_channel_add_watch(
+            QIO_CHANNEL(listener->sioc[listener->nsioc]), G_IO_IN,
+            qio_net_listener_channel_func,
+            listener, (GDestroyNotify)object_unref);
+    }
+
+    listener->nsioc++;
+}
+
+
+void qio_net_listener_set_client_func(QIONetListener *listener,
+                                      QIONetListenerClientFunc func,
+                                      gpointer data,
+                                      GDestroyNotify notify)
+{
+    size_t i;
+
+    if (listener->io_notify) {
+        listener->io_notify(listener->io_data);
+    }
+    listener->io_func = func;
+    listener->io_data = data;
+    listener->io_notify = notify;
+
+    for (i = 0; i < listener->nsioc; i++) {
+        if (listener->io_tag[i]) {
+            g_source_remove(listener->io_tag[i]);
+            listener->io_tag[i] = 0;
+        }
+    }
+
+    if (listener->io_func != NULL) {
+        for (i = 0; i < listener->nsioc; i++) {
+            object_ref(OBJECT(listener));
+            listener->io_tag[i] = qio_channel_add_watch(
+                QIO_CHANNEL(listener->sioc[i]), G_IO_IN,
+                qio_net_listener_channel_func,
+                listener, (GDestroyNotify)object_unref);
+        }
+    }
+}
+
+
+struct QIONetListenerClientWaitData {
+    QIOChannelSocket *sioc;
+    GMainLoop *loop;
+};
+
+
+static gboolean qio_net_listener_wait_client_func(QIOChannel *ioc,
+                                                  GIOCondition condition,
+                                                  gpointer opaque)
+{
+    struct QIONetListenerClientWaitData *data = opaque;
+    QIOChannelSocket *sioc;
+
+    sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
+                                     NULL);
+    if (!sioc) {
+        return TRUE;
+    }
+
+    if (data->sioc) {
+        object_unref(OBJECT(sioc));
+    } else {
+        data->sioc = sioc;
+        g_main_loop_quit(data->loop);
+    }
+
+    return TRUE;
+}
+
+QIOChannelSocket *qio_net_listener_wait_client(QIONetListener *listener)
+{
+    GMainContext *ctxt = g_main_context_new();
+    GMainLoop *loop = g_main_loop_new(ctxt, TRUE);
+    GSource **sources;
+    struct QIONetListenerClientWaitData data = {
+        .sioc = NULL,
+        .loop = loop
+    };
+    size_t i;
+
+    for (i = 0; i < listener->nsioc; i++) {
+        if (listener->io_tag[i]) {
+            g_source_remove(listener->io_tag[i]);
+            listener->io_tag[i] = 0;
+        }
+    }
+
+    sources = g_new0(GSource *, listener->nsioc);
+    for (i = 0; i < listener->nsioc; i++) {
+        sources[i] = qio_channel_create_watch(QIO_CHANNEL(listener->sioc[i]),
+                                              G_IO_IN);
+
+        g_source_set_callback(sources[i],
+                              (GSourceFunc)qio_net_listener_wait_client_func,
+                              &data,
+                              NULL);
+        g_source_attach(sources[i], ctxt);
+    }
+
+    g_main_loop_run(loop);
+
+    for (i = 0; i < listener->nsioc; i++) {
+        g_source_unref(sources[i]);
+    }
+    g_main_loop_unref(loop);
+    g_main_context_unref(ctxt);
+
+    if (listener->io_func != NULL) {
+        for (i = 0; i < listener->nsioc; i++) {
+            object_ref(OBJECT(listener));
+            listener->io_tag[i] = qio_channel_add_watch(
+                QIO_CHANNEL(listener->sioc[i]), G_IO_IN,
+                qio_net_listener_channel_func,
+                listener, (GDestroyNotify)object_unref);
+        }
+    }
+
+    return data.sioc;
+}
+
+void qio_net_listener_disconnect(QIONetListener *listener)
+{
+    size_t i;
+
+    if (!listener->connected) {
+        return;
+    }
+
+    for (i = 0; i < listener->nsioc; i++) {
+        if (listener->io_tag[i]) {
+            g_source_remove(listener->io_tag[i]);
+            listener->io_tag[i] = 0;
+        }
+        qio_channel_close(QIO_CHANNEL(listener->sioc[i]), NULL);
+    }
+    listener->connected = false;
+}
+
+
+bool qio_net_listener_is_connected(QIONetListener *listener)
+{
+    return listener->connected;
+}
+
+static void qio_net_listener_finalize(Object *obj)
+{
+    QIONetListener *listener = QIO_NET_LISTENER(obj);
+    size_t i;
+
+    qio_net_listener_disconnect(listener);
+
+    for (i = 0; i < listener->nsioc; i++) {
+        object_unref(OBJECT(listener->sioc[i]));
+    }
+    g_free(listener->io_tag);
+    g_free(listener->sioc);
+    g_free(listener->name);
+}
+
+static const TypeInfo qio_net_listener_info = {
+    .parent = TYPE_OBJECT,
+    .name = TYPE_QIO_NET_LISTENER,
+    .instance_size = sizeof(QIONetListener),
+    .instance_finalize = qio_net_listener_finalize,
+    .class_size = sizeof(QIONetListenerClass),
+};
+
+
+static void qio_net_listener_register_types(void)
+{
+    type_register_static(&qio_net_listener_info);
+}
+
+
+type_init(qio_net_listener_register_types);