net/filter-mirror.c

   1 /*
   2  * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
   3  * Copyright (c) 2016 FUJITSU LIMITED
   4  * Copyright (c) 2016 Intel Corporation
   5  *
   6  * Author: Zhang Chen <[email protected]>
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or
   9  * later.  See the COPYING file in the top-level directory.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "net/filter.h"
  14 #include "net/net.h"
  15 #include "qemu-common.h"
  16 #include "qapi/error.h"
  17 #include "qapi/qmp/qerror.h"
  18 #include "qapi-visit.h"
  19 #include "qom/object.h"
  20 #include "qemu/main-loop.h"
  21 #include "qemu/error-report.h"
  22 #include "trace.h"
  23 #include "sysemu/char.h"
  24 #include "qemu/iov.h"
  25 #include "qemu/sockets.h"
  26
  27 #define FILTER_MIRROR(obj) \
  28     OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_MIRROR)
  29
  30 #define FILTER_REDIRECTOR(obj) \
  31     OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_REDIRECTOR)
  32
  33 #define TYPE_FILTER_MIRROR "filter-mirror"
  34 #define TYPE_FILTER_REDIRECTOR "filter-redirector"
  35 #define REDIRECTOR_MAX_LEN NET_BUFSIZE
  36
  37 typedef struct MirrorState {
  38     NetFilterState parent_obj;
  39     char *indev;
  40     char *outdev;
  41     CharBackend chr_in;
  42     CharBackend chr_out;
  43     SocketReadState rs;
  44 } MirrorState;
  45
  46 static int filter_mirror_send(CharBackend *chr_out,
  47                               const struct iovec *iov,
  48                               int iovcnt)
  49 {
  50     int ret = 0;
  51     ssize_t size = 0;
  52     uint32_t len =  0;
  53     char *buf;
  54
  55     size = iov_size(iov, iovcnt);
  56     if (!size) {
  57         return 0;
  58     }
  59
  60     len = htonl(size);
  61     ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)&len, sizeof(len));
  62     if (ret != sizeof(len)) {
  63         goto err;
  64     }
  65
  66     buf = g_malloc(size);
  67     iov_to_buf(iov, iovcnt, 0, buf, size);
  68     ret = qemu_chr_fe_write_all(chr_out, (uint8_t *)buf, size);
  69     g_free(buf);
  70     if (ret != size) {
  71         goto err;
  72     }
  73
  74     return 0;
  75
  76 err:
  77     return ret < 0 ? ret : -EIO;
  78 }
  79
  80 static void
  81 redirector_to_filter(NetFilterState *nf, const uint8_t *buf, int len)
  82 {
  83     struct iovec iov = {
  84         .iov_base = (void *)buf,
  85         .iov_len = len,
  86     };
  87
  88     if (nf->direction == NET_FILTER_DIRECTION_ALL ||
  89         nf->direction == NET_FILTER_DIRECTION_TX) {
  90         qemu_netfilter_pass_to_next(nf->netdev, 0, &iov, 1, nf);
  91     }
  92
  93     if (nf->direction == NET_FILTER_DIRECTION_ALL ||
  94         nf->direction == NET_FILTER_DIRECTION_RX) {
  95         qemu_netfilter_pass_to_next(nf->netdev->peer, 0, &iov, 1, nf);
  96      }
  97 }
  98
  99 static int redirector_chr_can_read(void *opaque)
 100 {
 101     return REDIRECTOR_MAX_LEN;
 102 }
 103
 104 static void redirector_chr_read(void *opaque, const uint8_t *buf, int size)
 105 {
 106     NetFilterState *nf = opaque;
 107     MirrorState *s = FILTER_REDIRECTOR(nf);
 108     int ret;
 109
 110     ret = net_fill_rstate(&s->rs, buf, size);
 111
 112     if (ret == -1) {
 113         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, NULL, NULL);
 114     }
 115 }
 116
 117 static void redirector_chr_event(void *opaque, int event)
 118 {
 119     NetFilterState *nf = opaque;
 120     MirrorState *s = FILTER_REDIRECTOR(nf);
 121
 122     switch (event) {
 123     case CHR_EVENT_CLOSED:
 124         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, NULL, NULL);
 125         break;
 126     default:
 127         break;
 128     }
 129 }
 130
 131 static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
 132                                          NetClientState *sender,
 133                                          unsigned flags,
 134                                          const struct iovec *iov,
 135                                          int iovcnt,
 136                                          NetPacketSent *sent_cb)
 137 {
 138     MirrorState *s = FILTER_MIRROR(nf);
 139     int ret;
 140
 141     ret = filter_mirror_send(&s->chr_out, iov, iovcnt);
 142     if (ret) {
 143         error_report("filter_mirror_send failed(%s)", strerror(-ret));
 144     }
 145
 146     /*
 147      * we don't hope this error interrupt the normal
 148      * path of net packet, so we always return zero.
 149      */
 150     return 0;
 151 }
 152
 153 static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
 154                                              NetClientState *sender,
 155                                              unsigned flags,
 156                                              const struct iovec *iov,
 157                                              int iovcnt,
 158                                              NetPacketSent *sent_cb)
 159 {
 160     MirrorState *s = FILTER_REDIRECTOR(nf);
 161     int ret;
 162
 163     if (qemu_chr_fe_get_driver(&s->chr_out)) {
 164         ret = filter_mirror_send(&s->chr_out, iov, iovcnt);
 165         if (ret) {
 166             error_report("filter_mirror_send failed(%s)", strerror(-ret));
 167         }
 168         return iov_size(iov, iovcnt);
 169     } else {
 170         return 0;
 171     }
 172 }
 173
 174 static void filter_mirror_cleanup(NetFilterState *nf)
 175 {
 176     MirrorState *s = FILTER_MIRROR(nf);
 177
 178     if (s->chr_out.chr) {
 179         qemu_chr_fe_release(s->chr_out.chr);
 180     }
 181 }
 182
 183 static void filter_redirector_cleanup(NetFilterState *nf)
 184 {
 185     MirrorState *s = FILTER_REDIRECTOR(nf);
 186
 187     if (s->chr_in.chr) {
 188         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, NULL, NULL);
 189         qemu_chr_fe_release(s->chr_in.chr);
 190     }
 191     if (s->chr_out.chr) {
 192         qemu_chr_fe_release(s->chr_out.chr);
 193     }
 194 }
 195
 196 static void filter_mirror_setup(NetFilterState *nf, Error **errp)
 197 {
 198     MirrorState *s = FILTER_MIRROR(nf);
 199     CharDriverState *chr;
 200
 201     if (!s->outdev) {
 202         error_setg(errp, "filter mirror needs 'outdev' "
 203                    "property set");
 204         return;
 205     }
 206
 207     chr = qemu_chr_find(s->outdev);
 208     if (chr == NULL) {
 209         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 210                   "Device '%s' not found", s->outdev);
 211         return;
 212     }
 213
 214     if (qemu_chr_fe_claim(chr) != 0) {
 215         error_setg(errp, QERR_DEVICE_IN_USE, s->outdev);
 216         return;
 217     }
 218
 219     qemu_chr_fe_init(&s->chr_out, chr, errp);
 220 }
 221
 222 static void redirector_rs_finalize(SocketReadState *rs)
 223 {
 224     MirrorState *s = container_of(rs, MirrorState, rs);
 225     NetFilterState *nf = NETFILTER(s);
 226
 227     redirector_to_filter(nf, rs->buf, rs->packet_len);
 228 }
 229
 230 static void filter_redirector_setup(NetFilterState *nf, Error **errp)
 231 {
 232     MirrorState *s = FILTER_REDIRECTOR(nf);
 233     CharDriverState *chr;
 234
 235     if (!s->indev && !s->outdev) {
 236         error_setg(errp, "filter redirector needs 'indev' or "
 237                    "'outdev' at least one property set");
 238         return;
 239     } else if (s->indev && s->outdev) {
 240         if (!strcmp(s->indev, s->outdev)) {
 241             error_setg(errp, "'indev' and 'outdev' could not be same "
 242                        "for filter redirector");
 243             return;
 244         }
 245     }
 246
 247     net_socket_rs_init(&s->rs, redirector_rs_finalize);
 248
 249     if (s->indev) {
 250         chr = qemu_chr_find(s->indev);
 251         if (chr == NULL) {
 252             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 253                       "IN Device '%s' not found", s->indev);
 254             return;
 255         }
 256
 257         qemu_chr_fe_claim_no_fail(chr);
 258         if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
 259             return;
 260         }
 261
 262         qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read,
 263                                  redirector_chr_read, redirector_chr_event,
 264                                  nf, NULL);
 265     }
 266
 267     if (s->outdev) {
 268         chr = qemu_chr_find(s->outdev);
 269         if (chr == NULL) {
 270             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 271                       "OUT Device '%s' not found", s->outdev);
 272             return;
 273         }
 274         qemu_chr_fe_claim_no_fail(chr);
 275         if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
 276             return;
 277         }
 278     }
 279 }
 280
 281 static void filter_mirror_class_init(ObjectClass *oc, void *data)
 282 {
 283     NetFilterClass *nfc = NETFILTER_CLASS(oc);
 284
 285     nfc->setup = filter_mirror_setup;
 286     nfc->cleanup = filter_mirror_cleanup;
 287     nfc->receive_iov = filter_mirror_receive_iov;
 288 }
 289
 290 static void filter_redirector_class_init(ObjectClass *oc, void *data)
 291 {
 292     NetFilterClass *nfc = NETFILTER_CLASS(oc);
 293
 294     nfc->setup = filter_redirector_setup;
 295     nfc->cleanup = filter_redirector_cleanup;
 296     nfc->receive_iov = filter_redirector_receive_iov;
 297 }
 298
 299 static char *filter_redirector_get_indev(Object *obj, Error **errp)
 300 {
 301     MirrorState *s = FILTER_REDIRECTOR(obj);
 302
 303     return g_strdup(s->indev);
 304 }
 305
 306 static void
 307 filter_redirector_set_indev(Object *obj, const char *value, Error **errp)
 308 {
 309     MirrorState *s = FILTER_REDIRECTOR(obj);
 310
 311     g_free(s->indev);
 312     s->indev = g_strdup(value);
 313 }
 314
 315 static char *filter_mirror_get_outdev(Object *obj, Error **errp)
 316 {
 317     MirrorState *s = FILTER_MIRROR(obj);
 318
 319     return g_strdup(s->outdev);
 320 }
 321
 322 static void
 323 filter_mirror_set_outdev(Object *obj, const char *value, Error **errp)
 324 {
 325     MirrorState *s = FILTER_MIRROR(obj);
 326
 327     g_free(s->outdev);
 328     s->outdev = g_strdup(value);
 329     if (!s->outdev) {
 330         error_setg(errp, "filter mirror needs 'outdev' "
 331                    "property set");
 332         return;
 333     }
 334 }
 335
 336 static char *filter_redirector_get_outdev(Object *obj, Error **errp)
 337 {
 338     MirrorState *s = FILTER_REDIRECTOR(obj);
 339
 340     return g_strdup(s->outdev);
 341 }
 342
 343 static void
 344 filter_redirector_set_outdev(Object *obj, const char *value, Error **errp)
 345 {
 346     MirrorState *s = FILTER_REDIRECTOR(obj);
 347
 348     g_free(s->outdev);
 349     s->outdev = g_strdup(value);
 350 }
 351
 352 static void filter_mirror_init(Object *obj)
 353 {
 354     object_property_add_str(obj, "outdev", filter_mirror_get_outdev,
 355                             filter_mirror_set_outdev, NULL);
 356 }
 357
 358 static void filter_redirector_init(Object *obj)
 359 {
 360     object_property_add_str(obj, "indev", filter_redirector_get_indev,
 361                             filter_redirector_set_indev, NULL);
 362     object_property_add_str(obj, "outdev", filter_redirector_get_outdev,
 363                             filter_redirector_set_outdev, NULL);
 364 }
 365
 366 static void filter_mirror_fini(Object *obj)
 367 {
 368     MirrorState *s = FILTER_MIRROR(obj);
 369
 370     g_free(s->outdev);
 371 }
 372
 373 static void filter_redirector_fini(Object *obj)
 374 {
 375     MirrorState *s = FILTER_REDIRECTOR(obj);
 376
 377     g_free(s->indev);
 378     g_free(s->outdev);
 379 }
 380
 381 static const TypeInfo filter_redirector_info = {
 382     .name = TYPE_FILTER_REDIRECTOR,
 383     .parent = TYPE_NETFILTER,
 384     .class_init = filter_redirector_class_init,
 385     .instance_init = filter_redirector_init,
 386     .instance_finalize = filter_redirector_fini,
 387     .instance_size = sizeof(MirrorState),
 388 };
 389
 390 static const TypeInfo filter_mirror_info = {
 391     .name = TYPE_FILTER_MIRROR,
 392     .parent = TYPE_NETFILTER,
 393     .class_init = filter_mirror_class_init,
 394     .instance_init = filter_mirror_init,
 395     .instance_finalize = filter_mirror_fini,
 396     .instance_size = sizeof(MirrorState),
 397 };
 398
 399 static void register_types(void)
 400 {
 401     type_register_static(&filter_mirror_info);
 402     type_register_static(&filter_redirector_info);
 403 }
 404
 405 type_init(register_types);