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