459 lines
12 KiB
C
459 lines
12 KiB
C
/*
|
|
* Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
|
|
* Copyright (c) 2016 FUJITSU LIMITED
|
|
* Copyright (c) 2016 Intel Corporation
|
|
*
|
|
* Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or
|
|
* later. See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "net/filter.h"
|
|
#include "net/net.h"
|
|
#include "qapi/error.h"
|
|
#include "qom/object.h"
|
|
#include "qemu/main-loop.h"
|
|
#include "qemu/error-report.h"
|
|
#include "trace.h"
|
|
#include "chardev/char-fe.h"
|
|
#include "qemu/iov.h"
|
|
#include "qemu/sockets.h"
|
|
|
|
#define TYPE_FILTER_MIRROR "filter-mirror"
|
|
typedef struct MirrorState MirrorState;
|
|
DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_MIRROR,
|
|
TYPE_FILTER_MIRROR)
|
|
|
|
#define TYPE_FILTER_REDIRECTOR "filter-redirector"
|
|
DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_REDIRECTOR,
|
|
TYPE_FILTER_REDIRECTOR)
|
|
|
|
#define REDIRECTOR_MAX_LEN NET_BUFSIZE
|
|
|
|
struct MirrorState {
|
|
NetFilterState parent_obj;
|
|
char *indev;
|
|
char *outdev;
|
|
CharBackend chr_in;
|
|
CharBackend chr_out;
|
|
SocketReadState rs;
|
|
bool vnet_hdr;
|
|
};
|
|
|
|
static int filter_send(MirrorState *s,
|
|
const struct iovec *iov,
|
|
int iovcnt)
|
|
{
|
|
NetFilterState *nf = NETFILTER(s);
|
|
int ret = 0;
|
|
ssize_t size = 0;
|
|
uint32_t len = 0;
|
|
char *buf;
|
|
|
|
size = iov_size(iov, iovcnt);
|
|
if (!size) {
|
|
return 0;
|
|
}
|
|
|
|
len = htonl(size);
|
|
ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
|
|
if (ret != sizeof(len)) {
|
|
goto err;
|
|
}
|
|
|
|
if (s->vnet_hdr) {
|
|
/*
|
|
* If vnet_hdr = on, we send vnet header len to make other
|
|
* module(like colo-compare) know how to parse net
|
|
* packet correctly.
|
|
*/
|
|
ssize_t vnet_hdr_len;
|
|
|
|
vnet_hdr_len = nf->netdev->vnet_hdr_len;
|
|
|
|
len = htonl(vnet_hdr_len);
|
|
ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len));
|
|
if (ret != sizeof(len)) {
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
buf = g_malloc(size);
|
|
iov_to_buf(iov, iovcnt, 0, buf, size);
|
|
ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size);
|
|
g_free(buf);
|
|
if (ret != size) {
|
|
goto err;
|
|
}
|
|
|
|
return size;
|
|
|
|
err:
|
|
return ret < 0 ? ret : -EIO;
|
|
}
|
|
|
|
static void redirector_to_filter(NetFilterState *nf,
|
|
const uint8_t *buf,
|
|
int len)
|
|
{
|
|
struct iovec iov = {
|
|
.iov_base = (void *)buf,
|
|
.iov_len = len,
|
|
};
|
|
|
|
if (nf->direction == NET_FILTER_DIRECTION_ALL ||
|
|
nf->direction == NET_FILTER_DIRECTION_TX) {
|
|
qemu_netfilter_pass_to_next(nf->netdev, 0, &iov, 1, nf);
|
|
}
|
|
|
|
if (nf->direction == NET_FILTER_DIRECTION_ALL ||
|
|
nf->direction == NET_FILTER_DIRECTION_RX) {
|
|
qemu_netfilter_pass_to_next(nf->netdev->peer, 0, &iov, 1, nf);
|
|
}
|
|
}
|
|
|
|
static int redirector_chr_can_read(void *opaque)
|
|
{
|
|
return REDIRECTOR_MAX_LEN;
|
|
}
|
|
|
|
static void redirector_chr_read(void *opaque, const uint8_t *buf, int size)
|
|
{
|
|
NetFilterState *nf = opaque;
|
|
MirrorState *s = FILTER_REDIRECTOR(nf);
|
|
int ret;
|
|
|
|
ret = net_fill_rstate(&s->rs, buf, size);
|
|
|
|
if (ret == -1) {
|
|
qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, true);
|
|
}
|
|
}
|
|
|
|
static void redirector_chr_event(void *opaque, QEMUChrEvent event)
|
|
{
|
|
NetFilterState *nf = opaque;
|
|
MirrorState *s = FILTER_REDIRECTOR(nf);
|
|
|
|
switch (event) {
|
|
case CHR_EVENT_CLOSED:
|
|
qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, true);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static ssize_t filter_mirror_receive_iov(NetFilterState *nf,
|
|
NetClientState *sender,
|
|
unsigned flags,
|
|
const struct iovec *iov,
|
|
int iovcnt,
|
|
NetPacketSent *sent_cb)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(nf);
|
|
int ret;
|
|
|
|
ret = filter_send(s, iov, iovcnt);
|
|
if (ret < 0) {
|
|
error_report("filter mirror send failed(%s)", strerror(-ret));
|
|
}
|
|
|
|
/*
|
|
* we don't hope this error interrupt the normal
|
|
* path of net packet, so we always return zero.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t filter_redirector_receive_iov(NetFilterState *nf,
|
|
NetClientState *sender,
|
|
unsigned flags,
|
|
const struct iovec *iov,
|
|
int iovcnt,
|
|
NetPacketSent *sent_cb)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(nf);
|
|
int ret;
|
|
|
|
if (qemu_chr_fe_backend_connected(&s->chr_out)) {
|
|
ret = filter_send(s, iov, iovcnt);
|
|
if (ret < 0) {
|
|
error_report("filter redirector send failed(%s)", strerror(-ret));
|
|
}
|
|
return ret;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static void filter_mirror_cleanup(NetFilterState *nf)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(nf);
|
|
|
|
qemu_chr_fe_deinit(&s->chr_out, false);
|
|
}
|
|
|
|
static void filter_redirector_cleanup(NetFilterState *nf)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(nf);
|
|
|
|
qemu_chr_fe_deinit(&s->chr_in, false);
|
|
qemu_chr_fe_deinit(&s->chr_out, false);
|
|
}
|
|
|
|
static void filter_mirror_setup(NetFilterState *nf, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(nf);
|
|
Chardev *chr;
|
|
|
|
if (s->outdev == NULL) {
|
|
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "filter-mirror parameter"\
|
|
" 'outdev' cannot be empty");
|
|
return;
|
|
}
|
|
|
|
chr = qemu_chr_find(s->outdev);
|
|
if (chr == NULL) {
|
|
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
|
|
"Device '%s' not found", s->outdev);
|
|
return;
|
|
}
|
|
|
|
qemu_chr_fe_init(&s->chr_out, chr, errp);
|
|
}
|
|
|
|
static void redirector_rs_finalize(SocketReadState *rs)
|
|
{
|
|
MirrorState *s = container_of(rs, MirrorState, rs);
|
|
NetFilterState *nf = NETFILTER(s);
|
|
|
|
redirector_to_filter(nf, rs->buf, rs->packet_len);
|
|
}
|
|
|
|
static void filter_redirector_setup(NetFilterState *nf, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(nf);
|
|
Chardev *chr;
|
|
|
|
if (!s->indev && !s->outdev) {
|
|
error_setg(errp, "filter redirector needs 'indev' or "
|
|
"'outdev' at least one property set");
|
|
return;
|
|
} else if (s->indev && s->outdev) {
|
|
if (!strcmp(s->indev, s->outdev)) {
|
|
error_setg(errp, "'indev' and 'outdev' could not be same "
|
|
"for filter redirector");
|
|
return;
|
|
}
|
|
}
|
|
|
|
net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr);
|
|
|
|
if (s->indev) {
|
|
chr = qemu_chr_find(s->indev);
|
|
if (chr == NULL) {
|
|
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
|
|
"IN Device '%s' not found", s->indev);
|
|
return;
|
|
}
|
|
|
|
if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) {
|
|
return;
|
|
}
|
|
|
|
qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read,
|
|
redirector_chr_read, redirector_chr_event,
|
|
NULL, nf, NULL, true);
|
|
}
|
|
|
|
if (s->outdev) {
|
|
chr = qemu_chr_find(s->outdev);
|
|
if (chr == NULL) {
|
|
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
|
|
"OUT Device '%s' not found", s->outdev);
|
|
return;
|
|
}
|
|
if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static char *filter_redirector_get_indev(Object *obj, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
return g_strdup(s->indev);
|
|
}
|
|
|
|
static void filter_redirector_set_indev(Object *obj,
|
|
const char *value,
|
|
Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
g_free(s->indev);
|
|
s->indev = g_strdup(value);
|
|
}
|
|
|
|
static char *filter_mirror_get_outdev(Object *obj, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(obj);
|
|
|
|
return g_strdup(s->outdev);
|
|
}
|
|
|
|
static void filter_mirror_set_outdev(Object *obj,
|
|
const char *value,
|
|
Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(obj);
|
|
|
|
g_free(s->outdev);
|
|
s->outdev = g_strdup(value);
|
|
if (!s->outdev) {
|
|
error_setg(errp, "filter mirror needs 'outdev' "
|
|
"property set");
|
|
return;
|
|
}
|
|
}
|
|
|
|
static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(obj);
|
|
|
|
return s->vnet_hdr;
|
|
}
|
|
|
|
static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(obj);
|
|
|
|
s->vnet_hdr = value;
|
|
}
|
|
|
|
static char *filter_redirector_get_outdev(Object *obj, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
return g_strdup(s->outdev);
|
|
}
|
|
|
|
static void filter_redirector_set_outdev(Object *obj,
|
|
const char *value,
|
|
Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
g_free(s->outdev);
|
|
s->outdev = g_strdup(value);
|
|
}
|
|
|
|
static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
return s->vnet_hdr;
|
|
}
|
|
|
|
static void filter_redirector_set_vnet_hdr(Object *obj,
|
|
bool value,
|
|
Error **errp)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
s->vnet_hdr = value;
|
|
}
|
|
|
|
static void filter_mirror_class_init(ObjectClass *oc, void *data)
|
|
{
|
|
NetFilterClass *nfc = NETFILTER_CLASS(oc);
|
|
|
|
object_class_property_add_str(oc, "outdev", filter_mirror_get_outdev,
|
|
filter_mirror_set_outdev);
|
|
object_class_property_add_bool(oc, "vnet_hdr_support",
|
|
filter_mirror_get_vnet_hdr,
|
|
filter_mirror_set_vnet_hdr);
|
|
|
|
nfc->setup = filter_mirror_setup;
|
|
nfc->cleanup = filter_mirror_cleanup;
|
|
nfc->receive_iov = filter_mirror_receive_iov;
|
|
}
|
|
|
|
static void filter_redirector_class_init(ObjectClass *oc, void *data)
|
|
{
|
|
NetFilterClass *nfc = NETFILTER_CLASS(oc);
|
|
|
|
object_class_property_add_str(oc, "indev", filter_redirector_get_indev,
|
|
filter_redirector_set_indev);
|
|
object_class_property_add_str(oc, "outdev", filter_redirector_get_outdev,
|
|
filter_redirector_set_outdev);
|
|
object_class_property_add_bool(oc, "vnet_hdr_support",
|
|
filter_redirector_get_vnet_hdr,
|
|
filter_redirector_set_vnet_hdr);
|
|
|
|
nfc->setup = filter_redirector_setup;
|
|
nfc->cleanup = filter_redirector_cleanup;
|
|
nfc->receive_iov = filter_redirector_receive_iov;
|
|
}
|
|
|
|
static void filter_mirror_init(Object *obj)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(obj);
|
|
|
|
s->vnet_hdr = false;
|
|
}
|
|
|
|
static void filter_redirector_init(Object *obj)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
s->vnet_hdr = false;
|
|
}
|
|
|
|
static void filter_mirror_fini(Object *obj)
|
|
{
|
|
MirrorState *s = FILTER_MIRROR(obj);
|
|
|
|
g_free(s->outdev);
|
|
}
|
|
|
|
static void filter_redirector_fini(Object *obj)
|
|
{
|
|
MirrorState *s = FILTER_REDIRECTOR(obj);
|
|
|
|
g_free(s->indev);
|
|
g_free(s->outdev);
|
|
}
|
|
|
|
static const TypeInfo filter_redirector_info = {
|
|
.name = TYPE_FILTER_REDIRECTOR,
|
|
.parent = TYPE_NETFILTER,
|
|
.class_init = filter_redirector_class_init,
|
|
.instance_init = filter_redirector_init,
|
|
.instance_finalize = filter_redirector_fini,
|
|
.instance_size = sizeof(MirrorState),
|
|
};
|
|
|
|
static const TypeInfo filter_mirror_info = {
|
|
.name = TYPE_FILTER_MIRROR,
|
|
.parent = TYPE_NETFILTER,
|
|
.class_init = filter_mirror_class_init,
|
|
.instance_init = filter_mirror_init,
|
|
.instance_finalize = filter_mirror_fini,
|
|
.instance_size = sizeof(MirrorState),
|
|
};
|
|
|
|
static void register_types(void)
|
|
{
|
|
type_register_static(&filter_mirror_info);
|
|
type_register_static(&filter_redirector_info);
|
|
}
|
|
|
|
type_init(register_types);
|