2 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
3 * Copyright (c) 2016 FUJITSU LIMITED
4 * Copyright (c) 2016 Intel Corporation
6 * Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
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.
12 #include "qemu/osdep.h"
13 #include "net/filter.h"
15 #include "qapi/error.h"
16 #include "qom/object.h"
17 #include "qemu/main-loop.h"
18 #include "qemu/error-report.h"
20 #include "chardev/char-fe.h"
22 #include "qemu/sockets.h"
24 #define TYPE_FILTER_MIRROR "filter-mirror"
25 typedef struct MirrorState MirrorState;
26 DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_MIRROR,
29 #define TYPE_FILTER_REDIRECTOR "filter-redirector"
30 DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_REDIRECTOR,
31 TYPE_FILTER_REDIRECTOR)
33 #define REDIRECTOR_MAX_LEN NET_BUFSIZE
36 NetFilterState parent_obj;
45 static int filter_send(MirrorState *s,
46 const struct iovec *iov,
49 NetFilterState *nf = NETFILTER(s);
55 size = iov_size(iov, iovcnt);
61 ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
62 if (ret != sizeof(len)) {
68 * If vnet_hdr = on, we send vnet header len to make other
69 * module(like colo-compare) know how to parse net
74 vnet_hdr_len = nf->netdev->vnet_hdr_len;
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)) {
84 iov_to_buf(iov, iovcnt, 0, buf, size);
85 ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
94 return ret < 0 ? ret : -EIO;
97 static void redirector_to_filter(NetFilterState *nf,
102 .iov_base = (void *)buf,
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);
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);
117 static int redirector_chr_can_read(void *opaque)
119 return REDIRECTOR_MAX_LEN;
122 static void redirector_chr_read(void *opaque, const uint8_t *buf, int size)
124 NetFilterState *nf = opaque;
125 MirrorState *s = FILTER_REDIRECTOR(nf);
128 ret = net_fill_rstate(&s->rs, buf, size);
131 qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
132 NULL, NULL, NULL, true);
136 static void redirector_chr_event(void *opaque, QEMUChrEvent event)
138 NetFilterState *nf = opaque;
139 MirrorState *s = FILTER_REDIRECTOR(nf);
142 case CHR_EVENT_CLOSED:
143 qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
144 NULL, NULL, NULL, true);
151 static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
152 NetClientState *sender,
154 const struct iovec *iov,
156 NetPacketSent *sent_cb)
158 MirrorState *s = FILTER_MIRROR(nf);
161 ret = filter_send(s, iov, iovcnt);
163 error_report("filter mirror send failed(%s)", strerror(-ret));
167 * we don't hope this error interrupt the normal
168 * path of net packet, so we always return zero.
173 static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
174 NetClientState *sender,
176 const struct iovec *iov,
178 NetPacketSent *sent_cb)
180 MirrorState *s = FILTER_REDIRECTOR(nf);
183 if (qemu_chr_fe_backend_connected(&s->chr_out)) {
184 ret = filter_send(s, iov, iovcnt);
186 error_report("filter redirector send failed(%s)", strerror(-ret));
188 return iov_size(iov, iovcnt);
194 static void filter_mirror_cleanup(NetFilterState *nf)
196 MirrorState *s = FILTER_MIRROR(nf);
198 qemu_chr_fe_deinit(&s->chr_out, false);
201 static void filter_redirector_cleanup(NetFilterState *nf)
203 MirrorState *s = FILTER_REDIRECTOR(nf);
205 qemu_chr_fe_deinit(&s->chr_in, false);
206 qemu_chr_fe_deinit(&s->chr_out, false);
209 static void filter_mirror_setup(NetFilterState *nf, Error **errp)
211 MirrorState *s = FILTER_MIRROR(nf);
214 if (s->outdev == NULL) {
215 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "filter-mirror parameter"\
216 " 'outdev' cannot be empty");
220 chr = qemu_chr_find(s->outdev);
222 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
223 "Device '%s' not found", s->outdev);
227 qemu_chr_fe_init(&s->chr_out, chr, errp);
230 static void redirector_rs_finalize(SocketReadState *rs)
232 MirrorState *s = container_of(rs, MirrorState, rs);
233 NetFilterState *nf = NETFILTER(s);
235 redirector_to_filter(nf, rs->buf, rs->packet_len);
238 static void filter_redirector_setup(NetFilterState *nf, Error **errp)
240 MirrorState *s = FILTER_REDIRECTOR(nf);
243 if (!s->indev && !s->outdev) {
244 error_setg(errp, "filter redirector needs 'indev' or "
245 "'outdev' at least one property set");
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");
255 net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
258 chr = qemu_chr_find(s->indev);
260 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
261 "IN Device '%s' not found", s->indev);
265 if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
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);
275 chr = qemu_chr_find(s->outdev);
277 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
278 "OUT Device '%s' not found", s->outdev);
281 if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
287 static char *filter_redirector_get_indev(Object *obj, Error **errp)
289 MirrorState *s = FILTER_REDIRECTOR(obj);
291 return g_strdup(s->indev);
294 static void filter_redirector_set_indev(Object *obj,
298 MirrorState *s = FILTER_REDIRECTOR(obj);
301 s->indev = g_strdup(value);
304 static char *filter_mirror_get_outdev(Object *obj, Error **errp)
306 MirrorState *s = FILTER_MIRROR(obj);
308 return g_strdup(s->outdev);
311 static void filter_mirror_set_outdev(Object *obj,
315 MirrorState *s = FILTER_MIRROR(obj);
318 s->outdev = g_strdup(value);
320 error_setg(errp, "filter mirror needs 'outdev' "
326 static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
328 MirrorState *s = FILTER_MIRROR(obj);
333 static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
335 MirrorState *s = FILTER_MIRROR(obj);
340 static char *filter_redirector_get_outdev(Object *obj, Error **errp)
342 MirrorState *s = FILTER_REDIRECTOR(obj);
344 return g_strdup(s->outdev);
347 static void filter_redirector_set_outdev(Object *obj,
351 MirrorState *s = FILTER_REDIRECTOR(obj);
354 s->outdev = g_strdup(value);
357 static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
359 MirrorState *s = FILTER_REDIRECTOR(obj);
364 static void filter_redirector_set_vnet_hdr(Object *obj,
368 MirrorState *s = FILTER_REDIRECTOR(obj);
373 static void filter_mirror_class_init(ObjectClass *oc, void *data)
375 NetFilterClass *nfc = NETFILTER_CLASS(oc);
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);
383 nfc->setup = filter_mirror_setup;
384 nfc->cleanup = filter_mirror_cleanup;
385 nfc->receive_iov = filter_mirror_receive_iov;
388 static void filter_redirector_class_init(ObjectClass *oc, void *data)
390 NetFilterClass *nfc = NETFILTER_CLASS(oc);
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);
400 nfc->setup = filter_redirector_setup;
401 nfc->cleanup = filter_redirector_cleanup;
402 nfc->receive_iov = filter_redirector_receive_iov;
405 static void filter_mirror_init(Object *obj)
407 MirrorState *s = FILTER_MIRROR(obj);
412 static void filter_redirector_init(Object *obj)
414 MirrorState *s = FILTER_REDIRECTOR(obj);
419 static void filter_mirror_fini(Object *obj)
421 MirrorState *s = FILTER_MIRROR(obj);
426 static void filter_redirector_fini(Object *obj)
428 MirrorState *s = FILTER_REDIRECTOR(obj);
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),
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),
452 static void register_types(void)
454 type_register_static(&filter_mirror_info);
455 type_register_static(&filter_redirector_info);
458 type_init(register_types);