net/filter.c

   1 /*
   2  * Copyright (c) 2015 FUJITSU LIMITED
   3  * Author: Yang Hongyang <yanghy@cn.fujitsu.com>
   4  *
   5  * This work is licensed under the terms of the GNU GPL, version 2 or
   6  * later.  See the COPYING file in the top-level directory.
   7  */
   8
   9 #include "qemu-common.h"
  10 #include "qapi/qmp/qerror.h"
  11 #include "qemu/error-report.h"
  12
  13 #include "net/filter.h"
  14 #include "net/net.h"
  15 #include "net/vhost_net.h"
  16 #include "qom/object_interfaces.h"
  17 #include "qemu/iov.h"
  18 #include "qapi/string-output-visitor.h"
  19
  20 ssize_t qemu_netfilter_receive(NetFilterState *nf,
  21                                NetFilterDirection direction,
  22                                NetClientState *sender,
  23                                unsigned flags,
  24                                const struct iovec *iov,
  25                                int iovcnt,
  26                                NetPacketSent *sent_cb)
  27 {
  28     if (nf->direction == direction ||
  29         nf->direction == NET_FILTER_DIRECTION_ALL) {
  30         return NETFILTER_GET_CLASS(OBJECT(nf))->receive_iov(
  31                                    nf, sender, flags, iov, iovcnt, sent_cb);
  32     }
  33
  34     return 0;
  35 }
  36
  37 static NetFilterState *netfilter_next(NetFilterState *nf,
  38                                       NetFilterDirection dir)
  39 {
  40     NetFilterState *next;
  41
  42     if (dir == NET_FILTER_DIRECTION_TX) {
  43         /* forward walk through filters */
  44         next = QTAILQ_NEXT(nf, next);
  45     } else {
  46         /* reverse order */
  47         next = QTAILQ_PREV(nf, NetFilterHead, next);
  48     }
  49
  50     return next;
  51 }
  52
  53 ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
  54                                     unsigned flags,
  55                                     const struct iovec *iov,
  56                                     int iovcnt,
  57                                     void *opaque)
  58 {
  59     int ret = 0;
  60     int direction;
  61     NetFilterState *nf = opaque;
  62     NetFilterState *next = NULL;
  63
  64     if (!sender || !sender->peer) {
  65         /* no receiver, or sender been deleted, no need to pass it further */
  66         goto out;
  67     }
  68
  69     if (nf->direction == NET_FILTER_DIRECTION_ALL) {
  70         if (sender == nf->netdev) {
  71             /* This packet is sent by netdev itself */
  72             direction = NET_FILTER_DIRECTION_TX;
  73         } else {
  74             direction = NET_FILTER_DIRECTION_RX;
  75         }
  76     } else {
  77         direction = nf->direction;
  78     }
  79
  80     next = netfilter_next(nf, direction);
  81     while (next) {
  82         /*
  83          * if qemu_netfilter_pass_to_next been called, means that
  84          * the packet has been hold by filter and has already retured size
  85          * to the sender, so sent_cb shouldn't be called later, just
  86          * pass NULL to next.
  87          */
  88         ret = qemu_netfilter_receive(next, direction, sender, flags, iov,
  89                                      iovcnt, NULL);
  90         if (ret) {
  91             return ret;
  92         }
  93         next = netfilter_next(next, direction);
  94     }
  95
  96     /*
  97      * We have gone through all filters, pass it to receiver.
  98      * Do the valid check again incase sender or receiver been
  99      * deleted while we go through filters.
 100      */
 101     if (sender && sender->peer) {
 102         qemu_net_queue_send_iov(sender->peer->incoming_queue,
 103                                 sender, flags, iov, iovcnt, NULL);
 104     }
 105
 106 out:
 107     /* no receiver, or sender been deleted */
 108     return iov_size(iov, iovcnt);
 109 }
 110
 111 static char *netfilter_get_netdev_id(Object *obj, Error **errp)
 112 {
 113     NetFilterState *nf = NETFILTER(obj);
 114
 115     return g_strdup(nf->netdev_id);
 116 }
 117
 118 static void netfilter_set_netdev_id(Object *obj, const char *str, Error **errp)
 119 {
 120     NetFilterState *nf = NETFILTER(obj);
 121
 122     nf->netdev_id = g_strdup(str);
 123 }
 124
 125 static int netfilter_get_direction(Object *obj, Error **errp G_GNUC_UNUSED)
 126 {
 127     NetFilterState *nf = NETFILTER(obj);
 128     return nf->direction;
 129 }
 130
 131 static void netfilter_set_direction(Object *obj, int direction, Error **errp)
 132 {
 133     NetFilterState *nf = NETFILTER(obj);
 134     nf->direction = direction;
 135 }
 136
 137 static void netfilter_init(Object *obj)
 138 {
 139     object_property_add_str(obj, "netdev",
 140                             netfilter_get_netdev_id, netfilter_set_netdev_id,
 141                             NULL);
 142     object_property_add_enum(obj, "queue", "NetFilterDirection",
 143                              NetFilterDirection_lookup,
 144                              netfilter_get_direction, netfilter_set_direction,
 145                              NULL);
 146 }
 147
 148 static void netfilter_complete(UserCreatable *uc, Error **errp)
 149 {
 150     NetFilterState *nf = NETFILTER(uc);
 151     NetClientState *ncs[MAX_QUEUE_NUM];
 152     NetFilterClass *nfc = NETFILTER_GET_CLASS(uc);
 153     int queues;
 154     Error *local_err = NULL;
 155     char *str, *info;
 156     ObjectProperty *prop;
 157     ObjectPropertyIterator iter;
 158     StringOutputVisitor *ov;
 159
 160     if (!nf->netdev_id) {
 161         error_setg(errp, "Parameter 'netdev' is required");
 162         return;
 163     }
 164
 165     queues = qemu_find_net_clients_except(nf->netdev_id, ncs,
 166                                           NET_CLIENT_OPTIONS_KIND_NIC,
 167                                           MAX_QUEUE_NUM);
 168     if (queues < 1) {
 169         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "netdev",
 170                    "a network backend id");
 171         return;
 172     } else if (queues > 1) {
 173         error_setg(errp, "multiqueue is not supported");
 174         return;
 175     }
 176
 177     if (get_vhost_net(ncs[0])) {
 178         error_setg(errp, "Vhost is not supported");
 179         return;
 180     }
 181
 182     nf->netdev = ncs[0];
 183
 184     if (nfc->setup) {
 185         nfc->setup(nf, &local_err);
 186         if (local_err) {
 187             error_propagate(errp, local_err);
 188             return;
 189         }
 190     }
 191     QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
 192
 193     /* generate info str */
 194     object_property_iter_init(&iter, OBJECT(nf));
 195     while ((prop = object_property_iter_next(&iter))) {
 196         if (!strcmp(prop->name, "type")) {
 197             continue;
 198         }
 199         ov = string_output_visitor_new(false);
 200         object_property_get(OBJECT(nf), string_output_get_visitor(ov),
 201                             prop->name, errp);
 202         str = string_output_get_string(ov);
 203         string_output_visitor_cleanup(ov);
 204         info = g_strdup_printf(",%s=%s", prop->name, str);
 205         g_strlcat(nf->info_str, info, sizeof(nf->info_str));
 206         g_free(str);
 207         g_free(info);
 208     }
 209 }
 210
 211 static void netfilter_finalize(Object *obj)
 212 {
 213     NetFilterState *nf = NETFILTER(obj);
 214     NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
 215
 216     if (nfc->cleanup) {
 217         nfc->cleanup(nf);
 218     }
 219
 220     if (nf->netdev && !QTAILQ_EMPTY(&nf->netdev->filters)) {
 221         QTAILQ_REMOVE(&nf->netdev->filters, nf, next);
 222     }
 223     g_free(nf->netdev_id);
 224 }
 225
 226 static void netfilter_class_init(ObjectClass *oc, void *data)
 227 {
 228     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 229
 230     ucc->complete = netfilter_complete;
 231 }
 232
 233 static const TypeInfo netfilter_info = {
 234     .name = TYPE_NETFILTER,
 235     .parent = TYPE_OBJECT,
 236     .abstract = true,
 237     .class_size = sizeof(NetFilterClass),
 238     .class_init = netfilter_class_init,
 239     .instance_size = sizeof(NetFilterState),
 240     .instance_init = netfilter_init,
 241     .instance_finalize = netfilter_finalize,
 242     .interfaces = (InterfaceInfo[]) {
 243         { TYPE_USER_CREATABLE },
 244         { }
 245     }
 246 };
 247
 248 static void register_types(void)
 249 {
 250     type_register_static(&netfilter_info);
 251 }
 252
 253 type_init(register_types);