]>
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 <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" | |
f6d3afb5 | 15 | #include "qapi/error.h" |
f6d3afb5 ZC |
16 | #include "qom/object.h" |
17 | #include "qemu/main-loop.h" | |
18 | #include "qemu/error-report.h" | |
19 | #include "trace.h" | |
4d43a603 | 20 | #include "chardev/char-fe.h" |
f6d3afb5 ZC |
21 | #include "qemu/iov.h" |
22 | #include "qemu/sockets.h" | |
23 | ||
db1015e9 EH |
24 | #define TYPE_FILTER_MIRROR "filter-mirror" |
25 | typedef struct MirrorState MirrorState; | |
8110fa1d EH |
26 | DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_MIRROR, |
27 | TYPE_FILTER_MIRROR) | |
f6d3afb5 | 28 | |
db1015e9 | 29 | #define TYPE_FILTER_REDIRECTOR "filter-redirector" |
8110fa1d EH |
30 | DECLARE_INSTANCE_CHECKER(MirrorState, FILTER_REDIRECTOR, |
31 | TYPE_FILTER_REDIRECTOR) | |
d46f75b2 | 32 | |
d46f75b2 | 33 | #define REDIRECTOR_MAX_LEN NET_BUFSIZE |
f6d3afb5 | 34 | |
db1015e9 | 35 | struct MirrorState { |
f6d3afb5 | 36 | NetFilterState parent_obj; |
d46f75b2 | 37 | char *indev; |
f6d3afb5 | 38 | char *outdev; |
32a6ebec MAL |
39 | CharBackend chr_in; |
40 | CharBackend chr_out; | |
16a3df40 | 41 | SocketReadState rs; |
e2521f0e | 42 | bool vnet_hdr; |
db1015e9 | 43 | }; |
f6d3afb5 | 44 | |
dc3c5ac6 | 45 | static int filter_send(MirrorState *s, |
e05dc4cf ZC |
46 | const struct iovec *iov, |
47 | int iovcnt) | |
f6d3afb5 | 48 | { |
e2521f0e | 49 | NetFilterState *nf = NETFILTER(s); |
f6d3afb5 ZC |
50 | int ret = 0; |
51 | ssize_t size = 0; | |
f0aabd5c | 52 | uint32_t len = 0; |
f6d3afb5 ZC |
53 | char *buf; |
54 | ||
55 | size = iov_size(iov, iovcnt); | |
56 | if (!size) { | |
57 | return 0; | |
58 | } | |
59 | ||
60 | len = htonl(size); | |
dc3c5ac6 | 61 | ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)&len, sizeof(len)); |
f6d3afb5 ZC |
62 | if (ret != sizeof(len)) { |
63 | goto err; | |
64 | } | |
65 | ||
e2521f0e ZC |
66 | if (s->vnet_hdr) { |
67 | /* | |
68 | * If vnet_hdr = on, we send vnet header len to make other | |
69 | * module(like colo-compare) know how to parse net | |
70 | * packet correctly. | |
71 | */ | |
72 | ssize_t vnet_hdr_len; | |
73 | ||
74 | vnet_hdr_len = nf->netdev->vnet_hdr_len; | |
75 | ||
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)) { | |
79 | goto err; | |
80 | } | |
81 | } | |
82 | ||
f6d3afb5 ZC |
83 | buf = g_malloc(size); |
84 | iov_to_buf(iov, iovcnt, 0, buf, size); | |
dc3c5ac6 | 85 | ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size); |
f6d3afb5 ZC |
86 | g_free(buf); |
87 | if (ret != size) { | |
88 | goto err; | |
89 | } | |
90 | ||
91 | return 0; | |
92 | ||
93 | err: | |
94 | return ret < 0 ? ret : -EIO; | |
95 | } | |
96 | ||
f0aabd5c ZC |
97 | static void redirector_to_filter(NetFilterState *nf, |
98 | const uint8_t *buf, | |
99 | int len) | |
d46f75b2 ZC |
100 | { |
101 | struct iovec iov = { | |
102 | .iov_base = (void *)buf, | |
103 | .iov_len = len, | |
104 | }; | |
105 | ||
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); | |
109 | } | |
110 | ||
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); | |
114 | } | |
115 | } | |
116 | ||
117 | static int redirector_chr_can_read(void *opaque) | |
118 | { | |
119 | return REDIRECTOR_MAX_LEN; | |
120 | } | |
121 | ||
122 | static void redirector_chr_read(void *opaque, const uint8_t *buf, int size) | |
123 | { | |
124 | NetFilterState *nf = opaque; | |
125 | MirrorState *s = FILTER_REDIRECTOR(nf); | |
16a3df40 ZC |
126 | int ret; |
127 | ||
128 | ret = net_fill_rstate(&s->rs, buf, size); | |
129 | ||
130 | if (ret == -1) { | |
39ab61c6 | 131 | qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, |
81517ba3 | 132 | NULL, NULL, NULL, true); |
d46f75b2 ZC |
133 | } |
134 | } | |
135 | ||
083b266f | 136 | static void redirector_chr_event(void *opaque, QEMUChrEvent event) |
d46f75b2 ZC |
137 | { |
138 | NetFilterState *nf = opaque; | |
139 | MirrorState *s = FILTER_REDIRECTOR(nf); | |
140 | ||
141 | switch (event) { | |
142 | case CHR_EVENT_CLOSED: | |
39ab61c6 | 143 | qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, |
81517ba3 | 144 | NULL, NULL, NULL, true); |
d46f75b2 ZC |
145 | break; |
146 | default: | |
147 | break; | |
148 | } | |
149 | } | |
150 | ||
f6d3afb5 ZC |
151 | static ssize_t filter_mirror_receive_iov(NetFilterState *nf, |
152 | NetClientState *sender, | |
153 | unsigned flags, | |
154 | const struct iovec *iov, | |
155 | int iovcnt, | |
156 | NetPacketSent *sent_cb) | |
157 | { | |
ba8940dd | 158 | MirrorState *s = FILTER_MIRROR(nf); |
f6d3afb5 ZC |
159 | int ret; |
160 | ||
dc3c5ac6 | 161 | ret = filter_send(s, iov, iovcnt); |
f6d3afb5 | 162 | if (ret) { |
e05dc4cf | 163 | error_report("filter mirror send failed(%s)", strerror(-ret)); |
f6d3afb5 ZC |
164 | } |
165 | ||
166 | /* | |
167 | * we don't hope this error interrupt the normal | |
168 | * path of net packet, so we always return zero. | |
169 | */ | |
170 | return 0; | |
171 | } | |
172 | ||
d46f75b2 ZC |
173 | static ssize_t filter_redirector_receive_iov(NetFilterState *nf, |
174 | NetClientState *sender, | |
175 | unsigned flags, | |
176 | const struct iovec *iov, | |
177 | int iovcnt, | |
178 | NetPacketSent *sent_cb) | |
179 | { | |
180 | MirrorState *s = FILTER_REDIRECTOR(nf); | |
181 | int ret; | |
182 | ||
30650701 | 183 | if (qemu_chr_fe_backend_connected(&s->chr_out)) { |
dc3c5ac6 | 184 | ret = filter_send(s, iov, iovcnt); |
d46f75b2 | 185 | if (ret) { |
e05dc4cf | 186 | error_report("filter redirector send failed(%s)", strerror(-ret)); |
d46f75b2 ZC |
187 | } |
188 | return iov_size(iov, iovcnt); | |
189 | } else { | |
190 | return 0; | |
191 | } | |
192 | } | |
193 | ||
f6d3afb5 ZC |
194 | static void filter_mirror_cleanup(NetFilterState *nf) |
195 | { | |
196 | MirrorState *s = FILTER_MIRROR(nf); | |
197 | ||
1ce2610c | 198 | qemu_chr_fe_deinit(&s->chr_out, false); |
f6d3afb5 ZC |
199 | } |
200 | ||
d46f75b2 ZC |
201 | static void filter_redirector_cleanup(NetFilterState *nf) |
202 | { | |
203 | MirrorState *s = FILTER_REDIRECTOR(nf); | |
204 | ||
1ce2610c MAL |
205 | qemu_chr_fe_deinit(&s->chr_in, false); |
206 | qemu_chr_fe_deinit(&s->chr_out, false); | |
d46f75b2 ZC |
207 | } |
208 | ||
f6d3afb5 ZC |
209 | static void filter_mirror_setup(NetFilterState *nf, Error **errp) |
210 | { | |
211 | MirrorState *s = FILTER_MIRROR(nf); | |
0ec7b3e7 | 212 | Chardev *chr; |
f6d3afb5 | 213 | |
aa1530de EO |
214 | if (s->outdev == NULL) { |
215 | error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, "filter-mirror parameter"\ | |
216 | " 'outdev' cannot be empty"); | |
217 | return; | |
218 | } | |
219 | ||
32a6ebec MAL |
220 | chr = qemu_chr_find(s->outdev); |
221 | if (chr == NULL) { | |
f6d3afb5 ZC |
222 | error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, |
223 | "Device '%s' not found", s->outdev); | |
224 | return; | |
225 | } | |
226 | ||
32a6ebec | 227 | qemu_chr_fe_init(&s->chr_out, chr, errp); |
f6d3afb5 ZC |
228 | } |
229 | ||
16a3df40 ZC |
230 | static void redirector_rs_finalize(SocketReadState *rs) |
231 | { | |
232 | MirrorState *s = container_of(rs, MirrorState, rs); | |
233 | NetFilterState *nf = NETFILTER(s); | |
234 | ||
235 | redirector_to_filter(nf, rs->buf, rs->packet_len); | |
236 | } | |
237 | ||
d46f75b2 ZC |
238 | static void filter_redirector_setup(NetFilterState *nf, Error **errp) |
239 | { | |
240 | MirrorState *s = FILTER_REDIRECTOR(nf); | |
0ec7b3e7 | 241 | Chardev *chr; |
d46f75b2 ZC |
242 | |
243 | if (!s->indev && !s->outdev) { | |
244 | error_setg(errp, "filter redirector needs 'indev' or " | |
245 | "'outdev' at least one property set"); | |
246 | return; | |
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"); | |
251 | return; | |
252 | } | |
253 | } | |
254 | ||
e2521f0e | 255 | net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr); |
d46f75b2 ZC |
256 | |
257 | if (s->indev) { | |
32a6ebec MAL |
258 | chr = qemu_chr_find(s->indev); |
259 | if (chr == NULL) { | |
d46f75b2 ZC |
260 | error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, |
261 | "IN Device '%s' not found", s->indev); | |
262 | return; | |
263 | } | |
264 | ||
32a6ebec MAL |
265 | if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) { |
266 | return; | |
267 | } | |
5345fdb4 MAL |
268 | |
269 | qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read, | |
270 | redirector_chr_read, redirector_chr_event, | |
81517ba3 | 271 | NULL, nf, NULL, true); |
d46f75b2 ZC |
272 | } |
273 | ||
274 | if (s->outdev) { | |
32a6ebec MAL |
275 | chr = qemu_chr_find(s->outdev); |
276 | if (chr == NULL) { | |
d46f75b2 ZC |
277 | error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, |
278 | "OUT Device '%s' not found", s->outdev); | |
279 | return; | |
280 | } | |
32a6ebec MAL |
281 | if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) { |
282 | return; | |
283 | } | |
d46f75b2 ZC |
284 | } |
285 | } | |
286 | ||
d46f75b2 ZC |
287 | static char *filter_redirector_get_indev(Object *obj, Error **errp) |
288 | { | |
289 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
290 | ||
291 | return g_strdup(s->indev); | |
292 | } | |
293 | ||
e05dc4cf ZC |
294 | static void filter_redirector_set_indev(Object *obj, |
295 | const char *value, | |
296 | Error **errp) | |
d46f75b2 ZC |
297 | { |
298 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
299 | ||
300 | g_free(s->indev); | |
301 | s->indev = g_strdup(value); | |
302 | } | |
303 | ||
f6d3afb5 ZC |
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 | ||
e05dc4cf ZC |
311 | static void filter_mirror_set_outdev(Object *obj, |
312 | const char *value, | |
313 | Error **errp) | |
f6d3afb5 ZC |
314 | { |
315 | MirrorState *s = FILTER_MIRROR(obj); | |
316 | ||
317 | g_free(s->outdev); | |
318 | s->outdev = g_strdup(value); | |
319 | if (!s->outdev) { | |
52cfcb46 | 320 | error_setg(errp, "filter mirror needs 'outdev' " |
d46f75b2 | 321 | "property set"); |
f6d3afb5 ZC |
322 | return; |
323 | } | |
324 | } | |
325 | ||
e2521f0e ZC |
326 | static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp) |
327 | { | |
328 | MirrorState *s = FILTER_MIRROR(obj); | |
329 | ||
330 | return s->vnet_hdr; | |
331 | } | |
332 | ||
333 | static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp) | |
334 | { | |
335 | MirrorState *s = FILTER_MIRROR(obj); | |
336 | ||
337 | s->vnet_hdr = value; | |
338 | } | |
339 | ||
d46f75b2 ZC |
340 | static char *filter_redirector_get_outdev(Object *obj, Error **errp) |
341 | { | |
342 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
343 | ||
344 | return g_strdup(s->outdev); | |
345 | } | |
346 | ||
e05dc4cf ZC |
347 | static void filter_redirector_set_outdev(Object *obj, |
348 | const char *value, | |
349 | Error **errp) | |
d46f75b2 ZC |
350 | { |
351 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
352 | ||
353 | g_free(s->outdev); | |
354 | s->outdev = g_strdup(value); | |
355 | } | |
356 | ||
00d5c240 ZC |
357 | static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp) |
358 | { | |
359 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
360 | ||
361 | return s->vnet_hdr; | |
362 | } | |
363 | ||
364 | static void filter_redirector_set_vnet_hdr(Object *obj, | |
365 | bool value, | |
366 | Error **errp) | |
367 | { | |
368 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
369 | ||
370 | s->vnet_hdr = value; | |
371 | } | |
372 | ||
6d11ea6d EH |
373 | static void filter_mirror_class_init(ObjectClass *oc, void *data) |
374 | { | |
375 | NetFilterClass *nfc = NETFILTER_CLASS(oc); | |
376 | ||
f0e34a06 EH |
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); | |
382 | ||
6d11ea6d EH |
383 | nfc->setup = filter_mirror_setup; |
384 | nfc->cleanup = filter_mirror_cleanup; | |
385 | nfc->receive_iov = filter_mirror_receive_iov; | |
386 | } | |
387 | ||
388 | static void filter_redirector_class_init(ObjectClass *oc, void *data) | |
389 | { | |
390 | NetFilterClass *nfc = NETFILTER_CLASS(oc); | |
391 | ||
f0e34a06 EH |
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); | |
399 | ||
6d11ea6d EH |
400 | nfc->setup = filter_redirector_setup; |
401 | nfc->cleanup = filter_redirector_cleanup; | |
402 | nfc->receive_iov = filter_redirector_receive_iov; | |
403 | } | |
404 | ||
f6d3afb5 ZC |
405 | static void filter_mirror_init(Object *obj) |
406 | { | |
e2521f0e ZC |
407 | MirrorState *s = FILTER_MIRROR(obj); |
408 | ||
e2521f0e | 409 | s->vnet_hdr = false; |
f6d3afb5 ZC |
410 | } |
411 | ||
d46f75b2 ZC |
412 | static void filter_redirector_init(Object *obj) |
413 | { | |
00d5c240 ZC |
414 | MirrorState *s = FILTER_REDIRECTOR(obj); |
415 | ||
00d5c240 | 416 | s->vnet_hdr = false; |
d46f75b2 ZC |
417 | } |
418 | ||
f6d3afb5 ZC |
419 | static void filter_mirror_fini(Object *obj) |
420 | { | |
421 | MirrorState *s = FILTER_MIRROR(obj); | |
422 | ||
423 | g_free(s->outdev); | |
424 | } | |
425 | ||
d46f75b2 ZC |
426 | static void filter_redirector_fini(Object *obj) |
427 | { | |
428 | MirrorState *s = FILTER_REDIRECTOR(obj); | |
429 | ||
430 | g_free(s->indev); | |
431 | g_free(s->outdev); | |
432 | } | |
433 | ||
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), | |
441 | }; | |
442 | ||
f6d3afb5 ZC |
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), | |
450 | }; | |
451 | ||
452 | static void register_types(void) | |
453 | { | |
454 | type_register_static(&filter_mirror_info); | |
d46f75b2 | 455 | type_register_static(&filter_redirector_info); |
f6d3afb5 ZC |
456 | } |
457 | ||
458 | type_init(register_types); |