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 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_fe_set_handlers(&s->chr_in, NULL, 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_fe_set_handlers(&s->chr_in, NULL, 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 (qemu_chr_fe_get_driver(&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 qemu_chr_fe_deinit(&s->chr_out); 179 } 180 181 static void filter_redirector_cleanup(NetFilterState *nf) 182 { 183 MirrorState *s = FILTER_REDIRECTOR(nf); 184 185 qemu_chr_fe_deinit(&s->chr_in); 186 qemu_chr_fe_deinit(&s->chr_out); 187 } 188 189 static void filter_mirror_setup(NetFilterState *nf, Error **errp) 190 { 191 MirrorState *s = FILTER_MIRROR(nf); 192 CharDriverState *chr; 193 194 if (!s->outdev) { 195 error_setg(errp, "filter mirror needs 'outdev' " 196 "property set"); 197 return; 198 } 199 200 chr = qemu_chr_find(s->outdev); 201 if (chr == NULL) { 202 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 203 "Device '%s' not found", s->outdev); 204 return; 205 } 206 207 qemu_chr_fe_init(&s->chr_out, chr, errp); 208 } 209 210 static void redirector_rs_finalize(SocketReadState *rs) 211 { 212 MirrorState *s = container_of(rs, MirrorState, rs); 213 NetFilterState *nf = NETFILTER(s); 214 215 redirector_to_filter(nf, rs->buf, rs->packet_len); 216 } 217 218 static void filter_redirector_setup(NetFilterState *nf, Error **errp) 219 { 220 MirrorState *s = FILTER_REDIRECTOR(nf); 221 CharDriverState *chr; 222 223 if (!s->indev && !s->outdev) { 224 error_setg(errp, "filter redirector needs 'indev' or " 225 "'outdev' at least one property set"); 226 return; 227 } else if (s->indev && s->outdev) { 228 if (!strcmp(s->indev, s->outdev)) { 229 error_setg(errp, "'indev' and 'outdev' could not be same " 230 "for filter redirector"); 231 return; 232 } 233 } 234 235 net_socket_rs_init(&s->rs, redirector_rs_finalize); 236 237 if (s->indev) { 238 chr = qemu_chr_find(s->indev); 239 if (chr == NULL) { 240 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 241 "IN Device '%s' not found", s->indev); 242 return; 243 } 244 245 if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) { 246 return; 247 } 248 249 qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read, 250 redirector_chr_read, redirector_chr_event, 251 nf, NULL); 252 } 253 254 if (s->outdev) { 255 chr = qemu_chr_find(s->outdev); 256 if (chr == NULL) { 257 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 258 "OUT Device '%s' not found", s->outdev); 259 return; 260 } 261 if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) { 262 return; 263 } 264 } 265 } 266 267 static void filter_mirror_class_init(ObjectClass *oc, void *data) 268 { 269 NetFilterClass *nfc = NETFILTER_CLASS(oc); 270 271 nfc->setup = filter_mirror_setup; 272 nfc->cleanup = filter_mirror_cleanup; 273 nfc->receive_iov = filter_mirror_receive_iov; 274 } 275 276 static void filter_redirector_class_init(ObjectClass *oc, void *data) 277 { 278 NetFilterClass *nfc = NETFILTER_CLASS(oc); 279 280 nfc->setup = filter_redirector_setup; 281 nfc->cleanup = filter_redirector_cleanup; 282 nfc->receive_iov = filter_redirector_receive_iov; 283 } 284 285 static char *filter_redirector_get_indev(Object *obj, Error **errp) 286 { 287 MirrorState *s = FILTER_REDIRECTOR(obj); 288 289 return g_strdup(s->indev); 290 } 291 292 static void 293 filter_redirector_set_indev(Object *obj, const char *value, Error **errp) 294 { 295 MirrorState *s = FILTER_REDIRECTOR(obj); 296 297 g_free(s->indev); 298 s->indev = g_strdup(value); 299 } 300 301 static char *filter_mirror_get_outdev(Object *obj, Error **errp) 302 { 303 MirrorState *s = FILTER_MIRROR(obj); 304 305 return g_strdup(s->outdev); 306 } 307 308 static void 309 filter_mirror_set_outdev(Object *obj, const char *value, Error **errp) 310 { 311 MirrorState *s = FILTER_MIRROR(obj); 312 313 g_free(s->outdev); 314 s->outdev = g_strdup(value); 315 if (!s->outdev) { 316 error_setg(errp, "filter mirror needs 'outdev' " 317 "property set"); 318 return; 319 } 320 } 321 322 static char *filter_redirector_get_outdev(Object *obj, Error **errp) 323 { 324 MirrorState *s = FILTER_REDIRECTOR(obj); 325 326 return g_strdup(s->outdev); 327 } 328 329 static void 330 filter_redirector_set_outdev(Object *obj, const char *value, Error **errp) 331 { 332 MirrorState *s = FILTER_REDIRECTOR(obj); 333 334 g_free(s->outdev); 335 s->outdev = g_strdup(value); 336 } 337 338 static void filter_mirror_init(Object *obj) 339 { 340 object_property_add_str(obj, "outdev", filter_mirror_get_outdev, 341 filter_mirror_set_outdev, NULL); 342 } 343 344 static void filter_redirector_init(Object *obj) 345 { 346 object_property_add_str(obj, "indev", filter_redirector_get_indev, 347 filter_redirector_set_indev, NULL); 348 object_property_add_str(obj, "outdev", filter_redirector_get_outdev, 349 filter_redirector_set_outdev, NULL); 350 } 351 352 static void filter_mirror_fini(Object *obj) 353 { 354 MirrorState *s = FILTER_MIRROR(obj); 355 356 g_free(s->outdev); 357 } 358 359 static void filter_redirector_fini(Object *obj) 360 { 361 MirrorState *s = FILTER_REDIRECTOR(obj); 362 363 g_free(s->indev); 364 g_free(s->outdev); 365 } 366 367 static const TypeInfo filter_redirector_info = { 368 .name = TYPE_FILTER_REDIRECTOR, 369 .parent = TYPE_NETFILTER, 370 .class_init = filter_redirector_class_init, 371 .instance_init = filter_redirector_init, 372 .instance_finalize = filter_redirector_fini, 373 .instance_size = sizeof(MirrorState), 374 }; 375 376 static const TypeInfo filter_mirror_info = { 377 .name = TYPE_FILTER_MIRROR, 378 .parent = TYPE_NETFILTER, 379 .class_init = filter_mirror_class_init, 380 .instance_init = filter_mirror_init, 381 .instance_finalize = filter_mirror_fini, 382 .instance_size = sizeof(MirrorState), 383 }; 384 385 static void register_types(void) 386 { 387 type_register_static(&filter_mirror_info); 388 type_register_static(&filter_redirector_info); 389 } 390 391 type_init(register_types); 392