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 <zhangchen.fnst@cn.fujitsu.com>
   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 "qapi/error.h"
  16 #include "qom/object.h"
  17 #include "qemu/main-loop.h"
  18 #include "qemu/error-report.h"
  19 #include "trace.h"
  20 #include "chardev/char-fe.h"
  21 #include "qemu/iov.h"
  22 #include "qemu/sockets.h"
  23
  24 #define TYPE_FILTER_MIRROR "filter-mirror"
  25 typedef struct MirrorState MirrorState;
  26 DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_MIRROR,
  27                          TYPE_FILTER_MIRROR)
  28
  29 #define TYPE_FILTER_REDIRECTOR "filter-redirector"
  30 DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_REDIRECTOR,
  31                          TYPE_FILTER_REDIRECTOR)
  32
  33 #define REDIRECTOR_MAX_LEN NET_BUFSIZE
  34
  35 struct MirrorState {
  36     NetFilterState parent_obj;
  37     char *indev;
  38     char *outdev;
  39     CharBackend chr_in;
  40     CharBackend chr_out;
  41     SocketReadState rs;
  42     bool vnet_hdr;
  43 };
  44
  45 static int filter_send(MirrorState *s,
  46                        const struct iovec *iov,
  47                        int iovcnt)
  48 {
  49     NetFilterState *nf = NETFILTER(s);
  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(&s->chr_out, (uint8_t *)&len, sizeof(len));
  62     if (ret != sizeof(len)) {
  63         goto err;
  64     }
  65
  66     if (s->vnet_hdr) {
  67         /*
  68          * If vnet_hdr = on, we send vnet header len to make other
  69          * module(like colo-compare) know how to parse net
  70          * packet correctly.
  71          */
  72         ssize_t vnet_hdr_len;
  73
  74         vnet_hdr_len = nf->netdev->vnet_hdr_len;
  75
  76         len = htonl(vnet_hdr_len);
  77         ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
  78         if (ret != sizeof(len)) {
  79             goto err;
  80         }
  81     }
  82
  83     buf = g_malloc(size);
  84     iov_to_buf(iov, iovcnt, 0, buf, size);
  85     ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
  86     g_free(buf);
  87     if (ret != size) {
  88         goto err;
  89     }
  90
  91     return 0;
  92
  93 err:
  94     return ret < 0 ? ret : -EIO;
  95 }
  96
  97 static void redirector_to_filter(NetFilterState *nf,
  98                                  const uint8_t *buf,
  99                                  int len)
 100 {
 101     struct iovec iov = {
 102         .iov_base = (void *)buf,
 103         .iov_len = len,
 104     };
 105
 106     if (nf->direction == NET_FILTER_DIRECTION_ALL ||
 107         nf->direction == NET_FILTER_DIRECTION_TX) {
 108         qemu_netfilter_pass_to_next(nf->netdev, 0, &iov, 1, nf);
 109     }
 110
 111     if (nf->direction == NET_FILTER_DIRECTION_ALL ||
 112         nf->direction == NET_FILTER_DIRECTION_RX) {
 113         qemu_netfilter_pass_to_next(nf->netdev->peer, 0, &iov, 1, nf);
 114      }
 115 }
 116
 117 static int redirector_chr_can_read(void *opaque)
 118 {
 119     return REDIRECTOR_MAX_LEN;
 120 }
 121
 122 static void redirector_chr_read(void *opaque, const uint8_t *buf, int size)
 123 {
 124     NetFilterState *nf = opaque;
 125     MirrorState *s = FILTER_REDIRECTOR(nf);
 126     int ret;
 127
 128     ret = net_fill_rstate(&s->rs, buf, size);
 129
 130     if (ret == -1) {
 131         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
 132                                  NULL, NULL, NULL, true);
 133     }
 134 }
 135
 136 static void redirector_chr_event(void *opaque, QEMUChrEvent event)
 137 {
 138     NetFilterState *nf = opaque;
 139     MirrorState *s = FILTER_REDIRECTOR(nf);
 140
 141     switch (event) {
 142     case CHR_EVENT_CLOSED:
 143         qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
 144                                  NULL, NULL, NULL, true);
 145         break;
 146     default:
 147         break;
 148     }
 149 }
 150
 151 static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
 152                                          NetClientState *sender,
 153                                          unsigned flags,
 154                                          const struct iovec *iov,
 155                                          int iovcnt,
 156                                          NetPacketSent *sent_cb)
 157 {
 158     MirrorState *s = FILTER_MIRROR(nf);
 159     int ret;
 160
 161     ret = filter_send(s, iov, iovcnt);
 162     if (ret) {
 163         error_report("filter mirror send failed(%s)", strerror(-ret));
 164     }
 165
 166     /*
 167      * we don't hope this error interrupt the normal
 168      * path of net packet, so we always return zero.
 169      */
 170     return 0;
 171 }
 172
 173 static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
 174                                              NetClientState *sender,
 175                                              unsigned flags,
 176                                              const struct iovec *iov,
 177                                              int iovcnt,
 178                                              NetPacketSent *sent_cb)
 179 {
 180     MirrorState *s = FILTER_REDIRECTOR(nf);
 181     int ret;
 182
 183     if (qemu_chr_fe_backend_connected(&s->chr_out)) {
 184         ret = filter_send(s, iov, iovcnt);
 185         if (ret) {
 186             error_report("filter redirector send failed(%s)", strerror(-ret));
 187         }
 188         return iov_size(iov, iovcnt);
 189     } else {
 190         return 0;
 191     }
 192 }
 193
 194 static void filter_mirror_cleanup(NetFilterState *nf)
 195 {
 196     MirrorState *s = FILTER_MIRROR(nf);
 197
 198     qemu_chr_fe_deinit(&s->chr_out, false);
 199 }
 200
 201 static void filter_redirector_cleanup(NetFilterState *nf)
 202 {
 203     MirrorState *s = FILTER_REDIRECTOR(nf);
 204
 205     qemu_chr_fe_deinit(&s->chr_in, false);
 206     qemu_chr_fe_deinit(&s->chr_out, false);
 207 }
 208
 209 static void filter_mirror_setup(NetFilterState *nf, Error **errp)
 210 {
 211     MirrorState *s = FILTER_MIRROR(nf);
 212     Chardev *chr;
 213
 214     if (s->outdev == NULL) {
 215         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "filter-mirror parameter"\
 216                   " 'outdev' cannot be empty");
 217         return;
 218     }
 219
 220     chr = qemu_chr_find(s->outdev);
 221     if (chr == NULL) {
 222         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 223                   "Device '%s' not found", s->outdev);
 224         return;
 225     }
 226
 227     qemu_chr_fe_init(&s->chr_out, chr, errp);
 228 }
 229
 230 static void redirector_rs_finalize(SocketReadState *rs)
 231 {
 232     MirrorState *s = container_of(rs, MirrorState, rs);
 233     NetFilterState *nf = NETFILTER(s);
 234
 235     redirector_to_filter(nf, rs->buf, rs->packet_len);
 236 }
 237
 238 static void filter_redirector_setup(NetFilterState *nf, Error **errp)
 239 {
 240     MirrorState *s = FILTER_REDIRECTOR(nf);
 241     Chardev *chr;
 242
 243     if (!s->indev && !s->outdev) {
 244         error_setg(errp, "filter redirector needs 'indev' or "
 245                    "'outdev' at least one property set");
 246         return;
 247     } else if (s->indev && s->outdev) {
 248         if (!strcmp(s->indev, s->outdev)) {
 249             error_setg(errp, "'indev' and 'outdev' could not be same "
 250                        "for filter redirector");
 251             return;
 252         }
 253     }
 254
 255     net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
 256
 257     if (s->indev) {
 258         chr = qemu_chr_find(s->indev);
 259         if (chr == NULL) {
 260             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 261                       "IN Device '%s' not found", s->indev);
 262             return;
 263         }
 264
 265         if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
 266             return;
 267         }
 268
 269         qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read,
 270                                  redirector_chr_read, redirector_chr_event,
 271                                  NULL, nf, NULL, true);
 272     }
 273
 274     if (s->outdev) {
 275         chr = qemu_chr_find(s->outdev);
 276         if (chr == NULL) {
 277             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 278                       "OUT Device '%s' not found", s->outdev);
 279             return;
 280         }
 281         if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
 282             return;
 283         }
 284     }
 285 }
 286
 287 static char *filter_redirector_get_indev(Object *obj, Error **errp)
 288 {
 289     MirrorState *s = FILTER_REDIRECTOR(obj);
 290
 291     return g_strdup(s->indev);
 292 }
 293
 294 static void filter_redirector_set_indev(Object *obj,
 295                                         const char *value,
 296                                         Error **errp)
 297 {
 298     MirrorState *s = FILTER_REDIRECTOR(obj);
 299
 300     g_free(s->indev);
 301     s->indev = g_strdup(value);
 302 }
 303
 304 static char *filter_mirror_get_outdev(Object *obj, Error **errp)
 305 {
 306     MirrorState *s = FILTER_MIRROR(obj);
 307
 308     return g_strdup(s->outdev);
 309 }
 310
 311 static void filter_mirror_set_outdev(Object *obj,
 312                                      const char *value,
 313                                      Error **errp)
 314 {
 315     MirrorState *s = FILTER_MIRROR(obj);
 316
 317     g_free(s->outdev);
 318     s->outdev = g_strdup(value);
 319     if (!s->outdev) {
 320         error_setg(errp, "filter mirror needs 'outdev' "
 321                    "property set");
 322         return;
 323     }
 324 }
 325
 326 static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
 327 {
 328     MirrorState *s = FILTER_MIRROR(obj);
 329
 330     return s->vnet_hdr;
 331 }
 332
 333 static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
 334 {
 335     MirrorState *s = FILTER_MIRROR(obj);
 336
 337     s->vnet_hdr = value;
 338 }
 339
 340 static char *filter_redirector_get_outdev(Object *obj, Error **errp)
 341 {
 342     MirrorState *s = FILTER_REDIRECTOR(obj);
 343
 344     return g_strdup(s->outdev);
 345 }
 346
 347 static void filter_redirector_set_outdev(Object *obj,
 348                                          const char *value,
 349                                          Error **errp)
 350 {
 351     MirrorState *s = FILTER_REDIRECTOR(obj);
 352
 353     g_free(s->outdev);
 354     s->outdev = g_strdup(value);
 355 }
 356
 357 static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
 358 {
 359     MirrorState *s = FILTER_REDIRECTOR(obj);
 360
 361     return s->vnet_hdr;
 362 }
 363
 364 static void filter_redirector_set_vnet_hdr(Object *obj,
 365                                            bool value,
 366                                            Error **errp)
 367 {
 368     MirrorState *s = FILTER_REDIRECTOR(obj);
 369
 370     s->vnet_hdr = value;
 371 }
 372
 373 static void filter_mirror_class_init(ObjectClass *oc, void *data)
 374 {
 375     NetFilterClass *nfc = NETFILTER_CLASS(oc);
 376
 377     object_class_property_add_str(oc, "outdev", filter_mirror_get_outdev,
 378                                   filter_mirror_set_outdev);
 379     object_class_property_add_bool(oc, "vnet_hdr_support",
 380                                    filter_mirror_get_vnet_hdr,
 381                                    filter_mirror_set_vnet_hdr);
 382
 383     nfc->setup = filter_mirror_setup;
 384     nfc->cleanup = filter_mirror_cleanup;
 385     nfc->receive_iov = filter_mirror_receive_iov;
 386 }
 387
 388 static void filter_redirector_class_init(ObjectClass *oc, void *data)
 389 {
 390     NetFilterClass *nfc = NETFILTER_CLASS(oc);
 391
 392     object_class_property_add_str(oc, "indev", filter_redirector_get_indev,
 393                                   filter_redirector_set_indev);
 394     object_class_property_add_str(oc, "outdev", filter_redirector_get_outdev,
 395                                   filter_redirector_set_outdev);
 396     object_class_property_add_bool(oc, "vnet_hdr_support",
 397                                    filter_redirector_get_vnet_hdr,
 398                                    filter_redirector_set_vnet_hdr);
 399
 400     nfc->setup = filter_redirector_setup;
 401     nfc->cleanup = filter_redirector_cleanup;
 402     nfc->receive_iov = filter_redirector_receive_iov;
 403 }
 404
 405 static void filter_mirror_init(Object *obj)
 406 {
 407     MirrorState *s = FILTER_MIRROR(obj);
 408
 409     s->vnet_hdr = false;
 410 }
 411
 412 static void filter_redirector_init(Object *obj)
 413 {
 414     MirrorState *s = FILTER_REDIRECTOR(obj);
 415
 416     s->vnet_hdr = false;
 417 }
 418
 419 static void filter_mirror_fini(Object *obj)
 420 {
 421     MirrorState *s = FILTER_MIRROR(obj);
 422
 423     g_free(s->outdev);
 424 }
 425
 426 static void filter_redirector_fini(Object *obj)
 427 {
 428     MirrorState *s = FILTER_REDIRECTOR(obj);
 429
 430     g_free(s->indev);
 431     g_free(s->outdev);
 432 }
 433
 434 static const TypeInfo filter_redirector_info = {
 435     .name = TYPE_FILTER_REDIRECTOR,
 436     .parent = TYPE_NETFILTER,
 437     .class_init = filter_redirector_class_init,
 438     .instance_init = filter_redirector_init,
 439     .instance_finalize = filter_redirector_fini,
 440     .instance_size = sizeof(MirrorState),
 441 };
 442
 443 static const TypeInfo filter_mirror_info = {
 444     .name = TYPE_FILTER_MIRROR,
 445     .parent = TYPE_NETFILTER,
 446     .class_init = filter_mirror_class_init,
 447     .instance_init = filter_mirror_init,
 448     .instance_finalize = filter_mirror_fini,
 449     .instance_size = sizeof(MirrorState),
 450 };
 451
 452 static void register_types(void)
 453 {
 454     type_register_static(&filter_mirror_info);
 455     type_register_static(&filter_redirector_info);
 456 }
 457
 458 type_init(register_types);