kernel/netgraph7: Replace usage of MALLOC/FREE with kmalloc/kfree here too.
[dragonfly.git] / sys / netgraph7 / netflow / ng_netflow.c
CommitLineData
b06ebda0
MD
1/*-
2 * Copyright (c) 2004-2005 Gleb Smirnoff <glebius@FreeBSD.org>
3 * Copyright (c) 2001-2003 Roman V. Palagin <romanp@unshadow.net>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $SourceForge: ng_netflow.c,v 1.30 2004/09/05 11:37:43 glebius Exp $
5a975a3d
MD
28 * $FreeBSD: src/sys/netgraph/netflow/ng_netflow.c,v 1.17 2008/04/16 16:47:14 kris Exp $
29 * $DragonFly: src/sys/netgraph7/netflow/ng_netflow.c,v 1.2 2008/06/26 23:05:40 dillon Exp $
b06ebda0
MD
30 */
31
b06ebda0
MD
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/kernel.h>
35#include <sys/limits.h>
36#include <sys/mbuf.h>
37#include <sys/socket.h>
38#include <sys/syslog.h>
39#include <sys/ctype.h>
40
41#include <net/if.h>
42#include <net/ethernet.h>
43#include <net/if_arp.h>
44#include <net/if_var.h>
45#include <net/if_vlan_var.h>
46#include <net/bpf.h>
47#include <netinet/in.h>
48#include <netinet/in_systm.h>
49#include <netinet/ip.h>
50#include <netinet/tcp.h>
51#include <netinet/udp.h>
52
5a975a3d
MD
53#include "ng_message.h"
54#include "ng_parse.h"
55#include "netgraph.h"
56#include "netflow/netflow.h"
57#include "netflow/ng_netflow.h"
b06ebda0
MD
58
59/* Netgraph methods */
60static ng_constructor_t ng_netflow_constructor;
61static ng_rcvmsg_t ng_netflow_rcvmsg;
62static ng_close_t ng_netflow_close;
63static ng_shutdown_t ng_netflow_rmnode;
64static ng_newhook_t ng_netflow_newhook;
65static ng_rcvdata_t ng_netflow_rcvdata;
66static ng_disconnect_t ng_netflow_disconnect;
67
68/* Parse type for struct ng_netflow_info */
69static const struct ng_parse_struct_field ng_netflow_info_type_fields[]
70 = NG_NETFLOW_INFO_TYPE;
71static const struct ng_parse_type ng_netflow_info_type = {
72 &ng_parse_struct_type,
73 &ng_netflow_info_type_fields
74};
75
76/* Parse type for struct ng_netflow_ifinfo */
77static const struct ng_parse_struct_field ng_netflow_ifinfo_type_fields[]
78 = NG_NETFLOW_IFINFO_TYPE;
79static const struct ng_parse_type ng_netflow_ifinfo_type = {
80 &ng_parse_struct_type,
81 &ng_netflow_ifinfo_type_fields
82};
83
84/* Parse type for struct ng_netflow_setdlt */
85static const struct ng_parse_struct_field ng_netflow_setdlt_type_fields[]
86 = NG_NETFLOW_SETDLT_TYPE;
87static const struct ng_parse_type ng_netflow_setdlt_type = {
88 &ng_parse_struct_type,
89 &ng_netflow_setdlt_type_fields
90};
91
92/* Parse type for ng_netflow_setifindex */
93static const struct ng_parse_struct_field ng_netflow_setifindex_type_fields[]
94 = NG_NETFLOW_SETIFINDEX_TYPE;
95static const struct ng_parse_type ng_netflow_setifindex_type = {
96 &ng_parse_struct_type,
97 &ng_netflow_setifindex_type_fields
98};
99
100/* Parse type for ng_netflow_settimeouts */
101static const struct ng_parse_struct_field ng_netflow_settimeouts_type_fields[]
102 = NG_NETFLOW_SETTIMEOUTS_TYPE;
103static const struct ng_parse_type ng_netflow_settimeouts_type = {
104 &ng_parse_struct_type,
105 &ng_netflow_settimeouts_type_fields
106};
107
108/* List of commands and how to convert arguments to/from ASCII */
109static const struct ng_cmdlist ng_netflow_cmds[] = {
110 {
111 NGM_NETFLOW_COOKIE,
112 NGM_NETFLOW_INFO,
113 "info",
114 NULL,
115 &ng_netflow_info_type
116 },
117 {
118 NGM_NETFLOW_COOKIE,
119 NGM_NETFLOW_IFINFO,
120 "ifinfo",
121 &ng_parse_uint16_type,
122 &ng_netflow_ifinfo_type
123 },
124 {
125 NGM_NETFLOW_COOKIE,
126 NGM_NETFLOW_SETDLT,
127 "setdlt",
128 &ng_netflow_setdlt_type,
129 NULL
130 },
131 {
132 NGM_NETFLOW_COOKIE,
133 NGM_NETFLOW_SETIFINDEX,
134 "setifindex",
135 &ng_netflow_setifindex_type,
136 NULL
137 },
138 {
139 NGM_NETFLOW_COOKIE,
140 NGM_NETFLOW_SETTIMEOUTS,
141 "settimeouts",
142 &ng_netflow_settimeouts_type,
143 NULL
144 },
145 { 0 }
146};
147
148
149/* Netgraph node type descriptor */
150static struct ng_type ng_netflow_typestruct = {
151 .version = NG_ABI_VERSION,
152 .name = NG_NETFLOW_NODE_TYPE,
153 .constructor = ng_netflow_constructor,
154 .rcvmsg = ng_netflow_rcvmsg,
155 .close = ng_netflow_close,
156 .shutdown = ng_netflow_rmnode,
157 .newhook = ng_netflow_newhook,
158 .rcvdata = ng_netflow_rcvdata,
159 .disconnect = ng_netflow_disconnect,
160 .cmdlist = ng_netflow_cmds,
161};
162NETGRAPH_INIT(netflow, &ng_netflow_typestruct);
163
164/* Called at node creation */
165static int
166ng_netflow_constructor(node_p node)
167{
168 priv_p priv;
169 int error = 0;
170
171 /* Initialize private data */
fc025606 172 priv = kmalloc(sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK);
b06ebda0
MD
173 if (priv == NULL)
174 return (ENOMEM);
175 bzero(priv, sizeof(*priv));
176
177 /* Make node and its data point at each other */
178 NG_NODE_SET_PRIVATE(node, priv);
179 priv->node = node;
180
181 /* Initialize timeouts to default values */
182 priv->info.nfinfo_inact_t = INACTIVE_TIMEOUT;
183 priv->info.nfinfo_act_t = ACTIVE_TIMEOUT;
184
185 /* Initialize callout handle */
186 callout_init(&priv->exp_callout, CALLOUT_MPSAFE);
187
188 /* Allocate memory and set up flow cache */
189 if ((error = ng_netflow_cache_init(priv)))
190 return (error);
191
192 return (0);
193}
194
195/*
196 * ng_netflow supports two hooks: data and export.
197 * Incoming traffic is expected on data, and expired
198 * netflow datagrams are sent to export.
199 */
200static int
201ng_netflow_newhook(node_p node, hook_p hook, const char *name)
202{
203 const priv_p priv = NG_NODE_PRIVATE(node);
204
205 if (strncmp(name, NG_NETFLOW_HOOK_DATA, /* an iface hook? */
206 strlen(NG_NETFLOW_HOOK_DATA)) == 0) {
207 iface_p iface;
208 int ifnum = -1;
209 const char *cp;
210 char *eptr;
211
212 cp = name + strlen(NG_NETFLOW_HOOK_DATA);
213 if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0'))
214 return (EINVAL);
215
216 ifnum = (int)strtoul(cp, &eptr, 10);
217 if (*eptr != '\0' || ifnum < 0 || ifnum >= NG_NETFLOW_MAXIFACES)
218 return (EINVAL);
219
220 /* See if hook is already connected */
221 if (priv->ifaces[ifnum].hook != NULL)
222 return (EISCONN);
223
224 iface = &priv->ifaces[ifnum];
225
226 /* Link private info and hook together */
227 NG_HOOK_SET_PRIVATE(hook, iface);
228 iface->hook = hook;
229
230 /*
231 * In most cases traffic accounting is done on an
232 * Ethernet interface, so default data link type
233 * will be DLT_EN10MB.
234 */
235 iface->info.ifinfo_dlt = DLT_EN10MB;
236
237 } else if (strncmp(name, NG_NETFLOW_HOOK_OUT,
238 strlen(NG_NETFLOW_HOOK_OUT)) == 0) {
239 iface_p iface;
240 int ifnum = -1;
241 const char *cp;
242 char *eptr;
243
244 cp = name + strlen(NG_NETFLOW_HOOK_OUT);
245 if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0'))
246 return (EINVAL);
247
248 ifnum = (int)strtoul(cp, &eptr, 10);
249 if (*eptr != '\0' || ifnum < 0 || ifnum >= NG_NETFLOW_MAXIFACES)
250 return (EINVAL);
251
252 /* See if hook is already connected */
253 if (priv->ifaces[ifnum].out != NULL)
254 return (EISCONN);
255
256 iface = &priv->ifaces[ifnum];
257
258 /* Link private info and hook together */
259 NG_HOOK_SET_PRIVATE(hook, iface);
260 iface->out = hook;
261
262 } else if (strcmp(name, NG_NETFLOW_HOOK_EXPORT) == 0) {
263
264 if (priv->export != NULL)
265 return (EISCONN);
266
267 priv->export = hook;
268
269#if 0 /* TODO: profile & test first */
270 /*
271 * We send export dgrams in interrupt handlers and in
272 * callout threads. We'd better queue data for later
273 * netgraph ISR processing.
274 */
275 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook));
276#endif
277
278 /* Exporter is ready. Let's schedule expiry. */
279 callout_reset(&priv->exp_callout, (1*hz), &ng_netflow_expire,
280 (void *)priv);
281 } else
282 return (EINVAL);
283
284 return (0);
285}
286
287/* Get a netgraph control message. */
288static int
289ng_netflow_rcvmsg (node_p node, item_p item, hook_p lasthook)
290{
291 const priv_p priv = NG_NODE_PRIVATE(node);
292 struct ng_mesg *resp = NULL;
293 int error = 0;
294 struct ng_mesg *msg;
295
296 NGI_GET_MSG(item, msg);
297
298 /* Deal with message according to cookie and command */
299 switch (msg->header.typecookie) {
300 case NGM_NETFLOW_COOKIE:
301 switch (msg->header.cmd) {
302 case NGM_NETFLOW_INFO:
303 {
304 struct ng_netflow_info *i;
305
306 NG_MKRESPONSE(resp, msg, sizeof(struct ng_netflow_info),
5a975a3d 307 M_WAITOK | M_NULLOK);
b06ebda0
MD
308 i = (struct ng_netflow_info *)resp->data;
309 ng_netflow_copyinfo(priv, i);
310
311 break;
312 }
313 case NGM_NETFLOW_IFINFO:
314 {
315 struct ng_netflow_ifinfo *i;
316 const uint16_t *index;
317
318 if (msg->header.arglen != sizeof(uint16_t))
319 ERROUT(EINVAL);
320
321 index = (uint16_t *)msg->data;
322 if (*index >= NG_NETFLOW_MAXIFACES)
323 ERROUT(EINVAL);
324
325 /* connected iface? */
326 if (priv->ifaces[*index].hook == NULL)
327 ERROUT(EINVAL);
328
329 NG_MKRESPONSE(resp, msg,
5a975a3d 330 sizeof(struct ng_netflow_ifinfo), M_WAITOK | M_NULLOK);
b06ebda0
MD
331 i = (struct ng_netflow_ifinfo *)resp->data;
332 memcpy((void *)i, (void *)&priv->ifaces[*index].info,
333 sizeof(priv->ifaces[*index].info));
334
335 break;
336 }
337 case NGM_NETFLOW_SETDLT:
338 {
339 struct ng_netflow_setdlt *set;
340 struct ng_netflow_iface *iface;
341
342 if (msg->header.arglen != sizeof(struct ng_netflow_setdlt))
343 ERROUT(EINVAL);
344
345 set = (struct ng_netflow_setdlt *)msg->data;
346 if (set->iface >= NG_NETFLOW_MAXIFACES)
347 ERROUT(EINVAL);
348 iface = &priv->ifaces[set->iface];
349
350 /* connected iface? */
351 if (iface->hook == NULL)
352 ERROUT(EINVAL);
353
354 switch (set->dlt) {
355 case DLT_EN10MB:
356 iface->info.ifinfo_dlt = DLT_EN10MB;
357 break;
358 case DLT_RAW:
359 iface->info.ifinfo_dlt = DLT_RAW;
360 break;
361 default:
362 ERROUT(EINVAL);
363 }
364 break;
365 }
366 case NGM_NETFLOW_SETIFINDEX:
367 {
368 struct ng_netflow_setifindex *set;
369 struct ng_netflow_iface *iface;
370
371 if (msg->header.arglen != sizeof(struct ng_netflow_setifindex))
372 ERROUT(EINVAL);
373
374 set = (struct ng_netflow_setifindex *)msg->data;
375 if (set->iface >= NG_NETFLOW_MAXIFACES)
376 ERROUT(EINVAL);
377 iface = &priv->ifaces[set->iface];
378
379 /* connected iface? */
380 if (iface->hook == NULL)
381 ERROUT(EINVAL);
382
383 iface->info.ifinfo_index = set->index;
384
385 break;
386 }
387 case NGM_NETFLOW_SETTIMEOUTS:
388 {
389 struct ng_netflow_settimeouts *set;
390
391 if (msg->header.arglen != sizeof(struct ng_netflow_settimeouts))
392 ERROUT(EINVAL);
393
394 set = (struct ng_netflow_settimeouts *)msg->data;
395
396 priv->info.nfinfo_inact_t = set->inactive_timeout;
397 priv->info.nfinfo_act_t = set->active_timeout;
398
399 break;
400 }
401 case NGM_NETFLOW_SHOW:
402 {
403 uint32_t *last;
404
405 if (msg->header.arglen != sizeof(uint32_t))
406 ERROUT(EINVAL);
407
408 last = (uint32_t *)msg->data;
409
5a975a3d 410 NG_MKRESPONSE(resp, msg, NGRESP_SIZE, M_WAITOK | M_NULLOK);
b06ebda0
MD
411
412 if (!resp)
413 ERROUT(ENOMEM);
414
415 error = ng_netflow_flow_show(priv, *last, resp);
416
417 break;
418 }
419 default:
420 ERROUT(EINVAL); /* unknown command */
421 break;
422 }
423 break;
424 default:
425 ERROUT(EINVAL); /* incorrect cookie */
426 break;
427 }
428
429 /*
430 * Take care of synchronous response, if any.
431 * Free memory and return.
432 */
433done:
434 NG_RESPOND_MSG(error, node, item, resp);
435 NG_FREE_MSG(msg);
436
437 return (error);
438}
439
440/* Receive data on hook. */
441static int
442ng_netflow_rcvdata (hook_p hook, item_p item)
443{
444 const node_p node = NG_HOOK_NODE(hook);
445 const priv_p priv = NG_NODE_PRIVATE(node);
446 const iface_p iface = NG_HOOK_PRIVATE(hook);
447 struct mbuf *m = NULL;
448 struct ip *ip;
449 int pullup_len = 0;
450 int error = 0;
451
452 if (hook == priv->export) {
453 /*
454 * Data arrived on export hook.
455 * This must not happen.
456 */
457 log(LOG_ERR, "ng_netflow: incoming data on export hook!\n");
458 ERROUT(EINVAL);
459 };
460
461 if (hook == iface->out) {
462 /*
463 * Data arrived on out hook. Bypass it.
464 */
465 if (iface->hook == NULL)
466 ERROUT(ENOTCONN);
467
468 NG_FWD_ITEM_HOOK(error, item, iface->hook);
469 return (error);
470 }
471
472 NGI_GET_M(item, m);
473
474 /* Increase counters. */
475 iface->info.ifinfo_packets++;
476
477 /*
478 * Depending on interface data link type and packet contents
479 * we pullup enough data, so that ng_netflow_flow_add() does not
480 * need to know about mbuf at all. We keep current length of data
481 * needed to be contiguous in pullup_len. mtod() is done at the
482 * very end one more time, since m can had changed after pulluping.
483 *
484 * In case of unrecognized data we don't return error, but just
485 * pass data to downstream hook, if it is available.
486 */
487
488#define M_CHECK(length) do { \
489 pullup_len += length; \
490 if ((m)->m_pkthdr.len < (pullup_len)) { \
491 error = EINVAL; \
492 goto bypass; \
493 } \
494 if ((m)->m_len < (pullup_len) && \
495 (((m) = m_pullup((m),(pullup_len))) == NULL)) { \
496 error = ENOBUFS; \
497 goto done; \
498 } \
499} while (0)
500
501 switch (iface->info.ifinfo_dlt) {
502 case DLT_EN10MB: /* Ethernet */
503 {
504 struct ether_header *eh;
505 uint16_t etype;
506
507 M_CHECK(sizeof(struct ether_header));
508 eh = mtod(m, struct ether_header *);
509
510 /* Make sure this is IP frame. */
511 etype = ntohs(eh->ether_type);
512 switch (etype) {
513 case ETHERTYPE_IP:
514 M_CHECK(sizeof(struct ip));
515 eh = mtod(m, struct ether_header *);
516 ip = (struct ip *)(eh + 1);
517 break;
518 case ETHERTYPE_VLAN:
519 {
520 struct ether_vlan_header *evh;
521
522 M_CHECK(sizeof(struct ether_vlan_header) -
523 sizeof(struct ether_header));
524 evh = mtod(m, struct ether_vlan_header *);
525 if (ntohs(evh->evl_proto) == ETHERTYPE_IP) {
526 M_CHECK(sizeof(struct ip));
527 ip = (struct ip *)(evh + 1);
528 break;
529 }
530 }
531 default:
532 goto bypass; /* pass this frame */
533 }
534 break;
535 }
536 case DLT_RAW: /* IP packets */
537 M_CHECK(sizeof(struct ip));
538 ip = mtod(m, struct ip *);
539 break;
540 default:
541 goto bypass;
542 break;
543 }
544
545 if ((ip->ip_off & htons(IP_OFFMASK)) == 0) {
546 /*
547 * In case of IP header with options, we haven't pulled
548 * up enough, yet.
549 */
550 pullup_len += (ip->ip_hl << 2) - sizeof(struct ip);
551
552 switch (ip->ip_p) {
553 case IPPROTO_TCP:
554 M_CHECK(sizeof(struct tcphdr));
555 break;
556 case IPPROTO_UDP:
557 M_CHECK(sizeof(struct udphdr));
558 break;
559 }
560 }
561
562 switch (iface->info.ifinfo_dlt) {
563 case DLT_EN10MB:
564 {
565 struct ether_header *eh;
566
567 eh = mtod(m, struct ether_header *);
568 switch (ntohs(eh->ether_type)) {
569 case ETHERTYPE_IP:
570 ip = (struct ip *)(eh + 1);
571 break;
572 case ETHERTYPE_VLAN:
573 {
574 struct ether_vlan_header *evh;
575
576 evh = mtod(m, struct ether_vlan_header *);
577 ip = (struct ip *)(evh + 1);
578 break;
579 }
580 default:
581 panic("ng_netflow entered deadcode");
582 }
583 break;
584 }
585 case DLT_RAW:
586 ip = mtod(m, struct ip *);
587 break;
588 default:
589 panic("ng_netflow entered deadcode");
590 }
591
592#undef M_CHECK
593
594 error = ng_netflow_flow_add(priv, ip, iface, m->m_pkthdr.rcvif);
595
596bypass:
597 if (iface->out != NULL) {
598 /* XXX: error gets overwritten here */
599 NG_FWD_NEW_DATA(error, item, iface->out, m);
600 return (error);
601 }
602done:
603 if (item)
604 NG_FREE_ITEM(item);
605 if (m)
606 NG_FREE_M(m);
607
608 return (error);
609}
610
611/* We will be shut down in a moment */
612static int
613ng_netflow_close(node_p node)
614{
615 const priv_p priv = NG_NODE_PRIVATE(node);
616
617 callout_drain(&priv->exp_callout);
618 ng_netflow_cache_flush(priv);
619
620 return (0);
621}
622
623/* Do local shutdown processing. */
624static int
625ng_netflow_rmnode(node_p node)
626{
627 const priv_p priv = NG_NODE_PRIVATE(node);
628
629 NG_NODE_SET_PRIVATE(node, NULL);
630 NG_NODE_UNREF(priv->node);
631
fc025606 632 kfree(priv, M_NETGRAPH);
b06ebda0
MD
633
634 return (0);
635}
636
637/* Hook disconnection. */
638static int
639ng_netflow_disconnect(hook_p hook)
640{
641 node_p node = NG_HOOK_NODE(hook);
642 priv_p priv = NG_NODE_PRIVATE(node);
643 iface_p iface = NG_HOOK_PRIVATE(hook);
644
645 if (iface != NULL) {
646 if (iface->hook == hook)
647 iface->hook = NULL;
648 if (iface->out == hook)
649 iface->out = NULL;
650 }
651
652 /* if export hook disconnected stop running expire(). */
653 if (hook == priv->export) {
654 callout_drain(&priv->exp_callout);
655 priv->export = NULL;
656 }
657
658 /* Removal of the last link destroys the node. */
659 if (NG_NODE_NUMHOOKS(node) == 0)
660 ng_rmnode_self(node);
661
662 return (0);
663}