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 "qom/object.h" 18 #include "qemu/main-loop.h" 19 #include "qemu/error-report.h" 20 #include "trace.h" 21 #include "chardev/char-fe.h" 22 #include "qemu/iov.h" 23 #include "qemu/sockets.h" 24 25 #define FILTER_MIRROR(obj) \ 26 OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_MIRROR) 27 28 #define FILTER_REDIRECTOR(obj) \ 29 OBJECT_CHECK(MirrorState, (obj), TYPE_FILTER_REDIRECTOR) 30 31 #define TYPE_FILTER_MIRROR "filter-mirror" 32 #define TYPE_FILTER_REDIRECTOR "filter-redirector" 33 #define REDIRECTOR_MAX_LEN NET_BUFSIZE 34 35 typedef struct MirrorState { 36 NetFilterState parent_obj; 37 char *indev; 38 char *outdev; 39 CharBackend chr_in; 40 CharBackend chr_out; 41 SocketReadState rs; 42 bool vnet_hdr; 43 } MirrorState; 44 45 static int filter_send(MirrorState *s, 46 const struct iovec *iov, 47 int iovcnt) 48 { 49 NetFilterState *nf = NETFILTER(s); 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(&s->chr_out, (uint8_t *)&len, sizeof(len)); 62 if (ret != sizeof(len)) { 63 goto err; 64 } 65 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 83 buf = g_malloc(size); 84 iov_to_buf(iov, iovcnt, 0, buf, size); 85 ret = qemu_chr_fe_write_all(&s->chr_out, (uint8_t *)buf, size); 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 97 static void redirector_to_filter(NetFilterState *nf, 98 const uint8_t *buf, 99 int len) 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); 126 int ret; 127 128 ret = net_fill_rstate(&s->rs, buf, size); 129 130 if (ret == -1) { 131 qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, 132 NULL, NULL, NULL, true); 133 } 134 } 135 136 static void redirector_chr_event(void *opaque, int event) 137 { 138 NetFilterState *nf = opaque; 139 MirrorState *s = FILTER_REDIRECTOR(nf); 140 141 switch (event) { 142 case CHR_EVENT_CLOSED: 143 qemu_chr_fe_set_handlers(&s->chr_in, NULL, NULL, NULL, 144 NULL, NULL, NULL, true); 145 break; 146 default: 147 break; 148 } 149 } 150 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 { 158 MirrorState *s = FILTER_MIRROR(nf); 159 int ret; 160 161 ret = filter_send(s, iov, iovcnt); 162 if (ret) { 163 error_report("filter mirror send failed(%s)", strerror(-ret)); 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 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 183 if (qemu_chr_fe_backend_connected(&s->chr_out)) { 184 ret = filter_send(s, iov, iovcnt); 185 if (ret) { 186 error_report("filter redirector send failed(%s)", strerror(-ret)); 187 } 188 return iov_size(iov, iovcnt); 189 } else { 190 return 0; 191 } 192 } 193 194 static void filter_mirror_cleanup(NetFilterState *nf) 195 { 196 MirrorState *s = FILTER_MIRROR(nf); 197 198 qemu_chr_fe_deinit(&s->chr_out, false); 199 } 200 201 static void filter_redirector_cleanup(NetFilterState *nf) 202 { 203 MirrorState *s = FILTER_REDIRECTOR(nf); 204 205 qemu_chr_fe_deinit(&s->chr_in, false); 206 qemu_chr_fe_deinit(&s->chr_out, false); 207 } 208 209 static void filter_mirror_setup(NetFilterState *nf, Error **errp) 210 { 211 MirrorState *s = FILTER_MIRROR(nf); 212 Chardev *chr; 213 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 220 chr = qemu_chr_find(s->outdev); 221 if (chr == NULL) { 222 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 223 "Device '%s' not found", s->outdev); 224 return; 225 } 226 227 qemu_chr_fe_init(&s->chr_out, chr, errp); 228 } 229 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 238 static void filter_redirector_setup(NetFilterState *nf, Error **errp) 239 { 240 MirrorState *s = FILTER_REDIRECTOR(nf); 241 Chardev *chr; 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 255 net_socket_rs_init(&s->rs, redirector_rs_finalize, s->vnet_hdr); 256 257 if (s->indev) { 258 chr = qemu_chr_find(s->indev); 259 if (chr == NULL) { 260 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 261 "IN Device '%s' not found", s->indev); 262 return; 263 } 264 265 if (!qemu_chr_fe_init(&s->chr_in, chr, errp)) { 266 return; 267 } 268 269 qemu_chr_fe_set_handlers(&s->chr_in, redirector_chr_can_read, 270 redirector_chr_read, redirector_chr_event, 271 NULL, nf, NULL, true); 272 } 273 274 if (s->outdev) { 275 chr = qemu_chr_find(s->outdev); 276 if (chr == NULL) { 277 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 278 "OUT Device '%s' not found", s->outdev); 279 return; 280 } 281 if (!qemu_chr_fe_init(&s->chr_out, chr, errp)) { 282 return; 283 } 284 } 285 } 286 287 static void filter_mirror_class_init(ObjectClass *oc, void *data) 288 { 289 NetFilterClass *nfc = NETFILTER_CLASS(oc); 290 291 nfc->setup = filter_mirror_setup; 292 nfc->cleanup = filter_mirror_cleanup; 293 nfc->receive_iov = filter_mirror_receive_iov; 294 } 295 296 static void filter_redirector_class_init(ObjectClass *oc, void *data) 297 { 298 NetFilterClass *nfc = NETFILTER_CLASS(oc); 299 300 nfc->setup = filter_redirector_setup; 301 nfc->cleanup = filter_redirector_cleanup; 302 nfc->receive_iov = filter_redirector_receive_iov; 303 } 304 305 static char *filter_redirector_get_indev(Object *obj, Error **errp) 306 { 307 MirrorState *s = FILTER_REDIRECTOR(obj); 308 309 return g_strdup(s->indev); 310 } 311 312 static void filter_redirector_set_indev(Object *obj, 313 const char *value, 314 Error **errp) 315 { 316 MirrorState *s = FILTER_REDIRECTOR(obj); 317 318 g_free(s->indev); 319 s->indev = g_strdup(value); 320 } 321 322 static char *filter_mirror_get_outdev(Object *obj, Error **errp) 323 { 324 MirrorState *s = FILTER_MIRROR(obj); 325 326 return g_strdup(s->outdev); 327 } 328 329 static void filter_mirror_set_outdev(Object *obj, 330 const char *value, 331 Error **errp) 332 { 333 MirrorState *s = FILTER_MIRROR(obj); 334 335 g_free(s->outdev); 336 s->outdev = g_strdup(value); 337 if (!s->outdev) { 338 error_setg(errp, "filter mirror needs 'outdev' " 339 "property set"); 340 return; 341 } 342 } 343 344 static bool filter_mirror_get_vnet_hdr(Object *obj, Error **errp) 345 { 346 MirrorState *s = FILTER_MIRROR(obj); 347 348 return s->vnet_hdr; 349 } 350 351 static void filter_mirror_set_vnet_hdr(Object *obj, bool value, Error **errp) 352 { 353 MirrorState *s = FILTER_MIRROR(obj); 354 355 s->vnet_hdr = value; 356 } 357 358 static char *filter_redirector_get_outdev(Object *obj, Error **errp) 359 { 360 MirrorState *s = FILTER_REDIRECTOR(obj); 361 362 return g_strdup(s->outdev); 363 } 364 365 static void filter_redirector_set_outdev(Object *obj, 366 const char *value, 367 Error **errp) 368 { 369 MirrorState *s = FILTER_REDIRECTOR(obj); 370 371 g_free(s->outdev); 372 s->outdev = g_strdup(value); 373 } 374 375 static bool filter_redirector_get_vnet_hdr(Object *obj, Error **errp) 376 { 377 MirrorState *s = FILTER_REDIRECTOR(obj); 378 379 return s->vnet_hdr; 380 } 381 382 static void filter_redirector_set_vnet_hdr(Object *obj, 383 bool value, 384 Error **errp) 385 { 386 MirrorState *s = FILTER_REDIRECTOR(obj); 387 388 s->vnet_hdr = value; 389 } 390 391 static void filter_mirror_init(Object *obj) 392 { 393 MirrorState *s = FILTER_MIRROR(obj); 394 395 object_property_add_str(obj, "outdev", filter_mirror_get_outdev, 396 filter_mirror_set_outdev, NULL); 397 398 s->vnet_hdr = false; 399 object_property_add_bool(obj, "vnet_hdr_support", 400 filter_mirror_get_vnet_hdr, 401 filter_mirror_set_vnet_hdr, NULL); 402 } 403 404 static void filter_redirector_init(Object *obj) 405 { 406 MirrorState *s = FILTER_REDIRECTOR(obj); 407 408 object_property_add_str(obj, "indev", filter_redirector_get_indev, 409 filter_redirector_set_indev, NULL); 410 object_property_add_str(obj, "outdev", filter_redirector_get_outdev, 411 filter_redirector_set_outdev, NULL); 412 413 s->vnet_hdr = false; 414 object_property_add_bool(obj, "vnet_hdr_support", 415 filter_redirector_get_vnet_hdr, 416 filter_redirector_set_vnet_hdr, NULL); 417 } 418 419 static void filter_mirror_fini(Object *obj) 420 { 421 MirrorState *s = FILTER_MIRROR(obj); 422 423 g_free(s->outdev); 424 } 425 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 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); 455 type_register_static(&filter_redirector_info); 456 } 457 458 type_init(register_types); 459