io/net-listener.c

   1 /*
   2  * QEMU network listener
   3  *
   4  * Copyright (c) 2016-2017 Red Hat, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "io/net-listener.h"
  23 #include "io/dns-resolver.h"
  24 #include "qapi/error.h"
  25
  26 QIONetListener *qio_net_listener_new(void)
  27 {
  28     QIONetListener *ret;
  29
  30     ret = QIO_NET_LISTENER(object_new(TYPE_QIO_NET_LISTENER));
  31
  32     return ret;
  33 }
  34
  35 void qio_net_listener_set_name(QIONetListener *listener,
  36                                const char *name)
  37 {
  38     g_free(listener->name);
  39     listener->name = g_strdup(name);
  40 }
  41
  42
  43 static gboolean qio_net_listener_channel_func(QIOChannel *ioc,
  44                                               GIOCondition condition,
  45                                               gpointer opaque)
  46 {
  47     QIONetListener *listener = QIO_NET_LISTENER(opaque);
  48     QIOChannelSocket *sioc;
  49
  50     sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
  51                                      NULL);
  52     if (!sioc) {
  53         return TRUE;
  54     }
  55
  56     if (listener->io_func) {
  57         listener->io_func(listener, sioc, listener->io_data);
  58     }
  59
  60     object_unref(OBJECT(sioc));
  61
  62     return TRUE;
  63 }
  64
  65
  66 int qio_net_listener_open_sync(QIONetListener *listener,
  67                                SocketAddress *addr,
  68                                Error **errp)
  69 {
  70     QIODNSResolver *resolver = qio_dns_resolver_get_instance();
  71     SocketAddress **resaddrs;
  72     size_t nresaddrs;
  73     size_t i;
  74     Error *err = NULL;
  75     bool success = false;
  76
  77     if (qio_dns_resolver_lookup_sync(resolver,
  78                                      addr,
  79                                      &nresaddrs,
  80                                      &resaddrs,
  81                                      errp) < 0) {
  82         return -1;
  83     }
  84
  85     for (i = 0; i < nresaddrs; i++) {
  86         QIOChannelSocket *sioc = qio_channel_socket_new();
  87
  88         if (qio_channel_socket_listen_sync(sioc, resaddrs[i],
  89                                            err ? NULL : &err) == 0) {
  90             success = true;
  91
  92             qio_net_listener_add(listener, sioc);
  93         }
  94
  95         qapi_free_SocketAddress(resaddrs[i]);
  96         object_unref(OBJECT(sioc));
  97     }
  98     g_free(resaddrs);
  99
 100     if (success) {
 101         error_free(err);
 102         return 0;
 103     } else {
 104         error_propagate(errp, err);
 105         return -1;
 106     }
 107 }
 108
 109
 110 void qio_net_listener_add(QIONetListener *listener,
 111                           QIOChannelSocket *sioc)
 112 {
 113     if (listener->name) {
 114         char *name = g_strdup_printf("%s-listen", listener->name);
 115         qio_channel_set_name(QIO_CHANNEL(sioc), name);
 116         g_free(name);
 117     }
 118
 119     listener->sioc = g_renew(QIOChannelSocket *, listener->sioc,
 120                              listener->nsioc + 1);
 121     listener->io_source = g_renew(typeof(listener->io_source[0]),
 122                                   listener->io_source,
 123                                   listener->nsioc + 1);
 124     listener->sioc[listener->nsioc] = sioc;
 125     listener->io_source[listener->nsioc] = NULL;
 126
 127     object_ref(OBJECT(sioc));
 128     listener->connected = true;
 129
 130     if (listener->io_func != NULL) {
 131         object_ref(OBJECT(listener));
 132         listener->io_source[listener->nsioc] = qio_channel_add_watch_source(
 133             QIO_CHANNEL(listener->sioc[listener->nsioc]), G_IO_IN,
 134             qio_net_listener_channel_func,
 135             listener, (GDestroyNotify)object_unref, NULL);
 136     }
 137
 138     listener->nsioc++;
 139 }
 140
 141
 142 void qio_net_listener_set_client_func_full(QIONetListener *listener,
 143                                            QIONetListenerClientFunc func,
 144                                            gpointer data,
 145                                            GDestroyNotify notify,
 146                                            GMainContext *context)
 147 {
 148     size_t i;
 149
 150     if (listener->io_notify) {
 151         listener->io_notify(listener->io_data);
 152     }
 153     listener->io_func = func;
 154     listener->io_data = data;
 155     listener->io_notify = notify;
 156
 157     for (i = 0; i < listener->nsioc; i++) {
 158         if (listener->io_source[i]) {
 159             g_source_destroy(listener->io_source[i]);
 160             g_source_unref(listener->io_source[i]);
 161             listener->io_source[i] = NULL;
 162         }
 163     }
 164
 165     if (listener->io_func != NULL) {
 166         for (i = 0; i < listener->nsioc; i++) {
 167             object_ref(OBJECT(listener));
 168             listener->io_source[i] = qio_channel_add_watch_source(
 169                 QIO_CHANNEL(listener->sioc[i]), G_IO_IN,
 170                 qio_net_listener_channel_func,
 171                 listener, (GDestroyNotify)object_unref, context);
 172         }
 173     }
 174 }
 175
 176 void qio_net_listener_set_client_func(QIONetListener *listener,
 177                                       QIONetListenerClientFunc func,
 178                                       gpointer data,
 179                                       GDestroyNotify notify)
 180 {
 181     qio_net_listener_set_client_func_full(listener, func, data,
 182                                           notify, NULL);
 183 }
 184
 185 struct QIONetListenerClientWaitData {
 186     QIOChannelSocket *sioc;
 187     GMainLoop *loop;
 188 };
 189
 190
 191 static gboolean qio_net_listener_wait_client_func(QIOChannel *ioc,
 192                                                   GIOCondition condition,
 193                                                   gpointer opaque)
 194 {
 195     struct QIONetListenerClientWaitData *data = opaque;
 196     QIOChannelSocket *sioc;
 197
 198     sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
 199                                      NULL);
 200     if (!sioc) {
 201         return TRUE;
 202     }
 203
 204     if (data->sioc) {
 205         object_unref(OBJECT(sioc));
 206     } else {
 207         data->sioc = sioc;
 208         g_main_loop_quit(data->loop);
 209     }
 210
 211     return TRUE;
 212 }
 213
 214 QIOChannelSocket *qio_net_listener_wait_client(QIONetListener *listener)
 215 {
 216     GMainContext *ctxt = g_main_context_new();
 217     GMainLoop *loop = g_main_loop_new(ctxt, TRUE);
 218     GSource **sources;
 219     struct QIONetListenerClientWaitData data = {
 220         .sioc = NULL,
 221         .loop = loop
 222     };
 223     size_t i;
 224
 225     for (i = 0; i < listener->nsioc; i++) {
 226         if (listener->io_source[i]) {
 227             g_source_destroy(listener->io_source[i]);
 228             g_source_unref(listener->io_source[i]);
 229             listener->io_source[i] = NULL;
 230         }
 231     }
 232
 233     sources = g_new0(GSource *, listener->nsioc);
 234     for (i = 0; i < listener->nsioc; i++) {
 235         sources[i] = qio_channel_create_watch(QIO_CHANNEL(listener->sioc[i]),
 236                                               G_IO_IN);
 237
 238         g_source_set_callback(sources[i],
 239                               (GSourceFunc)qio_net_listener_wait_client_func,
 240                               &data,
 241                               NULL);
 242         g_source_attach(sources[i], ctxt);
 243     }
 244
 245     g_main_loop_run(loop);
 246
 247     for (i = 0; i < listener->nsioc; i++) {
 248         g_source_unref(sources[i]);
 249     }
 250     g_free(sources);
 251     g_main_loop_unref(loop);
 252     g_main_context_unref(ctxt);
 253
 254     if (listener->io_func != NULL) {
 255         for (i = 0; i < listener->nsioc; i++) {
 256             object_ref(OBJECT(listener));
 257             listener->io_source[i] = qio_channel_add_watch_source(
 258                 QIO_CHANNEL(listener->sioc[i]), G_IO_IN,
 259                 qio_net_listener_channel_func,
 260                 listener, (GDestroyNotify)object_unref, NULL);
 261         }
 262     }
 263
 264     return data.sioc;
 265 }
 266
 267 void qio_net_listener_disconnect(QIONetListener *listener)
 268 {
 269     size_t i;
 270
 271     if (!listener->connected) {
 272         return;
 273     }
 274
 275     for (i = 0; i < listener->nsioc; i++) {
 276         if (listener->io_source[i]) {
 277             g_source_destroy(listener->io_source[i]);
 278             g_source_unref(listener->io_source[i]);
 279             listener->io_source[i] = NULL;
 280         }
 281         qio_channel_close(QIO_CHANNEL(listener->sioc[i]), NULL);
 282     }
 283     listener->connected = false;
 284 }
 285
 286
 287 bool qio_net_listener_is_connected(QIONetListener *listener)
 288 {
 289     return listener->connected;
 290 }
 291
 292 static void qio_net_listener_finalize(Object *obj)
 293 {
 294     QIONetListener *listener = QIO_NET_LISTENER(obj);
 295     size_t i;
 296
 297     qio_net_listener_disconnect(listener);
 298
 299     for (i = 0; i < listener->nsioc; i++) {
 300         object_unref(OBJECT(listener->sioc[i]));
 301     }
 302     g_free(listener->io_source);
 303     g_free(listener->sioc);
 304     g_free(listener->name);
 305 }
 306
 307 static const TypeInfo qio_net_listener_info = {
 308     .parent = TYPE_OBJECT,
 309     .name = TYPE_QIO_NET_LISTENER,
 310     .instance_size = sizeof(QIONetListener),
 311     .instance_finalize = qio_net_listener_finalize,
 312     .class_size = sizeof(QIONetListenerClass),
 313 };
 314
 315
 316 static void qio_net_listener_register_types(void)
 317 {
 318     type_register_static(&qio_net_listener_info);
 319 }
 320
 321
 322 type_init(qio_net_listener_register_types);