The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netgraph/ng_tee.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 
    2 /*
    3  * ng_tee.c
    4  */
    5 
    6 /*-
    7  * Copyright (c) 1996-1999 Whistle Communications, Inc.
    8  * All rights reserved.
    9  * 
   10  * Subject to the following obligations and disclaimer of warranty, use and
   11  * redistribution of this software, in source or object code forms, with or
   12  * without modifications are expressly permitted by Whistle Communications;
   13  * provided, however, that:
   14  * 1. Any and all reproductions of the source or object code must include the
   15  *    copyright notice above and the following disclaimer of warranties; and
   16  * 2. No rights are granted, in any manner or form, to use Whistle
   17  *    Communications, Inc. trademarks, including the mark "WHISTLE
   18  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
   19  *    such appears in the above copyright notice or in the software.
   20  * 
   21  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
   22  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
   23  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
   24  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
   25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
   26  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
   27  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
   28  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
   29  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
   30  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
   31  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
   32  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
   33  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
   34  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   35  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   36  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
   37  * OF SUCH DAMAGE.
   38  *
   39  * Author: Julian Elischer <julian@freebsd.org>
   40  *
   41  * $FreeBSD: releng/6.2/sys/netgraph/ng_tee.c 147104 2005-06-07 12:22:13Z glebius $
   42  * $Whistle: ng_tee.c,v 1.18 1999/11/01 09:24:52 julian Exp $
   43  */
   44 
   45 /*
   46  * This node is like the tee(1) command and is useful for ``snooping.''
   47  * It has 4 hooks: left, right, left2right, and right2left. Data
   48  * entering from the right is passed to the left and duplicated on
   49  * right2left, and data entering from the left is passed to the right
   50  * and duplicated on left2right. Data entering from left2right is
   51  * sent to left, and data from right2left to right.
   52  */
   53 
   54 #include <sys/param.h>
   55 #include <sys/systm.h>
   56 #include <sys/errno.h>
   57 #include <sys/kernel.h>
   58 #include <sys/malloc.h>
   59 #include <sys/mbuf.h>
   60 #include <netgraph/ng_message.h>
   61 #include <netgraph/netgraph.h>
   62 #include <netgraph/ng_parse.h>
   63 #include <netgraph/ng_tee.h>
   64 
   65 /* Per hook info */
   66 struct hookinfo {
   67         hook_p                  hook;
   68         struct ng_tee_hookstat  stats;
   69 };
   70 
   71 /* Per node info */
   72 struct privdata {
   73         node_p                  node;
   74         struct hookinfo         left;
   75         struct hookinfo         right;
   76         struct hookinfo         left2right;
   77         struct hookinfo         right2left;
   78 };
   79 typedef struct privdata *sc_p;
   80 
   81 /* Netgraph methods */
   82 static ng_constructor_t ngt_constructor;
   83 static ng_rcvmsg_t      ngt_rcvmsg;
   84 static ng_close_t       ngt_close;
   85 static ng_shutdown_t    ngt_shutdown;
   86 static ng_newhook_t     ngt_newhook;
   87 static ng_rcvdata_t     ngt_rcvdata;
   88 static ng_disconnect_t  ngt_disconnect;
   89 
   90 /* Parse type for struct ng_tee_hookstat */
   91 static const struct ng_parse_struct_field ng_tee_hookstat_type_fields[]
   92         = NG_TEE_HOOKSTAT_INFO;
   93 static const struct ng_parse_type ng_tee_hookstat_type = {
   94         &ng_parse_struct_type,
   95         &ng_tee_hookstat_type_fields
   96 };
   97 
   98 /* Parse type for struct ng_tee_stats */
   99 static const struct ng_parse_struct_field ng_tee_stats_type_fields[]
  100         = NG_TEE_STATS_INFO(&ng_tee_hookstat_type);
  101 static const struct ng_parse_type ng_tee_stats_type = {
  102         &ng_parse_struct_type,
  103         &ng_tee_stats_type_fields
  104 };
  105 
  106 /* List of commands and how to convert arguments to/from ASCII */
  107 static const struct ng_cmdlist ng_tee_cmds[] = {
  108         {
  109           NGM_TEE_COOKIE,
  110           NGM_TEE_GET_STATS,
  111           "getstats",
  112           NULL,
  113           &ng_tee_stats_type
  114         },
  115         {
  116           NGM_TEE_COOKIE,
  117           NGM_TEE_CLR_STATS,
  118           "clrstats",
  119           NULL,
  120           NULL
  121         },
  122         {
  123           NGM_TEE_COOKIE,
  124           NGM_TEE_GETCLR_STATS,
  125           "getclrstats",
  126           NULL,
  127           &ng_tee_stats_type
  128         },
  129         { 0 }
  130 };
  131 
  132 /* Netgraph type descriptor */
  133 static struct ng_type ng_tee_typestruct = {
  134         .version =      NG_ABI_VERSION,
  135         .name =         NG_TEE_NODE_TYPE,
  136         .constructor =  ngt_constructor,
  137         .rcvmsg =       ngt_rcvmsg,
  138         .close =        ngt_close,
  139         .shutdown =     ngt_shutdown,
  140         .newhook =      ngt_newhook,
  141         .rcvdata =      ngt_rcvdata,
  142         .disconnect =   ngt_disconnect,
  143         .cmdlist =      ng_tee_cmds,
  144 };
  145 NETGRAPH_INIT(tee, &ng_tee_typestruct);
  146 
  147 /*
  148  * Node constructor
  149  */
  150 static int
  151 ngt_constructor(node_p node)
  152 {
  153         sc_p privdata;
  154 
  155         MALLOC(privdata, sc_p, sizeof(*privdata), M_NETGRAPH, M_NOWAIT|M_ZERO);
  156         if (privdata == NULL)
  157                 return (ENOMEM);
  158 
  159         NG_NODE_SET_PRIVATE(node, privdata);
  160         privdata->node = node;
  161         return (0);
  162 }
  163 
  164 /*
  165  * Add a hook
  166  */
  167 static int
  168 ngt_newhook(node_p node, hook_p hook, const char *name)
  169 {
  170         const sc_p sc = NG_NODE_PRIVATE(node);
  171 
  172         if (strcmp(name, NG_TEE_HOOK_RIGHT) == 0) {
  173                 sc->right.hook = hook;
  174                 bzero(&sc->right.stats, sizeof(sc->right.stats));
  175                 NG_HOOK_SET_PRIVATE(hook, &sc->right);
  176         } else if (strcmp(name, NG_TEE_HOOK_LEFT) == 0) {
  177                 sc->left.hook = hook;
  178                 bzero(&sc->left.stats, sizeof(sc->left.stats));
  179                 NG_HOOK_SET_PRIVATE(hook, &sc->left);
  180         } else if (strcmp(name, NG_TEE_HOOK_RIGHT2LEFT) == 0) {
  181                 sc->right2left.hook = hook;
  182                 bzero(&sc->right2left.stats, sizeof(sc->right2left.stats));
  183                 NG_HOOK_SET_PRIVATE(hook, &sc->right2left);
  184         } else if (strcmp(name, NG_TEE_HOOK_LEFT2RIGHT) == 0) {
  185                 sc->left2right.hook = hook;
  186                 bzero(&sc->left2right.stats, sizeof(sc->left2right.stats));
  187                 NG_HOOK_SET_PRIVATE(hook, &sc->left2right);
  188         } else
  189                 return (EINVAL);
  190         return (0);
  191 }
  192 
  193 /*
  194  * Receive a control message
  195  */
  196 static int
  197 ngt_rcvmsg(node_p node, item_p item, hook_p lasthook)
  198 {
  199         const sc_p sc = NG_NODE_PRIVATE(node);
  200         struct ng_mesg *resp = NULL;
  201         int error = 0;
  202         struct ng_mesg *msg;
  203 
  204         NGI_GET_MSG(item, msg);
  205         switch (msg->header.typecookie) {
  206         case NGM_TEE_COOKIE:
  207                 switch (msg->header.cmd) {
  208                 case NGM_TEE_GET_STATS:
  209                 case NGM_TEE_CLR_STATS:
  210                 case NGM_TEE_GETCLR_STATS:
  211                     {
  212                         struct ng_tee_stats *stats;
  213 
  214                         if (msg->header.cmd != NGM_TEE_CLR_STATS) {
  215                                 NG_MKRESPONSE(resp, msg,
  216                                     sizeof(*stats), M_NOWAIT);
  217                                 if (resp == NULL) {
  218                                         error = ENOMEM;
  219                                         goto done;
  220                                 }
  221                                 stats = (struct ng_tee_stats *)resp->data;
  222                                 bcopy(&sc->right.stats, &stats->right,
  223                                     sizeof(stats->right));
  224                                 bcopy(&sc->left.stats, &stats->left,
  225                                     sizeof(stats->left));
  226                                 bcopy(&sc->right2left.stats, &stats->right2left,
  227                                     sizeof(stats->right2left));
  228                                 bcopy(&sc->left2right.stats, &stats->left2right,
  229                                     sizeof(stats->left2right));
  230                         }
  231                         if (msg->header.cmd != NGM_TEE_GET_STATS) {
  232                                 bzero(&sc->right.stats,
  233                                     sizeof(sc->right.stats));
  234                                 bzero(&sc->left.stats,
  235                                     sizeof(sc->left.stats));
  236                                 bzero(&sc->right2left.stats,
  237                                     sizeof(sc->right2left.stats));
  238                                 bzero(&sc->left2right.stats,
  239                                     sizeof(sc->left2right.stats));
  240                         }
  241                         break;
  242                     }
  243                 default:
  244                         error = EINVAL;
  245                         break;
  246                 }
  247                 break;
  248         case NGM_FLOW_COOKIE:
  249                 if (lasthook)  {
  250                         if (lasthook == sc->left.hook) {
  251                                 if (sc->right.hook) {
  252                                         NGI_MSG(item) = msg;
  253                                         NG_FWD_ITEM_HOOK(error, item,
  254                                                         sc->right.hook);
  255                                         return (error);
  256                                 }
  257                         } else {
  258                                 if (sc->left.hook) {
  259                                         NGI_MSG(item) = msg;
  260                                         NG_FWD_ITEM_HOOK(error, item, 
  261                                                         sc->left.hook);
  262                                         return (error);
  263                                 }
  264                         }
  265                 }
  266                 break;
  267         default:
  268                 error = EINVAL;
  269                 break;
  270         }
  271 done:
  272         NG_RESPOND_MSG(error, node, item, resp);
  273         NG_FREE_MSG(msg);
  274         return (error);
  275 }
  276 
  277 /*
  278  * Receive data on a hook
  279  *
  280  * If data comes in the right link send a copy out right2left, and then
  281  * send the original onwards out through the left link.
  282  * Do the opposite for data coming in from the left link.
  283  * Data coming in right2left or left2right is forwarded
  284  * on through the appropriate destination hook as if it had come
  285  * from the other side.
  286  */
  287 static int
  288 ngt_rcvdata(hook_p hook, item_p item)
  289 {
  290         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  291         struct hookinfo *const hinfo = NG_HOOK_PRIVATE(hook);
  292         struct hookinfo *dest;
  293         struct hookinfo *dup;
  294         int error = 0;
  295         struct mbuf *m;
  296 
  297         m = NGI_M(item);
  298         /* Which hook? */
  299         if (hinfo == &sc->left) {
  300                 dup = &sc->left2right;
  301                 dest = &sc->right;
  302         } else if (hinfo == &sc->right) {
  303                 dup = &sc->right2left;
  304                 dest = &sc->left;
  305         } else if (hinfo == &sc->right2left) {
  306                 dup = NULL;
  307                 dest = &sc->right;
  308         } else if (hinfo == &sc->left2right) {
  309                 dup = NULL;
  310                 dest = &sc->left;
  311         } else {
  312                 panic("%s: no hook!", __func__);
  313 #ifdef  RESTARTABLE_PANICS
  314                 return(EINVAL);
  315 #endif
  316         }
  317 
  318         /* Update stats on incoming hook */
  319         hinfo->stats.inOctets += m->m_pkthdr.len;
  320         hinfo->stats.inFrames++;
  321 
  322         /*
  323          * Don't make a copy if only the dup hook exists.
  324          */
  325         if ((dup && dup->hook) && (dest->hook == NULL)) {
  326                 dest = dup;
  327                 dup = NULL;
  328         }
  329 
  330         /* Duplicate packet if requried */
  331         if (dup && dup->hook) {
  332                 struct mbuf *m2;
  333 
  334                 /* Copy packet (failure will not stop the original)*/
  335                 m2 = m_dup(m, M_DONTWAIT);
  336                 if (m2) {
  337                         /* Deliver duplicate */
  338                         NG_SEND_DATA_ONLY(error, dup->hook, m2);
  339                         if (error == 0) {
  340                                 dup->stats.outOctets += m->m_pkthdr.len;
  341                                 dup->stats.outFrames++;
  342                         }
  343                 }
  344         }
  345         /* Deliver frame out destination hook */
  346         if (dest->hook) {
  347                 dest->stats.outOctets += m->m_pkthdr.len;
  348                 dest->stats.outFrames++;
  349                 NG_FWD_ITEM_HOOK(error, item, dest->hook);
  350         } else
  351                 NG_FREE_ITEM(item);
  352         return (error);
  353 }
  354 
  355 /*
  356  * We are going to be shut down soon
  357  *
  358  * If we have both a left and right hook, then we probably want to extricate
  359  * ourselves and leave the two peers still linked to each other. Otherwise we
  360  * should just shut down as a normal node would.
  361  */
  362 static int
  363 ngt_close(node_p node)
  364 {
  365         const sc_p privdata = NG_NODE_PRIVATE(node);
  366 
  367         if (privdata->left.hook && privdata->right.hook)
  368                 ng_bypass(privdata->left.hook, privdata->right.hook);
  369 
  370         return (0);
  371 }
  372 
  373 /*
  374  * Shutdown processing
  375  */
  376 static int
  377 ngt_shutdown(node_p node)
  378 {
  379         const sc_p privdata = NG_NODE_PRIVATE(node);
  380 
  381         NG_NODE_SET_PRIVATE(node, NULL);
  382         NG_NODE_UNREF(privdata->node);
  383         FREE(privdata, M_NETGRAPH);
  384         return (0);
  385 }
  386 
  387 /*
  388  * Hook disconnection
  389  */
  390 static int
  391 ngt_disconnect(hook_p hook)
  392 {
  393         struct hookinfo *const hinfo = NG_HOOK_PRIVATE(hook);
  394 
  395         KASSERT(hinfo != NULL, ("%s: null info", __func__));
  396         hinfo->hook = NULL;
  397         if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
  398         && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
  399                 ng_rmnode_self(NG_HOOK_NODE(hook));
  400         return (0);
  401 }
  402 

Cache object: cf63453c87f41181b3a510465ea7281f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.