Buglet in last commit, the first argument of bpf_ptap is the actual bpf_if.
[dragonfly.git] / sys / netgraph / iface / ng_iface.c
1
2 /*
3  * ng_iface.c
4  *
5  * Copyright (c) 1996-1999 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  * Author: Archie Cobbs <archie@freebsd.org>
38  *
39  * $FreeBSD: src/sys/netgraph/ng_iface.c,v 1.7.2.5 2002/07/02 23:44:02 archie Exp $
40  * $DragonFly: src/sys/netgraph/iface/ng_iface.c,v 1.9 2005/01/31 21:40:04 joerg Exp $
41  * $Whistle: ng_iface.c,v 1.33 1999/11/01 09:24:51 julian Exp $
42  */
43
44 /*
45  * This node is also a system networking interface. It has
46  * a hook for each protocol (IP, AppleTalk, IPX, etc). Packets
47  * are simply relayed between the interface and the hooks.
48  *
49  * Interfaces are named ng0, ng1, etc.  New nodes take the
50  * first available interface name.
51  *
52  * This node also includes Berkeley packet filter support.
53  */
54
55 #include "opt_atalk.h"
56 #include "opt_inet.h"
57 #include "opt_inet6.h"
58 #include "opt_ipx.h"
59
60 #include <sys/param.h>
61 #include <sys/systm.h>
62 #include <sys/errno.h>
63 #include <sys/kernel.h>
64 #include <sys/malloc.h>
65 #include <sys/mbuf.h>
66 #include <sys/errno.h>
67 #include <sys/sockio.h>
68 #include <sys/socket.h>
69 #include <sys/syslog.h>
70 #include <sys/libkern.h>
71
72 #include <net/if.h>
73 #include <net/if_types.h>
74 #include <net/netisr.h>
75 #include <net/bpf.h>
76
77 #include <netinet/in.h>
78
79 #include <netgraph/ng_message.h>
80 #include <netgraph/netgraph.h>
81 #include <netgraph/ng_parse.h>
82 #include "ng_iface.h"
83 #include <netgraph/cisco/ng_cisco.h>
84
85 /* This struct describes one address family */
86 struct iffam {
87         sa_family_t     family;         /* Address family */
88         const char      *hookname;      /* Name for hook */
89 };
90 typedef const struct iffam *iffam_p;
91
92 /* List of address families supported by our interface */
93 const static struct iffam gFamilies[] = {
94         { AF_INET,      NG_IFACE_HOOK_INET      },
95         { AF_INET6,     NG_IFACE_HOOK_INET6     },
96         { AF_APPLETALK, NG_IFACE_HOOK_ATALK     },
97         { AF_IPX,       NG_IFACE_HOOK_IPX       },
98         { AF_ATM,       NG_IFACE_HOOK_ATM       },
99         { AF_NATM,      NG_IFACE_HOOK_NATM      },
100         { AF_NS,        NG_IFACE_HOOK_NS        },
101 };
102 #define NUM_FAMILIES            (sizeof(gFamilies) / sizeof(*gFamilies))
103
104 /* Node private data */
105 struct ng_iface_private {
106         struct  ifnet *ifp;             /* Our interface */
107         int     unit;                   /* Interface unit number */
108         node_p  node;                   /* Our netgraph node */
109         hook_p  hooks[NUM_FAMILIES];    /* Hook for each address family */
110 };
111 typedef struct ng_iface_private *priv_p;
112
113 /* Interface methods */
114 static void     ng_iface_start(struct ifnet *ifp);
115 static int      ng_iface_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data,
116                         struct ucred *cr);
117 static int      ng_iface_output(struct ifnet *ifp, struct mbuf *m0,
118                         struct sockaddr *dst, struct rtentry *rt0);
119 static void     ng_iface_bpftap(struct ifnet *ifp,
120                         struct mbuf *m, sa_family_t family);
121 #ifdef DEBUG
122 static void     ng_iface_print_ioctl(struct ifnet *ifp, int cmd, caddr_t data);
123 #endif
124
125 /* Netgraph methods */
126 static ng_constructor_t ng_iface_constructor;
127 static ng_rcvmsg_t      ng_iface_rcvmsg;
128 static ng_shutdown_t    ng_iface_rmnode;
129 static ng_newhook_t     ng_iface_newhook;
130 static ng_rcvdata_t     ng_iface_rcvdata;
131 static ng_disconnect_t  ng_iface_disconnect;
132
133 /* Helper stuff */
134 static iffam_p  get_iffam_from_af(sa_family_t family);
135 static iffam_p  get_iffam_from_hook(priv_p priv, hook_p hook);
136 static iffam_p  get_iffam_from_name(const char *name);
137 static hook_p  *get_hook_from_iffam(priv_p priv, iffam_p iffam);
138
139 /* Parse type for struct ng_iface_ifname */
140 static const struct ng_parse_fixedstring_info ng_iface_ifname_info = {
141         NG_IFACE_IFACE_NAME_MAX + 1
142 };
143 static const struct ng_parse_type ng_iface_ifname_type = {
144         &ng_parse_fixedstring_type,
145         &ng_iface_ifname_info
146 };
147
148 /* Parse type for struct ng_cisco_ipaddr */
149 static const struct ng_parse_struct_field ng_cisco_ipaddr_type_fields[]
150         = NG_CISCO_IPADDR_TYPE_INFO;
151 static const struct ng_parse_type ng_cisco_ipaddr_type = {
152         &ng_parse_struct_type,
153         &ng_cisco_ipaddr_type_fields
154 };
155
156 /* List of commands and how to convert arguments to/from ASCII */
157 static const struct ng_cmdlist ng_iface_cmds[] = {
158         {
159           NGM_IFACE_COOKIE,
160           NGM_IFACE_GET_IFNAME,
161           "getifname",
162           NULL,
163           &ng_iface_ifname_type
164         },
165         {
166           NGM_IFACE_COOKIE,
167           NGM_IFACE_POINT2POINT,
168           "point2point",
169           NULL,
170           NULL
171         },
172         {
173           NGM_IFACE_COOKIE,
174           NGM_IFACE_BROADCAST,
175           "broadcast",
176           NULL,
177           NULL
178         },
179         {
180           NGM_CISCO_COOKIE,
181           NGM_CISCO_GET_IPADDR,
182           "getipaddr",
183           NULL,
184           &ng_cisco_ipaddr_type
185         },
186         { 0 }
187 };
188
189 /* Node type descriptor */
190 static struct ng_type typestruct = {
191         NG_VERSION,
192         NG_IFACE_NODE_TYPE,
193         NULL,
194         ng_iface_constructor,
195         ng_iface_rcvmsg,
196         ng_iface_rmnode,
197         ng_iface_newhook,
198         NULL,
199         NULL,
200         ng_iface_rcvdata,
201         ng_iface_rcvdata,
202         ng_iface_disconnect,
203         ng_iface_cmds
204 };
205 NETGRAPH_INIT(iface, &typestruct);
206
207 /* We keep a bitmap indicating which unit numbers are free.
208    One means the unit number is free, zero means it's taken. */
209 static int      *ng_iface_units = NULL;
210 static int      ng_iface_units_len = 0;
211
212 #define UNITS_BITSPERWORD       (sizeof(*ng_iface_units) * NBBY)
213
214 /************************************************************************
215                         HELPER STUFF
216  ************************************************************************/
217
218 /*
219  * Get the family descriptor from the family ID
220  */
221 static __inline__ iffam_p
222 get_iffam_from_af(sa_family_t family)
223 {
224         iffam_p iffam;
225         int k;
226
227         for (k = 0; k < NUM_FAMILIES; k++) {
228                 iffam = &gFamilies[k];
229                 if (iffam->family == family)
230                         return (iffam);
231         }
232         return (NULL);
233 }
234
235 /*
236  * Get the family descriptor from the hook
237  */
238 static __inline__ iffam_p
239 get_iffam_from_hook(priv_p priv, hook_p hook)
240 {
241         int k;
242
243         for (k = 0; k < NUM_FAMILIES; k++)
244                 if (priv->hooks[k] == hook)
245                         return (&gFamilies[k]);
246         return (NULL);
247 }
248
249 /*
250  * Get the hook from the iffam descriptor
251  */
252
253 static __inline__ hook_p *
254 get_hook_from_iffam(priv_p priv, iffam_p iffam)
255 {
256         return (&priv->hooks[iffam - gFamilies]);
257 }
258
259 /*
260  * Get the iffam descriptor from the name
261  */
262 static __inline__ iffam_p
263 get_iffam_from_name(const char *name)
264 {
265         iffam_p iffam;
266         int k;
267
268         for (k = 0; k < NUM_FAMILIES; k++) {
269                 iffam = &gFamilies[k];
270                 if (!strcmp(iffam->hookname, name))
271                         return (iffam);
272         }
273         return (NULL);
274 }
275
276 /*
277  * Find the first free unit number for a new interface.
278  * Increase the size of the unit bitmap as necessary.
279  */
280 static __inline__ int
281 ng_iface_get_unit(int *unit)
282 {
283         int index, bit;
284
285         for (index = 0; index < ng_iface_units_len
286             && ng_iface_units[index] == 0; index++);
287         if (index == ng_iface_units_len) {              /* extend array */
288                 int i, *newarray, newlen;
289
290                 newlen = (2 * ng_iface_units_len) + 4;
291                 MALLOC(newarray, int *, newlen * sizeof(*ng_iface_units),
292                     M_NETGRAPH, M_NOWAIT);
293                 if (newarray == NULL)
294                         return (ENOMEM);
295                 bcopy(ng_iface_units, newarray,
296                     ng_iface_units_len * sizeof(*ng_iface_units));
297                 for (i = ng_iface_units_len; i < newlen; i++)
298                         newarray[i] = ~0;
299                 if (ng_iface_units != NULL)
300                         FREE(ng_iface_units, M_NETGRAPH);
301                 ng_iface_units = newarray;
302                 ng_iface_units_len = newlen;
303         }
304         bit = ffs(ng_iface_units[index]) - 1;
305         KASSERT(bit >= 0 && bit <= UNITS_BITSPERWORD - 1,
306             ("%s: word=%d bit=%d", __FUNCTION__, ng_iface_units[index], bit));
307         ng_iface_units[index] &= ~(1 << bit);
308         *unit = (index * UNITS_BITSPERWORD) + bit;
309         return (0);
310 }
311
312 /*
313  * Free a no longer needed unit number.
314  */
315 static __inline__ void
316 ng_iface_free_unit(int unit)
317 {
318         int index, bit;
319
320         index = unit / UNITS_BITSPERWORD;
321         bit = unit % UNITS_BITSPERWORD;
322         KASSERT(index < ng_iface_units_len,
323             ("%s: unit=%d len=%d", __FUNCTION__, unit, ng_iface_units_len));
324         KASSERT((ng_iface_units[index] & (1 << bit)) == 0,
325             ("%s: unit=%d is free", __FUNCTION__, unit));
326         ng_iface_units[index] |= (1 << bit);
327         /*
328          * XXX We could think about reducing the size of ng_iface_units[]
329          * XXX here if the last portion is all ones
330          */
331 }
332
333 /************************************************************************
334                         INTERFACE STUFF
335  ************************************************************************/
336
337 /*
338  * Process an ioctl for the virtual interface
339  */
340 static int
341 ng_iface_ioctl(struct ifnet *ifp, u_long command, caddr_t data,
342     struct ucred *cr)
343 {
344         struct ifreq *const ifr = (struct ifreq *) data;
345         int s, error = 0;
346
347 #ifdef DEBUG
348         ng_iface_print_ioctl(ifp, command, data);
349 #endif
350         s = splimp();
351         switch (command) {
352
353         /* These two are mostly handled at a higher layer */
354         case SIOCSIFADDR:
355                 ifp->if_flags |= (IFF_UP | IFF_RUNNING);
356                 ifp->if_flags &= ~(IFF_OACTIVE);
357                 break;
358         case SIOCGIFADDR:
359                 break;
360
361         /* Set flags */
362         case SIOCSIFFLAGS:
363                 /*
364                  * If the interface is marked up and stopped, then start it.
365                  * If it is marked down and running, then stop it.
366                  */
367                 if (ifr->ifr_flags & IFF_UP) {
368                         if (!(ifp->if_flags & IFF_RUNNING)) {
369                                 ifp->if_flags &= ~(IFF_OACTIVE);
370                                 ifp->if_flags |= IFF_RUNNING;
371                         }
372                 } else {
373                         if (ifp->if_flags & IFF_RUNNING)
374                                 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
375                 }
376                 break;
377
378         /* Set the interface MTU */
379         case SIOCSIFMTU:
380                 if (ifr->ifr_mtu > NG_IFACE_MTU_MAX
381                     || ifr->ifr_mtu < NG_IFACE_MTU_MIN)
382                         error = EINVAL;
383                 else
384                         ifp->if_mtu = ifr->ifr_mtu;
385                 break;
386
387         /* Stuff that's not supported */
388         case SIOCADDMULTI:
389         case SIOCDELMULTI:
390                 error = 0;
391                 break;
392         case SIOCSIFPHYS:
393                 error = EOPNOTSUPP;
394                 break;
395
396         default:
397                 error = EINVAL;
398                 break;
399         }
400         (void) splx(s);
401         return (error);
402 }
403
404 /*
405  * This routine is called to deliver a packet out the interface.
406  * We simply look at the address family and relay the packet to
407  * the corresponding hook, if it exists and is connected.
408  */
409
410 static int
411 ng_iface_output(struct ifnet *ifp, struct mbuf *m,
412                 struct sockaddr *dst, struct rtentry *rt0)
413 {
414         const priv_p priv = (priv_p) ifp->if_softc;
415         const iffam_p iffam = get_iffam_from_af(dst->sa_family);
416         meta_p meta = NULL;
417         int len, error = 0;
418
419         /* Check interface flags */
420         if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
421                 m_freem(m);
422                 return (ENETDOWN);
423         }
424
425         /* BPF writes need to be handled specially */
426         if (dst->sa_family == AF_UNSPEC) {
427                 if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL)
428                         return (ENOBUFS);
429                 dst->sa_family = (sa_family_t)*mtod(m, int32_t *);
430                 m->m_data += 4;
431                 m->m_len -= 4;
432                 m->m_pkthdr.len -= 4;
433         }
434
435         /* Berkeley packet filter */
436         ng_iface_bpftap(ifp, m, dst->sa_family);
437
438         /* Check address family to determine hook (if known) */
439         if (iffam == NULL) {
440                 m_freem(m);
441                 log(LOG_WARNING, "%s: can't handle af%d\n",
442                        ifp->if_xname, (int)dst->sa_family);
443                 return (EAFNOSUPPORT);
444         }
445
446         /* Copy length before the mbuf gets invalidated */
447         len = m->m_pkthdr.len;
448
449         /* Send packet; if hook is not connected, mbuf will get freed. */
450         NG_SEND_DATA(error, *get_hook_from_iffam(priv, iffam), m, meta);
451
452         /* Update stats */
453         if (error == 0) {
454                 ifp->if_obytes += len;
455                 ifp->if_opackets++;
456         }
457         return (error);
458 }
459
460 /*
461  * This routine should never be called
462  */
463
464 static void
465 ng_iface_start(struct ifnet *ifp)
466 {
467         printf("%s: %s called?", ifp->if_xname, __FUNCTION__);
468 }
469
470 /*
471  * Flash a packet by the BPF (requires prepending 4 byte AF header)
472  */
473 static void
474 ng_iface_bpftap(struct ifnet *ifp, struct mbuf *m, sa_family_t family)
475 {
476         int32_t family4 = (int32_t)family;
477
478         KASSERT(family != AF_UNSPEC, ("%s: family=AF_UNSPEC", __FUNCTION__));
479
480         if (ifp->if_bpf)
481                 bpf_ptap(ifp->if_bpf, m, &family, sizeof(family4));
482 }
483
484 #ifdef DEBUG
485 /*
486  * Display an ioctl to the virtual interface
487  */
488
489 static void
490 ng_iface_print_ioctl(struct ifnet *ifp, int command, caddr_t data)
491 {
492         char   *str;
493
494         switch (command & IOC_DIRMASK) {
495         case IOC_VOID:
496                 str = "IO";
497                 break;
498         case IOC_OUT:
499                 str = "IOR";
500                 break;
501         case IOC_IN:
502                 str = "IOW";
503                 break;
504         case IOC_INOUT:
505                 str = "IORW";
506                 break;
507         default:
508                 str = "IO??";
509         }
510         log(LOG_DEBUG, "%s: %s('%c', %d, char[%d])\n",
511                ifp->if_xname,
512                str,
513                IOCGROUP(command),
514                command & 0xff,
515                IOCPARM_LEN(command));
516 }
517 #endif /* DEBUG */
518
519 /************************************************************************
520                         NETGRAPH NODE STUFF
521  ************************************************************************/
522
523 /*
524  * Constructor for a node
525  */
526 static int
527 ng_iface_constructor(node_p *nodep)
528 {
529         char ifname[NG_IFACE_IFACE_NAME_MAX + 1];
530         struct ifnet *ifp;
531         node_p node;
532         priv_p priv;
533         int error = 0;
534
535         /* Allocate node and interface private structures */
536         MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_NOWAIT);
537         if (priv == NULL)
538                 return (ENOMEM);
539         bzero(priv, sizeof(*priv));
540         MALLOC(ifp, struct ifnet *, sizeof(*ifp), M_NETGRAPH, M_NOWAIT);
541         if (ifp == NULL) {
542                 FREE(priv, M_NETGRAPH);
543                 return (ENOMEM);
544         }
545         bzero(ifp, sizeof(*ifp));
546
547         /* Link them together */
548         ifp->if_softc = priv;
549         priv->ifp = ifp;
550
551         /* Get an interface unit number */
552         if ((error = ng_iface_get_unit(&priv->unit)) != 0) {
553                 FREE(ifp, M_NETGRAPH);
554                 FREE(priv, M_NETGRAPH);
555                 return (error);
556         }
557
558         /* Call generic node constructor */
559         if ((error = ng_make_node_common(&typestruct, nodep)) != 0) {
560                 ng_iface_free_unit(priv->unit);
561                 FREE(ifp, M_NETGRAPH);
562                 FREE(priv, M_NETGRAPH);
563                 return (error);
564         }
565         node = *nodep;
566
567         /* Link together node and private info */
568         node->private = priv;
569         priv->node = node;
570
571         /* Initialize interface structure */
572         if_initname(ifp, NG_IFACE_IFACE_NAME, priv->unit);
573         ifp->if_output = ng_iface_output;
574         ifp->if_start = ng_iface_start;
575         ifp->if_ioctl = ng_iface_ioctl;
576         ifp->if_watchdog = NULL;
577         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
578         ifp->if_mtu = NG_IFACE_MTU_DEFAULT;
579         ifp->if_flags = (IFF_SIMPLEX|IFF_POINTOPOINT|IFF_NOARP|IFF_MULTICAST);
580         ifp->if_type = IFT_PROPVIRTUAL;         /* XXX */
581         ifp->if_addrlen = 0;                    /* XXX */
582         ifp->if_hdrlen = 0;                     /* XXX */
583         ifp->if_baudrate = 64000;               /* XXX */
584         TAILQ_INIT(&ifp->if_addrhead);
585
586         /* Give this node the same name as the interface (if possible) */
587         bzero(ifname, sizeof(ifname));
588         strlcpy(ifname, ifp->if_xname, sizeof(ifname));
589         if (ng_name_node(node, ifname) != 0)
590                 log(LOG_WARNING, "%s: can't acquire netgraph name\n", ifname);
591
592         /* Attach the interface */
593         if_attach(ifp);
594         bpfattach(ifp, DLT_NULL, sizeof(u_int));
595
596         /* Done */
597         return (0);
598 }
599
600 /*
601  * Give our ok for a hook to be added
602  */
603 static int
604 ng_iface_newhook(node_p node, hook_p hook, const char *name)
605 {
606         const iffam_p iffam = get_iffam_from_name(name);
607         hook_p *hookptr;
608
609         if (iffam == NULL)
610                 return (EPFNOSUPPORT);
611         hookptr = get_hook_from_iffam((priv_p) node->private, iffam);
612         if (*hookptr != NULL)
613                 return (EISCONN);
614         *hookptr = hook;
615         return (0);
616 }
617
618 /*
619  * Receive a control message
620  */
621 static int
622 ng_iface_rcvmsg(node_p node, struct ng_mesg *msg,
623                 const char *retaddr, struct ng_mesg **rptr)
624 {
625         const priv_p priv = node->private;
626         struct ifnet *const ifp = priv->ifp;
627         struct ng_mesg *resp = NULL;
628         int error = 0;
629
630         switch (msg->header.typecookie) {
631         case NGM_IFACE_COOKIE:
632                 switch (msg->header.cmd) {
633                 case NGM_IFACE_GET_IFNAME:
634                     {
635                         struct ng_iface_ifname *arg;
636
637                         NG_MKRESPONSE(resp, msg, sizeof(*arg), M_NOWAIT);
638                         if (resp == NULL) {
639                                 error = ENOMEM;
640                                 break;
641                         }
642                         arg = (struct ng_iface_ifname *)resp->data;
643                         strlcpy(arg->ngif_name, ifp->if_xname,
644                             sizeof(arg->ngif_name));
645                         break;
646                     }
647
648                 case NGM_IFACE_POINT2POINT:
649                 case NGM_IFACE_BROADCAST:
650                     {
651
652                         /* Deny request if interface is UP */
653                         if ((ifp->if_flags & IFF_UP) != 0)
654                                 return (EBUSY);
655
656                         /* Change flags */
657                         switch (msg->header.cmd) {
658                         case NGM_IFACE_POINT2POINT:
659                                 ifp->if_flags |= IFF_POINTOPOINT;
660                                 ifp->if_flags &= ~IFF_BROADCAST;
661                                 break;
662                         case NGM_IFACE_BROADCAST:
663                                 ifp->if_flags &= ~IFF_POINTOPOINT;
664                                 ifp->if_flags |= IFF_BROADCAST;
665                                 break;
666                         }
667                         break;
668                     }
669
670                 default:
671                         error = EINVAL;
672                         break;
673                 }
674                 break;
675         case NGM_CISCO_COOKIE:
676                 switch (msg->header.cmd) {
677                 case NGM_CISCO_GET_IPADDR:      /* we understand this too */
678                     {
679                         struct ifaddr *ifa;
680
681                         /* Return the first configured IP address */
682                         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
683                                 struct ng_cisco_ipaddr *ips;
684
685                                 if (ifa->ifa_addr->sa_family != AF_INET)
686                                         continue;
687                                 NG_MKRESPONSE(resp, msg, sizeof(ips), M_NOWAIT);
688                                 if (resp == NULL) {
689                                         error = ENOMEM;
690                                         break;
691                                 }
692                                 ips = (struct ng_cisco_ipaddr *)resp->data;
693                                 ips->ipaddr = ((struct sockaddr_in *)
694                                                 ifa->ifa_addr)->sin_addr;
695                                 ips->netmask = ((struct sockaddr_in *)
696                                                 ifa->ifa_netmask)->sin_addr;
697                                 break;
698                         }
699
700                         /* No IP addresses on this interface? */
701                         if (ifa == NULL)
702                                 error = EADDRNOTAVAIL;
703                         break;
704                     }
705                 default:
706                         error = EINVAL;
707                         break;
708                 }
709                 break;
710         default:
711                 error = EINVAL;
712                 break;
713         }
714         if (rptr)
715                 *rptr = resp;
716         else if (resp)
717                 FREE(resp, M_NETGRAPH);
718         FREE(msg, M_NETGRAPH);
719         return (error);
720 }
721
722 /*
723  * Recive data from a hook. Pass the packet to the correct input routine.
724  */
725 static int
726 ng_iface_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
727 {
728         const priv_p priv = hook->node->private;
729         const iffam_p iffam = get_iffam_from_hook(priv, hook);
730         struct ifnet *const ifp = priv->ifp;
731         int isr;
732
733         /* Sanity checks */
734         KASSERT(iffam != NULL, ("%s: iffam", __FUNCTION__));
735         KASSERT(m->m_flags & M_PKTHDR, ("%s: not pkthdr", __FUNCTION__));
736         if (m == NULL)
737                 return (EINVAL);
738         if ((ifp->if_flags & IFF_UP) == 0) {
739                 NG_FREE_DATA(m, meta);
740                 return (ENETDOWN);
741         }
742
743         /* Update interface stats */
744         ifp->if_ipackets++;
745         ifp->if_ibytes += m->m_pkthdr.len;
746
747         /* Note receiving interface */
748         m->m_pkthdr.rcvif = ifp;
749
750         /* Berkeley packet filter */
751         ng_iface_bpftap(ifp, m, iffam->family);
752
753         /* Ignore any meta-data */
754         NG_FREE_META(meta);
755
756         /* Send packet */
757         switch (iffam->family) {
758 #ifdef INET
759         case AF_INET:
760                 isr = NETISR_IP;
761                 break;
762 #endif
763 #ifdef INET6
764         case AF_INET6:
765                 isr = NETISR_IPV6;
766                 break;
767 #endif
768 #ifdef IPX
769         case AF_IPX:
770                 isr = NETISR_IPX;
771                 break;
772 #endif
773 #ifdef NETATALK
774         case AF_APPLETALK:
775                 isr = NETISR_ATALK2;
776                 break;
777 #endif
778         default:
779                 m_freem(m);
780                 return (EAFNOSUPPORT);
781         }
782         netisr_dispatch(isr, m);
783         return (0);
784 }
785
786 /*
787  * Shutdown and remove the node and its associated interface.
788  */
789 static int
790 ng_iface_rmnode(node_p node)
791 {
792         const priv_p priv = node->private;
793
794         ng_cutlinks(node);
795         ng_unname(node);
796         bpfdetach(priv->ifp);
797         if_detach(priv->ifp);
798         FREE(priv->ifp, M_NETGRAPH);
799         priv->ifp = NULL;
800         ng_iface_free_unit(priv->unit);
801         FREE(priv, M_NETGRAPH);
802         node->private = NULL;
803         ng_unref(node);
804         return (0);
805 }
806
807 /*
808  * Hook disconnection. Note that we do *not* shutdown when all
809  * hooks have been disconnected.
810  */
811 static int
812 ng_iface_disconnect(hook_p hook)
813 {
814         const priv_p priv = hook->node->private;
815         const iffam_p iffam = get_iffam_from_hook(priv, hook);
816
817         if (iffam == NULL)
818                 panic(__FUNCTION__);
819         *get_hook_from_iffam(priv, iffam) = NULL;
820         return (0);
821 }
822