1 /*- 2 * Copyright (c) 2010-2011 Alexander V. Chernikov <melifaro@ipfw.ru> 3 * Copyright (c) 2004-2005 Gleb Smirnoff <glebius@FreeBSD.org> 4 * Copyright (c) 2001-2003 Roman V. Palagin <romanp@unshadow.net> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $SourceForge: ng_netflow.c,v 1.30 2004/09/05 11:37:43 glebius Exp $ 29 */ 30 31 static const char rcs_id[] = 32 "@(#) $FreeBSD$"; 33 34 #include "opt_inet6.h" 35 #include "opt_route.h" 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/kernel.h> 40 #include <sys/limits.h> 41 #include <sys/mbuf.h> 42 #include <sys/socket.h> 43 #include <sys/syslog.h> 44 #include <sys/ctype.h> 45 46 #include <net/if.h> 47 #include <net/ethernet.h> 48 #include <net/route.h> 49 #include <net/if_arp.h> 50 #include <net/if_var.h> 51 #include <net/if_vlan_var.h> 52 #include <net/bpf.h> 53 #include <netinet/in.h> 54 #include <netinet/in_systm.h> 55 #include <netinet/ip.h> 56 #include <netinet/ip6.h> 57 #include <netinet/tcp.h> 58 #include <netinet/udp.h> 59 #include <netinet/sctp.h> 60 61 #include <netgraph/ng_message.h> 62 #include <netgraph/ng_parse.h> 63 #include <netgraph/netgraph.h> 64 #include <netgraph/netflow/netflow.h> 65 #include <netgraph/netflow/netflow_v9.h> 66 #include <netgraph/netflow/ng_netflow.h> 67 68 /* Netgraph methods */ 69 static ng_constructor_t ng_netflow_constructor; 70 static ng_rcvmsg_t ng_netflow_rcvmsg; 71 static ng_close_t ng_netflow_close; 72 static ng_shutdown_t ng_netflow_rmnode; 73 static ng_newhook_t ng_netflow_newhook; 74 static ng_rcvdata_t ng_netflow_rcvdata; 75 static ng_disconnect_t ng_netflow_disconnect; 76 77 /* Parse type for struct ng_netflow_info */ 78 static const struct ng_parse_struct_field ng_netflow_info_type_fields[] 79 = NG_NETFLOW_INFO_TYPE; 80 static const struct ng_parse_type ng_netflow_info_type = { 81 &ng_parse_struct_type, 82 &ng_netflow_info_type_fields 83 }; 84 85 /* Parse type for struct ng_netflow_ifinfo */ 86 static const struct ng_parse_struct_field ng_netflow_ifinfo_type_fields[] 87 = NG_NETFLOW_IFINFO_TYPE; 88 static const struct ng_parse_type ng_netflow_ifinfo_type = { 89 &ng_parse_struct_type, 90 &ng_netflow_ifinfo_type_fields 91 }; 92 93 /* Parse type for struct ng_netflow_setdlt */ 94 static const struct ng_parse_struct_field ng_netflow_setdlt_type_fields[] 95 = NG_NETFLOW_SETDLT_TYPE; 96 static const struct ng_parse_type ng_netflow_setdlt_type = { 97 &ng_parse_struct_type, 98 &ng_netflow_setdlt_type_fields 99 }; 100 101 /* Parse type for ng_netflow_setifindex */ 102 static const struct ng_parse_struct_field ng_netflow_setifindex_type_fields[] 103 = NG_NETFLOW_SETIFINDEX_TYPE; 104 static const struct ng_parse_type ng_netflow_setifindex_type = { 105 &ng_parse_struct_type, 106 &ng_netflow_setifindex_type_fields 107 }; 108 109 /* Parse type for ng_netflow_settimeouts */ 110 static const struct ng_parse_struct_field ng_netflow_settimeouts_type_fields[] 111 = NG_NETFLOW_SETTIMEOUTS_TYPE; 112 static const struct ng_parse_type ng_netflow_settimeouts_type = { 113 &ng_parse_struct_type, 114 &ng_netflow_settimeouts_type_fields 115 }; 116 117 /* Parse type for ng_netflow_setconfig */ 118 static const struct ng_parse_struct_field ng_netflow_setconfig_type_fields[] 119 = NG_NETFLOW_SETCONFIG_TYPE; 120 static const struct ng_parse_type ng_netflow_setconfig_type = { 121 &ng_parse_struct_type, 122 &ng_netflow_setconfig_type_fields 123 }; 124 125 /* Parse type for ng_netflow_settemplate */ 126 static const struct ng_parse_struct_field ng_netflow_settemplate_type_fields[] 127 = NG_NETFLOW_SETTEMPLATE_TYPE; 128 static const struct ng_parse_type ng_netflow_settemplate_type = { 129 &ng_parse_struct_type, 130 &ng_netflow_settemplate_type_fields 131 }; 132 133 /* Parse type for ng_netflow_setmtu */ 134 static const struct ng_parse_struct_field ng_netflow_setmtu_type_fields[] 135 = NG_NETFLOW_SETMTU_TYPE; 136 static const struct ng_parse_type ng_netflow_setmtu_type = { 137 &ng_parse_struct_type, 138 &ng_netflow_setmtu_type_fields 139 }; 140 141 /* List of commands and how to convert arguments to/from ASCII */ 142 static const struct ng_cmdlist ng_netflow_cmds[] = { 143 { 144 NGM_NETFLOW_COOKIE, 145 NGM_NETFLOW_INFO, 146 "info", 147 NULL, 148 &ng_netflow_info_type 149 }, 150 { 151 NGM_NETFLOW_COOKIE, 152 NGM_NETFLOW_IFINFO, 153 "ifinfo", 154 &ng_parse_uint16_type, 155 &ng_netflow_ifinfo_type 156 }, 157 { 158 NGM_NETFLOW_COOKIE, 159 NGM_NETFLOW_SETDLT, 160 "setdlt", 161 &ng_netflow_setdlt_type, 162 NULL 163 }, 164 { 165 NGM_NETFLOW_COOKIE, 166 NGM_NETFLOW_SETIFINDEX, 167 "setifindex", 168 &ng_netflow_setifindex_type, 169 NULL 170 }, 171 { 172 NGM_NETFLOW_COOKIE, 173 NGM_NETFLOW_SETTIMEOUTS, 174 "settimeouts", 175 &ng_netflow_settimeouts_type, 176 NULL 177 }, 178 { 179 NGM_NETFLOW_COOKIE, 180 NGM_NETFLOW_SETCONFIG, 181 "setconfig", 182 &ng_netflow_setconfig_type, 183 NULL 184 }, 185 { 186 NGM_NETFLOW_COOKIE, 187 NGM_NETFLOW_SETTEMPLATE, 188 "settemplate", 189 &ng_netflow_settemplate_type, 190 NULL 191 }, 192 { 193 NGM_NETFLOW_COOKIE, 194 NGM_NETFLOW_SETMTU, 195 "setmtu", 196 &ng_netflow_setmtu_type, 197 NULL 198 }, 199 { 0 } 200 }; 201 202 203 /* Netgraph node type descriptor */ 204 static struct ng_type ng_netflow_typestruct = { 205 .version = NG_ABI_VERSION, 206 .name = NG_NETFLOW_NODE_TYPE, 207 .constructor = ng_netflow_constructor, 208 .rcvmsg = ng_netflow_rcvmsg, 209 .close = ng_netflow_close, 210 .shutdown = ng_netflow_rmnode, 211 .newhook = ng_netflow_newhook, 212 .rcvdata = ng_netflow_rcvdata, 213 .disconnect = ng_netflow_disconnect, 214 .cmdlist = ng_netflow_cmds, 215 }; 216 NETGRAPH_INIT(netflow, &ng_netflow_typestruct); 217 218 /* Called at node creation */ 219 static int 220 ng_netflow_constructor(node_p node) 221 { 222 priv_p priv; 223 int error = 0, i; 224 225 /* Initialize private data */ 226 priv = malloc(sizeof(*priv), M_NETGRAPH, M_NOWAIT); 227 if (priv == NULL) 228 return (ENOMEM); 229 bzero(priv, sizeof(*priv)); 230 231 /* Make node and its data point at each other */ 232 NG_NODE_SET_PRIVATE(node, priv); 233 priv->node = node; 234 235 /* Initialize timeouts to default values */ 236 priv->info.nfinfo_inact_t = INACTIVE_TIMEOUT; 237 priv->info.nfinfo_act_t = ACTIVE_TIMEOUT; 238 239 /* Set default config */ 240 for (i = 0; i < NG_NETFLOW_MAXIFACES; i++) 241 priv->ifaces[i].info.conf = NG_NETFLOW_CONF_INGRESS; 242 243 /* Initialize callout handle */ 244 callout_init(&priv->exp_callout, CALLOUT_MPSAFE); 245 246 /* Allocate memory and set up flow cache */ 247 if ((error = ng_netflow_cache_init(priv))) 248 return (error); 249 250 return (0); 251 } 252 253 /* 254 * ng_netflow supports two hooks: data and export. 255 * Incoming traffic is expected on data, and expired 256 * netflow datagrams are sent to export. 257 */ 258 static int 259 ng_netflow_newhook(node_p node, hook_p hook, const char *name) 260 { 261 const priv_p priv = NG_NODE_PRIVATE(node); 262 263 if (strncmp(name, NG_NETFLOW_HOOK_DATA, /* an iface hook? */ 264 strlen(NG_NETFLOW_HOOK_DATA)) == 0) { 265 iface_p iface; 266 int ifnum = -1; 267 const char *cp; 268 char *eptr; 269 270 cp = name + strlen(NG_NETFLOW_HOOK_DATA); 271 if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0')) 272 return (EINVAL); 273 274 ifnum = (int)strtoul(cp, &eptr, 10); 275 if (*eptr != '\0' || ifnum < 0 || ifnum >= NG_NETFLOW_MAXIFACES) 276 return (EINVAL); 277 278 /* See if hook is already connected */ 279 if (priv->ifaces[ifnum].hook != NULL) 280 return (EISCONN); 281 282 iface = &priv->ifaces[ifnum]; 283 284 /* Link private info and hook together */ 285 NG_HOOK_SET_PRIVATE(hook, iface); 286 iface->hook = hook; 287 288 /* 289 * In most cases traffic accounting is done on an 290 * Ethernet interface, so default data link type 291 * will be DLT_EN10MB. 292 */ 293 iface->info.ifinfo_dlt = DLT_EN10MB; 294 295 } else if (strncmp(name, NG_NETFLOW_HOOK_OUT, 296 strlen(NG_NETFLOW_HOOK_OUT)) == 0) { 297 iface_p iface; 298 int ifnum = -1; 299 const char *cp; 300 char *eptr; 301 302 cp = name + strlen(NG_NETFLOW_HOOK_OUT); 303 if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0')) 304 return (EINVAL); 305 306 ifnum = (int)strtoul(cp, &eptr, 10); 307 if (*eptr != '\0' || ifnum < 0 || ifnum >= NG_NETFLOW_MAXIFACES) 308 return (EINVAL); 309 310 /* See if hook is already connected */ 311 if (priv->ifaces[ifnum].out != NULL) 312 return (EISCONN); 313 314 iface = &priv->ifaces[ifnum]; 315 316 /* Link private info and hook together */ 317 NG_HOOK_SET_PRIVATE(hook, iface); 318 iface->out = hook; 319 320 } else if (strcmp(name, NG_NETFLOW_HOOK_EXPORT) == 0) { 321 322 if (priv->export != NULL) 323 return (EISCONN); 324 325 /* Netflow version 5 supports 32-bit counters only */ 326 if (CNTR_MAX == UINT64_MAX) 327 return (EINVAL); 328 329 priv->export = hook; 330 331 /* Exporter is ready. Let's schedule expiry. */ 332 callout_reset(&priv->exp_callout, (1*hz), &ng_netflow_expire, 333 (void *)priv); 334 } else if (strcmp(name, NG_NETFLOW_HOOK_EXPORT9) == 0) { 335 336 if (priv->export9 != NULL) 337 return (EISCONN); 338 339 priv->export9 = hook; 340 341 /* Exporter is ready. Let's schedule expiry. */ 342 callout_reset(&priv->exp_callout, (1*hz), &ng_netflow_expire, 343 (void *)priv); 344 } else 345 return (EINVAL); 346 347 return (0); 348 } 349 350 /* Get a netgraph control message. */ 351 static int 352 ng_netflow_rcvmsg (node_p node, item_p item, hook_p lasthook) 353 { 354 const priv_p priv = NG_NODE_PRIVATE(node); 355 struct ng_mesg *resp = NULL; 356 int error = 0; 357 struct ng_mesg *msg; 358 359 NGI_GET_MSG(item, msg); 360 361 /* Deal with message according to cookie and command */ 362 switch (msg->header.typecookie) { 363 case NGM_NETFLOW_COOKIE: 364 switch (msg->header.cmd) { 365 case NGM_NETFLOW_INFO: 366 { 367 struct ng_netflow_info *i; 368 369 NG_MKRESPONSE(resp, msg, sizeof(struct ng_netflow_info), 370 M_NOWAIT); 371 i = (struct ng_netflow_info *)resp->data; 372 ng_netflow_copyinfo(priv, i); 373 374 break; 375 } 376 case NGM_NETFLOW_IFINFO: 377 { 378 struct ng_netflow_ifinfo *i; 379 const uint16_t *index; 380 381 if (msg->header.arglen != sizeof(uint16_t)) 382 ERROUT(EINVAL); 383 384 index = (uint16_t *)msg->data; 385 if (*index >= NG_NETFLOW_MAXIFACES) 386 ERROUT(EINVAL); 387 388 /* connected iface? */ 389 if (priv->ifaces[*index].hook == NULL) 390 ERROUT(EINVAL); 391 392 NG_MKRESPONSE(resp, msg, 393 sizeof(struct ng_netflow_ifinfo), M_NOWAIT); 394 i = (struct ng_netflow_ifinfo *)resp->data; 395 memcpy((void *)i, (void *)&priv->ifaces[*index].info, 396 sizeof(priv->ifaces[*index].info)); 397 398 break; 399 } 400 case NGM_NETFLOW_SETDLT: 401 { 402 struct ng_netflow_setdlt *set; 403 struct ng_netflow_iface *iface; 404 405 if (msg->header.arglen != sizeof(struct ng_netflow_setdlt)) 406 ERROUT(EINVAL); 407 408 set = (struct ng_netflow_setdlt *)msg->data; 409 if (set->iface >= NG_NETFLOW_MAXIFACES) 410 ERROUT(EINVAL); 411 iface = &priv->ifaces[set->iface]; 412 413 /* connected iface? */ 414 if (iface->hook == NULL) 415 ERROUT(EINVAL); 416 417 switch (set->dlt) { 418 case DLT_EN10MB: 419 iface->info.ifinfo_dlt = DLT_EN10MB; 420 break; 421 case DLT_RAW: 422 iface->info.ifinfo_dlt = DLT_RAW; 423 break; 424 default: 425 ERROUT(EINVAL); 426 } 427 break; 428 } 429 case NGM_NETFLOW_SETIFINDEX: 430 { 431 struct ng_netflow_setifindex *set; 432 struct ng_netflow_iface *iface; 433 434 if (msg->header.arglen != sizeof(struct ng_netflow_setifindex)) 435 ERROUT(EINVAL); 436 437 set = (struct ng_netflow_setifindex *)msg->data; 438 if (set->iface >= NG_NETFLOW_MAXIFACES) 439 ERROUT(EINVAL); 440 iface = &priv->ifaces[set->iface]; 441 442 /* connected iface? */ 443 if (iface->hook == NULL) 444 ERROUT(EINVAL); 445 446 iface->info.ifinfo_index = set->index; 447 448 break; 449 } 450 case NGM_NETFLOW_SETTIMEOUTS: 451 { 452 struct ng_netflow_settimeouts *set; 453 454 if (msg->header.arglen != sizeof(struct ng_netflow_settimeouts)) 455 ERROUT(EINVAL); 456 457 set = (struct ng_netflow_settimeouts *)msg->data; 458 459 priv->info.nfinfo_inact_t = set->inactive_timeout; 460 priv->info.nfinfo_act_t = set->active_timeout; 461 462 break; 463 } 464 case NGM_NETFLOW_SETCONFIG: 465 { 466 struct ng_netflow_setconfig *set; 467 468 if (msg->header.arglen != sizeof(struct ng_netflow_setconfig)) 469 ERROUT(EINVAL); 470 471 set = (struct ng_netflow_setconfig *)msg->data; 472 473 if (set->iface >= NG_NETFLOW_MAXIFACES) 474 ERROUT(EINVAL); 475 476 priv->ifaces[set->iface].info.conf = set->conf; 477 478 break; 479 } 480 case NGM_NETFLOW_SETTEMPLATE: 481 { 482 struct ng_netflow_settemplate *set; 483 484 if (msg->header.arglen != sizeof(struct ng_netflow_settemplate)) 485 ERROUT(EINVAL); 486 487 set = (struct ng_netflow_settemplate *)msg->data; 488 489 priv->templ_packets = set->packets; 490 priv->templ_time = set->time; 491 492 break; 493 } 494 case NGM_NETFLOW_SETMTU: 495 { 496 struct ng_netflow_setmtu *set; 497 498 if (msg->header.arglen != sizeof(struct ng_netflow_setmtu)) 499 ERROUT(EINVAL); 500 501 set = (struct ng_netflow_setmtu *)msg->data; 502 if ((set->mtu < MIN_MTU) || (set->mtu > MAX_MTU)) 503 ERROUT(EINVAL); 504 505 priv->mtu = set->mtu; 506 507 break; 508 } 509 case NGM_NETFLOW_SHOW: 510 { 511 uint32_t *last; 512 513 if (msg->header.arglen != sizeof(uint32_t)) 514 ERROUT(EINVAL); 515 516 last = (uint32_t *)msg->data; 517 518 NG_MKRESPONSE(resp, msg, NGRESP_SIZE, M_NOWAIT); 519 520 if (!resp) 521 ERROUT(ENOMEM); 522 523 error = ng_netflow_flow_show(priv, *last, resp); 524 525 break; 526 } 527 default: 528 ERROUT(EINVAL); /* unknown command */ 529 break; 530 } 531 break; 532 default: 533 ERROUT(EINVAL); /* incorrect cookie */ 534 break; 535 } 536 537 /* 538 * Take care of synchronous response, if any. 539 * Free memory and return. 540 */ 541 done: 542 NG_RESPOND_MSG(error, node, item, resp); 543 NG_FREE_MSG(msg); 544 545 return (error); 546 } 547 548 /* Receive data on hook. */ 549 static int 550 ng_netflow_rcvdata (hook_p hook, item_p item) 551 { 552 const node_p node = NG_HOOK_NODE(hook); 553 const priv_p priv = NG_NODE_PRIVATE(node); 554 const iface_p iface = NG_HOOK_PRIVATE(hook); 555 hook_p out; 556 struct mbuf *m = NULL, *m_old = NULL; 557 struct ip *ip = NULL; 558 struct ip6_hdr *ip6 = NULL; 559 struct m_tag *mtag; 560 int pullup_len = 0, off; 561 uint8_t upper_proto = 0, is_frag = 0; 562 int error = 0, bypass = 0, acct = 0; 563 unsigned int src_if_index; 564 caddr_t upper_ptr = NULL; 565 fib_export_p fe; 566 uint32_t fib; 567 568 if ((hook == priv->export) || (hook == priv->export9)) { 569 /* 570 * Data arrived on export hook. 571 * This must not happen. 572 */ 573 log(LOG_ERR, "ng_netflow: incoming data on export hook!\n"); 574 ERROUT(EINVAL); 575 }; 576 577 if (hook == iface->hook) { 578 if ((iface->info.conf & NG_NETFLOW_CONF_INGRESS) == 0) 579 bypass = 1; 580 out = iface->out; 581 } else if (hook == iface->out) { 582 if ((iface->info.conf & NG_NETFLOW_CONF_EGRESS) == 0) 583 bypass = 1; 584 out = iface->hook; 585 } else 586 ERROUT(EINVAL); 587 588 if ((!bypass) && 589 (iface->info.conf & (NG_NETFLOW_CONF_ONCE | NG_NETFLOW_CONF_THISONCE))) { 590 mtag = m_tag_locate(NGI_M(item), MTAG_NETFLOW, 591 MTAG_NETFLOW_CALLED, NULL); 592 while (mtag != NULL) { 593 if ((iface->info.conf & NG_NETFLOW_CONF_ONCE) || 594 ((ng_ID_t *)(mtag + 1))[0] == NG_NODE_ID(node)) { 595 bypass = 1; 596 break; 597 } 598 mtag = m_tag_locate(NGI_M(item), MTAG_NETFLOW, 599 MTAG_NETFLOW_CALLED, mtag); 600 } 601 } 602 603 if (bypass) { 604 if (out == NULL) 605 ERROUT(ENOTCONN); 606 607 NG_FWD_ITEM_HOOK(error, item, out); 608 return (error); 609 } 610 611 if (iface->info.conf & (NG_NETFLOW_CONF_ONCE | NG_NETFLOW_CONF_THISONCE)) { 612 mtag = m_tag_alloc(MTAG_NETFLOW, MTAG_NETFLOW_CALLED, 613 sizeof(ng_ID_t), M_NOWAIT); 614 if (mtag) { 615 ((ng_ID_t *)(mtag + 1))[0] = NG_NODE_ID(node); 616 m_tag_prepend(NGI_M(item), mtag); 617 } 618 } 619 620 NGI_GET_M(item, m); 621 m_old = m; 622 623 /* Increase counters. */ 624 iface->info.ifinfo_packets++; 625 626 /* 627 * Depending on interface data link type and packet contents 628 * we pullup enough data, so that ng_netflow_flow_add() does not 629 * need to know about mbuf at all. We keep current length of data 630 * needed to be contiguous in pullup_len. mtod() is done at the 631 * very end one more time, since m can had changed after pulluping. 632 * 633 * In case of unrecognized data we don't return error, but just 634 * pass data to downstream hook, if it is available. 635 */ 636 637 #define M_CHECK(length) do { \ 638 pullup_len += length; \ 639 if (((m)->m_pkthdr.len < (pullup_len)) || \ 640 ((pullup_len) > MHLEN)) { \ 641 error = EINVAL; \ 642 goto bypass; \ 643 } \ 644 if ((m)->m_len < (pullup_len) && \ 645 (((m) = m_pullup((m),(pullup_len))) == NULL)) { \ 646 error = ENOBUFS; \ 647 goto done; \ 648 } \ 649 } while (0) 650 651 switch (iface->info.ifinfo_dlt) { 652 case DLT_EN10MB: /* Ethernet */ 653 { 654 struct ether_header *eh; 655 uint16_t etype; 656 657 M_CHECK(sizeof(struct ether_header)); 658 eh = mtod(m, struct ether_header *); 659 660 /* Make sure this is IP frame. */ 661 etype = ntohs(eh->ether_type); 662 switch (etype) { 663 case ETHERTYPE_IP: 664 M_CHECK(sizeof(struct ip)); 665 eh = mtod(m, struct ether_header *); 666 ip = (struct ip *)(eh + 1); 667 break; 668 #ifdef INET6 669 case ETHERTYPE_IPV6: 670 /* 671 * m_pullup() called by M_CHECK() pullups 672 * kern.ipc.max_protohdr (default 60 bytes) which is enough 673 */ 674 M_CHECK(sizeof(struct ip6_hdr)); 675 eh = mtod(m, struct ether_header *); 676 ip6 = (struct ip6_hdr *)(eh + 1); 677 break; 678 #endif 679 case ETHERTYPE_VLAN: 680 { 681 struct ether_vlan_header *evh; 682 683 M_CHECK(sizeof(struct ether_vlan_header) - 684 sizeof(struct ether_header)); 685 evh = mtod(m, struct ether_vlan_header *); 686 etype = ntohs(evh->evl_proto); 687 688 if (etype == ETHERTYPE_IP) { 689 M_CHECK(sizeof(struct ip)); 690 ip = (struct ip *)(evh + 1); 691 break; 692 #ifdef INET6 693 } else if (etype == ETHERTYPE_IPV6) { 694 M_CHECK(sizeof(struct ip6_hdr)); 695 ip6 = (struct ip6_hdr *)(evh + 1); 696 break; 697 #endif 698 } 699 } 700 default: 701 goto bypass; /* pass this frame */ 702 } 703 break; 704 } 705 case DLT_RAW: /* IP packets */ 706 M_CHECK(sizeof(struct ip)); 707 ip = mtod(m, struct ip *); 708 #ifdef INET6 709 /* If INET6 is not defined IPv6 packets will be discarded in ng_netflow_flow_add() */ 710 if (ip->ip_v == IP6VERSION) { 711 /* IPv6 packet */ 712 ip = NULL; 713 M_CHECK(sizeof(struct ip6_hdr)); 714 ip6 = mtod(m, struct ip6_hdr *); 715 } 716 #endif 717 break; 718 default: 719 goto bypass; 720 break; 721 } 722 723 off = pullup_len; 724 725 if ((ip != NULL) && ((ip->ip_off & htons(IP_OFFMASK)) == 0)) { 726 if ((ip->ip_v != IPVERSION) || 727 ((ip->ip_hl << 2) < sizeof(struct ip))) 728 goto bypass; 729 /* 730 * In case of IPv4 header with options, we haven't pulled 731 * up enough, yet. 732 */ 733 M_CHECK((ip->ip_hl << 2) - sizeof(struct ip)); 734 735 /* Save upper layer offset and proto */ 736 off = pullup_len; 737 upper_proto = ip->ip_p; 738 739 /* 740 * XXX: in case of wrong upper layer header we will forward this packet 741 * but skip this record in netflow 742 */ 743 switch (ip->ip_p) { 744 case IPPROTO_TCP: 745 M_CHECK(sizeof(struct tcphdr)); 746 break; 747 case IPPROTO_UDP: 748 M_CHECK(sizeof(struct udphdr)); 749 break; 750 case IPPROTO_SCTP: 751 M_CHECK(sizeof(struct sctphdr)); 752 break; 753 } 754 } else if (ip != NULL) { 755 /* Nothing to save except upper layer proto, since this is packet fragment */ 756 is_frag = 1; 757 upper_proto = ip->ip_p; 758 if ((ip->ip_v != IPVERSION) || 759 ((ip->ip_hl << 2) < sizeof(struct ip))) 760 goto bypass; 761 #ifdef INET6 762 } else if (ip6 != NULL) { 763 /* Check if we can export */ 764 if (priv->export9 == NULL) 765 goto bypass; 766 767 /* Loop thru IPv6 extended headers to get upper layer header / frag */ 768 int cur = ip6->ip6_nxt, hdr_off = 0; 769 struct ip6_ext *ip6e; 770 struct ip6_frag *ip6f; 771 772 /* Save upper layer info */ 773 off = pullup_len; 774 upper_proto = cur; 775 776 if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) 777 goto bypass; 778 779 while (42) { 780 switch (cur) { 781 /* 782 * Same as in IPv4, we can forward 'bad' packet without accounting 783 */ 784 case IPPROTO_TCP: 785 M_CHECK(sizeof(struct tcphdr)); 786 goto loopend; 787 case IPPROTO_UDP: 788 M_CHECK(sizeof(struct udphdr)); 789 goto loopend; 790 case IPPROTO_SCTP: 791 M_CHECK(sizeof(struct sctphdr)); 792 goto loopend; 793 794 /* Loop until 'real' upper layer headers */ 795 case IPPROTO_HOPOPTS: 796 case IPPROTO_ROUTING: 797 case IPPROTO_DSTOPTS: 798 M_CHECK(sizeof(struct ip6_ext)); 799 ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + off); 800 upper_proto = ip6e->ip6e_nxt; 801 hdr_off = (ip6e->ip6e_len + 1) << 3; 802 break; 803 804 /* RFC4302, can be before DSTOPTS */ 805 case IPPROTO_AH: 806 M_CHECK(sizeof(struct ip6_ext)); 807 ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + off); 808 upper_proto = ip6e->ip6e_nxt; 809 hdr_off = (ip6e->ip6e_len + 2) << 2; 810 break; 811 812 case IPPROTO_FRAGMENT: 813 M_CHECK(sizeof(struct ip6_frag)); 814 ip6f = (struct ip6_frag *)(mtod(m, caddr_t) + off); 815 upper_proto = ip6f->ip6f_nxt; 816 hdr_off = sizeof(struct ip6_frag); 817 off += hdr_off; 818 is_frag = 1; 819 goto loopend; 820 821 #if 0 822 case IPPROTO_NONE: 823 goto loopend; 824 #endif 825 /* Any unknow header (new extension or IPv6/IPv4 header for tunnels) */ 826 default: 827 goto loopend; 828 } 829 830 off += hdr_off; 831 cur = upper_proto; 832 } 833 #endif 834 } 835 #undef M_CHECK 836 837 #ifdef INET6 838 loopend: 839 #endif 840 /* Just in case of real reallocation in M_CHECK() / m_pullup() */ 841 if (m != m_old) { 842 atomic_fetchadd_32(&priv->info.nfinfo_realloc_mbuf, 1); 843 ip = NULL; 844 ip6 = NULL; 845 switch (iface->info.ifinfo_dlt) { 846 case DLT_EN10MB: /* Ethernet */ 847 { 848 struct ether_header *eh; 849 850 eh = mtod(m, struct ether_header *); 851 switch (ntohs(eh->ether_type)) { 852 case ETHERTYPE_IP: 853 ip = (struct ip *)(eh + 1); 854 break; 855 #ifdef INET6 856 case ETHERTYPE_IPV6: 857 ip6 = (struct ip6_hdr *)(eh + 1); 858 break; 859 #endif 860 case ETHERTYPE_VLAN: 861 { 862 struct ether_vlan_header *evh; 863 864 evh = mtod(m, struct ether_vlan_header *); 865 if (ntohs(evh->evl_proto) == ETHERTYPE_IP) { 866 ip = (struct ip *)(evh + 1); 867 break; 868 #ifdef INET6 869 } else if (ntohs(evh->evl_proto) == ETHERTYPE_IPV6) { 870 ip6 = (struct ip6_hdr *)(evh + 1); 871 break; 872 #endif 873 } 874 } 875 default: 876 panic("ng_netflow entered deadcode"); 877 } 878 break; 879 } 880 case DLT_RAW: /* IP packets */ 881 ip = mtod(m, struct ip *); 882 #ifdef INET6 883 if (ip->ip_v == IP6VERSION) { 884 /* IPv6 packet */ 885 ip = NULL; 886 ip6 = mtod(m, struct ip6_hdr *); 887 } 888 #endif 889 break; 890 default: 891 panic("ng_netflow entered deadcode"); 892 } 893 } 894 895 upper_ptr = (caddr_t)(mtod(m, caddr_t) + off); 896 897 /* Determine packet input interface. Prefer configured. */ 898 src_if_index = 0; 899 if (hook == iface->out || iface->info.ifinfo_index == 0) { 900 if (m->m_pkthdr.rcvif != NULL) 901 src_if_index = m->m_pkthdr.rcvif->if_index; 902 } else 903 src_if_index = iface->info.ifinfo_index; 904 905 /* Check packet FIB */ 906 fib = M_GETFIB(m); 907 if (fib >= RT_NUMFIBS) { 908 CTR2(KTR_NET, "ng_netflow_rcvdata(): packet fib %d is out of range of available fibs: 0 .. %d", fib, RT_NUMFIBS); 909 goto bypass; 910 } 911 912 if ((fe = priv_to_fib(priv, fib)) == NULL) { 913 /* Setup new FIB */ 914 if (ng_netflow_fib_init(priv, fib) != 0) { 915 /* malloc() failed */ 916 goto bypass; 917 } 918 919 fe = priv_to_fib(priv, fib); 920 } 921 922 if (ip != NULL) 923 error = ng_netflow_flow_add(priv, fe, ip, upper_ptr, upper_proto, is_frag, src_if_index); 924 #ifdef INET6 925 else if (ip6 != NULL) 926 error = ng_netflow_flow6_add(priv, fe, ip6, upper_ptr, upper_proto, is_frag, src_if_index); 927 #endif 928 else 929 goto bypass; 930 931 acct = 1; 932 bypass: 933 if (out != NULL) { 934 if (acct == 0) { 935 /* Accounting failure */ 936 if (ip != NULL) { 937 atomic_fetchadd_32(&priv->info.nfinfo_spackets, 1); 938 priv->info.nfinfo_sbytes += m_length(m, NULL); 939 } else if (ip6 != NULL) { 940 atomic_fetchadd_32(&priv->info.nfinfo_spackets6, 1); 941 priv->info.nfinfo_sbytes6 += m_length(m, NULL); 942 } 943 } 944 945 /* XXX: error gets overwritten here */ 946 NG_FWD_NEW_DATA(error, item, out, m); 947 return (error); 948 } 949 done: 950 if (item) 951 NG_FREE_ITEM(item); 952 if (m) 953 NG_FREE_M(m); 954 955 return (error); 956 } 957 958 /* We will be shut down in a moment */ 959 static int 960 ng_netflow_close(node_p node) 961 { 962 const priv_p priv = NG_NODE_PRIVATE(node); 963 964 callout_drain(&priv->exp_callout); 965 ng_netflow_cache_flush(priv); 966 967 return (0); 968 } 969 970 /* Do local shutdown processing. */ 971 static int 972 ng_netflow_rmnode(node_p node) 973 { 974 const priv_p priv = NG_NODE_PRIVATE(node); 975 976 NG_NODE_SET_PRIVATE(node, NULL); 977 NG_NODE_UNREF(priv->node); 978 979 free(priv, M_NETGRAPH); 980 981 return (0); 982 } 983 984 /* Hook disconnection. */ 985 static int 986 ng_netflow_disconnect(hook_p hook) 987 { 988 node_p node = NG_HOOK_NODE(hook); 989 priv_p priv = NG_NODE_PRIVATE(node); 990 iface_p iface = NG_HOOK_PRIVATE(hook); 991 992 if (iface != NULL) { 993 if (iface->hook == hook) 994 iface->hook = NULL; 995 if (iface->out == hook) 996 iface->out = NULL; 997 } 998 999 /* if export hook disconnected stop running expire(). */ 1000 if (hook == priv->export) { 1001 if (priv->export9 == NULL) 1002 callout_drain(&priv->exp_callout); 1003 priv->export = NULL; 1004 } 1005 1006 if (hook == priv->export9) { 1007 if (priv->export == NULL) 1008 callout_drain(&priv->exp_callout); 1009 priv->export9 = NULL; 1010 } 1011 1012 /* Removal of the last link destroys the node. */ 1013 if (NG_NODE_NUMHOOKS(node) == 0) 1014 ng_rmnode_self(node); 1015 1016 return (0); 1017 } 1018