For kmalloc(), MALLOC() and contigmalloc(), use M_ZERO instead of
[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.13 2008/01/05 14:02:39 swildner 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 | M_ZERO);
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         node->private = priv;
321         priv->ifp = ifp;
322         IFP2NG(ifp) = node;
323         priv->autoSrcAddr = 1;
324         priv->hwassist = ifp->if_hwassist;
325
326         /* Try to give the node the same name as the interface */
327         if (ng_name_node(node, name) != 0) {
328                 log(LOG_WARNING, "%s: can't name node %s\n",
329                     __func__, name);
330         }
331 }
332
333 /*
334  * An Ethernet interface is being detached.
335  * Destroy its node.
336  */
337 static void
338 ng_ether_detach(struct ifnet *ifp)
339 {
340         const node_p node = IFP2NG(ifp);
341         priv_p priv;
342
343         if (node == NULL)               /* no node (why not?), ignore */
344                 return;
345         ng_rmnode(node);                /* break all links to other nodes */
346         node->flags |= NG_INVALID;
347         ng_unname(node);                /* free name (and its reference) */
348         IFP2NG(ifp) = NULL;             /* detach node from interface */
349         priv = node->private;           /* free node private info */
350         bzero(priv, sizeof(*priv));
351         FREE(priv, M_NETGRAPH);
352         node->private = NULL;
353         ng_unref(node);                 /* free node itself */
354 }
355
356 /*
357  * Optimization for gluing the Ethernet header back onto
358  * the front of an incoming packet.
359  */
360 static int
361 ng_ether_glueback_header(struct mbuf **mp, const struct ether_header *eh)
362 {
363         struct mbuf *m = *mp;
364         int error = 0;
365
366         /*
367          * Optimize for the case where the header is already in place
368          * at the front of the mbuf. This is actually quite likely
369          * because many Ethernet drivers generate packets this way.
370          */
371         if (eh == mtod(m, struct ether_header *) - 1) {
372                 m->m_len += sizeof(*eh);
373                 m->m_data -= sizeof(*eh);
374                 m->m_pkthdr.len += sizeof(*eh);
375                 goto done;
376         }
377
378         /* Prepend the header back onto the front of the mbuf */
379         M_PREPEND(m, sizeof(*eh), MB_DONTWAIT);
380         if (m == NULL) {
381                 error = ENOBUFS;
382                 goto done;
383         }
384
385         /* Copy header into front of mbuf */
386         bcopy(eh, mtod(m, void *), sizeof(*eh));
387
388 done:
389         /* Done */
390         *mp = m;
391         return error;
392 }
393
394 /******************************************************************
395                     NETGRAPH NODE METHODS
396 ******************************************************************/
397
398 /*
399  * It is not possible or allowable to create a node of this type.
400  * Nodes get created when the interface is attached (or, when
401  * this node type's KLD is loaded).
402  */
403 static int
404 ng_ether_constructor(node_p *nodep)
405 {
406         return (EINVAL);
407 }
408
409 /*
410  * Check for attaching a new hook.
411  */
412 static  int
413 ng_ether_newhook(node_p node, hook_p hook, const char *name)
414 {
415         const priv_p priv = node->private;
416         u_char orphan = priv->lowerOrphan;
417         hook_p *hookptr;
418
419         /* Divert hook is an alias for lower */
420         if (strcmp(name, NG_ETHER_HOOK_DIVERT) == 0)
421                 name = NG_ETHER_HOOK_LOWER;
422
423         /* Which hook? */
424         if (strcmp(name, NG_ETHER_HOOK_UPPER) == 0)
425                 hookptr = &priv->upper;
426         else if (strcmp(name, NG_ETHER_HOOK_LOWER) == 0) {
427                 hookptr = &priv->lower;
428                 orphan = 0;
429         } else if (strcmp(name, NG_ETHER_HOOK_ORPHAN) == 0) {
430                 hookptr = &priv->lower;
431                 orphan = 1;
432         } else
433                 return (EINVAL);
434
435         /* Check if already connected (shouldn't be, but doesn't hurt) */
436         if (*hookptr != NULL)
437                 return (EISCONN);
438
439         /* Disable hardware checksums while 'upper' hook is connected */
440         if (hookptr == &priv->upper)
441                 priv->ifp->if_hwassist = 0;
442
443         /* OK */
444         *hookptr = hook;
445         priv->lowerOrphan = orphan;
446         return (0);
447 }
448
449 /*
450  * Receive an incoming control message.
451  */
452 static int
453 ng_ether_rcvmsg(node_p node, struct ng_mesg *msg,
454         const char *retaddr, struct ng_mesg **rptr)
455 {
456         const priv_p priv = node->private;
457         struct ng_mesg *resp = NULL;
458         int error = 0;
459
460         switch (msg->header.typecookie) {
461         case NGM_ETHER_COOKIE:
462                 switch (msg->header.cmd) {
463                 case NGM_ETHER_GET_IFNAME:
464                         NG_MKRESPONSE(resp, msg, IFNAMSIZ + 1, M_NOWAIT);
465                         if (resp == NULL) {
466                                 error = ENOMEM;
467                                 break;
468                         }
469                         strlcpy(resp->data, priv->ifp->if_xname, IFNAMSIZ);
470                         break;
471                 case NGM_ETHER_GET_IFINDEX:
472                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
473                         if (resp == NULL) {
474                                 error = ENOMEM;
475                                 break;
476                         }
477                         *((u_int32_t *)resp->data) = priv->ifp->if_index;
478                         break;
479                 case NGM_ETHER_GET_ENADDR:
480                         NG_MKRESPONSE(resp, msg, ETHER_ADDR_LEN, M_NOWAIT);
481                         if (resp == NULL) {
482                                 error = ENOMEM;
483                                 break;
484                         }
485                         bcopy((IFP2AC(priv->ifp))->ac_enaddr,
486                             resp->data, ETHER_ADDR_LEN);
487                         break;
488                 case NGM_ETHER_SET_ENADDR:
489                     {
490                         if (msg->header.arglen != ETHER_ADDR_LEN) {
491                                 error = EINVAL;
492                                 break;
493                         }
494                         error = if_setlladdr(priv->ifp,
495                             (u_char *)msg->data, ETHER_ADDR_LEN);
496                         break;
497                     }
498                 case NGM_ETHER_GET_PROMISC:
499                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
500                         if (resp == NULL) {
501                                 error = ENOMEM;
502                                 break;
503                         }
504                         *((u_int32_t *)resp->data) = priv->promisc;
505                         break;
506                 case NGM_ETHER_SET_PROMISC:
507                     {
508                         u_char want;
509
510                         if (msg->header.arglen != sizeof(u_int32_t)) {
511                                 error = EINVAL;
512                                 break;
513                         }
514                         want = !!*((u_int32_t *)msg->data);
515                         if (want ^ priv->promisc) {
516                                 if ((error = ifpromisc(priv->ifp, want)) != 0)
517                                         break;
518                                 priv->promisc = want;
519                         }
520                         break;
521                     }
522                 case NGM_ETHER_GET_AUTOSRC:
523                         NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
524                         if (resp == NULL) {
525                                 error = ENOMEM;
526                                 break;
527                         }
528                         *((u_int32_t *)resp->data) = priv->autoSrcAddr;
529                         break;
530                 case NGM_ETHER_SET_AUTOSRC:
531                         if (msg->header.arglen != sizeof(u_int32_t)) {
532                                 error = EINVAL;
533                                 break;
534                         }
535                         priv->autoSrcAddr = !!*((u_int32_t *)msg->data);
536                         break;
537                 default:
538                         error = EINVAL;
539                         break;
540                 }
541                 break;
542         default:
543                 error = EINVAL;
544                 break;
545         }
546         if (rptr)
547                 *rptr = resp;
548         else if (resp != NULL)
549                 FREE(resp, M_NETGRAPH);
550         FREE(msg, M_NETGRAPH);
551         return (error);
552 }
553
554 /*
555  * Receive data on a hook.
556  */
557 static int
558 ng_ether_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
559 {
560         const node_p node = hook->node;
561         const priv_p priv = node->private;
562
563         if (hook == priv->lower)
564                 return ng_ether_rcv_lower(node, m, meta);
565         if (hook == priv->upper)
566                 return ng_ether_rcv_upper(node, m, meta);
567         panic("%s: weird hook", __func__);
568 }
569
570 /*
571  * Handle an mbuf received on the "lower" hook.
572  */
573 static int
574 ng_ether_rcv_lower(node_p node, struct mbuf *m, meta_p meta)
575 {
576         const priv_p priv = node->private;
577         struct ifnet *const ifp = priv->ifp;
578         int error;
579
580         /* Discard meta info */
581         NG_FREE_META(meta);
582
583         /* Check whether interface is ready for packets */
584         if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
585                 m_freem(m);
586                 return (ENETDOWN);
587         }
588
589         /* Make sure header is fully pulled up */
590         if (m->m_pkthdr.len < sizeof(struct ether_header)) {
591                 m_freem(m);
592                 return (EINVAL);
593         }
594         if (m->m_len < sizeof(struct ether_header)
595             && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
596                 return (ENOBUFS);
597
598         /* Drop in the MAC address if desired */
599         if (priv->autoSrcAddr) {
600
601                 /* Make the mbuf writable if it's not already */
602                 if (!M_WRITABLE(m)
603                     && (m = m_pullup(m, sizeof(struct ether_header))) == NULL)
604                         return (ENOBUFS);
605
606                 /* Overwrite source MAC address */
607                 bcopy((IFP2AC(ifp))->ac_enaddr,
608                     mtod(m, struct ether_header *)->ether_shost,
609                     ETHER_ADDR_LEN);
610         }
611
612         /* Send it on its way */
613         lwkt_serialize_enter(ifp->if_serializer);
614         error = ether_output_frame(ifp, m);
615         lwkt_serialize_exit(ifp->if_serializer);
616
617         return (error);
618 }
619
620 /*
621  * Handle an mbuf received on the "upper" hook.
622  */
623 static int
624 ng_ether_rcv_upper(node_p node, struct mbuf *m, meta_p meta)
625 {
626         const priv_p priv = node->private;
627         struct ether_header *eh;
628
629         /* Discard meta info */
630         NG_FREE_META(meta);
631
632         /* Check length and pull off header */
633         if (m->m_pkthdr.len < sizeof(*eh)) {
634                 m_freem(m);
635                 return (EINVAL);
636         }
637         if (m->m_len < sizeof(*eh) && (m = m_pullup(m, sizeof(*eh))) == NULL)
638                 return (ENOBUFS);
639         eh = mtod(m, struct ether_header *);
640         m->m_data += sizeof(*eh);
641         m->m_len -= sizeof(*eh);
642         m->m_pkthdr.len -= sizeof(*eh);
643         m->m_pkthdr.rcvif = priv->ifp;
644
645         /* Route packet back in */
646         lwkt_serialize_enter(priv->ifp->if_serializer);
647         ether_demux(priv->ifp, eh, m);
648         lwkt_serialize_exit(priv->ifp->if_serializer);
649         return (0);
650 }
651
652 /*
653  * Shutdown node. This resets the node but does not remove it.
654  */
655 static int
656 ng_ether_rmnode(node_p node)
657 {
658         const priv_p priv = node->private;
659
660         ng_cutlinks(node);
661         node->flags &= ~NG_INVALID;     /* bounce back to life */
662         if (priv->promisc) {            /* disable promiscuous mode */
663                 ifpromisc(priv->ifp, 0);
664                 priv->promisc = 0;
665         }
666         priv->autoSrcAddr = 1;          /* reset auto-src-addr flag */
667         return (0);
668 }
669
670 /*
671  * Hook disconnection.
672  */
673 static int
674 ng_ether_disconnect(hook_p hook)
675 {
676         const priv_p priv = hook->node->private;
677
678         if (hook == priv->upper) {
679                 priv->upper = NULL;
680                 priv->ifp->if_hwassist = priv->hwassist;  /* restore h/w csum */
681         } else if (hook == priv->lower) {
682                 priv->lower = NULL;
683                 priv->lowerOrphan = 0;
684         } else
685                 panic("%s: weird hook", __func__);
686         if (hook->node->numhooks == 0)
687                 ng_rmnode(hook->node);  /* reset node */
688         return (0);
689 }
690
691 static int
692 ng_enaddr_parse(const struct ng_parse_type *type,
693         const char *s, int *const off, const u_char *const start,
694         u_char *const buf, int *const buflen)
695 {
696         char *eptr;
697         u_long val;
698         int i;
699
700         if (*buflen < ETHER_ADDR_LEN)
701                 return (ERANGE);
702         for (i = 0; i < ETHER_ADDR_LEN; i++) {
703                 val = strtoul(s + *off, &eptr, 16);
704                 if (val > 0xff || eptr == s + *off)
705                         return (EINVAL);
706                 buf[i] = (u_char)val;
707                 *off = (eptr - s);
708                 if (i < ETHER_ADDR_LEN - 1) {
709                         if (*eptr != ':')
710                                 return (EINVAL);
711                         (*off)++;
712                 }
713         }
714         *buflen = ETHER_ADDR_LEN;
715         return (0);
716 }
717
718 static int
719 ng_enaddr_unparse(const struct ng_parse_type *type,
720         const u_char *data, int *off, char *cbuf, int cbuflen)
721 {
722         int len;
723
724         len = ksnprintf(cbuf, cbuflen, "%02x:%02x:%02x:%02x:%02x:%02x",
725             data[*off], data[*off + 1], data[*off + 2],
726             data[*off + 3], data[*off + 4], data[*off + 5]);
727         if (len >= cbuflen)
728                 return (ERANGE);
729         *off += ETHER_ADDR_LEN;
730         return (0);
731 }
732
733 /******************************************************************
734                         INITIALIZATION
735 ******************************************************************/
736
737 /*
738  * Handle loading and unloading for this node type.
739  */
740 static int
741 ng_ether_mod_event(module_t mod, int event, void *data)
742 {
743         struct ifnet *ifp;
744         int error = 0;
745
746         crit_enter();
747         switch (event) {
748         case MOD_LOAD:
749
750                 /* Register function hooks */
751                 if (ng_ether_attach_p != NULL) {
752                         error = EEXIST;
753                         break;
754                 }
755                 ng_ether_attach_p = ng_ether_attach;
756                 ng_ether_detach_p = ng_ether_detach;
757                 ng_ether_output_p = ng_ether_output;
758                 ng_ether_input_p = ng_ether_input;
759                 ng_ether_input_orphan_p = ng_ether_input_orphan;
760
761                 /* Create nodes for any already-existing Ethernet interfaces */
762                 TAILQ_FOREACH(ifp, &ifnet, if_link) {
763                         if (ifp->if_type == IFT_ETHER ||
764                             ifp->if_type == IFT_L2VLAN)
765                                 ng_ether_attach(ifp);
766                 }
767                 break;
768
769         case MOD_UNLOAD:
770
771                 /*
772                  * Note that the base code won't try to unload us until
773                  * all nodes have been removed, and that can't happen
774                  * until all Ethernet interfaces are removed. In any
775                  * case, we know there are no nodes left if the action
776                  * is MOD_UNLOAD, so there's no need to detach any nodes.
777                  */
778
779                 /* Unregister function hooks */
780                 ng_ether_attach_p = NULL;
781                 ng_ether_detach_p = NULL;
782                 ng_ether_output_p = NULL;
783                 ng_ether_input_p = NULL;
784                 ng_ether_input_orphan_p = NULL;
785                 break;
786
787         default:
788                 error = EOPNOTSUPP;
789                 break;
790         }
791         crit_exit();
792         return (error);
793 }
794