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.3 2003/08/07 21:17:31 dillon 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", __FUNCTION__));
 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