kernel/netgraph7: Replace usage of MALLOC/FREE with kmalloc/kfree here too.
[dragonfly.git] / sys / netgraph7 / ng_tag.c
CommitLineData
b06ebda0
MD
1/*-
2 * Copyright (c) 2006 Vadim Goncharov <vadimnuclight@tpu.ru>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
10 * 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 * Portions Copyright (c) 1999 Whistle Communications, Inc.
28 * (ng_bpf by Archie Cobbs <archie@freebsd.org>)
29 *
30 * $FreeBSD: src/sys/netgraph/ng_tag.c,v 1.1 2006/06/27 12:45:28 glebius Exp $
5a975a3d 31 * $DragonFly: src/sys/netgraph7/ng_tag.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
b06ebda0
MD
32 */
33
34/*
35 * TAG NETGRAPH NODE TYPE
36 *
37 * This node type accepts an arbitrary number of hooks. Each hook can be
38 * configured for an mbuf_tags(9) definition and two hook names: a hook
39 * for matched packets, and a hook for packets, that didn't match. Incoming
40 * packets are examined for configured tag, matched packets are delivered
41 * out via first hook, and not matched out via second. If corresponding hook
42 * is not configured, packets are dropped.
43 *
44 * A hook can also have an outgoing tag definition configured, so that
45 * all packets leaving the hook will be unconditionally appended with newly
46 * allocated tag.
47 *
48 * Both hooks can be set to null tag definitions (that is, with zeroed
49 * fields), so that packet tags are unmodified on output or all packets
50 * are unconditionally forwarded to non-matching hook on input. There is
51 * also a possibility to replace tags by specifying strip flag on input
52 * and replacing tag on corresponding output tag (or simply remove tag if
53 * no tag specified on output).
54 *
55 * If compiled with NG_TAG_DEBUG, each hook also keeps statistics about
56 * how many packets have matched, etc.
57 */
58
59#include <sys/param.h>
60#include <sys/systm.h>
61#include <sys/errno.h>
62#include <sys/kernel.h>
63#include <sys/malloc.h>
64#include <sys/mbuf.h>
65#include <sys/stddef.h>
66
5a975a3d
MD
67#include "ng_message.h"
68#include "netgraph.h"
69#include "ng_parse.h"
70#include "ng_tag.h"
b06ebda0
MD
71
72#ifdef NG_SEPARATE_MALLOC
73MALLOC_DEFINE(M_NETGRAPH_TAG, "netgraph_tag", "netgraph tag node ");
74#else
75#define M_NETGRAPH_TAG M_NETGRAPH
76#endif
77
78#define ERROUT(x) do { error = (x); goto done; } while (0)
79
80/*
81 * Per hook private info.
82 *
83 * We've separated API and ABI here, to make easier changes in this node,
84 * if needed. If you want to change representation, please do not break API.
85 * We still keep API structures in memory to simplify access to them for
86 * GET* messages, but most of data is accessed in internal representation
87 * only. The reason for this is to speed things up - if data will be
88 * accessed from API structures, there would be double pointer dereferencing
89 * in the code, which almost necessarily leads to CPU cache misses and
90 * reloads.
91 *
92 * We also do another optimization by using resolved pointers to
93 * destination hooks instead of expensive ng_findhook().
94 */
95struct ng_tag_hookinfo {
96 hook_p hi_match; /* matching hook pointer */
97 hook_p hi_nonmatch; /* non-matching hook pointer */
98 uint32_t in_tag_cookie;
99 uint32_t out_tag_cookie;
100 uint16_t in_tag_id;
101 uint16_t in_tag_len;
102 uint16_t out_tag_id;
103 uint16_t out_tag_len;
104 uint8_t strip;
105 void *in_tag_data;
106 void *out_tag_data;
107 struct ng_tag_hookin *in;
108 struct ng_tag_hookout *out;
109#ifdef NG_TAG_DEBUG
110 struct ng_tag_hookstat stats;
111#endif
112};
113typedef struct ng_tag_hookinfo *hinfo_p;
114
115/* Netgraph methods. */
116static ng_constructor_t ng_tag_constructor;
117static ng_rcvmsg_t ng_tag_rcvmsg;
118static ng_shutdown_t ng_tag_shutdown;
119static ng_newhook_t ng_tag_newhook;
120static ng_rcvdata_t ng_tag_rcvdata;
121static ng_disconnect_t ng_tag_disconnect;
122
123/* Internal helper functions. */
124static int ng_tag_setdata_in(hook_p hook, const struct ng_tag_hookin *hp);
125static int ng_tag_setdata_out(hook_p hook, const struct ng_tag_hookout *hp);
126
127/* Parse types for the field 'tag_data' in structs ng_tag_hookin and out. */
128static int
129ng_tag_hookinary_getLength(const struct ng_parse_type *type,
130 const u_char *start, const u_char *buf)
131{
132 const struct ng_tag_hookin *hp;
133
134 hp = (const struct ng_tag_hookin *)
135 (buf - offsetof(struct ng_tag_hookin, tag_data));
136 return (hp->tag_len);
137}
138
139static int
140ng_tag_hookoutary_getLength(const struct ng_parse_type *type,
141 const u_char *start, const u_char *buf)
142{
143 const struct ng_tag_hookout *hp;
144
145 hp = (const struct ng_tag_hookout *)
146 (buf - offsetof(struct ng_tag_hookout, tag_data));
147 return (hp->tag_len);
148}
149
150static const struct ng_parse_type ng_tag_hookinary_type = {
151 &ng_parse_bytearray_type,
152 &ng_tag_hookinary_getLength
153};
154
155static const struct ng_parse_type ng_tag_hookoutary_type = {
156 &ng_parse_bytearray_type,
157 &ng_tag_hookoutary_getLength
158};
159
160/* Parse type for struct ng_tag_hookin. */
161static const struct ng_parse_struct_field ng_tag_hookin_type_fields[]
162 = NG_TAG_HOOKIN_TYPE_INFO(&ng_tag_hookinary_type);
163static const struct ng_parse_type ng_tag_hookin_type = {
164 &ng_parse_struct_type,
165 &ng_tag_hookin_type_fields
166};
167
168/* Parse type for struct ng_tag_hookout. */
169static const struct ng_parse_struct_field ng_tag_hookout_type_fields[]
170 = NG_TAG_HOOKOUT_TYPE_INFO(&ng_tag_hookoutary_type);
171static const struct ng_parse_type ng_tag_hookout_type = {
172 &ng_parse_struct_type,
173 &ng_tag_hookout_type_fields
174};
175
176#ifdef NG_TAG_DEBUG
177/* Parse type for struct ng_tag_hookstat. */
178static const struct ng_parse_struct_field ng_tag_hookstat_type_fields[]
179 = NG_TAG_HOOKSTAT_TYPE_INFO;
180static const struct ng_parse_type ng_tag_hookstat_type = {
181 &ng_parse_struct_type,
182 &ng_tag_hookstat_type_fields
183};
184#endif
185
186/* List of commands and how to convert arguments to/from ASCII. */
187static const struct ng_cmdlist ng_tag_cmdlist[] = {
188 {
189 NGM_TAG_COOKIE,
190 NGM_TAG_SET_HOOKIN,
191 "sethookin",
192 &ng_tag_hookin_type,
193 NULL
194 },
195 {
196 NGM_TAG_COOKIE,
197 NGM_TAG_GET_HOOKIN,
198 "gethookin",
199 &ng_parse_hookbuf_type,
200 &ng_tag_hookin_type
201 },
202 {
203 NGM_TAG_COOKIE,
204 NGM_TAG_SET_HOOKOUT,
205 "sethookout",
206 &ng_tag_hookout_type,
207 NULL
208 },
209 {
210 NGM_TAG_COOKIE,
211 NGM_TAG_GET_HOOKOUT,
212 "gethookout",
213 &ng_parse_hookbuf_type,
214 &ng_tag_hookout_type
215 },
216#ifdef NG_TAG_DEBUG
217 {
218 NGM_TAG_COOKIE,
219 NGM_TAG_GET_STATS,
220 "getstats",
221 &ng_parse_hookbuf_type,
222 &ng_tag_hookstat_type
223 },
224 {
225 NGM_TAG_COOKIE,
226 NGM_TAG_CLR_STATS,
227 "clrstats",
228 &ng_parse_hookbuf_type,
229 NULL
230 },
231 {
232 NGM_TAG_COOKIE,
233 NGM_TAG_GETCLR_STATS,
234 "getclrstats",
235 &ng_parse_hookbuf_type,
236 &ng_tag_hookstat_type
237 },
238#endif
239 { 0 }
240};
241
242/* Netgraph type descriptor. */
243static struct ng_type typestruct = {
244 .version = NG_ABI_VERSION,
245 .name = NG_TAG_NODE_TYPE,
246 .constructor = ng_tag_constructor,
247 .rcvmsg = ng_tag_rcvmsg,
248 .shutdown = ng_tag_shutdown,
249 .newhook = ng_tag_newhook,
250 .rcvdata = ng_tag_rcvdata,
251 .disconnect = ng_tag_disconnect,
252 .cmdlist = ng_tag_cmdlist,
253};
254NETGRAPH_INIT(tag, &typestruct);
255
256/*
257 * This are default API structures (initialized to zeroes) which are
258 * returned in response to GET* messages when no configuration was made.
259 * One could ask why to have this structures at all when we have
260 * ng_tag_hookinfo initialized to zero and don't need in and out structures
261 * at all to operate. Unfortunatelly, we have to return thisHook field
262 * in response to messages so the fastest and simpliest way is to have
263 * this default structures and initialize thisHook once at hook creation
264 * rather than to do it on every response.
265 */
266
267/* Default tag values for a hook that matches nothing. */
268static const struct ng_tag_hookin ng_tag_default_in = {
269 { '\0' }, /* to be filled in at hook creation time */
270 { '\0' },
271 { '\0' },
272 0,
273 0,
274 0,
275 0
276};
277
278/* Default tag values for a hook that adds nothing */
279static const struct ng_tag_hookout ng_tag_default_out = {
280 { '\0' }, /* to be filled in at hook creation time */
281 0,
282 0,
283 0
284};
285
286/*
287 * Node constructor.
288 *
289 * We don't keep any per-node private data - we do it on per-hook basis.
290 */
291static int
292ng_tag_constructor(node_p node)
293{
294 return (0);
295}
296
297/*
298 * Add a hook.
299 */
300static int
301ng_tag_newhook(node_p node, hook_p hook, const char *name)
302{
303 hinfo_p hip;
304 int error;
305
306 /* Create hook private structure. */
fc025606 307 hip = kmalloc(sizeof(*hip), M_NETGRAPH_TAG, M_WAITOK | M_ZERO);
b06ebda0
MD
308 /* M_WAITOK can't return NULL. */
309 NG_HOOK_SET_PRIVATE(hook, hip);
310
311 /*
312 * After M_ZERO both in and out hook pointers are set to NULL,
313 * as well as all members and pointers to in and out API
314 * structures, so we need to set explicitly only thisHook field
315 * in that structures (after allocating them, of course).
316 */
317
318 /* Attach the default IN data. */
319 if ((error = ng_tag_setdata_in(hook, &ng_tag_default_in)) != 0) {
fc025606 320 kfree(hip, M_NETGRAPH_TAG);
b06ebda0
MD
321 return (error);
322 }
323
324 /* Attach the default OUT data. */
325 if ((error = ng_tag_setdata_out(hook, &ng_tag_default_out)) != 0) {
fc025606 326 kfree(hip, M_NETGRAPH_TAG);
b06ebda0
MD
327 return (error);
328 }
329
330 /*
331 * Set hook name. This is done only once at hook creation time
332 * since hook name can't change, rather than to do it on every
333 * response to messages requesting API structures with data who
334 * we are etc.
335 */
336 strncpy(hip->in->thisHook, name, sizeof(hip->in->thisHook) - 1);
337 hip->in->thisHook[sizeof(hip->in->thisHook) - 1] = '\0';
338 strncpy(hip->out->thisHook, name, sizeof(hip->out->thisHook) - 1);
339 hip->out->thisHook[sizeof(hip->out->thisHook) - 1] = '\0';
340 return (0);
341}
342
343/*
344 * Receive a control message.
345 */
346static int
347ng_tag_rcvmsg(node_p node, item_p item, hook_p lasthook)
348{
349 struct ng_mesg *msg;
350 struct ng_mesg *resp = NULL;
351 int error = 0;
352
353 NGI_GET_MSG(item, msg);
354 switch (msg->header.typecookie) {
355 case NGM_TAG_COOKIE:
356 switch (msg->header.cmd) {
357 case NGM_TAG_SET_HOOKIN:
358 {
359 struct ng_tag_hookin *const
360 hp = (struct ng_tag_hookin *)msg->data;
361 hook_p hook;
362
363 /* Sanity check. */
364 if (msg->header.arglen < sizeof(*hp)
365 || msg->header.arglen !=
366 NG_TAG_HOOKIN_SIZE(hp->tag_len))
367 ERROUT(EINVAL);
368
369 /* Find hook. */
370 if ((hook = ng_findhook(node, hp->thisHook)) == NULL)
371 ERROUT(ENOENT);
372
373 /* Set new tag values. */
374 if ((error = ng_tag_setdata_in(hook, hp)) != 0)
375 ERROUT(error);
376 break;
377 }
378
379 case NGM_TAG_SET_HOOKOUT:
380 {
381 struct ng_tag_hookout *const
382 hp = (struct ng_tag_hookout *)msg->data;
383 hook_p hook;
384
385 /* Sanity check. */
386 if (msg->header.arglen < sizeof(*hp)
387 || msg->header.arglen !=
388 NG_TAG_HOOKOUT_SIZE(hp->tag_len))
389 ERROUT(EINVAL);
390
391 /* Find hook. */
392 if ((hook = ng_findhook(node, hp->thisHook)) == NULL)
393 ERROUT(ENOENT);
394
395 /* Set new tag values. */
396 if ((error = ng_tag_setdata_out(hook, hp)) != 0)
397 ERROUT(error);
398 break;
399 }
400
401 case NGM_TAG_GET_HOOKIN:
402 {
403 struct ng_tag_hookin *hp;
404 hook_p hook;
405
406 /* Sanity check. */
407 if (msg->header.arglen == 0)
408 ERROUT(EINVAL);
409 msg->data[msg->header.arglen - 1] = '\0';
410
411 /* Find hook. */
412 if ((hook = ng_findhook(node, msg->data)) == NULL)
413 ERROUT(ENOENT);
414
415 /* Build response. */
416 hp = ((hinfo_p)NG_HOOK_PRIVATE(hook))->in;
417 NG_MKRESPONSE(resp, msg,
418 NG_TAG_HOOKIN_SIZE(hp->tag_len), M_WAITOK);
419 /* M_WAITOK can't return NULL. */
420 bcopy(hp, resp->data,
421 NG_TAG_HOOKIN_SIZE(hp->tag_len));
422 break;
423 }
424
425 case NGM_TAG_GET_HOOKOUT:
426 {
427 struct ng_tag_hookout *hp;
428 hook_p hook;
429
430 /* Sanity check. */
431 if (msg->header.arglen == 0)
432 ERROUT(EINVAL);
433 msg->data[msg->header.arglen - 1] = '\0';
434
435 /* Find hook. */
436 if ((hook = ng_findhook(node, msg->data)) == NULL)
437 ERROUT(ENOENT);
438
439 /* Build response. */
440 hp = ((hinfo_p)NG_HOOK_PRIVATE(hook))->out;
441 NG_MKRESPONSE(resp, msg,
442 NG_TAG_HOOKOUT_SIZE(hp->tag_len), M_WAITOK);
443 /* M_WAITOK can't return NULL. */
444 bcopy(hp, resp->data,
445 NG_TAG_HOOKOUT_SIZE(hp->tag_len));
446 break;
447 }
448
449#ifdef NG_TAG_DEBUG
450 case NGM_TAG_GET_STATS:
451 case NGM_TAG_CLR_STATS:
452 case NGM_TAG_GETCLR_STATS:
453 {
454 struct ng_tag_hookstat *stats;
455 hook_p hook;
456
457 /* Sanity check. */
458 if (msg->header.arglen == 0)
459 ERROUT(EINVAL);
460 msg->data[msg->header.arglen - 1] = '\0';
461
462 /* Find hook. */
463 if ((hook = ng_findhook(node, msg->data)) == NULL)
464 ERROUT(ENOENT);
465 stats = &((hinfo_p)NG_HOOK_PRIVATE(hook))->stats;
466
467 /* Build response (if desired). */
468 if (msg->header.cmd != NGM_TAG_CLR_STATS) {
469 NG_MKRESPONSE(resp,
470 msg, sizeof(*stats), M_WAITOK);
471 /* M_WAITOK can't return NULL. */
472 bcopy(stats, resp->data, sizeof(*stats));
473 }
474
475 /* Clear stats (if desired). */
476 if (msg->header.cmd != NGM_TAG_GET_STATS)
477 bzero(stats, sizeof(*stats));
478 break;
479 }
480#endif /* NG_TAG_DEBUG */
481
482 default:
483 error = EINVAL;
484 break;
485 }
486 break;
487 default:
488 error = EINVAL;
489 break;
490 }
491done:
492 NG_RESPOND_MSG(error, node, item, resp);
493 NG_FREE_MSG(msg);
494 return (error);
495}
496
497/*
498 * Receive data on a hook.
499 *
500 * Apply the filter, and then drop or forward packet as appropriate.
501 */
502static int
503ng_tag_rcvdata(hook_p hook, item_p item)
504{
505 struct mbuf *m;
506 struct m_tag *tag = NULL;
507 const hinfo_p hip = NG_HOOK_PRIVATE(hook);
508 uint16_t type, tag_len;
509 uint32_t cookie;
510 hinfo_p dhip;
511 hook_p dest;
512 int totlen;
513 int found = 0, error = 0;
514
515 m = NGI_M(item); /* 'item' still owns it.. we are peeking */
516 totlen = m->m_pkthdr.len;
517
518#ifdef NG_TAG_DEBUG
519 hip->stats.recvFrames++;
520 hip->stats.recvOctets += totlen;
521#endif
522
523 /* Looking up incoming tag. */
524 cookie = hip->in_tag_cookie;
525 type = hip->in_tag_id;
526 tag_len = hip->in_tag_len;
527
528 /*
529 * We treat case of all zeroes specially (that is, cookie and
530 * type are equal to zero), as we assume that such tag
531 * can never occur in the wild. So we don't waste time trying
532 * to find such tag (for example, these are zeroes after hook
533 * creation in default structures).
534 */
535 if ((cookie != 0) || (type != 0)) {
536 tag = m_tag_locate(m, cookie, type, NULL);
537 while (tag != NULL) {
538 if (memcmp((void *)(tag + 1),
539 hip->in_tag_data, tag_len) == 0) {
540 found = 1;
541 break;
542 }
543 tag = m_tag_locate(m, cookie, type, tag);
544 }
545 }
546
547 /* See if we got a match and find destination hook. */
548 if (found) {
549#ifdef NG_TAG_DEBUG
550 hip->stats.recvMatchFrames++;
551 hip->stats.recvMatchOctets += totlen;
552#endif
553 if (hip->strip)
554 m_tag_delete(m, tag);
555 dest = hip->hi_match;
556 } else
557 dest = hip->hi_nonmatch;
558 if (dest == NULL) {
559 NG_FREE_ITEM(item);
560 return (0);
561 }
562
563 /* Deliver frame out destination hook. */
564 dhip = NG_HOOK_PRIVATE(dest);
565
566#ifdef NG_TAG_DEBUG
567 dhip->stats.xmitOctets += totlen;
568 dhip->stats.xmitFrames++;
569#endif
570
571 cookie = dhip->out_tag_cookie;
572 type = dhip->out_tag_id;
573 tag_len = dhip->out_tag_len;
574
575 if ((cookie != 0) || (type != 0)) {
5a975a3d 576 tag = m_tag_alloc(cookie, type, tag_len, MB_DONTWAIT);
b06ebda0
MD
577 /* XXX may be free the mbuf if tag allocation failed? */
578 if (tag != NULL) {
579 if (tag_len != 0) {
580 /* copy tag data to its place */
581 memcpy((void *)(tag + 1),
582 dhip->out_tag_data, tag_len);
583 }
584 m_tag_prepend(m, tag);
585 }
586 }
587
588 NG_FWD_ITEM_HOOK(error, item, dest);
589 return (error);
590}
591
592/*
593 * Shutdown processing.
594 */
595static int
596ng_tag_shutdown(node_p node)
597{
598 NG_NODE_UNREF(node);
599 return (0);
600}
601
602/*
603 * Hook disconnection.
604 *
605 * We must check all hooks, since they may reference this one.
606 */
607static int
608ng_tag_disconnect(hook_p hook)
609{
610 const hinfo_p hip = NG_HOOK_PRIVATE(hook);
611 node_p node = NG_HOOK_NODE(hook);
612 hook_p hook2;
613
614 KASSERT(hip != NULL, ("%s: null info", __func__));
615
616 LIST_FOREACH(hook2, &node->nd_hooks, hk_hooks) {
617 hinfo_p priv = NG_HOOK_PRIVATE(hook2);
618
619 if (priv->hi_match == hook)
620 priv->hi_match = NULL;
621 if (priv->hi_nonmatch == hook)
622 priv->hi_nonmatch = NULL;
623 }
624
fc025606
SW
625 kfree(hip->in, M_NETGRAPH_TAG);
626 kfree(hip->out, M_NETGRAPH_TAG);
627 kfree(hip, M_NETGRAPH_TAG);
b06ebda0
MD
628 NG_HOOK_SET_PRIVATE(hook, NULL); /* for good measure */
629 if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) &&
630 (NG_NODE_IS_VALID(NG_HOOK_NODE(hook)))) {
631 ng_rmnode_self(NG_HOOK_NODE(hook));
632 }
633 return (0);
634}
635
636/************************************************************************
637 HELPER STUFF
638 ************************************************************************/
639
640/*
641 * Set the IN tag values associated with a hook.
642 */
643static int
644ng_tag_setdata_in(hook_p hook, const struct ng_tag_hookin *hp0)
645{
646 const hinfo_p hip = NG_HOOK_PRIVATE(hook);
647 struct ng_tag_hookin *hp;
648 int size;
649
650 /* Make a copy of the tag values and data. */
651 size = NG_TAG_HOOKIN_SIZE(hp0->tag_len);
fc025606 652 hp = kmalloc(size, M_NETGRAPH_TAG, M_WAITOK);
b06ebda0
MD
653 /* M_WAITOK can't return NULL. */
654 bcopy(hp0, hp, size);
655
656 /* Free previous tag, if any, and assign new one. */
657 if (hip->in != NULL)
fc025606 658 kfree(hip->in, M_NETGRAPH_TAG);
b06ebda0
MD
659 hip->in = hp;
660
661 /*
662 * Resolve hook names to pointers.
663 *
664 * As ng_findhook() is expensive operation to do it on every packet
665 * after tag matching check, we do it here and use resolved pointers
666 * where appropriate.
667 *
668 * XXX The drawback is that user can configure a hook to use
669 * ifMatch/ifNotMatch hooks that do not yet exist and will be added
670 * by user later, so that resolved pointers will be NULL even
671 * if the hook already exists, causing node to drop packets and
672 * user to report bugs. We could do check for this situation on
673 * every hook creation with pointers correction, but that involves
674 * re-resolving for all pointers in all hooks, up to O(n^2) operations,
675 * so we better document this in man page for user not to do
676 * configuration before creating all hooks.
677 */
678 hip->hi_match = ng_findhook(NG_HOOK_NODE(hook), hip->in->ifMatch);
679 hip->hi_nonmatch = ng_findhook(NG_HOOK_NODE(hook), hip->in->ifNotMatch);
680
681 /* Fill internal values from API structures. */
682 hip->in_tag_cookie = hip->in->tag_cookie;
683 hip->in_tag_id = hip->in->tag_id;
684 hip->in_tag_len = hip->in->tag_len;
685 hip->strip = hip->in->strip;
686 hip->in_tag_data = (void*)(hip->in->tag_data);
687 return (0);
688}
689
690/*
691 * Set the OUT tag values associated with a hook.
692 */
693static int
694ng_tag_setdata_out(hook_p hook, const struct ng_tag_hookout *hp0)
695{
696 const hinfo_p hip = NG_HOOK_PRIVATE(hook);
697 struct ng_tag_hookout *hp;
698 int size;
699
700 /* Make a copy of the tag values and data. */
701 size = NG_TAG_HOOKOUT_SIZE(hp0->tag_len);
fc025606 702 hp = kmalloc(size, M_NETGRAPH_TAG, M_WAITOK);
b06ebda0
MD
703 /* M_WAITOK can't return NULL. */
704 bcopy(hp0, hp, size);
705
706 /* Free previous tag, if any, and assign new one. */
707 if (hip->out != NULL)
fc025606 708 kfree(hip->out, M_NETGRAPH_TAG);
b06ebda0
MD
709 hip->out = hp;
710
711 /* Fill internal values from API structures. */
712 hip->out_tag_cookie = hip->out->tag_cookie;
713 hip->out_tag_id = hip->out->tag_id;
714 hip->out_tag_len = hip->out->tag_len;
715 hip->out_tag_data = (void*)(hip->out->tag_data);
716 return (0);
717}
718