4dfef3f395bb19526784dfbb3f9ec37f47d858da
[dragonfly.git] / sys / netgraph / bpf / ng_bpf.c
1
2 /*
3  * ng_bpf.c
4  *
5  * Copyright (c) 1999 Whistle Communications, Inc.
6  * All rights reserved.
7  * 
8  * Subject to the following obligations and disclaimer of warranty, use and
9  * redistribution of this software, in source or object code forms, with or
10  * without modifications are expressly permitted by Whistle Communications;
11  * provided, however, that:
12  * 1. Any and all reproductions of the source or object code must include the
13  *    copyright notice above and the following disclaimer of warranties; and
14  * 2. No rights are granted, in any manner or form, to use Whistle
15  *    Communications, Inc. trademarks, including the mark "WHISTLE
16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
17  *    such appears in the above copyright notice or in the software.
18  * 
19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANBPF, OR MAKE ANY
25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
35  * OF SUCH DAMAGE.
36  *
37  * Author: Archie Cobbs <archie@freebsd.org>
38  *
39  * $FreeBSD: src/sys/netgraph/ng_bpf.c,v 1.2.4.4 2002/07/02 23:44:02 archie Exp $
40  * $DragonFly: src/sys/netgraph/bpf/ng_bpf.c,v 1.4 2005/02/17 13:59:59 joerg Exp $
41  * $Whistle: ng_bpf.c,v 1.3 1999/12/03 20:30:23 archie Exp $
42  */
43
44 /*
45  * BPF NETGRAPH NODE TYPE
46  *
47  * This node type accepts any number of hook connections.  With each hook
48  * is associated a bpf(4) filter program, and two hook names (each possibly
49  * the empty string).  Incoming packets are compared against the filter;
50  * matching packets are delivered out the first named hook (or dropped if
51  * the empty string), and non-matching packets are delivered out the second
52  * named hook (or dropped if the empty string).
53  *
54  * Each hook also keeps statistics about how many packets have matched, etc.
55  */
56
57 #include <sys/param.h>
58 #include <sys/systm.h>
59 #include <sys/errno.h>
60 #include <sys/kernel.h>
61 #include <sys/malloc.h>
62 #include <sys/mbuf.h>
63
64 #include <net/bpf.h>
65
66 #include <netgraph/ng_message.h>
67 #include <netgraph/netgraph.h>
68 #include <netgraph/ng_parse.h>
69 #include "ng_bpf.h"
70
71 #define OFFSETOF(s, e) ((char *)&((s *)0)->e - (char *)((s *)0))
72
73 #define ERROUT(x)       do { error = (x); goto done; } while (0)
74
75 /* Per hook private info */
76 struct ng_bpf_hookinfo {
77         node_p                  node;
78         hook_p                  hook;
79         struct ng_bpf_hookprog  *prog;
80         struct ng_bpf_hookstat  stats;
81 };
82 typedef struct ng_bpf_hookinfo *hinfo_p;
83
84 /* Netgraph methods */
85 static ng_constructor_t ng_bpf_constructor;
86 static ng_rcvmsg_t      ng_bpf_rcvmsg;
87 static ng_shutdown_t    ng_bpf_rmnode;
88 static ng_newhook_t     ng_bpf_newhook;
89 static ng_rcvdata_t     ng_bpf_rcvdata;
90 static ng_disconnect_t  ng_bpf_disconnect;
91
92 /* Internal helper functions */
93 static int      ng_bpf_setprog(hook_p hook, const struct ng_bpf_hookprog *hp);
94
95 /* Parse type for one struct bfp_insn */
96 static const struct ng_parse_struct_field ng_bpf_insn_type_fields[] = {
97         { "code",       &ng_parse_hint16_type   },
98         { "jt",         &ng_parse_uint8_type    },
99         { "jf",         &ng_parse_uint8_type    },
100         { "k",          &ng_parse_uint32_type   },
101         { NULL }
102 };
103 static const struct ng_parse_type ng_bpf_insn_type = {
104         &ng_parse_struct_type,
105         &ng_bpf_insn_type_fields
106 };
107
108 /* Parse type for the field 'bpf_prog' in struct ng_bpf_hookprog */
109 static int
110 ng_bpf_hookprogary_getLength(const struct ng_parse_type *type,
111         const u_char *start, const u_char *buf)
112 {
113         const struct ng_bpf_hookprog *hp;
114
115         hp = (const struct ng_bpf_hookprog *)
116             (buf - OFFSETOF(struct ng_bpf_hookprog, bpf_prog));
117         return hp->bpf_prog_len;
118 }
119
120 static const struct ng_parse_array_info ng_bpf_hookprogary_info = {
121         &ng_bpf_insn_type,
122         &ng_bpf_hookprogary_getLength,
123         NULL
124 };
125 static const struct ng_parse_type ng_bpf_hookprogary_type = {
126         &ng_parse_array_type,
127         &ng_bpf_hookprogary_info
128 };
129
130 /* Parse type for struct ng_bpf_hookprog */
131 static const struct ng_parse_struct_field ng_bpf_hookprog_type_fields[]
132         = NG_BPF_HOOKPROG_TYPE_INFO(&ng_bpf_hookprogary_type);
133 static const struct ng_parse_type ng_bpf_hookprog_type = {
134         &ng_parse_struct_type,
135         &ng_bpf_hookprog_type_fields
136 };
137
138 /* Parse type for struct ng_bpf_hookstat */
139 static const struct ng_parse_struct_field ng_bpf_hookstat_type_fields[]
140         = NG_BPF_HOOKSTAT_TYPE_INFO;
141 static const struct ng_parse_type ng_bpf_hookstat_type = {
142         &ng_parse_struct_type,
143         &ng_bpf_hookstat_type_fields
144 };
145
146 /* List of commands and how to convert arguments to/from ASCII */
147 static const struct ng_cmdlist ng_bpf_cmdlist[] = {
148         {
149           NGM_BPF_COOKIE,
150           NGM_BPF_SET_PROGRAM,
151           "setprogram",
152           &ng_bpf_hookprog_type,
153           NULL
154         },
155         {
156           NGM_BPF_COOKIE,
157           NGM_BPF_GET_PROGRAM,
158           "getprogram",
159           &ng_parse_hookbuf_type,
160           &ng_bpf_hookprog_type
161         },
162         {
163           NGM_BPF_COOKIE,
164           NGM_BPF_GET_STATS,
165           "getstats",
166           &ng_parse_hookbuf_type,
167           &ng_bpf_hookstat_type
168         },
169         {
170           NGM_BPF_COOKIE,
171           NGM_BPF_CLR_STATS,
172           "clrstats",
173           &ng_parse_hookbuf_type,
174           NULL
175         },
176         {
177           NGM_BPF_COOKIE,
178           NGM_BPF_GETCLR_STATS,
179           "getclrstats",
180           &ng_parse_hookbuf_type,
181           &ng_bpf_hookstat_type
182         },
183         { 0 }
184 };
185
186 /* Netgraph type descriptor */
187 static struct ng_type typestruct = {
188         NG_VERSION,
189         NG_BPF_NODE_TYPE,
190         NULL,
191         ng_bpf_constructor,
192         ng_bpf_rcvmsg,
193         ng_bpf_rmnode,
194         ng_bpf_newhook,
195         NULL,
196         NULL,
197         ng_bpf_rcvdata,
198         ng_bpf_rcvdata,
199         ng_bpf_disconnect,
200         ng_bpf_cmdlist
201 };
202 NETGRAPH_INIT(bpf, &typestruct);
203
204 /* Default BPF program for a hook that matches nothing */
205 static const struct ng_bpf_hookprog ng_bpf_default_prog = {
206         { '\0' },               /* to be filled in at hook creation time */
207         { '\0' },
208         { '\0' },
209         1,
210         { BPF_STMT(BPF_RET+BPF_K, 0) }
211 };
212
213 /*
214  * Node constructor
215  *
216  * We don't keep any per-node private data
217  */
218 static int
219 ng_bpf_constructor(node_p *nodep)
220 {
221         int error = 0;
222
223         if ((error = ng_make_node_common(&typestruct, nodep)))
224                 return (error);
225         (*nodep)->private = NULL;
226         return (0);
227 }
228
229 /*
230  * Add a hook
231  */
232 static int
233 ng_bpf_newhook(node_p node, hook_p hook, const char *name)
234 {
235         hinfo_p hip;
236         int error;
237
238         /* Create hook private structure */
239         MALLOC(hip, hinfo_p, sizeof(*hip), M_NETGRAPH, M_NOWAIT);
240         if (hip == NULL)
241                 return (ENOMEM);
242         bzero(hip, sizeof(*hip));
243         hip->hook = hook;
244         hook->private = hip;
245         hip->node = node;
246
247         /* Attach the default BPF program */
248         if ((error = ng_bpf_setprog(hook, &ng_bpf_default_prog)) != 0) {
249                 FREE(hip, M_NETGRAPH);
250                 hook->private = NULL;
251                 return (error);
252         }
253
254         /* Set hook name */
255         strncpy(hip->prog->thisHook, name, sizeof(hip->prog->thisHook) - 1);
256         hip->prog->thisHook[sizeof(hip->prog->thisHook) - 1] = '\0';
257         return (0);
258 }
259
260 /*
261  * Receive a control message
262  */
263 static int
264 ng_bpf_rcvmsg(node_p node, struct ng_mesg *msg, const char *retaddr,
265            struct ng_mesg **rptr)
266 {
267         struct ng_mesg *resp = NULL;
268         int error = 0;
269
270         switch (msg->header.typecookie) {
271         case NGM_BPF_COOKIE:
272                 switch (msg->header.cmd) {
273                 case NGM_BPF_SET_PROGRAM:
274                     {
275                         struct ng_bpf_hookprog *const
276                             hp = (struct ng_bpf_hookprog *)msg->data;
277                         hook_p hook;
278
279                         /* Sanity check */
280                         if (msg->header.arglen < sizeof(*hp)
281                             || msg->header.arglen
282                               != NG_BPF_HOOKPROG_SIZE(hp->bpf_prog_len))
283                                 ERROUT(EINVAL);
284
285                         /* Find hook */
286                         if ((hook = ng_findhook(node, hp->thisHook)) == NULL)
287                                 ERROUT(ENOENT);
288
289                         /* Set new program */
290                         if ((error = ng_bpf_setprog(hook, hp)) != 0)
291                                 ERROUT(error);
292                         break;
293                     }
294
295                 case NGM_BPF_GET_PROGRAM:
296                     {
297                         struct ng_bpf_hookprog *hp;
298                         hook_p hook;
299
300                         /* Sanity check */
301                         if (msg->header.arglen == 0)
302                                 ERROUT(EINVAL);
303                         msg->data[msg->header.arglen - 1] = '\0';
304
305                         /* Find hook */
306                         if ((hook = ng_findhook(node, msg->data)) == NULL)
307                                 ERROUT(ENOENT);
308
309                         /* Build response */
310                         hp = ((hinfo_p)hook->private)->prog;
311                         NG_MKRESPONSE(resp, msg,
312                             NG_BPF_HOOKPROG_SIZE(hp->bpf_prog_len), M_NOWAIT);
313                         if (resp == NULL)
314                                 ERROUT(ENOMEM);
315                         bcopy(hp, resp->data,
316                            NG_BPF_HOOKPROG_SIZE(hp->bpf_prog_len));
317                         break;
318                     }
319
320                 case NGM_BPF_GET_STATS:
321                 case NGM_BPF_CLR_STATS:
322                 case NGM_BPF_GETCLR_STATS:
323                     {
324                         struct ng_bpf_hookstat *stats;
325                         hook_p hook;
326
327                         /* Sanity check */
328                         if (msg->header.arglen == 0)
329                                 ERROUT(EINVAL);
330                         msg->data[msg->header.arglen - 1] = '\0';
331
332                         /* Find hook */
333                         if ((hook = ng_findhook(node, msg->data)) == NULL)
334                                 ERROUT(ENOENT);
335                         stats = &((hinfo_p)hook->private)->stats;
336
337                         /* Build response (if desired) */
338                         if (msg->header.cmd != NGM_BPF_CLR_STATS) {
339                                 NG_MKRESPONSE(resp,
340                                     msg, sizeof(*stats), M_NOWAIT);
341                                 if (resp == NULL)
342                                         ERROUT(ENOMEM);
343                                 bcopy(stats, resp->data, sizeof(*stats));
344                         }
345
346                         /* Clear stats (if desired) */
347                         if (msg->header.cmd != NGM_BPF_GET_STATS)
348                                 bzero(stats, sizeof(*stats));
349                         break;
350                     }
351
352                 default:
353                         error = EINVAL;
354                         break;
355                 }
356                 break;
357         default:
358                 error = EINVAL;
359                 break;
360         }
361         if (rptr)
362                 *rptr = resp;
363         else if (resp)
364                 FREE(resp, M_NETGRAPH);
365
366 done:
367         FREE(msg, M_NETGRAPH);
368         return (error);
369 }
370
371 /*
372  * Receive data on a hook
373  *
374  * Apply the filter, and then drop or forward packet as appropriate.
375  */
376 static int
377 ng_bpf_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
378 {
379         const hinfo_p hip = hook->private;
380         int totlen = m->m_pkthdr.len;
381         int needfree = 0, error = 0;
382         u_char *data, buf[256];
383         hinfo_p dhip;
384         hook_p dest;
385         u_int len;
386
387         /* Update stats on incoming hook */
388         hip->stats.recvFrames++;
389         hip->stats.recvOctets += totlen;
390
391         /* Need to put packet in contiguous memory for bpf */
392         if (m->m_next != NULL) {
393                 if (totlen > sizeof(buf)) {
394                         MALLOC(data, u_char *, totlen, M_NETGRAPH, M_NOWAIT);
395                         if (data == NULL) {
396                                 NG_FREE_DATA(m, meta);
397                                 return (ENOMEM);
398                         }
399                         needfree = 1;
400                 } else
401                         data = buf;
402                 m_copydata(m, 0, totlen, (caddr_t)data);
403         } else
404                 data = mtod(m, u_char *);
405
406         /* Run packet through filter */
407         len = bpf_filter(hip->prog->bpf_prog, data, totlen, totlen);
408         if (needfree)
409                 FREE(data, M_NETGRAPH);
410
411         /* See if we got a match and find destination hook */
412         if (len > 0) {
413
414                 /* Update stats */
415                 hip->stats.recvMatchFrames++;
416                 hip->stats.recvMatchOctets += totlen;
417
418                 /* Truncate packet length if required by the filter */
419                 if (len < totlen) {
420                         m_adj(m, -(totlen - len));
421                         totlen -= len;
422                 }
423                 dest = ng_findhook(hip->node, hip->prog->ifMatch);
424         } else
425                 dest = ng_findhook(hip->node, hip->prog->ifNotMatch);
426         if (dest == NULL) {
427                 NG_FREE_DATA(m, meta);
428                 return (0);
429         }
430
431         /* Deliver frame out destination hook */
432         dhip = (hinfo_p)dest->private;
433         dhip->stats.xmitOctets += totlen;
434         dhip->stats.xmitFrames++;
435         NG_SEND_DATA(error, dest, m, meta);
436         return (error);
437 }
438
439 /*
440  * Shutdown processing
441  */
442 static int
443 ng_bpf_rmnode(node_p node)
444 {
445         node->flags |= NG_INVALID;
446         ng_cutlinks(node);
447         ng_unname(node);
448         ng_unref(node);
449         return (0);
450 }
451
452 /*
453  * Hook disconnection
454  */
455 static int
456 ng_bpf_disconnect(hook_p hook)
457 {
458         const hinfo_p hip = hook->private;
459
460         KASSERT(hip != NULL, ("%s: null info", __func__));
461         FREE(hip->prog, M_NETGRAPH);
462         bzero(hip, sizeof(*hip));
463         FREE(hip, M_NETGRAPH);
464         hook->private = NULL;                   /* for good measure */
465         if (hook->node->numhooks == 0)
466                 ng_rmnode(hook->node);
467         return (0);
468 }
469
470 /************************************************************************
471                         HELPER STUFF
472  ************************************************************************/
473
474 /*
475  * Set the BPF program associated with a hook
476  */
477 static int
478 ng_bpf_setprog(hook_p hook, const struct ng_bpf_hookprog *hp0)
479 {
480         const hinfo_p hip = hook->private;
481         struct ng_bpf_hookprog *hp;
482         int size;
483
484         /* Check program for validity */
485         if (!bpf_validate(hp0->bpf_prog, hp0->bpf_prog_len))
486                 return (EINVAL);
487
488         /* Make a copy of the program */
489         size = NG_BPF_HOOKPROG_SIZE(hp0->bpf_prog_len);
490         MALLOC(hp, struct ng_bpf_hookprog *, size, M_NETGRAPH, M_NOWAIT);
491         if (hp == NULL)
492                 return (ENOMEM);
493         bcopy(hp0, hp, size);
494
495         /* Free previous program, if any, and assign new one */
496         if (hip->prog != NULL)
497                 FREE(hip->prog, M_NETGRAPH);
498         hip->prog = hp;
499         return (0);
500 }
501