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

Cache object: 44fe594023d06bec4773f3a7459b8c15


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