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_ether.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_ether.c
    4  */
    5 
    6 /*-
    7  * Copyright (c) 1996-2000 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  * Authors: Archie Cobbs <archie@freebsd.org>
   40  *          Julian Elischer <julian@freebsd.org>
   41  *
   42  * $FreeBSD: releng/6.3/sys/netgraph/ng_ether.c 161879 2006-09-02 12:34:08Z glebius $
   43  */
   44 
   45 /*
   46  * ng_ether(4) netgraph node type
   47  */
   48 
   49 #include <sys/param.h>
   50 #include <sys/systm.h>
   51 #include <sys/kernel.h>
   52 #include <sys/malloc.h>
   53 #include <sys/mbuf.h>
   54 #include <sys/errno.h>
   55 #include <sys/syslog.h>
   56 #include <sys/socket.h>
   57 
   58 #include <net/bridge.h>
   59 #include <net/if.h>
   60 #include <net/if_dl.h>
   61 #include <net/if_types.h>
   62 #include <net/if_arp.h>
   63 #include <net/if_var.h>
   64 #include <net/ethernet.h>
   65 #include <net/if_bridgevar.h>
   66 
   67 #include <netgraph/ng_message.h>
   68 #include <netgraph/netgraph.h>
   69 #include <netgraph/ng_parse.h>
   70 #include <netgraph/ng_ether.h>
   71 
   72 #define IFP2NG(ifp)  (IFP2AC((ifp))->ac_netgraph)
   73 
   74 /* Per-node private data */
   75 struct private {
   76         struct ifnet    *ifp;           /* associated interface */
   77         hook_p          upper;          /* upper hook connection */
   78         hook_p          lower;          /* lower hook connection */
   79         hook_p          orphan;         /* orphan hook connection */
   80         u_char          autoSrcAddr;    /* always overwrite source address */
   81         u_char          promisc;        /* promiscuous mode enabled */
   82         u_long          hwassist;       /* hardware checksum capabilities */
   83         u_int           flags;          /* flags e.g. really die */
   84 };
   85 typedef struct private *priv_p;
   86 
   87 /* Hook pointers used by if_ethersubr.c to callback to netgraph */
   88 extern  void    (*ng_ether_input_p)(struct ifnet *ifp, struct mbuf **mp);
   89 extern  void    (*ng_ether_input_orphan_p)(struct ifnet *ifp, struct mbuf *m);
   90 extern  int     (*ng_ether_output_p)(struct ifnet *ifp, struct mbuf **mp);
   91 extern  void    (*ng_ether_attach_p)(struct ifnet *ifp);
   92 extern  void    (*ng_ether_detach_p)(struct ifnet *ifp);
   93 extern  void    (*ng_ether_link_state_p)(struct ifnet *ifp, int state);
   94 
   95 /* Functional hooks called from if_ethersubr.c */
   96 static void     ng_ether_input(struct ifnet *ifp, struct mbuf **mp);
   97 static void     ng_ether_input_orphan(struct ifnet *ifp, struct mbuf *m);
   98 static int      ng_ether_output(struct ifnet *ifp, struct mbuf **mp);
   99 static void     ng_ether_attach(struct ifnet *ifp);
  100 static void     ng_ether_detach(struct ifnet *ifp); 
  101 static void     ng_ether_link_state(struct ifnet *ifp, int state); 
  102 
  103 /* Other functions */
  104 static int      ng_ether_rcv_lower(node_p node, struct mbuf *m);
  105 static int      ng_ether_rcv_upper(node_p node, struct mbuf *m);
  106 
  107 /* Netgraph node methods */
  108 static ng_constructor_t ng_ether_constructor;
  109 static ng_rcvmsg_t      ng_ether_rcvmsg;
  110 static ng_shutdown_t    ng_ether_shutdown;
  111 static ng_newhook_t     ng_ether_newhook;
  112 static ng_rcvdata_t     ng_ether_rcvdata;
  113 static ng_disconnect_t  ng_ether_disconnect;
  114 static int              ng_ether_mod_event(module_t mod, int event, void *data);
  115 
  116 /* List of commands and how to convert arguments to/from ASCII */
  117 static const struct ng_cmdlist ng_ether_cmdlist[] = {
  118         {
  119           NGM_ETHER_COOKIE,
  120           NGM_ETHER_GET_IFNAME,
  121           "getifname",
  122           NULL,
  123           &ng_parse_string_type
  124         },
  125         {
  126           NGM_ETHER_COOKIE,
  127           NGM_ETHER_GET_IFINDEX,
  128           "getifindex",
  129           NULL,
  130           &ng_parse_int32_type
  131         },
  132         {
  133           NGM_ETHER_COOKIE,
  134           NGM_ETHER_GET_ENADDR,
  135           "getenaddr",
  136           NULL,
  137           &ng_parse_enaddr_type
  138         },
  139         {
  140           NGM_ETHER_COOKIE,
  141           NGM_ETHER_SET_ENADDR,
  142           "setenaddr",
  143           &ng_parse_enaddr_type,
  144           NULL
  145         },
  146         {
  147           NGM_ETHER_COOKIE,
  148           NGM_ETHER_GET_PROMISC,
  149           "getpromisc",
  150           NULL,
  151           &ng_parse_int32_type
  152         },
  153         {
  154           NGM_ETHER_COOKIE,
  155           NGM_ETHER_SET_PROMISC,
  156           "setpromisc",
  157           &ng_parse_int32_type,
  158           NULL
  159         },
  160         {
  161           NGM_ETHER_COOKIE,
  162           NGM_ETHER_GET_AUTOSRC,
  163           "getautosrc",
  164           NULL,
  165           &ng_parse_int32_type
  166         },
  167         {
  168           NGM_ETHER_COOKIE,
  169           NGM_ETHER_SET_AUTOSRC,
  170           "setautosrc",
  171           &ng_parse_int32_type,
  172           NULL
  173         },
  174         {
  175           NGM_ETHER_COOKIE,
  176           NGM_ETHER_ADD_MULTI,
  177           "addmulti",
  178           &ng_parse_enaddr_type,
  179           NULL
  180         },
  181         {
  182           NGM_ETHER_COOKIE,
  183           NGM_ETHER_DEL_MULTI,
  184           "delmulti",
  185           &ng_parse_enaddr_type,
  186           NULL
  187         },
  188         {
  189           NGM_ETHER_COOKIE,
  190           NGM_ETHER_DETACH,
  191           "detach",
  192           NULL,
  193           NULL
  194         },
  195         { 0 }
  196 };
  197 
  198 static struct ng_type ng_ether_typestruct = {
  199         .version =      NG_ABI_VERSION,
  200         .name =         NG_ETHER_NODE_TYPE,
  201         .mod_event =    ng_ether_mod_event,
  202         .constructor =  ng_ether_constructor,
  203         .rcvmsg =       ng_ether_rcvmsg,
  204         .shutdown =     ng_ether_shutdown,
  205         .newhook =      ng_ether_newhook,
  206         .rcvdata =      ng_ether_rcvdata,
  207         .disconnect =   ng_ether_disconnect,
  208         .cmdlist =      ng_ether_cmdlist,
  209 };
  210 NETGRAPH_INIT(ether, &ng_ether_typestruct);
  211 
  212 /******************************************************************
  213                     ETHERNET FUNCTION HOOKS
  214 ******************************************************************/
  215 
  216 /*
  217  * Handle a packet that has come in on an interface. We get to
  218  * look at it here before any upper layer protocols do.
  219  *
  220  * NOTE: this function will get called at splimp()
  221  */
  222 static void
  223 ng_ether_input(struct ifnet *ifp, struct mbuf **mp)
  224 {
  225         const node_p node = IFP2NG(ifp);
  226         const priv_p priv = NG_NODE_PRIVATE(node);
  227         int error;
  228 
  229         /* If "lower" hook not connected, let packet continue */
  230         if (priv->lower == NULL)
  231                 return;
  232         NG_SEND_DATA_ONLY(error, priv->lower, *mp);     /* sets *mp = NULL */
  233 }
  234 
  235 /*
  236  * Handle a packet that has come in on an interface, and which
  237  * does not match any of our known protocols (an ``orphan'').
  238  *
  239  * NOTE: this function will get called at splimp()
  240  */
  241 static void
  242 ng_ether_input_orphan(struct ifnet *ifp, struct mbuf *m)
  243 {
  244         const node_p node = IFP2NG(ifp);
  245         const priv_p priv = NG_NODE_PRIVATE(node);
  246         int error;
  247 
  248         /* If "orphan" hook not connected, discard packet */
  249         if (priv->orphan == NULL) {
  250                 m_freem(m);
  251                 return;
  252         }
  253         NG_SEND_DATA_ONLY(error, priv->orphan, m);
  254 }
  255 
  256 /*
  257  * Handle a packet that is going out on an interface.
  258  * The Ethernet header is already attached to the mbuf.
  259  */
  260 static int
  261 ng_ether_output(struct ifnet *ifp, struct mbuf **mp)
  262 {
  263         const node_p node = IFP2NG(ifp);
  264         const priv_p priv = NG_NODE_PRIVATE(node);
  265         int error = 0;
  266 
  267         /* If "upper" hook not connected, let packet continue */
  268         if (priv->upper == NULL)
  269                 return (0);
  270 
  271         /* Send it out "upper" hook */
  272         NG_SEND_DATA_ONLY(error, priv->upper, *mp);
  273         return (error);
  274 }
  275 
  276 /*
  277  * A new Ethernet interface has been attached.
  278  * Create a new node for it, etc.
  279  */
  280 static void
  281 ng_ether_attach(struct ifnet *ifp)
  282 {
  283         priv_p priv;
  284         node_p node;
  285 
  286         /* Create node */
  287         KASSERT(!IFP2NG(ifp), ("%s: node already exists?", __func__));
  288         if (ng_make_node_common(&ng_ether_typestruct, &node) != 0) {
  289                 log(LOG_ERR, "%s: can't %s for %s\n",
  290                     __func__, "create node", ifp->if_xname);
  291                 return;
  292         }
  293 
  294         /* Allocate private data */
  295         MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_NOWAIT | M_ZERO);
  296         if (priv == NULL) {
  297                 log(LOG_ERR, "%s: can't %s for %s\n",
  298                     __func__, "allocate memory", ifp->if_xname);
  299                 NG_NODE_UNREF(node);
  300                 return;
  301         }
  302         NG_NODE_SET_PRIVATE(node, priv);
  303         priv->ifp = ifp;
  304         IFP2NG(ifp) = node;
  305         priv->hwassist = ifp->if_hwassist;
  306 
  307         /* Try to give the node the same name as the interface */
  308         if (ng_name_node(node, ifp->if_xname) != 0) {
  309                 log(LOG_WARNING, "%s: can't name node %s\n",
  310                     __func__, ifp->if_xname);
  311         }
  312 }
  313 
  314 /*
  315  * An Ethernet interface is being detached.
  316  * REALLY Destroy its node.
  317  */
  318 static void
  319 ng_ether_detach(struct ifnet *ifp)
  320 {
  321         const node_p node = IFP2NG(ifp);
  322         const priv_p priv = NG_NODE_PRIVATE(node);
  323 
  324         NG_NODE_REALLY_DIE(node);       /* Force real removal of node */
  325         /*
  326          * We can't assume the ifnet is still around when we run shutdown
  327          * So zap it now. XXX We HOPE that anything running at this time
  328          * handles it (as it should in the non netgraph case).
  329          */
  330         IFP2NG(ifp) = NULL;
  331         priv->ifp = NULL;       /* XXX race if interrupted an output packet */
  332         ng_rmnode_self(node);           /* remove all netgraph parts */
  333 }
  334 
  335 /*
  336  * Notify graph about link event.
  337  * if_link_state_change() has already checked that the state has changed.
  338  */
  339 static void
  340 ng_ether_link_state(struct ifnet *ifp, int state)
  341 {
  342         const node_p node = IFP2NG(ifp);
  343         const priv_p priv = NG_NODE_PRIVATE(node);
  344         struct ng_mesg *msg;
  345         int cmd, dummy_error = 0;
  346 
  347         if (priv->lower == NULL)
  348                 return;
  349 
  350         if (state == LINK_STATE_UP)
  351                 cmd = NGM_LINK_IS_UP;
  352         else if (state == LINK_STATE_DOWN)
  353                 cmd = NGM_LINK_IS_DOWN;
  354         else
  355                 return;
  356 
  357         NG_MKMESSAGE(msg, NGM_FLOW_COOKIE, cmd, 0, M_NOWAIT);
  358         if (msg != NULL)
  359                 NG_SEND_MSG_HOOK(dummy_error, node, msg, priv->lower, 0);
  360 }
  361 
  362 /******************************************************************
  363                     NETGRAPH NODE METHODS
  364 ******************************************************************/
  365 
  366 /*
  367  * It is not possible or allowable to create a node of this type.
  368  * Nodes get created when the interface is attached (or, when
  369  * this node type's KLD is loaded).
  370  */
  371 static int
  372 ng_ether_constructor(node_p node)
  373 {
  374         return (EINVAL);
  375 }
  376 
  377 /*
  378  * Check for attaching a new hook.
  379  */
  380 static  int
  381 ng_ether_newhook(node_p node, hook_p hook, const char *name)
  382 {
  383         const priv_p priv = NG_NODE_PRIVATE(node);
  384         hook_p *hookptr;
  385 
  386         /* Divert hook is an alias for lower */
  387         if (strcmp(name, NG_ETHER_HOOK_DIVERT) == 0)
  388                 name = NG_ETHER_HOOK_LOWER;
  389 
  390         /* Which hook? */
  391         if (strcmp(name, NG_ETHER_HOOK_UPPER) == 0)
  392                 hookptr = &priv->upper;
  393         else if (strcmp(name, NG_ETHER_HOOK_LOWER) == 0)
  394                 hookptr = &priv->lower;
  395         else if (strcmp(name, NG_ETHER_HOOK_ORPHAN) == 0)
  396                 hookptr = &priv->orphan;
  397         else
  398                 return (EINVAL);
  399 
  400         /* Check if already connected (shouldn't be, but doesn't hurt) */
  401         if (*hookptr != NULL)
  402                 return (EISCONN);
  403 
  404         /* Disable hardware checksums while 'upper' hook is connected */
  405         if (hookptr == &priv->upper)
  406                 priv->ifp->if_hwassist = 0;
  407 
  408         /* OK */
  409         *hookptr = hook;
  410         return (0);
  411 }
  412 
  413 /*
  414  * Receive an incoming control message.
  415  */
  416 static int
  417 ng_ether_rcvmsg(node_p node, item_p item, hook_p lasthook)
  418 {
  419         const priv_p priv = NG_NODE_PRIVATE(node);
  420         struct ng_mesg *resp = NULL;
  421         int error = 0;
  422         struct ng_mesg *msg;
  423 
  424         NGI_GET_MSG(item, msg);
  425         switch (msg->header.typecookie) {
  426         case NGM_ETHER_COOKIE:
  427                 switch (msg->header.cmd) {
  428                 case NGM_ETHER_GET_IFNAME:
  429                         NG_MKRESPONSE(resp, msg, IFNAMSIZ, M_NOWAIT);
  430                         if (resp == NULL) {
  431                                 error = ENOMEM;
  432                                 break;
  433                         }
  434                         strlcpy(resp->data, priv->ifp->if_xname, IFNAMSIZ);
  435                         break;
  436                 case NGM_ETHER_GET_IFINDEX:
  437                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
  438                         if (resp == NULL) {
  439                                 error = ENOMEM;
  440                                 break;
  441                         }
  442                         *((u_int32_t *)resp->data) = priv->ifp->if_index;
  443                         break;
  444                 case NGM_ETHER_GET_ENADDR:
  445                         NG_MKRESPONSE(resp, msg, ETHER_ADDR_LEN, M_NOWAIT);
  446                         if (resp == NULL) {
  447                                 error = ENOMEM;
  448                                 break;
  449                         }
  450                         bcopy(IFP2ENADDR(priv->ifp),
  451                             resp->data, ETHER_ADDR_LEN);
  452                         break;
  453                 case NGM_ETHER_SET_ENADDR:
  454                     {
  455                         if (msg->header.arglen != ETHER_ADDR_LEN) {
  456                                 error = EINVAL;
  457                                 break;
  458                         }
  459                         error = if_setlladdr(priv->ifp,
  460                             (u_char *)msg->data, ETHER_ADDR_LEN);
  461                         break;
  462                     }
  463                 case NGM_ETHER_GET_PROMISC:
  464                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
  465                         if (resp == NULL) {
  466                                 error = ENOMEM;
  467                                 break;
  468                         }
  469                         *((u_int32_t *)resp->data) = priv->promisc;
  470                         break;
  471                 case NGM_ETHER_SET_PROMISC:
  472                     {
  473                         u_char want;
  474 
  475                         if (msg->header.arglen != sizeof(u_int32_t)) {
  476                                 error = EINVAL;
  477                                 break;
  478                         }
  479                         want = !!*((u_int32_t *)msg->data);
  480                         if (want ^ priv->promisc) {
  481                                 if ((error = ifpromisc(priv->ifp, want)) != 0)
  482                                         break;
  483                                 priv->promisc = want;
  484                         }
  485                         break;
  486                     }
  487                 case NGM_ETHER_GET_AUTOSRC:
  488                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
  489                         if (resp == NULL) {
  490                                 error = ENOMEM;
  491                                 break;
  492                         }
  493                         *((u_int32_t *)resp->data) = priv->autoSrcAddr;
  494                         break;
  495                 case NGM_ETHER_SET_AUTOSRC:
  496                         if (msg->header.arglen != sizeof(u_int32_t)) {
  497                                 error = EINVAL;
  498                                 break;
  499                         }
  500                         priv->autoSrcAddr = !!*((u_int32_t *)msg->data);
  501                         break;
  502                 case NGM_ETHER_ADD_MULTI:
  503                     {
  504                         struct sockaddr_dl sa_dl;
  505                         struct ifmultiaddr *ifm;
  506 
  507                         if (msg->header.arglen != ETHER_ADDR_LEN) {
  508                                 error = EINVAL;
  509                                 break;
  510                         }
  511                         bzero(&sa_dl, sizeof(struct sockaddr_dl));
  512                         sa_dl.sdl_len = sizeof(struct sockaddr_dl);
  513                         sa_dl.sdl_family = AF_LINK;
  514                         sa_dl.sdl_alen = ETHER_ADDR_LEN;
  515                         bcopy((void *)msg->data, LLADDR(&sa_dl),
  516                             ETHER_ADDR_LEN);
  517                         error = if_addmulti(priv->ifp,
  518                             (struct sockaddr *)&sa_dl, &ifm);
  519                         break;
  520                     }
  521                 case NGM_ETHER_DEL_MULTI:
  522                     {
  523                         struct sockaddr_dl sa_dl;
  524 
  525                         if (msg->header.arglen != ETHER_ADDR_LEN) {
  526                                 error = EINVAL;
  527                                 break;
  528                         }
  529                         bzero(&sa_dl, sizeof(struct sockaddr_dl));
  530                         sa_dl.sdl_len = sizeof(struct sockaddr_dl);
  531                         sa_dl.sdl_family = AF_LINK;
  532                         sa_dl.sdl_alen = ETHER_ADDR_LEN;
  533                         bcopy((void *)msg->data, LLADDR(&sa_dl),
  534                             ETHER_ADDR_LEN);
  535                         error = if_delmulti(priv->ifp,
  536                             (struct sockaddr *)&sa_dl);
  537                         break;
  538                     }
  539                 case NGM_ETHER_DETACH:
  540                         ng_ether_detach(priv->ifp);
  541                         break;
  542                 default:
  543                         error = EINVAL;
  544                         break;
  545                 }
  546                 break;
  547         default:
  548                 error = EINVAL;
  549                 break;
  550         }
  551         NG_RESPOND_MSG(error, node, item, resp);
  552         NG_FREE_MSG(msg);
  553         return (error);
  554 }
  555 
  556 /*
  557  * Receive data on a hook.
  558  */
  559 static int
  560 ng_ether_rcvdata(hook_p hook, item_p item)
  561 {
  562         const node_p node = NG_HOOK_NODE(hook);
  563         const priv_p priv = NG_NODE_PRIVATE(node);
  564         struct mbuf *m;
  565 
  566         NGI_GET_M(item, m);
  567         NG_FREE_ITEM(item);
  568 
  569         if (hook == priv->lower || hook == priv->orphan)
  570                 return ng_ether_rcv_lower(node, m);
  571         if (hook == priv->upper)
  572                 return ng_ether_rcv_upper(node, m);
  573         panic("%s: weird hook", __func__);
  574 #ifdef RESTARTABLE_PANICS /* so we don't get an error msg in LINT */
  575         return (0);
  576 #endif
  577 }
  578 
  579 /*
  580  * Handle an mbuf received on the "lower" or "orphan" hook.
  581  */
  582 static int
  583 ng_ether_rcv_lower(node_p node, struct mbuf *m)
  584 {
  585         const priv_p priv = NG_NODE_PRIVATE(node);
  586         struct ifnet *const ifp = priv->ifp;
  587 
  588         /* Check whether interface is ready for packets */
  589         if (!((ifp->if_flags & IFF_UP) &&
  590             (ifp->if_drv_flags & IFF_DRV_RUNNING))) {
  591                 NG_FREE_M(m);
  592                 return (ENETDOWN);
  593         }
  594 
  595         /* Make sure header is fully pulled up */
  596         if (m->m_pkthdr.len < sizeof(struct ether_header)) {
  597                 NG_FREE_M(m);
  598                 return (EINVAL);
  599         }
  600         if (m->m_len < sizeof(struct ether_header)
  601             && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
  602                 return (ENOBUFS);
  603 
  604         /* Drop in the MAC address if desired */
  605         if (priv->autoSrcAddr) {
  606 
  607                 /* Make the mbuf writable if it's not already */
  608                 if (!M_WRITABLE(m)
  609                     && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
  610                         return (ENOBUFS);
  611 
  612                 /* Overwrite source MAC address */
  613                 bcopy(IFP2ENADDR(ifp),
  614                     mtod(m, struct ether_header *)->ether_shost,
  615                     ETHER_ADDR_LEN);
  616         }
  617 
  618         /* Send it on its way */
  619         return ether_output_frame(ifp, m);
  620 }
  621 
  622 /*
  623  * Handle an mbuf received on the "upper" hook.
  624  */
  625 static int
  626 ng_ether_rcv_upper(node_p node, struct mbuf *m)
  627 {
  628         const priv_p priv = NG_NODE_PRIVATE(node);
  629         struct ifnet *ifp = priv->ifp;
  630 
  631         /* Check length and pull off header */
  632         if (m->m_pkthdr.len < sizeof(struct ether_header)) {
  633                 NG_FREE_M(m);
  634                 return (EINVAL);
  635         }
  636         if (m->m_len < sizeof(struct ether_header) &&
  637             (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
  638                 return (ENOBUFS);
  639 
  640         m->m_pkthdr.rcvif = ifp;
  641 
  642         if (BDG_ACTIVE(priv->ifp) )
  643                 if ((m = bridge_in_ptr(priv->ifp, m)) == NULL)
  644                         return (0);
  645 
  646         /* Pass the packet to the bridge, it may come back to us */
  647         if (ifp->if_bridge) {
  648                 BRIDGE_INPUT(ifp, m);
  649                 if (m == NULL)
  650                         return (0);
  651         }
  652 
  653         /* Route packet back in */
  654         ether_demux(ifp, m);
  655         return (0);
  656 }
  657 
  658 /*
  659  * Shutdown node. This resets the node but does not remove it
  660  * unless the REALLY_DIE flag is set.
  661  */
  662 static int
  663 ng_ether_shutdown(node_p node)
  664 {
  665         const priv_p priv = NG_NODE_PRIVATE(node);
  666 
  667         if (node->nd_flags & NGF_REALLY_DIE) {
  668                 /*
  669                  * WE came here because the ethernet card is being unloaded,
  670                  * so stop being persistant.
  671                  * Actually undo all the things we did on creation.
  672                  * Assume the ifp has already been freed.
  673                  */
  674                 NG_NODE_SET_PRIVATE(node, NULL);
  675                 FREE(priv, M_NETGRAPH);         
  676                 NG_NODE_UNREF(node);    /* free node itself */
  677                 return (0);
  678         }
  679         if (priv->promisc) {            /* disable promiscuous mode */
  680                 (void)ifpromisc(priv->ifp, 0);
  681                 priv->promisc = 0;
  682         }
  683         priv->autoSrcAddr = 1;          /* reset auto-src-addr flag */
  684         NG_NODE_REVIVE(node);           /* Signal ng_rmnode we are persisant */
  685 
  686         return (0);
  687 }
  688 
  689 /*
  690  * Hook disconnection.
  691  */
  692 static int
  693 ng_ether_disconnect(hook_p hook)
  694 {
  695         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  696 
  697         if (hook == priv->upper) {
  698                 priv->upper = NULL;
  699                 if (priv->ifp != NULL)          /* restore h/w csum */
  700                         priv->ifp->if_hwassist = priv->hwassist;
  701         } else if (hook == priv->lower)
  702                 priv->lower = NULL;
  703         else if (hook == priv->orphan)
  704                 priv->orphan = NULL;
  705         else
  706                 panic("%s: weird hook", __func__);
  707         if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
  708         && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
  709                 ng_rmnode_self(NG_HOOK_NODE(hook));     /* reset node */
  710         return (0);
  711 }
  712 
  713 /******************************************************************
  714                         INITIALIZATION
  715 ******************************************************************/
  716 
  717 /*
  718  * Handle loading and unloading for this node type.
  719  */
  720 static int
  721 ng_ether_mod_event(module_t mod, int event, void *data)
  722 {
  723         struct ifnet *ifp;
  724         int error = 0;
  725         int s;
  726 
  727         s = splnet();
  728         switch (event) {
  729         case MOD_LOAD:
  730 
  731                 /* Register function hooks */
  732                 if (ng_ether_attach_p != NULL) {
  733                         error = EEXIST;
  734                         break;
  735                 }
  736                 ng_ether_attach_p = ng_ether_attach;
  737                 ng_ether_detach_p = ng_ether_detach;
  738                 ng_ether_output_p = ng_ether_output;
  739                 ng_ether_input_p = ng_ether_input;
  740                 ng_ether_input_orphan_p = ng_ether_input_orphan;
  741                 ng_ether_link_state_p = ng_ether_link_state;
  742 
  743                 /* Create nodes for any already-existing Ethernet interfaces */
  744                 IFNET_RLOCK();
  745                 TAILQ_FOREACH(ifp, &ifnet, if_link) {
  746                         if (ifp->if_type == IFT_ETHER
  747                             || ifp->if_type == IFT_L2VLAN)
  748                                 ng_ether_attach(ifp);
  749                 }
  750                 IFNET_RUNLOCK();
  751                 break;
  752 
  753         case MOD_UNLOAD:
  754 
  755                 /*
  756                  * Note that the base code won't try to unload us until
  757                  * all nodes have been removed, and that can't happen
  758                  * until all Ethernet interfaces are removed. In any
  759                  * case, we know there are no nodes left if the action
  760                  * is MOD_UNLOAD, so there's no need to detach any nodes.
  761                  */
  762 
  763                 /* Unregister function hooks */
  764                 ng_ether_attach_p = NULL;
  765                 ng_ether_detach_p = NULL;
  766                 ng_ether_output_p = NULL;
  767                 ng_ether_input_p = NULL;
  768                 ng_ether_input_orphan_p = NULL;
  769                 ng_ether_link_state_p = NULL;
  770                 break;
  771 
  772         default:
  773                 error = EOPNOTSUPP;
  774                 break;
  775         }
  776         splx(s);
  777         return (error);
  778 }
  779 

Cache object: 4cd394a11e9e84384e49c7445bf7709d


[ 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.