kernel/netgraph7: Replace usage of MALLOC/FREE with kmalloc/kfree here too.
[dragonfly.git] / sys / netgraph7 / ng_ether.c
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: src/sys/netgraph/ng_ether.c,v 1.62 2007/03/20 00:36:10 bms Exp $
43  * $DragonFly: src/sys/netgraph7/ng_ether.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
44  */
45
46 /*
47  * ng_ether(4) netgraph node type
48  */
49
50 #include <sys/param.h>
51 #include <sys/systm.h>
52 #include <sys/kernel.h>
53 #include <sys/malloc.h>
54 #include <sys/mbuf.h>
55 #include <sys/errno.h>
56 #include <sys/syslog.h>
57 #include <sys/socket.h>
58
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 "ng_message.h"
68 #include "netgraph.h"
69 #include "ng_parse.h"
70 #include "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         priv = kmalloc(sizeof(*priv), M_NETGRAPH,
296                        M_WAITOK | M_NULLOK | M_ZERO);
297         if (priv == NULL) {
298                 log(LOG_ERR, "%s: can't %s for %s\n",
299                     __func__, "allocate memory", ifp->if_xname);
300                 NG_NODE_UNREF(node);
301                 return;
302         }
303         NG_NODE_SET_PRIVATE(node, priv);
304         priv->ifp = ifp;
305         IFP2NG(ifp) = node;
306         priv->hwassist = ifp->if_hwassist;
307
308         /* Try to give the node the same name as the interface */
309         if (ng_name_node(node, ifp->if_xname) != 0) {
310                 log(LOG_WARNING, "%s: can't name node %s\n",
311                     __func__, ifp->if_xname);
312         }
313 }
314
315 /*
316  * An Ethernet interface is being detached.
317  * REALLY Destroy its node.
318  */
319 static void
320 ng_ether_detach(struct ifnet *ifp)
321 {
322         const node_p node = IFP2NG(ifp);
323         const priv_p priv = NG_NODE_PRIVATE(node);
324
325         NG_NODE_REALLY_DIE(node);       /* Force real removal of node */
326         /*
327          * We can't assume the ifnet is still around when we run shutdown
328          * So zap it now. XXX We HOPE that anything running at this time
329          * handles it (as it should in the non netgraph case).
330          */
331         IFP2NG(ifp) = NULL;
332         priv->ifp = NULL;       /* XXX race if interrupted an output packet */
333         ng_rmnode_self(node);           /* remove all netgraph parts */
334 }
335
336 /*
337  * Notify graph about link event.
338  * if_link_state_change() has already checked that the state has changed.
339  */
340 static void
341 ng_ether_link_state(struct ifnet *ifp, int state)
342 {
343         const node_p node = IFP2NG(ifp);
344         const priv_p priv = NG_NODE_PRIVATE(node);
345         struct ng_mesg *msg;
346         int cmd, dummy_error = 0;
347
348         if (priv->lower == NULL)
349                 return;
350
351         if (state == LINK_STATE_UP)
352                 cmd = NGM_LINK_IS_UP;
353         else if (state == LINK_STATE_DOWN)
354                 cmd = NGM_LINK_IS_DOWN;
355         else
356                 return;
357
358         NG_MKMESSAGE(msg, NGM_FLOW_COOKIE, cmd, 0, M_WAITOK | M_NULLOK);
359         if (msg != NULL)
360                 NG_SEND_MSG_HOOK(dummy_error, node, msg, priv->lower, 0);
361 }
362
363 /******************************************************************
364                     NETGRAPH NODE METHODS
365 ******************************************************************/
366
367 /*
368  * It is not possible or allowable to create a node of this type.
369  * Nodes get created when the interface is attached (or, when
370  * this node type's KLD is loaded).
371  */
372 static int
373 ng_ether_constructor(node_p node)
374 {
375         return (EINVAL);
376 }
377
378 /*
379  * Check for attaching a new hook.
380  */
381 static  int
382 ng_ether_newhook(node_p node, hook_p hook, const char *name)
383 {
384         const priv_p priv = NG_NODE_PRIVATE(node);
385         hook_p *hookptr;
386
387         /* Divert hook is an alias for lower */
388         if (strcmp(name, NG_ETHER_HOOK_DIVERT) == 0)
389                 name = NG_ETHER_HOOK_LOWER;
390
391         /* Which hook? */
392         if (strcmp(name, NG_ETHER_HOOK_UPPER) == 0)
393                 hookptr = &priv->upper;
394         else if (strcmp(name, NG_ETHER_HOOK_LOWER) == 0)
395                 hookptr = &priv->lower;
396         else if (strcmp(name, NG_ETHER_HOOK_ORPHAN) == 0)
397                 hookptr = &priv->orphan;
398         else
399                 return (EINVAL);
400
401         /* Check if already connected (shouldn't be, but doesn't hurt) */
402         if (*hookptr != NULL)
403                 return (EISCONN);
404
405         /* Disable hardware checksums while 'upper' hook is connected */
406         if (hookptr == &priv->upper)
407                 priv->ifp->if_hwassist = 0;
408
409         /* OK */
410         *hookptr = hook;
411         return (0);
412 }
413
414 /*
415  * Receive an incoming control message.
416  */
417 static int
418 ng_ether_rcvmsg(node_p node, item_p item, hook_p lasthook)
419 {
420         const priv_p priv = NG_NODE_PRIVATE(node);
421         struct ng_mesg *resp = NULL;
422         int error = 0;
423         struct ng_mesg *msg;
424
425         NGI_GET_MSG(item, msg);
426         switch (msg->header.typecookie) {
427         case NGM_ETHER_COOKIE:
428                 switch (msg->header.cmd) {
429                 case NGM_ETHER_GET_IFNAME:
430                         NG_MKRESPONSE(resp, msg, IFNAMSIZ, M_WAITOK | M_NULLOK);
431                         if (resp == NULL) {
432                                 error = ENOMEM;
433                                 break;
434                         }
435                         strlcpy(resp->data, priv->ifp->if_xname, IFNAMSIZ);
436                         break;
437                 case NGM_ETHER_GET_IFINDEX:
438                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_WAITOK | M_NULLOK);
439                         if (resp == NULL) {
440                                 error = ENOMEM;
441                                 break;
442                         }
443                         *((u_int32_t *)resp->data) = priv->ifp->if_index;
444                         break;
445                 case NGM_ETHER_GET_ENADDR:
446                         NG_MKRESPONSE(resp, msg, ETHER_ADDR_LEN, M_WAITOK | M_NULLOK);
447                         if (resp == NULL) {
448                                 error = ENOMEM;
449                                 break;
450                         }
451                         bcopy(IF_LLADDR(priv->ifp),
452                             resp->data, ETHER_ADDR_LEN);
453                         break;
454                 case NGM_ETHER_SET_ENADDR:
455                     {
456                         if (msg->header.arglen != ETHER_ADDR_LEN) {
457                                 error = EINVAL;
458                                 break;
459                         }
460                         error = if_setlladdr(priv->ifp,
461                             (u_char *)msg->data, ETHER_ADDR_LEN);
462                         break;
463                     }
464                 case NGM_ETHER_GET_PROMISC:
465                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_WAITOK | M_NULLOK);
466                         if (resp == NULL) {
467                                 error = ENOMEM;
468                                 break;
469                         }
470                         *((u_int32_t *)resp->data) = priv->promisc;
471                         break;
472                 case NGM_ETHER_SET_PROMISC:
473                     {
474                         u_char want;
475
476                         if (msg->header.arglen != sizeof(u_int32_t)) {
477                                 error = EINVAL;
478                                 break;
479                         }
480                         want = !!*((u_int32_t *)msg->data);
481                         if (want ^ priv->promisc) {
482                                 if ((error = ifpromisc(priv->ifp, want)) != 0)
483                                         break;
484                                 priv->promisc = want;
485                         }
486                         break;
487                     }
488                 case NGM_ETHER_GET_AUTOSRC:
489                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_WAITOK | M_NULLOK);
490                         if (resp == NULL) {
491                                 error = ENOMEM;
492                                 break;
493                         }
494                         *((u_int32_t *)resp->data) = priv->autoSrcAddr;
495                         break;
496                 case NGM_ETHER_SET_AUTOSRC:
497                         if (msg->header.arglen != sizeof(u_int32_t)) {
498                                 error = EINVAL;
499                                 break;
500                         }
501                         priv->autoSrcAddr = !!*((u_int32_t *)msg->data);
502                         break;
503                 case NGM_ETHER_ADD_MULTI:
504                     {
505                         struct sockaddr_dl sa_dl;
506                         struct ifmultiaddr *ifma;
507
508                         if (msg->header.arglen != ETHER_ADDR_LEN) {
509                                 error = EINVAL;
510                                 break;
511                         }
512                         bzero(&sa_dl, sizeof(struct sockaddr_dl));
513                         sa_dl.sdl_len = sizeof(struct sockaddr_dl);
514                         sa_dl.sdl_family = AF_LINK;
515                         sa_dl.sdl_alen = ETHER_ADDR_LEN;
516                         bcopy((void *)msg->data, LLADDR(&sa_dl),
517                             ETHER_ADDR_LEN);
518                         /*
519                          * Netgraph is only permitted to join groups once
520                          * via the if_addmulti() KPI, because it cannot hold
521                          * struct ifmultiaddr * between calls. It may also
522                          * lose a race while we check if the membership
523                          * already exists.
524                          */
525                         IF_ADDR_LOCK(priv->ifp);
526                         ifma = if_findmulti(priv->ifp,
527                             (struct sockaddr *)&sa_dl);
528                         IF_ADDR_UNLOCK(priv->ifp);
529                         if (ifma != NULL) {
530                                 error = EADDRINUSE;
531                         } else {
532                                 error = if_addmulti(priv->ifp,
533                                     (struct sockaddr *)&sa_dl, &ifma);
534                         }
535                         break;
536                     }
537                 case NGM_ETHER_DEL_MULTI:
538                     {
539                         struct sockaddr_dl sa_dl;
540
541                         if (msg->header.arglen != ETHER_ADDR_LEN) {
542                                 error = EINVAL;
543                                 break;
544                         }
545                         bzero(&sa_dl, sizeof(struct sockaddr_dl));
546                         sa_dl.sdl_len = sizeof(struct sockaddr_dl);
547                         sa_dl.sdl_family = AF_LINK;
548                         sa_dl.sdl_alen = ETHER_ADDR_LEN;
549                         bcopy((void *)msg->data, LLADDR(&sa_dl),
550                             ETHER_ADDR_LEN);
551                         error = if_delmulti(priv->ifp,
552                             (struct sockaddr *)&sa_dl);
553                         break;
554                     }
555                 case NGM_ETHER_DETACH:
556                         ng_ether_detach(priv->ifp);
557                         break;
558                 default:
559                         error = EINVAL;
560                         break;
561                 }
562                 break;
563         default:
564                 error = EINVAL;
565                 break;
566         }
567         NG_RESPOND_MSG(error, node, item, resp);
568         NG_FREE_MSG(msg);
569         return (error);
570 }
571
572 /*
573  * Receive data on a hook.
574  */
575 static int
576 ng_ether_rcvdata(hook_p hook, item_p item)
577 {
578         const node_p node = NG_HOOK_NODE(hook);
579         const priv_p priv = NG_NODE_PRIVATE(node);
580         struct mbuf *m;
581
582         NGI_GET_M(item, m);
583         NG_FREE_ITEM(item);
584
585         if (hook == priv->lower || hook == priv->orphan)
586                 return ng_ether_rcv_lower(node, m);
587         if (hook == priv->upper)
588                 return ng_ether_rcv_upper(node, m);
589         panic("%s: weird hook", __func__);
590 #ifdef RESTARTABLE_PANICS /* so we don't get an error msg in LINT */
591         return (0);
592 #endif
593 }
594
595 /*
596  * Handle an mbuf received on the "lower" or "orphan" hook.
597  */
598 static int
599 ng_ether_rcv_lower(node_p node, struct mbuf *m)
600 {
601         const priv_p priv = NG_NODE_PRIVATE(node);
602         struct ifnet *const ifp = priv->ifp;
603
604         /* Check whether interface is ready for packets */
605         if (!((ifp->if_flags & IFF_UP) &&
606             (ifp->if_drv_flags & IFF_DRV_RUNNING))) {
607                 NG_FREE_M(m);
608                 return (ENETDOWN);
609         }
610
611         /* Make sure header is fully pulled up */
612         if (m->m_pkthdr.len < sizeof(struct ether_header)) {
613                 NG_FREE_M(m);
614                 return (EINVAL);
615         }
616         if (m->m_len < sizeof(struct ether_header)
617             && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
618                 return (ENOBUFS);
619
620         /* Drop in the MAC address if desired */
621         if (priv->autoSrcAddr) {
622
623                 /* Make the mbuf writable if it's not already */
624                 if (!M_WRITABLE(m)
625                     && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
626                         return (ENOBUFS);
627
628                 /* Overwrite source MAC address */
629                 bcopy(IF_LLADDR(ifp),
630                     mtod(m, struct ether_header *)->ether_shost,
631                     ETHER_ADDR_LEN);
632         }
633
634         /* Send it on its way */
635         return ether_output_frame(ifp, m);
636 }
637
638 /*
639  * Handle an mbuf received on the "upper" hook.
640  */
641 static int
642 ng_ether_rcv_upper(node_p node, struct mbuf *m)
643 {
644         const priv_p priv = NG_NODE_PRIVATE(node);
645         struct ifnet *ifp = priv->ifp;
646
647         /* Check length and pull off header */
648         if (m->m_pkthdr.len < sizeof(struct ether_header)) {
649                 NG_FREE_M(m);
650                 return (EINVAL);
651         }
652         if (m->m_len < sizeof(struct ether_header) &&
653             (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
654                 return (ENOBUFS);
655
656         m->m_pkthdr.rcvif = ifp;
657
658         /* Pass the packet to the bridge, it may come back to us */
659         if (ifp->if_bridge) {
660                 BRIDGE_INPUT(ifp, m);
661                 if (m == NULL)
662                         return (0);
663         }
664
665         /* Route packet back in */
666         ether_demux(ifp, m);
667         return (0);
668 }
669
670 /*
671  * Shutdown node. This resets the node but does not remove it
672  * unless the REALLY_DIE flag is set.
673  */
674 static int
675 ng_ether_shutdown(node_p node)
676 {
677         const priv_p priv = NG_NODE_PRIVATE(node);
678
679         if (node->nd_flags & NGF_REALLY_DIE) {
680                 /*
681                  * WE came here because the ethernet card is being unloaded,
682                  * so stop being persistant.
683                  * Actually undo all the things we did on creation.
684                  * Assume the ifp has already been freed.
685                  */
686                 NG_NODE_SET_PRIVATE(node, NULL);
687                 kfree(priv, M_NETGRAPH);
688                 NG_NODE_UNREF(node);    /* free node itself */
689                 return (0);
690         }
691         if (priv->promisc) {            /* disable promiscuous mode */
692                 (void)ifpromisc(priv->ifp, 0);
693                 priv->promisc = 0;
694         }
695         priv->autoSrcAddr = 1;          /* reset auto-src-addr flag */
696         NG_NODE_REVIVE(node);           /* Signal ng_rmnode we are persisant */
697
698         return (0);
699 }
700
701 /*
702  * Hook disconnection.
703  */
704 static int
705 ng_ether_disconnect(hook_p hook)
706 {
707         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
708
709         if (hook == priv->upper) {
710                 priv->upper = NULL;
711                 if (priv->ifp != NULL)          /* restore h/w csum */
712                         priv->ifp->if_hwassist = priv->hwassist;
713         } else if (hook == priv->lower)
714                 priv->lower = NULL;
715         else if (hook == priv->orphan)
716                 priv->orphan = NULL;
717         else
718                 panic("%s: weird hook", __func__);
719         if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
720         && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
721                 ng_rmnode_self(NG_HOOK_NODE(hook));     /* reset node */
722         return (0);
723 }
724
725 /******************************************************************
726                         INITIALIZATION
727 ******************************************************************/
728
729 /*
730  * Handle loading and unloading for this node type.
731  */
732 static int
733 ng_ether_mod_event(module_t mod, int event, void *data)
734 {
735         struct ifnet *ifp;
736         int error = 0;
737         int s;
738
739         s = splnet();
740         switch (event) {
741         case MOD_LOAD:
742
743                 /* Register function hooks */
744                 if (ng_ether_attach_p != NULL) {
745                         error = EEXIST;
746                         break;
747                 }
748                 ng_ether_attach_p = ng_ether_attach;
749                 ng_ether_detach_p = ng_ether_detach;
750                 ng_ether_output_p = ng_ether_output;
751                 ng_ether_input_p = ng_ether_input;
752                 ng_ether_input_orphan_p = ng_ether_input_orphan;
753                 ng_ether_link_state_p = ng_ether_link_state;
754
755                 /* Create nodes for any already-existing Ethernet interfaces */
756                 IFNET_RLOCK();
757                 TAILQ_FOREACH(ifp, &ifnet, if_link) {
758                         if (ifp->if_type == IFT_ETHER
759                             || ifp->if_type == IFT_L2VLAN)
760                                 ng_ether_attach(ifp);
761                 }
762                 IFNET_RUNLOCK();
763                 break;
764
765         case MOD_UNLOAD:
766
767                 /*
768                  * Note that the base code won't try to unload us until
769                  * all nodes have been removed, and that can't happen
770                  * until all Ethernet interfaces are removed. In any
771                  * case, we know there are no nodes left if the action
772                  * is MOD_UNLOAD, so there's no need to detach any nodes.
773                  */
774
775                 /* Unregister function hooks */
776                 ng_ether_attach_p = NULL;
777                 ng_ether_detach_p = NULL;
778                 ng_ether_output_p = NULL;
779                 ng_ether_input_p = NULL;
780                 ng_ether_input_orphan_p = NULL;
781                 ng_ether_link_state_p = NULL;
782                 break;
783
784         default:
785                 error = EOPNOTSUPP;
786                 break;
787         }
788         splx(s);
789         return (error);
790 }
791