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