[qemu.git] / net / filter-mirror.c

/*
 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
 * Copyright (c) 2016 FUJITSU LIMITED
 * Copyright (c) 2016 Intel Corporation
 *
 * Author: Zhang Chen <[email protected]>
 *
 * 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 "qemu-common.h"
#include "qapi/error.h"
#include "qapi/qmp/qerror.h"
#include "qapi-visit.h"
#include "qom/object.h"
#include "qemu/main-loop.h"
#include "qemu/error-report.h"
#include "trace.h"
#include "sysemu/char.h"
#include "qemu/iov.h"
#include "qemu/sockets.h"

#define FILTER_MIRROR(obj) \
    OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_MIRROR)

#define FILTER_REDIRECTOR(obj) \
    OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_REDIRECTOR)

#define TYPE_FILTER_MIRROR "filter-mirror"
#define TYPE_FILTER_REDIRECTOR "filter-redirector"
#define REDIRECTOR_MAX_LEN NET_BUFSIZE

typedef struct MirrorState {
    NetFilterState parent_obj;
    char *indev;
    char *outdev;
    CharDriverState *chr_in;
    CharDriverState *chr_out;
    int state; /* 0 = getting length, 1 = getting data */
    unsigned int index;
    unsigned int packet_len;
    uint8_t buf[REDIRECTOR_MAX_LEN];
} MirrorState;

static int filter_mirror_send(CharDriverState *chr_out,
                              const struct iovec *iov,
                              int iovcnt)
{
    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(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(chr_out, (uint8_t *)buf, size);
    g_free(buf);
    if (ret != size) {
        goto err;
    }

    return 0;

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);
    unsigned int l;

    while (size > 0) {
        /* reassemble a packet from the network */
        switch (s->state) { /* 0 = getting length, 1 = getting data */
        case 0:
            l = 4 - s->index;
            if (l > size) {
                l = size;
            }
            memcpy(s->buf + s->index, buf, l);
            buf += l;
            size -= l;
            s->index += l;
            if (s->index == 4) {
                /* got length */
                s->packet_len = ntohl(*(uint32_t *)s->buf);
                s->index = 0;
                s->state = 1;
            }
            break;
        case 1:
            l = s->packet_len - s->index;
            if (l > size) {
                l = size;
            }
            if (s->index + l <= sizeof(s->buf)) {
                memcpy(s->buf + s->index, buf, l);
            } else {
                error_report("serious error: oversized packet received.");
                s->index = s->state = 0;
                qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);
                return;
            }

            s->index += l;
            buf += l;
            size -= l;
            if (s->index >= s->packet_len) {
                s->index = 0;
                s->state = 0;
                redirector_to_filter(nf, s->buf, s->packet_len);
            }
            break;
        }
    }
}

static void redirector_chr_event(void *opaque, int event)
{
    NetFilterState *nf = opaque;
    MirrorState *s = FILTER_REDIRECTOR(nf);

    switch (event) {
    case CHR_EVENT_CLOSED:
        qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);
        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_mirror_send(s->chr_out, iov, iovcnt);
    if (ret) {
        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 (s->chr_out) {
        ret = filter_mirror_send(s->chr_out, iov, iovcnt);
        if (ret) {
            error_report("filter_mirror_send failed(%s)", strerror(-ret));
        }
        return iov_size(iov, iovcnt);
    } else {
        return 0;
    }
}

static void filter_mirror_cleanup(NetFilterState *nf)
{
    MirrorState *s = FILTER_MIRROR(nf);

    if (s->chr_out) {
        qemu_chr_fe_release(s->chr_out);
    }
}

static void filter_redirector_cleanup(NetFilterState *nf)
{
    MirrorState *s = FILTER_REDIRECTOR(nf);

    if (s->chr_in) {
        qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);
        qemu_chr_fe_release(s->chr_in);
    }
    if (s->chr_out) {
        qemu_chr_fe_release(s->chr_out);
    }
}

static void filter_mirror_setup(NetFilterState *nf, Error **errp)
{
    MirrorState *s = FILTER_MIRROR(nf);

    if (!s->outdev) {
        error_setg(errp, "filter filter mirror needs 'outdev' "
                   "property set");
        return;
    }

    s->chr_out = qemu_chr_find(s->outdev);
    if (s->chr_out == NULL) {
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", s->outdev);
        return;
    }

    if (qemu_chr_fe_claim(s->chr_out) != 0) {
        error_setg(errp, QERR_DEVICE_IN_USE, s->outdev);
        return;
    }
}

static void filter_redirector_setup(NetFilterState *nf, Error **errp)
{
    MirrorState *s = FILTER_REDIRECTOR(nf);

    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;
        }
    }

    s->state = s->index = 0;

    if (s->indev) {
        s->chr_in = qemu_chr_find(s->indev);
        if (s->chr_in == NULL) {
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                      "IN Device '%s' not found", s->indev);
            return;
        }

        qemu_chr_fe_claim_no_fail(s->chr_in);
        qemu_chr_add_handlers(s->chr_in, redirector_chr_can_read,
                              redirector_chr_read, redirector_chr_event, nf);
    }

    if (s->outdev) {
        s->chr_out = qemu_chr_find(s->outdev);
        if (s->chr_out == NULL) {
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                      "OUT Device '%s' not found", s->outdev);
            return;
        }
        qemu_chr_fe_claim_no_fail(s->chr_out);
    }
}

static void filter_mirror_class_init(ObjectClass *oc, void *data)
{
    NetFilterClass *nfc = NETFILTER_CLASS(oc);

    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);

    nfc->setup = filter_redirector_setup;
    nfc->cleanup = filter_redirector_cleanup;
    nfc->receive_iov = filter_redirector_receive_iov;
}

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 filter mirror needs 'outdev' "
                   "property set");
        return;
    }
}

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 void filter_mirror_init(Object *obj)
{
    object_property_add_str(obj, "outdev", filter_mirror_get_outdev,
                            filter_mirror_set_outdev, NULL);
}

static void filter_redirector_init(Object *obj)
{
    object_property_add_str(obj, "indev", filter_redirector_get_indev,
                            filter_redirector_set_indev, NULL);
    object_property_add_str(obj, "outdev", filter_redirector_get_outdev,
                            filter_redirector_set_outdev, NULL);
}

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