749a7ae4feec09043e621140ad74837bc5a5f9ed
[dragonfly.git] / sys / netgraph / ether / ng_ether.c
1
2 /*
3  * ng_ether.c
4  *
5  * Copyright (c) 1996-2000 Whistle Communications, Inc.
6  * All rights reserved.
7  * 
8  * Subject to the following obligations and disclaimer of warranty, use and
9  * redistribution of this software, in source or object code forms, with or
10  * without modifications are expressly permitted by Whistle Communications;
11  * provided, however, that:
12  * 1. Any and all reproductions of the source or object code must include the
13  *    copyright notice above and the following disclaimer of warranties; and
14  * 2. No rights are granted, in any manner or form, to use Whistle
15  *    Communications, Inc. trademarks, including the mark "WHISTLE
16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
17  *    such appears in the above copyright notice or in the software.
18  * 
19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
35  * OF SUCH DAMAGE.
36  *
37  * Authors: Archie Cobbs <archie@freebsd.org>
38  *          Julian Elischer <julian@freebsd.org>
39  *
40  * $FreeBSD: src/sys/netgraph/ng_ether.c,v 1.2.2.13 2002/07/02 20:10:25 archie Exp $
41  * $DragonFly: src/sys/netgraph/ether/ng_ether.c,v 1.12 2007/10/13 10:50:34 sephe Exp $
42  */
43
44 /*
45  * ng_ether(4) netgraph node type
46  */
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/kernel.h>
51 #include <sys/malloc.h>
52 #include <sys/mbuf.h>
53 #include <sys/errno.h>
54 #include <sys/syslog.h>
55 #include <sys/socket.h>
56 #include <sys/thread2.h>
57
58 #include <net/if.h>
59 #include <net/if_types.h>
60 #include <net/if_arp.h>
61 #include <net/if_var.h>
62 #include <net/ethernet.h>
63
64 #include <netgraph/ng_message.h>
65 #include <netgraph/netgraph.h>
66 #include <netgraph/ng_parse.h>
67 #include "ng_ether.h"
68
69 #define IFP2AC(IFP)  ((struct arpcom *)IFP)
70 #define IFP2NG(ifp)  (IFP2AC((ifp))->ac_netgraph)
71
72 /* Per-node private data */
73 struct private {
74         struct ifnet    *ifp;           /* associated interface */
75         hook_p          upper;          /* upper hook connection */
76         hook_p          lower;          /* lower OR orphan hook connection */
77         u_char          lowerOrphan;    /* whether lower is lower or orphan */
78         u_char          autoSrcAddr;    /* always overwrite source address */
79         u_char          promisc;        /* promiscuous mode enabled */
80         u_long          hwassist;       /* hardware checksum capabilities */
81 };
82 typedef struct private *priv_p;
83
84 /* Functional hooks called from if_ethersubr.c */
85 static void     ng_ether_input(struct ifnet *ifp,
86                     struct mbuf **mp, const struct ether_header *eh);
87 static void     ng_ether_input_orphan(struct ifnet *ifp,
88                     struct mbuf *m, const struct ether_header *eh);
89 static int      ng_ether_output(struct ifnet *ifp, struct mbuf **mp);
90 static void     ng_ether_attach(struct ifnet *ifp);
91 static void     ng_ether_detach(struct ifnet *ifp); 
92
93 /* Other functions */
94 static void     ng_ether_input2(node_p node,
95                     struct mbuf **mp, const struct ether_header *eh);
96 static int      ng_ether_glueback_header(struct mbuf **mp,
97                         const struct ether_header *eh);
98 static int      ng_ether_rcv_lower(node_p node, struct mbuf *m, meta_p meta);
99 static int      ng_ether_rcv_upper(node_p node, struct mbuf *m, meta_p meta);
100
101 /* Netgraph node methods */
102 static ng_constructor_t ng_ether_constructor;
103 static ng_rcvmsg_t      ng_ether_rcvmsg;
104 static ng_shutdown_t    ng_ether_rmnode;
105 static ng_newhook_t     ng_ether_newhook;
106 static ng_rcvdata_t     ng_ether_rcvdata;
107 static ng_disconnect_t  ng_ether_disconnect;
108 static int              ng_ether_mod_event(module_t mod, int event, void *data);
109
110 /* Parse type for an Ethernet address */
111 static ng_parse_t       ng_enaddr_parse;
112 static ng_unparse_t     ng_enaddr_unparse;
113 const struct ng_parse_type ng_ether_enaddr_type = {
114         NULL,
115         NULL,
116         NULL,
117         ng_enaddr_parse,
118         ng_enaddr_unparse,
119         NULL,                   /* no such thing as a "default" EN address */
120         0
121 };
122
123 /* List of commands and how to convert arguments to/from ASCII */
124 static const struct ng_cmdlist ng_ether_cmdlist[] = {
125         {
126           NGM_ETHER_COOKIE,
127           NGM_ETHER_GET_IFNAME,
128           "getifname",
129           NULL,
130           &ng_parse_string_type
131         },
132         {
133           NGM_ETHER_COOKIE,
134           NGM_ETHER_GET_IFINDEX,
135           "getifindex",
136           NULL,
137           &ng_parse_int32_type
138         },
139         {
140           NGM_ETHER_COOKIE,
141           NGM_ETHER_GET_ENADDR,
142           "getenaddr",
143           NULL,
144           &ng_ether_enaddr_type
145         },
146         {
147           NGM_ETHER_COOKIE,
148           NGM_ETHER_SET_ENADDR,
149           "setenaddr",
150           &ng_ether_enaddr_type,
151           NULL
152         },
153         {
154           NGM_ETHER_COOKIE,
155           NGM_ETHER_GET_PROMISC,
156           "getpromisc",
157           NULL,
158           &ng_parse_int32_type
159         },
160         {
161           NGM_ETHER_COOKIE,
162           NGM_ETHER_SET_PROMISC,
163           "setpromisc",
164           &ng_parse_int32_type,
165           NULL
166         },
167         {
168           NGM_ETHER_COOKIE,
169           NGM_ETHER_GET_AUTOSRC,
170           "getautosrc",
171           NULL,
172           &ng_parse_int32_type
173         },
174         {
175           NGM_ETHER_COOKIE,
176           NGM_ETHER_SET_AUTOSRC,
177           "setautosrc",
178           &ng_parse_int32_type,
179           NULL
180         },
181         { 0 }
182 };
183
184 static struct ng_type ng_ether_typestruct = {
185         NG_VERSION,
186         NG_ETHER_NODE_TYPE,
187         ng_ether_mod_event,
188         ng_ether_constructor,
189         ng_ether_rcvmsg,
190         ng_ether_rmnode,
191         ng_ether_newhook,
192         NULL,
193         NULL,
194         ng_ether_rcvdata,
195         ng_ether_rcvdata,
196         ng_ether_disconnect,
197         ng_ether_cmdlist,
198 };
199 NETGRAPH_INIT(ether, &ng_ether_typestruct);
200
201 /******************************************************************
202                     ETHERNET FUNCTION HOOKS
203 ******************************************************************/
204
205 /*
206  * Handle a packet that has come in on an interface. We get to
207  * look at it here before any upper layer protocols do.
208  *
209  * NOTE: this function will get called at splimp()
210  */
211 static void
212 ng_ether_input(struct ifnet *ifp,
213         struct mbuf **mp, const struct ether_header *eh)
214 {
215         const node_p node = IFP2NG(ifp);
216         const priv_p priv = node->private;
217
218         /* If "lower" hook not connected, let packet continue */
219         if (priv->lower == NULL || priv->lowerOrphan)
220                 return;
221         ng_ether_input2(node, mp, eh);
222 }
223
224 /*
225  * Handle a packet that has come in on an interface, and which
226  * does not match any of our known protocols (an ``orphan'').
227  *
228  * NOTE: this function will get called at splimp()
229  */
230 static void
231 ng_ether_input_orphan(struct ifnet *ifp,
232         struct mbuf *m, const struct ether_header *eh)
233 {
234         const node_p node = IFP2NG(ifp);
235         const priv_p priv = node->private;
236
237         /* If "orphan" hook not connected, let packet continue */
238         if (priv->lower == NULL || !priv->lowerOrphan) {
239                 m_freem(m);
240                 return;
241         }
242         ng_ether_input2(node, &m, eh);
243         if (m != NULL)
244                 m_freem(m);
245 }
246
247 /*
248  * Handle a packet that has come in on an interface.
249  * The Ethernet header has already been detached from the mbuf,
250  * so we have to put it back.
251  *
252  * NOTE: this function will get called at splimp()
253  */
254 static void
255 ng_ether_input2(node_p node, struct mbuf **mp, const struct ether_header *eh)
256 {
257         const priv_p priv = node->private;
258         meta_p meta = NULL;
259         int error;
260
261         /* Glue Ethernet header back on */
262         if ((error = ng_ether_glueback_header(mp, eh)) != 0)
263                 return;
264
265         /* Send out lower/orphan hook */
266         ng_queue_data(priv->lower, *mp, meta);
267         *mp = NULL;
268 }
269
270 /*
271  * Handle a packet that is going out on an interface.
272  * The Ethernet header is already attached to the mbuf.
273  */
274 static int
275 ng_ether_output(struct ifnet *ifp, struct mbuf **mp)
276 {
277         const node_p node = IFP2NG(ifp);
278         const priv_p priv = node->private;
279         meta_p meta = NULL;
280         int error = 0;
281
282         /* If "upper" hook not connected, let packet continue */
283         if (priv->upper == NULL)
284                 return (0);
285
286         /* Send it out "upper" hook */
287         NG_SEND_DATA(error, priv->upper, *mp, meta);
288         *mp = NULL;
289         return (error);
290 }
291
292 /*
293  * A new Ethernet interface has been attached.
294  * Create a new node for it, etc.
295  */
296 static void
297 ng_ether_attach(struct ifnet *ifp)
298 {
299         char name[IFNAMSIZ + 1];
300         priv_p priv;
301         node_p node;
302
303         /* Create node */
304         KASSERT(!IFP2NG(ifp), ("%s: node already exists?", __func__));
305         strlcpy(name, ifp->if_xname, sizeof(name));
306         if (ng_make_node_common(&ng_ether_typestruct, &node) != 0) {
307                 log(LOG_ERR, "%s: can't %s for %s\n",
308                     __func__, "create node", name);
309                 return;
310         }
311
312         /* Allocate private data */
313         MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_NOWAIT);
314         if (priv == NULL) {
315                 log(LOG_ERR, "%s: can't %s for %s\n",
316                     __func__, "allocate memory", name);
317                 ng_unref(node);
318                 return;
319         }
320         bzero(priv, sizeof(*priv));
321         node->private = priv;
322         priv->ifp = ifp;
323         IFP2NG(ifp) = node;
324         priv->autoSrcAddr = 1;
325         priv->hwassist = ifp->if_hwassist;
326
327         /* Try to give the node the same name as the interface */
328         if (ng_name_node(node, name) != 0) {
329                 log(LOG_WARNING, "%s: can't name node %s\n",
330                     __func__, name);
331         }
332 }
333
334 /*
335  * An Ethernet interface is being detached.
336  * Destroy its node.
337  */
338 static void
339 ng_ether_detach(struct ifnet *ifp)
340 {
341         const node_p node = IFP2NG(ifp);
342         priv_p priv;
343
344         if (node == NULL)               /* no node (why not?), ignore */
345                 return;
346         ng_rmnode(node);                /* break all links to other nodes */
347         node->flags |= NG_INVALID;
348         ng_unname(node);                /* free name (and its reference) */
349         IFP2NG(ifp) = NULL;             /* detach node from interface */
350         priv = node->private;           /* free node private info */
351         bzero(priv, sizeof(*priv));
352         FREE(priv, M_NETGRAPH);
353         node->private = NULL;
354         ng_unref(node);                 /* free node itself */
355 }
356
357 /*
358  * Optimization for gluing the Ethernet header back onto
359  * the front of an incoming packet.
360  */
361 static int
362 ng_ether_glueback_header(struct mbuf **mp, const struct ether_header *eh)
363 {
364         struct mbuf *m = *mp;
365         int error = 0;
366
367         /*
368          * Optimize for the case where the header is already in place
369          * at the front of the mbuf. This is actually quite likely
370          * because many Ethernet drivers generate packets this way.
371          */
372         if (eh == mtod(m, struct ether_header *) - 1) {
373                 m->m_len += sizeof(*eh);
374                 m->m_data -= sizeof(*eh);
375                 m->m_pkthdr.len += sizeof(*eh);
376                 goto done;
377         }
378
379         /* Prepend the header back onto the front of the mbuf */
380         M_PREPEND(m, sizeof(*eh), MB_DONTWAIT);
381         if (m == NULL) {
382                 error = ENOBUFS;
383                 goto done;
384         }
385
386         /* Copy header into front of mbuf */
387         bcopy(eh, mtod(m, void *), sizeof(*eh));
388
389 done:
390         /* Done */
391         *mp = m;
392         return error;
393 }
394
395 /******************************************************************
396                     NETGRAPH NODE METHODS
397 ******************************************************************/
398
399 /*
400  * It is not possible or allowable to create a node of this type.
401  * Nodes get created when the interface is attached (or, when
402  * this node type's KLD is loaded).
403  */
404 static int
405 ng_ether_constructor(node_p *nodep)
406 {
407         return (EINVAL);
408 }
409
410 /*
411  * Check for attaching a new hook.
412  */
413 static  int
414 ng_ether_newhook(node_p node, hook_p hook, const char *name)
415 {
416         const priv_p priv = node->private;
417         u_char orphan = priv->lowerOrphan;
418         hook_p *hookptr;
419
420         /* Divert hook is an alias for lower */
421         if (strcmp(name, NG_ETHER_HOOK_DIVERT) == 0)
422                 name = NG_ETHER_HOOK_LOWER;
423
424         /* Which hook? */
425         if (strcmp(name, NG_ETHER_HOOK_UPPER) == 0)
426                 hookptr = &priv->upper;
427         else if (strcmp(name, NG_ETHER_HOOK_LOWER) == 0) {
428                 hookptr = &priv->lower;
429                 orphan = 0;
430         } else if (strcmp(name, NG_ETHER_HOOK_ORPHAN) == 0) {
431                 hookptr = &priv->lower;
432                 orphan = 1;
433         } else
434                 return (EINVAL);
435
436         /* Check if already connected (shouldn't be, but doesn't hurt) */
437         if (*hookptr != NULL)
438                 return (EISCONN);
439
440         /* Disable hardware checksums while 'upper' hook is connected */
441         if (hookptr == &priv->upper)
442                 priv->ifp->if_hwassist = 0;
443
444         /* OK */
445         *hookptr = hook;
446         priv->lowerOrphan = orphan;
447         return (0);
448 }
449
450 /*
451  * Receive an incoming control message.
452  */
453 static int
454 ng_ether_rcvmsg(node_p node, struct ng_mesg *msg,
455         const char *retaddr, struct ng_mesg **rptr)
456 {
457         const priv_p priv = node->private;
458         struct ng_mesg *resp = NULL;
459         int error = 0;
460
461         switch (msg->header.typecookie) {
462         case NGM_ETHER_COOKIE:
463                 switch (msg->header.cmd) {
464                 case NGM_ETHER_GET_IFNAME:
465                         NG_MKRESPONSE(resp, msg, IFNAMSIZ + 1, M_NOWAIT);
466                         if (resp == NULL) {
467                                 error = ENOMEM;
468                                 break;
469                         }
470                         strlcpy(resp->data, priv->ifp->if_xname, IFNAMSIZ);
471                         break;
472                 case NGM_ETHER_GET_IFINDEX:
473                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
474                         if (resp == NULL) {
475                                 error = ENOMEM;
476                                 break;
477                         }
478                         *((u_int32_t *)resp->data) = priv->ifp->if_index;
479                         break;
480                 case NGM_ETHER_GET_ENADDR:
481                         NG_MKRESPONSE(resp, msg, ETHER_ADDR_LEN, M_NOWAIT);
482                         if (resp == NULL) {
483                                 error = ENOMEM;
484                                 break;
485                         }
486                         bcopy((IFP2AC(priv->ifp))->ac_enaddr,
487                             resp->data, ETHER_ADDR_LEN);
488                         break;
489                 case NGM_ETHER_SET_ENADDR:
490                     {
491                         if (msg->header.arglen != ETHER_ADDR_LEN) {
492                                 error = EINVAL;
493                                 break;
494                         }
495                         error = if_setlladdr(priv->ifp,
496                             (u_char *)msg->data, ETHER_ADDR_LEN);
497                         break;
498                     }
499                 case NGM_ETHER_GET_PROMISC:
500                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
501                         if (resp == NULL) {
502                                 error = ENOMEM;
503                                 break;
504                         }
505                         *((u_int32_t *)resp->data) = priv->promisc;
506                         break;
507                 case NGM_ETHER_SET_PROMISC:
508                     {
509                         u_char want;
510
511                         if (msg->header.arglen != sizeof(u_int32_t)) {
512                                 error = EINVAL;
513                                 break;
514                         }
515                         want = !!*((u_int32_t *)msg->data);
516                         if (want ^ priv->promisc) {
517                                 if ((error = ifpromisc(priv->ifp, want)) != 0)
518                                         break;
519                                 priv->promisc = want;
520                         }
521                         break;
522                     }
523                 case NGM_ETHER_GET_AUTOSRC:
524                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
525                         if (resp == NULL) {
526                                 error = ENOMEM;
527                                 break;
528                         }
529                         *((u_int32_t *)resp->data) = priv->autoSrcAddr;
530                         break;
531                 case NGM_ETHER_SET_AUTOSRC:
532                         if (msg->header.arglen != sizeof(u_int32_t)) {
533                                 error = EINVAL;
534                                 break;
535                         }
536                         priv->autoSrcAddr = !!*((u_int32_t *)msg->data);
537                         break;
538                 default:
539                         error = EINVAL;
540                         break;
541                 }
542                 break;
543         default:
544                 error = EINVAL;
545                 break;
546         }
547         if (rptr)
548                 *rptr = resp;
549         else if (resp != NULL)
550                 FREE(resp, M_NETGRAPH);
551         FREE(msg, M_NETGRAPH);
552         return (error);
553 }
554
555 /*
556  * Receive data on a hook.
557  */
558 static int
559 ng_ether_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
560 {
561         const node_p node = hook->node;
562         const priv_p priv = node->private;
563
564         if (hook == priv->lower)
565                 return ng_ether_rcv_lower(node, m, meta);
566         if (hook == priv->upper)
567                 return ng_ether_rcv_upper(node, m, meta);
568         panic("%s: weird hook", __func__);
569 }
570
571 /*
572  * Handle an mbuf received on the "lower" hook.
573  */
574 static int
575 ng_ether_rcv_lower(node_p node, struct mbuf *m, meta_p meta)
576 {
577         const priv_p priv = node->private;
578         struct ifnet *const ifp = priv->ifp;
579         int error;
580
581         /* Discard meta info */
582         NG_FREE_META(meta);
583
584         /* Check whether interface is ready for packets */
585         if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
586                 m_freem(m);
587                 return (ENETDOWN);
588         }
589
590         /* Make sure header is fully pulled up */
591         if (m->m_pkthdr.len < sizeof(struct ether_header)) {
592                 m_freem(m);
593                 return (EINVAL);
594         }
595         if (m->m_len < sizeof(struct ether_header)
596             && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
597                 return (ENOBUFS);
598
599         /* Drop in the MAC address if desired */
600         if (priv->autoSrcAddr) {
601
602                 /* Make the mbuf writable if it's not already */
603                 if (!M_WRITABLE(m)
604                     && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
605                         return (ENOBUFS);
606
607                 /* Overwrite source MAC address */
608                 bcopy((IFP2AC(ifp))->ac_enaddr,
609                     mtod(m, struct ether_header *)->ether_shost,
610                     ETHER_ADDR_LEN);
611         }
612
613         /* Send it on its way */
614         lwkt_serialize_enter(ifp->if_serializer);
615         error = ether_output_frame(ifp, m);
616         lwkt_serialize_exit(ifp->if_serializer);
617
618         return (error);
619 }
620
621 /*
622  * Handle an mbuf received on the "upper" hook.
623  */
624 static int
625 ng_ether_rcv_upper(node_p node, struct mbuf *m, meta_p meta)
626 {
627         const priv_p priv = node->private;
628         struct ether_header *eh;
629
630         /* Discard meta info */
631         NG_FREE_META(meta);
632
633         /* Check length and pull off header */
634         if (m->m_pkthdr.len < sizeof(*eh)) {
635                 m_freem(m);
636                 return (EINVAL);
637         }
638         if (m->m_len < sizeof(*eh) && (m = m_pullup(m, sizeof(*eh))) == NULL)
639                 return (ENOBUFS);
640         eh = mtod(m, struct ether_header *);
641         m->m_data += sizeof(*eh);
642         m->m_len -= sizeof(*eh);
643         m->m_pkthdr.len -= sizeof(*eh);
644         m->m_pkthdr.rcvif = priv->ifp;
645
646         /* Route packet back in */
647         lwkt_serialize_enter(priv->ifp->if_serializer);
648         ether_demux(priv->ifp, eh, m);
649         lwkt_serialize_exit(priv->ifp->if_serializer);
650         return (0);
651 }
652
653 /*
654  * Shutdown node. This resets the node but does not remove it.
655  */
656 static int
657 ng_ether_rmnode(node_p node)
658 {
659         const priv_p priv = node->private;
660
661         ng_cutlinks(node);
662         node->flags &= ~NG_INVALID;     /* bounce back to life */
663         if (priv->promisc) {            /* disable promiscuous mode */
664                 ifpromisc(priv->ifp, 0);
665                 priv->promisc = 0;
666         }
667         priv->autoSrcAddr = 1;          /* reset auto-src-addr flag */
668         return (0);
669 }
670
671 /*
672  * Hook disconnection.
673  */
674 static int
675 ng_ether_disconnect(hook_p hook)
676 {
677         const priv_p priv = hook->node->private;
678
679         if (hook == priv->upper) {
680                 priv->upper = NULL;
681                 priv->ifp->if_hwassist = priv->hwassist;  /* restore h/w csum */
682         } else if (hook == priv->lower) {
683                 priv->lower = NULL;
684                 priv->lowerOrphan = 0;
685         } else
686                 panic("%s: weird hook", __func__);
687         if (hook->node->numhooks == 0)
688                 ng_rmnode(hook->node);  /* reset node */
689         return (0);
690 }
691
692 static int
693 ng_enaddr_parse(const struct ng_parse_type *type,
694         const char *s, int *const off, const u_char *const start,
695         u_char *const buf, int *const buflen)
696 {
697         char *eptr;
698         u_long val;
699         int i;
700
701         if (*buflen < ETHER_ADDR_LEN)
702                 return (ERANGE);
703         for (i = 0; i < ETHER_ADDR_LEN; i++) {
704                 val = strtoul(s + *off, &eptr, 16);
705                 if (val > 0xff || eptr == s + *off)
706                         return (EINVAL);
707                 buf[i] = (u_char)val;
708                 *off = (eptr - s);
709                 if (i < ETHER_ADDR_LEN - 1) {
710                         if (*eptr != ':')
711                                 return (EINVAL);
712                         (*off)++;
713                 }
714         }
715         *buflen = ETHER_ADDR_LEN;
716         return (0);
717 }
718
719 static int
720 ng_enaddr_unparse(const struct ng_parse_type *type,
721         const u_char *data, int *off, char *cbuf, int cbuflen)
722 {
723         int len;
724
725         len = ksnprintf(cbuf, cbuflen, "%02x:%02x:%02x:%02x:%02x:%02x",
726             data[*off], data[*off + 1], data[*off + 2],
727             data[*off + 3], data[*off + 4], data[*off + 5]);
728         if (len >= cbuflen)
729                 return (ERANGE);
730         *off += ETHER_ADDR_LEN;
731         return (0);
732 }
733
734 /******************************************************************
735                         INITIALIZATION
736 ******************************************************************/
737
738 /*
739  * Handle loading and unloading for this node type.
740  */
741 static int
742 ng_ether_mod_event(module_t mod, int event, void *data)
743 {
744         struct ifnet *ifp;
745         int error = 0;
746
747         crit_enter();
748         switch (event) {
749         case MOD_LOAD:
750
751                 /* Register function hooks */
752                 if (ng_ether_attach_p != NULL) {
753                         error = EEXIST;
754                         break;
755                 }
756                 ng_ether_attach_p = ng_ether_attach;
757                 ng_ether_detach_p = ng_ether_detach;
758                 ng_ether_output_p = ng_ether_output;
759                 ng_ether_input_p = ng_ether_input;
760                 ng_ether_input_orphan_p = ng_ether_input_orphan;
761
762                 /* Create nodes for any already-existing Ethernet interfaces */
763                 TAILQ_FOREACH(ifp, &ifnet, if_link) {
764                         if (ifp->if_type == IFT_ETHER ||
765                             ifp->if_type == IFT_L2VLAN)
766                                 ng_ether_attach(ifp);
767                 }
768                 break;
769
770         case MOD_UNLOAD:
771
772                 /*
773                  * Note that the base code won't try to unload us until
774                  * all nodes have been removed, and that can't happen
775                  * until all Ethernet interfaces are removed. In any
776                  * case, we know there are no nodes left if the action
777                  * is MOD_UNLOAD, so there's no need to detach any nodes.
778                  */
779
780                 /* Unregister function hooks */
781                 ng_ether_attach_p = NULL;
782                 ng_ether_detach_p = NULL;
783                 ng_ether_output_p = NULL;
784                 ng_ether_input_p = NULL;
785                 ng_ether_input_orphan_p = NULL;
786                 break;
787
788         default:
789                 error = EOPNOTSUPP;
790                 break;
791         }
792         crit_exit();
793         return (error);
794 }
795