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