Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging
[qemu.git] / net / filter.c
1 /*
2 * Copyright (c) 2015 FUJITSU LIMITED
3 * Author: Yang Hongyang <yanghy@cn.fujitsu.com>
4 *
5 * This work is licensed under the terms of the GNU GPL, version 2 or
6 * later. See the COPYING file in the top-level directory.
7 */
8
9 #include "qemu/osdep.h"
10 #include "qapi/error.h"
11 #include "qemu-common.h"
12 #include "qapi/qmp/qerror.h"
13 #include "qemu/error-report.h"
14
15 #include "net/filter.h"
16 #include "net/net.h"
17 #include "net/vhost_net.h"
18 #include "qom/object_interfaces.h"
19 #include "qemu/iov.h"
20
21 static inline bool qemu_can_skip_netfilter(NetFilterState *nf)
22 {
23 return !nf->on;
24 }
25
26 ssize_t qemu_netfilter_receive(NetFilterState *nf,
27 NetFilterDirection direction,
28 NetClientState *sender,
29 unsigned flags,
30 const struct iovec *iov,
31 int iovcnt,
32 NetPacketSent *sent_cb)
33 {
34 if (qemu_can_skip_netfilter(nf)) {
35 return 0;
36 }
37 if (nf->direction == direction ||
38 nf->direction == NET_FILTER_DIRECTION_ALL) {
39 return NETFILTER_GET_CLASS(OBJECT(nf))->receive_iov(
40 nf, sender, flags, iov, iovcnt, sent_cb);
41 }
42
43 return 0;
44 }
45
46 static NetFilterState *netfilter_next(NetFilterState *nf,
47 NetFilterDirection dir)
48 {
49 NetFilterState *next;
50
51 if (dir == NET_FILTER_DIRECTION_TX) {
52 /* forward walk through filters */
53 next = QTAILQ_NEXT(nf, next);
54 } else {
55 /* reverse order */
56 next = QTAILQ_PREV(nf, NetFilterHead, next);
57 }
58
59 return next;
60 }
61
62 ssize_t qemu_netfilter_pass_to_next(NetClientState *sender,
63 unsigned flags,
64 const struct iovec *iov,
65 int iovcnt,
66 void *opaque)
67 {
68 int ret = 0;
69 int direction;
70 NetFilterState *nf = opaque;
71 NetFilterState *next = NULL;
72
73 if (!sender || !sender->peer) {
74 /* no receiver, or sender been deleted, no need to pass it further */
75 goto out;
76 }
77
78 if (nf->direction == NET_FILTER_DIRECTION_ALL) {
79 if (sender == nf->netdev) {
80 /* This packet is sent by netdev itself */
81 direction = NET_FILTER_DIRECTION_TX;
82 } else {
83 direction = NET_FILTER_DIRECTION_RX;
84 }
85 } else {
86 direction = nf->direction;
87 }
88
89 next = netfilter_next(nf, direction);
90 while (next) {
91 /*
92 * if qemu_netfilter_pass_to_next been called, means that
93 * the packet has been hold by filter and has already retured size
94 * to the sender, so sent_cb shouldn't be called later, just
95 * pass NULL to next.
96 */
97 ret = qemu_netfilter_receive(next, direction, sender, flags, iov,
98 iovcnt, NULL);
99 if (ret) {
100 return ret;
101 }
102 next = netfilter_next(next, direction);
103 }
104
105 /*
106 * We have gone through all filters, pass it to receiver.
107 * Do the valid check again incase sender or receiver been
108 * deleted while we go through filters.
109 */
110 if (sender && sender->peer) {
111 qemu_net_queue_send_iov(sender->peer->incoming_queue,
112 sender, flags, iov, iovcnt, NULL);
113 }
114
115 out:
116 /* no receiver, or sender been deleted */
117 return iov_size(iov, iovcnt);
118 }
119
120 static char *netfilter_get_netdev_id(Object *obj, Error **errp)
121 {
122 NetFilterState *nf = NETFILTER(obj);
123
124 return g_strdup(nf->netdev_id);
125 }
126
127 static void netfilter_set_netdev_id(Object *obj, const char *str, Error **errp)
128 {
129 NetFilterState *nf = NETFILTER(obj);
130
131 nf->netdev_id = g_strdup(str);
132 }
133
134 static int netfilter_get_direction(Object *obj, Error **errp G_GNUC_UNUSED)
135 {
136 NetFilterState *nf = NETFILTER(obj);
137 return nf->direction;
138 }
139
140 static void netfilter_set_direction(Object *obj, int direction, Error **errp)
141 {
142 NetFilterState *nf = NETFILTER(obj);
143 nf->direction = direction;
144 }
145
146 static char *netfilter_get_status(Object *obj, Error **errp)
147 {
148 NetFilterState *nf = NETFILTER(obj);
149
150 return nf->on ? g_strdup("on") : g_strdup("off");
151 }
152
153 static void netfilter_set_status(Object *obj, const char *str, Error **errp)
154 {
155 NetFilterState *nf = NETFILTER(obj);
156 NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
157
158 if (strcmp(str, "on") && strcmp(str, "off")) {
159 error_setg(errp, "Invalid value for netfilter status, "
160 "should be 'on' or 'off'");
161 return;
162 }
163 if (nf->on == !strcmp(str, "on")) {
164 return;
165 }
166 nf->on = !nf->on;
167 if (nf->netdev && nfc->status_changed) {
168 nfc->status_changed(nf, errp);
169 }
170 }
171
172 static void netfilter_init(Object *obj)
173 {
174 NetFilterState *nf = NETFILTER(obj);
175
176 nf->on = true;
177
178 object_property_add_str(obj, "netdev",
179 netfilter_get_netdev_id, netfilter_set_netdev_id,
180 NULL);
181 object_property_add_enum(obj, "queue", "NetFilterDirection",
182 NetFilterDirection_lookup,
183 netfilter_get_direction, netfilter_set_direction,
184 NULL);
185 object_property_add_str(obj, "status",
186 netfilter_get_status, netfilter_set_status,
187 NULL);
188 }
189
190 static void netfilter_complete(UserCreatable *uc, Error **errp)
191 {
192 NetFilterState *nf = NETFILTER(uc);
193 NetClientState *ncs[MAX_QUEUE_NUM];
194 NetFilterClass *nfc = NETFILTER_GET_CLASS(uc);
195 int queues;
196 Error *local_err = NULL;
197
198 if (!nf->netdev_id) {
199 error_setg(errp, "Parameter 'netdev' is required");
200 return;
201 }
202
203 queues = qemu_find_net_clients_except(nf->netdev_id, ncs,
204 NET_CLIENT_DRIVER_NIC,
205 MAX_QUEUE_NUM);
206 if (queues < 1) {
207 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "netdev",
208 "a network backend id");
209 return;
210 } else if (queues > 1) {
211 error_setg(errp, "multiqueue is not supported");
212 return;
213 }
214
215 if (get_vhost_net(ncs[0])) {
216 error_setg(errp, "Vhost is not supported");
217 return;
218 }
219
220 nf->netdev = ncs[0];
221
222 if (nfc->setup) {
223 nfc->setup(nf, &local_err);
224 if (local_err) {
225 error_propagate(errp, local_err);
226 return;
227 }
228 }
229 QTAILQ_INSERT_TAIL(&nf->netdev->filters, nf, next);
230 }
231
232 static void netfilter_finalize(Object *obj)
233 {
234 NetFilterState *nf = NETFILTER(obj);
235 NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
236
237 if (nfc->cleanup) {
238 nfc->cleanup(nf);
239 }
240
241 if (nf->netdev && !QTAILQ_EMPTY(&nf->netdev->filters) &&
242 QTAILQ_IN_USE(nf, next)) {
243 QTAILQ_REMOVE(&nf->netdev->filters, nf, next);
244 }
245 g_free(nf->netdev_id);
246 }
247
248 static void netfilter_class_init(ObjectClass *oc, void *data)
249 {
250 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
251
252 ucc->complete = netfilter_complete;
253 }
254
255 static const TypeInfo netfilter_info = {
256 .name = TYPE_NETFILTER,
257 .parent = TYPE_OBJECT,
258 .abstract = true,
259 .class_size = sizeof(NetFilterClass),
260 .class_init = netfilter_class_init,
261 .instance_size = sizeof(NetFilterState),
262 .instance_init = netfilter_init,
263 .instance_finalize = netfilter_finalize,
264 .interfaces = (InterfaceInfo[]) {
265 { TYPE_USER_CREATABLE },
266 { }
267 }
268 };
269
270 static void register_types(void)
271 {
272 type_register_static(&netfilter_info);
273 }
274
275 type_init(register_types);