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