[BACK]Return to if_ethersubr.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / net

Annotation of src/sys/net/if_ethersubr.c, Revision 1.126

1.126   ! bouyer      1: /*     $NetBSD: if_ethersubr.c,v 1.125 2005/05/29 21:22:52 christos Exp $      */
1.44      itojun      2:
                      3: /*
                      4:  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
                      5:  * All rights reserved.
1.120     perry       6:  *
1.44      itojun      7:  * Redistribution and use in source and binary forms, with or without
                      8:  * modification, are permitted provided that the following conditions
                      9:  * are met:
                     10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
                     12:  * 2. Redistributions in binary form must reproduce the above copyright
                     13:  *    notice, this list of conditions and the following disclaimer in the
                     14:  *    documentation and/or other materials provided with the distribution.
                     15:  * 3. Neither the name of the project nor the names of its contributors
                     16:  *    may be used to endorse or promote products derived from this software
                     17:  *    without specific prior written permission.
1.120     perry      18:  *
1.44      itojun     19:  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
                     20:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     21:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     22:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
                     23:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     24:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     25:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     26:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     27:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     28:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     29:  * SUCH DAMAGE.
                     30:  */
1.9       cgd        31:
1.1       cgd        32: /*
1.8       mycroft    33:  * Copyright (c) 1982, 1989, 1993
                     34:  *     The Regents of the University of California.  All rights reserved.
1.1       cgd        35:  *
                     36:  * Redistribution and use in source and binary forms, with or without
                     37:  * modification, are permitted provided that the following conditions
                     38:  * are met:
                     39:  * 1. Redistributions of source code must retain the above copyright
                     40:  *    notice, this list of conditions and the following disclaimer.
                     41:  * 2. Redistributions in binary form must reproduce the above copyright
                     42:  *    notice, this list of conditions and the following disclaimer in the
                     43:  *    documentation and/or other materials provided with the distribution.
1.113     agc        44:  * 3. Neither the name of the University nor the names of its contributors
1.1       cgd        45:  *    may be used to endorse or promote products derived from this software
                     46:  *    without specific prior written permission.
                     47:  *
                     48:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     49:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     50:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     51:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     52:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     53:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     54:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     55:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     56:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     57:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     58:  * SUCH DAMAGE.
                     59:  *
1.27      fvdl       60:  *     @(#)if_ethersubr.c      8.2 (Berkeley) 4/4/96
1.1       cgd        61:  */
1.90      lukem      62:
                     63: #include <sys/cdefs.h>
1.126   ! bouyer     64: __KERNEL_RCSID(0, "$NetBSD: if_ethersubr.c,v 1.125 2005/05/29 21:22:52 christos Exp $");
1.1       cgd        65:
1.33      jonathan   66: #include "opt_inet.h"
                     67: #include "opt_atalk.h"
1.34      jonathan   68: #include "opt_ccitt.h"
1.35      jonathan   69: #include "opt_llc.h"
1.36      jonathan   70: #include "opt_iso.h"
1.112     martin     71: #include "opt_ipx.h"
                     72: #include "opt_mbuftrace.h"
1.37      jonathan   73: #include "opt_ns.h"
1.30      matt       74: #include "opt_gateway.h"
1.77      thorpej    75: #include "opt_pfil_hooks.h"
1.59      thorpej    76: #include "vlan.h"
1.81      martin     77: #include "pppoe.h"
1.78      thorpej    78: #include "bridge.h"
1.69      thorpej    79: #include "bpfilter.h"
1.93      martin     80: #include "arp.h"
1.121     yamt       81: #include "agr.h"
1.30      matt       82:
1.4       mycroft    83: #include <sys/param.h>
                     84: #include <sys/systm.h>
                     85: #include <sys/kernel.h>
1.81      martin     86: #include <sys/callout.h>
1.4       mycroft    87: #include <sys/malloc.h>
                     88: #include <sys/mbuf.h>
                     89: #include <sys/protosw.h>
                     90: #include <sys/socket.h>
                     91: #include <sys/ioctl.h>
                     92: #include <sys/errno.h>
                     93: #include <sys/syslog.h>
                     94:
1.8       mycroft    95: #include <machine/cpu.h>
                     96:
1.4       mycroft    97: #include <net/if.h>
                     98: #include <net/netisr.h>
                     99: #include <net/route.h>
                    100: #include <net/if_llc.h>
                    101: #include <net/if_dl.h>
1.8       mycroft   102: #include <net/if_types.h>
1.93      martin    103:
                    104: #if NARP == 0
                    105: /*
1.102     jmmv      106:  * XXX there should really be a way to issue this warning from within config(8)
1.93      martin    107:  */
1.111     martin    108: #error You have included NETATALK or a pseudo-device in your configuration that depends on the presence of ethernet interfaces, but have no such interfaces configured. Check if you really need pseudo-device bridge, pppoe, vlan or options NETATALK.
1.93      martin    109: #endif
1.1       cgd       110:
1.120     perry     111: #if NBPFILTER > 0
1.69      thorpej   112: #include <net/bpf.h>
                    113: #endif
                    114:
1.22      is        115: #include <net/if_ether.h>
1.59      thorpej   116: #if NVLAN > 0
                    117: #include <net/if_vlanvar.h>
                    118: #endif
1.22      is        119:
1.81      martin    120: #if NPPPOE > 0
                    121: #include <net/if_pppoe.h>
                    122: #endif
                    123:
1.121     yamt      124: #if NAGR > 0
                    125: #include <net/agr/ieee8023_slowprotocols.h>    /* XXX */
                    126: #include <net/agr/ieee8023ad.h>
                    127: #include <net/agr/if_agrvar.h>
                    128: #endif
                    129:
1.78      thorpej   130: #if NBRIDGE > 0
                    131: #include <net/if_bridgevar.h>
                    132: #endif
                    133:
1.15      phil      134: #include <netinet/in.h>
1.1       cgd       135: #ifdef INET
1.4       mycroft   136: #include <netinet/in_var.h>
1.1       cgd       137: #endif
1.22      is        138: #include <netinet/if_inarp.h>
1.1       cgd       139:
1.44      itojun    140: #ifdef INET6
                    141: #ifndef INET
                    142: #include <netinet/in.h>
                    143: #endif
                    144: #include <netinet6/in6_var.h>
                    145: #include <netinet6/nd6.h>
                    146: #endif
                    147:
1.1       cgd       148: #ifdef NS
1.4       mycroft   149: #include <netns/ns.h>
                    150: #include <netns/ns_if.h>
1.1       cgd       151: #endif
                    152:
1.32      christos  153: #ifdef IPX
                    154: #include <netipx/ipx.h>
                    155: #include <netipx/ipx_if.h>
                    156: #endif
                    157:
1.1       cgd       158: #ifdef ISO
1.4       mycroft   159: #include <netiso/argo_debug.h>
                    160: #include <netiso/iso.h>
                    161: #include <netiso/iso_var.h>
                    162: #include <netiso/iso_snpac.h>
1.1       cgd       163: #endif
1.4       mycroft   164:
1.8       mycroft   165: #ifdef LLC
                    166: #include <netccitt/dll.h>
                    167: #include <netccitt/llc_var.h>
                    168: #endif
                    169:
                    170: #if defined(LLC) && defined(CCITT)
                    171: extern struct ifqueue pkintrq;
                    172: #endif
1.1       cgd       173:
1.23      christos  174: #ifdef NETATALK
                    175: #include <netatalk/at.h>
                    176: #include <netatalk/at_var.h>
                    177: #include <netatalk/at_extern.h>
                    178:
                    179: #define llc_snap_org_code llc_un.type_snap.org_code
                    180: #define llc_snap_ether_type llc_un.type_snap.ether_type
                    181:
                    182: extern u_char  at_org_code[3];
                    183: extern u_char  aarp_org_code[3];
                    184: #endif /* NETATALK */
                    185:
1.123     matt      186: static struct timeval bigpktppslim_last;
                    187: static int bigpktppslim = 2;   /* XXX */
                    188: static int bigpktpps_count;
                    189:
                    190:
1.118     yamt      191: const uint8_t etherbroadcastaddr[ETHER_ADDR_LEN] =
                    192:     { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1.121     yamt      193: const uint8_t ethermulticastaddr_slowprotocols[ETHER_ADDR_LEN] =
                    194:     { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x02 };
1.8       mycroft   195: #define senderr(e) { error = (e); goto bad;}
1.1       cgd       196:
1.22      is        197: #define SIN(x) ((struct sockaddr_in *)x)
                    198:
1.42      thorpej   199: static int ether_output __P((struct ifnet *, struct mbuf *,
                    200:            struct sockaddr *, struct rtentry *));
                    201: static void ether_input __P((struct ifnet *, struct mbuf *));
                    202:
1.1       cgd       203: /*
                    204:  * Ethernet output routine.
                    205:  * Encapsulate a packet of type family for the local net.
1.22      is        206:  * Assumes that ifp is actually pointer to ethercom structure.
1.1       cgd       207:  */
1.42      thorpej   208: static int
1.58      matt      209: ether_output(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
                    210:        struct rtentry *rt0)
1.1       cgd       211: {
1.49      matt      212:        u_int16_t etype = 0;
1.122     christos  213:        int error = 0, hdrcmplt = 0;
1.31      thorpej   214:        u_char esrc[6], edst[6];
1.29      mrg       215:        struct mbuf *m = m0;
                    216:        struct rtentry *rt;
1.1       cgd       217:        struct mbuf *mcopy = (struct mbuf *)0;
1.29      mrg       218:        struct ether_header *eh;
1.72      thorpej   219:        ALTQ_DECL(struct altq_pktattr pktattr;)
1.24      christos  220: #ifdef INET
1.22      is        221:        struct arphdr *ah;
1.24      christos  222: #endif /* INET */
1.23      christos  223: #ifdef NETATALK
                    224:        struct at_ifaddr *aa;
                    225: #endif /* NETATALK */
1.1       cgd       226:
1.104     matt      227: #ifdef MBUFTRACE
1.116     jonathan  228:        m_claimm(m, ifp->if_mowner);
1.104     matt      229: #endif
1.8       mycroft   230:        if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
                    231:                senderr(ENETDOWN);
1.18      christos  232:        if ((rt = rt0) != NULL) {
1.8       mycroft   233:                if ((rt->rt_flags & RTF_UP) == 0) {
1.27      fvdl      234:                        if ((rt0 = rt = rtalloc1(dst, 1)) != NULL) {
1.8       mycroft   235:                                rt->rt_refcnt--;
1.27      fvdl      236:                                if (rt->rt_ifp != ifp)
                    237:                                        return (*rt->rt_ifp->if_output)
                    238:                                                        (ifp, m0, dst, rt);
1.120     perry     239:                        } else
1.8       mycroft   240:                                senderr(EHOSTUNREACH);
                    241:                }
1.27      fvdl      242:                if ((rt->rt_flags & RTF_GATEWAY) && dst->sa_family != AF_NS) {
1.8       mycroft   243:                        if (rt->rt_gwroute == 0)
                    244:                                goto lookup;
                    245:                        if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
                    246:                                rtfree(rt); rt = rt0;
                    247:                        lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1);
                    248:                                if ((rt = rt->rt_gwroute) == 0)
                    249:                                        senderr(EHOSTUNREACH);
1.27      fvdl      250:                                /* the "G" test below also prevents rt == rt0 */
                    251:                                if ((rt->rt_flags & RTF_GATEWAY) ||
                    252:                                    (rt->rt_ifp != ifp)) {
                    253:                                        rt->rt_refcnt--;
                    254:                                        rt0->rt_gwroute = 0;
                    255:                                        senderr(EHOSTUNREACH);
                    256:                                }
1.8       mycroft   257:                        }
                    258:                }
                    259:                if (rt->rt_flags & RTF_REJECT)
                    260:                        if (rt->rt_rmx.rmx_expire == 0 ||
1.98      thorpej   261:                            (u_long) time.tv_sec < rt->rt_rmx.rmx_expire)
1.8       mycroft   262:                                senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
1.1       cgd       263:        }
1.72      thorpej   264:
1.1       cgd       265:        switch (dst->sa_family) {
                    266:
                    267: #ifdef INET
                    268:        case AF_INET:
1.22      is        269:                if (m->m_flags & M_BCAST)
1.125     christos  270:                        (void)memcpy(edst, etherbroadcastaddr, sizeof(edst));
1.22      is        271:
                    272:                else if (m->m_flags & M_MCAST) {
                    273:                        ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr,
                    274:                            (caddr_t)edst)
                    275:
                    276:                } else if (!arpresolve(ifp, rt, m, dst, edst))
1.1       cgd       277:                        return (0);     /* if not yet resolved */
1.3       hpeyerl   278:                /* If broadcasting on a simplex interface, loopback a copy */
                    279:                if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
1.1       cgd       280:                        mcopy = m_copy(m, 0, (int)M_COPYALL);
1.17      mycroft   281:                etype = htons(ETHERTYPE_IP);
1.8       mycroft   282:                break;
1.22      is        283:
                    284:        case AF_ARP:
                    285:                ah = mtod(m, struct arphdr *);
                    286:                if (m->m_flags & M_BCAST)
1.125     christos  287:                        (void)memcpy(edst, etherbroadcastaddr, sizeof(edst));
1.22      is        288:                else
                    289:                        bcopy((caddr_t)ar_tha(ah),
                    290:                                (caddr_t)edst, sizeof(edst));
1.120     perry     291:
1.22      is        292:                ah->ar_hrd = htons(ARPHRD_ETHER);
                    293:
1.107     itojun    294:                switch (ntohs(ah->ar_op)) {
1.22      is        295:                case ARPOP_REVREQUEST:
                    296:                case ARPOP_REVREPLY:
                    297:                        etype = htons(ETHERTYPE_REVARP);
                    298:                        break;
                    299:
                    300:                case ARPOP_REQUEST:
                    301:                case ARPOP_REPLY:
                    302:                default:
                    303:                        etype = htons(ETHERTYPE_ARP);
                    304:                }
                    305:
                    306:                break;
1.1       cgd       307: #endif
1.44      itojun    308: #ifdef INET6
                    309:        case AF_INET6:
1.51      itojun    310:                if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)edst)){
1.67      itojun    311:                        /* something bad happened */
1.99      itojun    312:                        return (0);
1.51      itojun    313:                }
1.44      itojun    314:                etype = htons(ETHERTYPE_IPV6);
                    315:                break;
                    316: #endif
1.23      christos  317: #ifdef NETATALK
                    318:     case AF_APPLETALK:
                    319:                if (!aarpresolve(ifp, m, (struct sockaddr_at *)dst, edst)) {
                    320: #ifdef NETATALKDEBUG
                    321:                        printf("aarpresolv failed\n");
                    322: #endif /* NETATALKDEBUG */
                    323:                        return (0);
                    324:                }
                    325:                /*
                    326:                 * ifaddr is the first thing in at_ifaddr
                    327:                 */
                    328:                aa = (struct at_ifaddr *) at_ifawithnet(
1.25      christos  329:                    (struct sockaddr_at *)dst, ifp);
1.23      christos  330:                if (aa == NULL)
                    331:                    goto bad;
1.120     perry     332:
1.23      christos  333:                /*
                    334:                 * In the phase 2 case, we need to prepend an mbuf for the
                    335:                 * llc header.  Since we must preserve the value of m,
                    336:                 * which is passed to us by value, we m_copy() the first
                    337:                 * mbuf, and use it for our llc header.
                    338:                 */
                    339:                if (aa->aa_flags & AFA_PHASE2) {
                    340:                        struct llc llc;
                    341:
1.43      bouyer    342:                        M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
1.23      christos  343:                        llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
                    344:                        llc.llc_control = LLC_UI;
                    345:                        bcopy(at_org_code, llc.llc_snap_org_code,
                    346:                            sizeof(llc.llc_snap_org_code));
1.38      kim       347:                        llc.llc_snap_ether_type = htons(ETHERTYPE_ATALK);
1.23      christos  348:                        bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
                    349:                } else {
1.38      kim       350:                        etype = htons(ETHERTYPE_ATALK);
1.23      christos  351:                }
                    352:                break;
                    353: #endif /* NETATALK */
1.1       cgd       354: #ifdef NS
                    355:        case AF_NS:
1.17      mycroft   356:                etype = htons(ETHERTYPE_NS);
1.1       cgd       357:                bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
                    358:                    (caddr_t)edst, sizeof (edst));
                    359:                if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst)))
                    360:                        return (looutput(ifp, m, dst, rt));
1.3       hpeyerl   361:                /* If broadcasting on a simplex interface, loopback a copy */
                    362:                if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
1.1       cgd       363:                        mcopy = m_copy(m, 0, (int)M_COPYALL);
1.8       mycroft   364:                break;
1.1       cgd       365: #endif
1.32      christos  366: #ifdef IPX
                    367:        case AF_IPX:
1.39      christos  368:                etype = htons(ETHERTYPE_IPX);
                    369:                bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
1.32      christos  370:                    (caddr_t)edst, sizeof (edst));
                    371:                /* If broadcasting on a simplex interface, loopback a copy */
                    372:                if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
                    373:                        mcopy = m_copy(m, 0, (int)M_COPYALL);
                    374:                break;
                    375: #endif
1.1       cgd       376: #ifdef ISO
                    377:        case AF_ISO: {
                    378:                int     snpalen;
                    379:                struct  llc *l;
1.29      mrg       380:                struct sockaddr_dl *sdl;
1.1       cgd       381:
1.8       mycroft   382:                if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
                    383:                    sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
                    384:                        bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
1.18      christos  385:                } else {
                    386:                        error = iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
                    387:                                                (char *)edst, &snpalen);
                    388:                        if (error)
                    389:                                goto bad; /* Not Resolved */
                    390:                }
1.3       hpeyerl   391:                /* If broadcasting on a simplex interface, loopback a copy */
1.8       mycroft   392:                if (*edst & 1)
                    393:                        m->m_flags |= (M_BCAST|M_MCAST);
1.3       hpeyerl   394:                if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
1.1       cgd       395:                    (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
                    396:                        M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
                    397:                        if (mcopy) {
                    398:                                eh = mtod(mcopy, struct ether_header *);
                    399:                                bcopy((caddr_t)edst,
                    400:                                      (caddr_t)eh->ether_dhost, sizeof (edst));
1.22      is        401:                                bcopy(LLADDR(ifp->if_sadl),
1.1       cgd       402:                                      (caddr_t)eh->ether_shost, sizeof (edst));
                    403:                        }
                    404:                }
                    405:                M_PREPEND(m, 3, M_DONTWAIT);
                    406:                if (m == NULL)
                    407:                        return (0);
                    408:                l = mtod(m, struct llc *);
                    409:                l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
                    410:                l->llc_control = LLC_UI;
1.18      christos  411: #ifdef ARGO_DEBUG
                    412:                if (argo_debug[D_ETHER]) {
1.1       cgd       413:                        int i;
1.21      christos  414:                        printf("unoutput: sending pkt to: ");
1.1       cgd       415:                        for (i=0; i<6; i++)
1.21      christos  416:                                printf("%x ", edst[i] & 0xff);
                    417:                        printf("\n");
1.18      christos  418:                }
                    419: #endif
1.8       mycroft   420:                } break;
                    421: #endif /* ISO */
                    422: #ifdef LLC
                    423: /*     case AF_NSAP: */
                    424:        case AF_CCITT: {
1.120     perry     425:                struct sockaddr_dl *sdl =
1.8       mycroft   426:                        (struct sockaddr_dl *) rt -> rt_gateway;
                    427:
                    428:                if (sdl && sdl->sdl_family == AF_LINK
                    429:                    && sdl->sdl_alen > 0) {
                    430:                        bcopy(LLADDR(sdl), (char *)edst,
                    431:                                sizeof(edst));
                    432:                } else goto bad; /* Not a link interface ? Funny ... */
                    433:                if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1) &&
                    434:                    (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
                    435:                        M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
                    436:                        if (mcopy) {
                    437:                                eh = mtod(mcopy, struct ether_header *);
                    438:                                bcopy((caddr_t)edst,
                    439:                                      (caddr_t)eh->ether_dhost, sizeof (edst));
1.22      is        440:                                bcopy(LLADDR(ifp->if_sadl),
1.8       mycroft   441:                                      (caddr_t)eh->ether_shost, sizeof (edst));
                    442:                        }
1.3       hpeyerl   443:                }
1.8       mycroft   444: #ifdef LLC_DEBUG
                    445:                {
                    446:                        int i;
1.29      mrg       447:                        struct llc *l = mtod(m, struct llc *);
1.8       mycroft   448:
1.21      christos  449:                        printf("ether_output: sending LLC2 pkt to: ");
1.8       mycroft   450:                        for (i=0; i<6; i++)
1.21      christos  451:                                printf("%x ", edst[i] & 0xff);
1.120     perry     452:                        printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n",
1.17      mycroft   453:                            m->m_pkthdr.len, l->llc_dsap & 0xff, l->llc_ssap &0xff,
                    454:                            l->llc_control & 0xff);
1.8       mycroft   455:
                    456:                }
                    457: #endif /* LLC_DEBUG */
                    458:                } break;
1.120     perry     459: #endif /* LLC */
1.1       cgd       460:
1.31      thorpej   461:        case pseudo_AF_HDRCMPLT:
                    462:                hdrcmplt = 1;
                    463:                eh = (struct ether_header *)dst->sa_data;
                    464:                bcopy((caddr_t)eh->ether_shost, (caddr_t)esrc, sizeof (esrc));
                    465:                /* FALLTHROUGH */
                    466:
1.1       cgd       467:        case AF_UNSPEC:
                    468:                eh = (struct ether_header *)dst->sa_data;
                    469:                bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
1.8       mycroft   470:                /* AF_UNSPEC doesn't swap the byte order of the ether_type. */
1.17      mycroft   471:                etype = eh->ether_type;
1.8       mycroft   472:                break;
1.1       cgd       473:
                    474:        default:
1.21      christos  475:                printf("%s: can't handle af%d\n", ifp->if_xname,
1.1       cgd       476:                        dst->sa_family);
1.8       mycroft   477:                senderr(EAFNOSUPPORT);
1.1       cgd       478:        }
                    479:
                    480:        if (mcopy)
                    481:                (void) looutput(ifp, mcopy, dst, rt);
1.16      mycroft   482:
1.50      matt      483:        /* If no ether type is set, this must be a 802.2 formatted packet.
                    484:         */
                    485:        if (etype == 0)
                    486:                etype = htons(m->m_pkthdr.len);
1.1       cgd       487:        /*
                    488:         * Add local net header.  If no space in first mbuf,
                    489:         * allocate another.
                    490:         */
                    491:        M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
1.8       mycroft   492:        if (m == 0)
                    493:                senderr(ENOBUFS);
1.1       cgd       494:        eh = mtod(m, struct ether_header *);
1.96      thorpej   495:        /* Note: etype is already in network byte order. */
                    496: #ifdef __NO_STRICT_ALIGNMENT
1.97      kristerw  497:        eh->ether_type = etype;
1.96      thorpej   498: #else
                    499:        {
                    500:                uint8_t *dstp = (uint8_t *) &eh->ether_type;
                    501: #if BYTE_ORDER == BIG_ENDIAN
                    502:                dstp[0] = etype >> 8;
1.120     perry     503:                dstp[1] = etype;
1.96      thorpej   504: #else
                    505:                dstp[0] = etype;
                    506:                dstp[1] = etype >> 8;
                    507: #endif /* BYTE_ORDER == BIG_ENDIAN */
                    508:        }
                    509: #endif /* __NO_STRICT_ALIGNMENT */
1.1       cgd       510:        bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
1.31      thorpej   511:        if (hdrcmplt)
                    512:                bcopy((caddr_t)esrc, (caddr_t)eh->ether_shost,
                    513:                    sizeof(eh->ether_shost));
                    514:        else
                    515:                bcopy(LLADDR(ifp->if_sadl), (caddr_t)eh->ether_shost,
                    516:                    sizeof(eh->ether_shost));
1.77      thorpej   517:
                    518: #ifdef PFIL_HOOKS
                    519:        if ((error = pfil_run_hooks(&ifp->if_pfil, &m, ifp, PFIL_OUT)) != 0)
                    520:                return (error);
                    521:        if (m == NULL)
                    522:                return (0);
                    523: #endif
                    524:
1.78      thorpej   525: #if NBRIDGE > 0
                    526:        /*
                    527:         * Bridges require special output handling.
                    528:         */
                    529:        if (ifp->if_bridge)
                    530:                return (bridge_output(ifp, m, NULL, NULL));
                    531: #endif
                    532:
1.77      thorpej   533: #ifdef ALTQ
                    534:        /*
                    535:         * If ALTQ is enabled on the parent interface, do
                    536:         * classification; the queueing discipline might not
                    537:         * require classification, but might require the
                    538:         * address family/header pointer in the pktattr.
                    539:         */
                    540:        if (ALTQ_IS_ENABLED(&ifp->if_snd))
                    541:                altq_etherclassify(&ifp->if_snd, m, &pktattr);
                    542: #endif
                    543:
1.122     christos  544:        return ifq_enqueue(ifp, m ALTQ_COMMA ALTQ_DECL(&pktattr));
1.1       cgd       545:
                    546: bad:
                    547:        if (m)
                    548:                m_freem(m);
                    549:        return (error);
                    550: }
1.76      thorpej   551:
                    552: #ifdef ALTQ
                    553: /*
                    554:  * This routine is a slight hack to allow a packet to be classified
                    555:  * if the Ethernet headers are present.  It will go away when ALTQ's
                    556:  * classification engine understands link headers.
                    557:  */
                    558: void
                    559: altq_etherclassify(struct ifaltq *ifq, struct mbuf *m,
                    560:     struct altq_pktattr *pktattr)
                    561: {
                    562:        struct ether_header *eh;
                    563:        u_int16_t ether_type;
                    564:        int hlen, af, hdrsize;
                    565:        caddr_t hdr;
                    566:
                    567:        hlen = ETHER_HDR_LEN;
                    568:        eh = mtod(m, struct ether_header *);
                    569:
                    570:        ether_type = htons(eh->ether_type);
                    571:
                    572:        if (ether_type < ETHERMTU) {
                    573:                /* LLC/SNAP */
                    574:                struct llc *llc = (struct llc *)(eh + 1);
                    575:                hlen += 8;
                    576:
                    577:                if (m->m_len < hlen ||
                    578:                    llc->llc_dsap != LLC_SNAP_LSAP ||
                    579:                    llc->llc_ssap != LLC_SNAP_LSAP ||
                    580:                    llc->llc_control != LLC_UI) {
                    581:                        /* Not SNAP. */
                    582:                        goto bad;
                    583:                }
                    584:
                    585:                ether_type = htons(llc->llc_un.type_snap.ether_type);
                    586:        }
                    587:
                    588:        switch (ether_type) {
                    589:        case ETHERTYPE_IP:
                    590:                af = AF_INET;
                    591:                hdrsize = 20;           /* sizeof(struct ip) */
                    592:                break;
                    593:
                    594:        case ETHERTYPE_IPV6:
                    595:                af = AF_INET6;
                    596:                hdrsize = 40;           /* sizeof(struct ip6_hdr) */
                    597:                break;
                    598:
                    599:        default:
                    600:                af = AF_UNSPEC;
                    601:                hdrsize = 0;
                    602:                break;
                    603:        }
                    604:
1.95      itojun    605:        while (m->m_len <= hlen) {
                    606:                hlen -= m->m_len;
                    607:                m = m->m_next;
                    608:        }
1.76      thorpej   609:        if (m->m_len < (hlen + hdrsize)) {
                    610:                /*
1.95      itojun    611:                 * protocol header not in a single mbuf.
                    612:                 * We can't cope with this situation right
1.76      thorpej   613:                 * now (but it shouldn't ever happen, really, anyhow).
                    614:                 */
1.92      itojun    615: #ifdef DEBUG
1.78      thorpej   616:                printf("altq_etherclassify: headers span multiple mbufs: "
                    617:                    "%d < %d\n", m->m_len, (hlen + hdrsize));
1.92      itojun    618: #endif
1.76      thorpej   619:                goto bad;
                    620:        }
                    621:
                    622:        m->m_data += hlen;
                    623:        m->m_len -= hlen;
                    624:
                    625:        hdr = mtod(m, caddr_t);
                    626:
                    627:        if (ALTQ_NEEDS_CLASSIFY(ifq))
                    628:                pktattr->pattr_class =
                    629:                    (*ifq->altq_classify)(ifq->altq_clfier, m, af);
                    630:        pktattr->pattr_af = af;
                    631:        pktattr->pattr_hdr = hdr;
                    632:
                    633:        m->m_data -= hlen;
                    634:        m->m_len += hlen;
                    635:
                    636:        return;
                    637:
                    638:  bad:
                    639:        pktattr->pattr_class = NULL;
                    640:        pktattr->pattr_hdr = NULL;
                    641:        pktattr->pattr_af = AF_UNSPEC;
                    642: }
                    643: #endif /* ALTQ */
1.1       cgd       644:
                    645: /*
                    646:  * Process a received Ethernet packet;
1.42      thorpej   647:  * the packet is in the mbuf chain m with
                    648:  * the ether header.
1.1       cgd       649:  */
1.42      thorpej   650: static void
1.58      matt      651: ether_input(struct ifnet *ifp, struct mbuf *m)
1.1       cgd       652: {
1.91      thorpej   653:        struct ethercom *ec = (struct ethercom *) ifp;
1.29      mrg       654:        struct ifqueue *inq;
1.18      christos  655:        u_int16_t etype;
1.42      thorpej   656:        struct ether_header *eh;
1.23      christos  657: #if defined (ISO) || defined (LLC) || defined(NETATALK)
1.29      mrg       658:        struct llc *l;
1.18      christos  659: #endif
1.1       cgd       660:
1.8       mycroft   661:        if ((ifp->if_flags & IFF_UP) == 0) {
                    662:                m_freem(m);
                    663:                return;
                    664:        }
1.42      thorpej   665:
1.104     matt      666: #ifdef MBUFTRACE
1.116     jonathan  667:        m_claimm(m, &ec->ec_rx_mowner);
1.104     matt      668: #endif
1.42      thorpej   669:        eh = mtod(m, struct ether_header *);
1.63      thorpej   670:        etype = ntohs(eh->ether_type);
                    671:
                    672:        /*
                    673:         * Determine if the packet is within its size limits.
                    674:         */
1.83      thorpej   675:        if (m->m_pkthdr.len >
                    676:            ETHER_MAX_FRAME(ifp, etype, m->m_flags & M_HASFCS)) {
1.123     matt      677:                if (ppsratecheck(&bigpktppslim_last, &bigpktpps_count,
                    678:                            bigpktppslim)) {
                    679:                        printf("%s: discarding oversize frame (len=%d)\n",
                    680:                            ifp->if_xname, m->m_pkthdr.len);
                    681:                }
1.63      thorpej   682:                m_freem(m);
                    683:                return;
                    684:        }
1.77      thorpej   685:
1.84      thorpej   686:        if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
                    687:                /*
                    688:                 * If this is not a simplex interface, drop the packet
                    689:                 * if it came from us.
                    690:                 */
                    691:                if ((ifp->if_flags & IFF_SIMPLEX) == 0 &&
                    692:                    memcmp(LLADDR(ifp->if_sadl), eh->ether_shost,
                    693:                    ETHER_ADDR_LEN) == 0) {
                    694:                        m_freem(m);
                    695:                        return;
                    696:                }
                    697:
                    698:                if (memcmp(etherbroadcastaddr,
                    699:                    eh->ether_dhost, ETHER_ADDR_LEN) == 0)
                    700:                        m->m_flags |= M_BCAST;
                    701:                else
                    702:                        m->m_flags |= M_MCAST;
                    703:                ifp->if_imcasts++;
                    704:        }
                    705:
1.79      thorpej   706:        /* If the CRC is still on the packet, trim it off. */
                    707:        if (m->m_flags & M_HASFCS) {
                    708:                m_adj(m, -ETHER_CRC_LEN);
                    709:                m->m_flags &= ~M_HASFCS;
                    710:        }
                    711:
1.42      thorpej   712:        ifp->if_ibytes += m->m_pkthdr.len;
1.78      thorpej   713:
                    714: #if NBRIDGE > 0
                    715:        /*
                    716:         * Tap the packet off here for a bridge.  bridge_input()
                    717:         * will return NULL if it has consumed the packet, otherwise
                    718:         * it gets processed as normal.  Note that bridge_input()
                    719:         * will always return the original packet if we need to
                    720:         * process it locally.
                    721:         */
                    722:        if (ifp->if_bridge) {
1.119     kim       723:                if(m->m_flags & M_PROTO1) {
                    724:                        m->m_flags &= ~M_PROTO1;
                    725:                } else {
                    726:                        /* clear M_PROMISC, in case the packets comes from a vlan */
                    727:                        m->m_flags &= ~M_PROMISC;
                    728:                        m = bridge_input(ifp, m);
                    729:                        if (m == NULL)
                    730:                                return;
1.78      thorpej   731:
1.119     kim       732:                        /*
                    733:                         * Bridge has determined that the packet is for us.
                    734:                         * Update our interface pointer -- we may have had
                    735:                         * to "bridge" the packet locally.
                    736:                         */
                    737:                        ifp = m->m_pkthdr.rcvif;
                    738:                }
1.120     perry     739:        } else
1.78      thorpej   740: #endif /* NBRIDGE > 0 */
1.106     bouyer    741:        {
                    742:                if ((m->m_flags & (M_BCAST|M_MCAST)) == 0 &&
                    743:                    (ifp->if_flags & IFF_PROMISC) != 0 &&
                    744:                    memcmp(LLADDR(ifp->if_sadl), eh->ether_dhost,
                    745:                           ETHER_ADDR_LEN) != 0) {
                    746:                        m->m_flags |= M_PROMISC;
                    747:                }
1.70      bouyer    748:        }
1.78      thorpej   749:
                    750: #ifdef PFIL_HOOKS
1.106     bouyer    751:        if ((m->m_flags & M_PROMISC) == 0) {
                    752:                if (pfil_run_hooks(&ifp->if_pfil, &m, ifp, PFIL_IN) != 0)
                    753:                        return;
                    754:                if (m == NULL)
                    755:                        return;
1.78      thorpej   756:
1.106     bouyer    757:                eh = mtod(m, struct ether_header *);
                    758:                etype = ntohs(eh->ether_type);
                    759:        }
1.78      thorpej   760: #endif
1.70      bouyer    761:
1.91      thorpej   762:        /*
                    763:         * If VLANs are configured on the interface, check to
                    764:         * see if the device performed the decapsulation and
                    765:         * provided us with the tag.
                    766:         */
1.114     simonb    767:        if (ec->ec_nvlans && m_tag_find(m, PACKET_TAG_VLAN, NULL) != NULL) {
1.70      bouyer    768: #if NVLAN > 0
                    769:                /*
                    770:                 * vlan_input() will either recursively call ether_input()
                    771:                 * or drop the packet.
                    772:                 */
1.91      thorpej   773:                vlan_input(ifp, m);
                    774: #else
                    775:                m_freem(m);
1.70      bouyer    776: #endif
1.61      thorpej   777:                return;
                    778:        }
1.1       cgd       779:
1.121     yamt      780: #if NAGR > 0
                    781:        if (ifp->if_agrprivate &&
                    782:            __predict_true(etype != ETHERTYPE_SLOWPROTOCOLS)) {
                    783:                m->m_flags &= ~M_PROMISC;
                    784:                agr_input(ifp, m);
                    785:                return;
                    786:        }
                    787: #endif /* NAGR > 0 */
                    788:
1.59      thorpej   789:        /*
                    790:         * Handle protocols that expect to have the Ethernet header
                    791:         * (and possibly FCS) intact.
                    792:         */
                    793:        switch (etype) {
                    794: #if NVLAN > 0
                    795:        case ETHERTYPE_VLAN:
                    796:                /*
                    797:                 * vlan_input() will either recursively call ether_input()
                    798:                 * or drop the packet.
                    799:                 */
1.63      thorpej   800:                if (((struct ethercom *)ifp)->ec_nvlans != 0)
                    801:                        vlan_input(ifp, m);
1.65      enami     802:                else
                    803:                        m_freem(m);
1.59      thorpej   804:                return;
                    805: #endif /* NVLAN > 0 */
1.81      martin    806: #if NPPPOE > 0
                    807:        case ETHERTYPE_PPPOEDISC:
                    808:        case ETHERTYPE_PPPOE:
1.106     bouyer    809:                if (m->m_flags & M_PROMISC) {
                    810:                        m_freem(m);
                    811:                        return;
                    812:                }
1.105     aymeric   813: #ifndef PPPOE_SERVER
                    814:                if (m->m_flags & (M_MCAST | M_BCAST)) {
                    815:                        m_freem(m);
                    816:                        return;
                    817:                }
                    818: #endif
                    819:
1.120     perry     820:                if (etype == ETHERTYPE_PPPOEDISC)
1.81      martin    821:                        inq = &ppoediscinq;
                    822:                else
                    823:                        inq = &ppoeinq;
                    824:                if (IF_QFULL(inq)) {
                    825:                        IF_DROP(inq);
                    826:                        m_freem(m);
                    827:                } else
                    828:                        IF_ENQUEUE(inq, m);
                    829: #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
1.103     thorpej   830:                if (!callout_pending(&pppoe_softintr))
1.81      martin    831:                        callout_reset(&pppoe_softintr, 1, pppoe_softintr_handler, NULL);
                    832: #else
                    833:                softintr_schedule(pppoe_softintr);
                    834: #endif
                    835:                return;
                    836: #endif /* NPPPOE > 0 */
1.121     yamt      837:        case ETHERTYPE_SLOWPROTOCOLS: {
                    838:                uint8_t subtype;
                    839:
                    840: #if defined(DIAGNOSTIC)
                    841:                if (m->m_pkthdr.len < sizeof(*eh) + sizeof(subtype)) {
                    842:                        panic("ether_input: too short slow protocol packet");
                    843:                }
                    844: #endif
                    845:                m_copydata(m, sizeof(*eh), sizeof(subtype), &subtype);
                    846:                switch (subtype) {
                    847: #if NAGR > 0
                    848:                case SLOWPROTOCOLS_SUBTYPE_LACP:
                    849:                        if (ifp->if_agrprivate) {
                    850:                                ieee8023ad_lacp_input(ifp, m);
                    851:                                return;
                    852:                        }
                    853:                        break;
                    854:
                    855:                case SLOWPROTOCOLS_SUBTYPE_MARKER:
                    856:                        if (ifp->if_agrprivate) {
                    857:                                ieee8023ad_marker_input(ifp, m);
                    858:                                return;
                    859:                        }
                    860:                        break;
                    861: #endif /* NAGR > 0 */
                    862:                default:
                    863:                        if (subtype == 0 || subtype > 10) {
                    864:                                /* illegal value */
                    865:                                m_freem(m);
                    866:                                return;
                    867:                        }
                    868:                        /* unknown subtype */
                    869:                        break;
                    870:                }
                    871:                /* FALLTHROUGH */
                    872:        }
1.59      thorpej   873:        default:
1.106     bouyer    874:                if (m->m_flags & M_PROMISC) {
                    875:                        m_freem(m);
                    876:                        return;
                    877:                }
1.59      thorpej   878:        }
1.42      thorpej   879:
                    880:        /* Strip off the Ethernet header. */
                    881:        m_adj(m, sizeof(struct ether_header));
1.45      thorpej   882:
                    883:        /* If the CRC is still on the packet, trim it off. */
1.79      thorpej   884:        if (m->m_flags & M_HASFCS) {
1.45      thorpej   885:                m_adj(m, -ETHER_CRC_LEN);
1.79      thorpej   886:                m->m_flags &= ~M_HASFCS;
                    887:        }
1.42      thorpej   888:
1.5       deraadt   889:        switch (etype) {
1.1       cgd       890: #ifdef INET
                    891:        case ETHERTYPE_IP:
1.30      matt      892: #ifdef GATEWAY
                    893:                if (ipflow_fastforward(m))
                    894:                        return;
                    895: #endif
1.1       cgd       896:                schednetisr(NETISR_IP);
                    897:                inq = &ipintrq;
                    898:                break;
                    899:
                    900:        case ETHERTYPE_ARP:
1.8       mycroft   901:                schednetisr(NETISR_ARP);
                    902:                inq = &arpintrq;
                    903:                break;
1.7       glass     904:
                    905:        case ETHERTYPE_REVARP:
1.8       mycroft   906:                revarpinput(m); /* XXX queue? */
1.1       cgd       907:                return;
                    908: #endif
1.44      itojun    909: #ifdef INET6
                    910:        case ETHERTYPE_IPV6:
                    911:                schednetisr(NETISR_IPV6);
                    912:                inq = &ip6intrq;
                    913:                break;
                    914: #endif
1.1       cgd       915: #ifdef NS
                    916:        case ETHERTYPE_NS:
                    917:                schednetisr(NETISR_NS);
                    918:                inq = &nsintrq;
                    919:                break;
                    920:
1.32      christos  921: #endif
                    922: #ifdef IPX
                    923:        case ETHERTYPE_IPX:
                    924:                schednetisr(NETISR_IPX);
                    925:                inq = &ipxintrq;
                    926:                break;
1.1       cgd       927: #endif
1.23      christos  928: #ifdef NETATALK
1.38      kim       929:         case ETHERTYPE_ATALK:
1.23      christos  930:                 schednetisr(NETISR_ATALK);
                    931:                 inq = &atintrq1;
                    932:                 break;
                    933:         case ETHERTYPE_AARP:
                    934:                /* probably this should be done with a NETISR as well */
                    935:                 aarpinput(ifp, m); /* XXX */
                    936:                 return;
                    937: #endif /* NETATALK */
1.1       cgd       938:        default:
1.23      christos  939: #if defined (ISO) || defined (LLC) || defined (NETATALK)
1.11      mycroft   940:                if (etype > ETHERMTU)
1.1       cgd       941:                        goto dropanyway;
                    942:                l = mtod(m, struct llc *);
1.8       mycroft   943:                switch (l->llc_dsap) {
1.23      christos  944: #ifdef NETATALK
                    945:                case LLC_SNAP_LSAP:
                    946:                        switch (l->llc_control) {
                    947:                        case LLC_UI:
                    948:                                if (l->llc_ssap != LLC_SNAP_LSAP) {
                    949:                                        goto dropanyway;
                    950:                                }
1.120     perry     951:
1.23      christos  952:                                if (Bcmp(&(l->llc_snap_org_code)[0],
                    953:                                    at_org_code, sizeof(at_org_code)) == 0 &&
                    954:                                    ntohs(l->llc_snap_ether_type) ==
1.38      kim       955:                                    ETHERTYPE_ATALK) {
1.23      christos  956:                                        inq = &atintrq2;
                    957:                                        m_adj(m, sizeof(struct llc));
                    958:                                        schednetisr(NETISR_ATALK);
                    959:                                        break;
                    960:                                }
                    961:
                    962:                                if (Bcmp(&(l->llc_snap_org_code)[0],
                    963:                                    aarp_org_code,
                    964:                                    sizeof(aarp_org_code)) == 0 &&
                    965:                                    ntohs(l->llc_snap_ether_type) ==
                    966:                                    ETHERTYPE_AARP) {
                    967:                                        m_adj( m, sizeof(struct llc));
                    968:                                        aarpinput(ifp, m); /* XXX */
                    969:                                    return;
                    970:                                }
1.120     perry     971:
1.23      christos  972:                        default:
                    973:                                goto dropanyway;
                    974:                        }
                    975:                        break;
                    976: #endif /* NETATALK */
1.8       mycroft   977: #ifdef ISO
1.120     perry     978:                case LLC_ISO_LSAP:
1.8       mycroft   979:                        switch (l->llc_control) {
                    980:                        case LLC_UI:
                    981:                                /* LLC_UI_P forbidden in class 1 service */
                    982:                                if ((l->llc_dsap == LLC_ISO_LSAP) &&
                    983:                                    (l->llc_ssap == LLC_ISO_LSAP)) {
                    984:                                        /* LSAP for ISO */
1.11      mycroft   985:                                        if (m->m_pkthdr.len > etype)
                    986:                                                m_adj(m, etype - m->m_pkthdr.len);
1.8       mycroft   987:                                        m->m_data += 3;         /* XXX */
                    988:                                        m->m_len -= 3;          /* XXX */
                    989:                                        m->m_pkthdr.len -= 3;   /* XXX */
                    990:                                        M_PREPEND(m, sizeof *eh, M_DONTWAIT);
                    991:                                        if (m == 0)
                    992:                                                return;
                    993:                                        *mtod(m, struct ether_header *) = *eh;
1.18      christos  994: #ifdef ARGO_DEBUG
                    995:                                        if (argo_debug[D_ETHER])
1.21      christos  996:                                                printf("clnp packet");
1.18      christos  997: #endif
1.8       mycroft   998:                                        schednetisr(NETISR_ISO);
                    999:                                        inq = &clnlintrq;
                   1000:                                        break;
                   1001:                                }
                   1002:                                goto dropanyway;
1.120     perry    1003:
1.8       mycroft  1004:                        case LLC_XID:
                   1005:                        case LLC_XID_P:
                   1006:                                if(m->m_len < 6)
                   1007:                                        goto dropanyway;
                   1008:                                l->llc_window = 0;
                   1009:                                l->llc_fid = 9;
                   1010:                                l->llc_class = 1;
                   1011:                                l->llc_dsap = l->llc_ssap = 0;
                   1012:                                /* Fall through to */
                   1013:                        case LLC_TEST:
                   1014:                        case LLC_TEST_P:
                   1015:                        {
                   1016:                                struct sockaddr sa;
1.29      mrg      1017:                                struct ether_header *eh2;
1.8       mycroft  1018:                                int i;
                   1019:                                u_char c = l->llc_dsap;
                   1020:
                   1021:                                l->llc_dsap = l->llc_ssap;
                   1022:                                l->llc_ssap = c;
                   1023:                                if (m->m_flags & (M_BCAST | M_MCAST))
1.22      is       1024:                                        bcopy(LLADDR(ifp->if_sadl),
1.8       mycroft  1025:                                              (caddr_t)eh->ether_dhost, 6);
                   1026:                                sa.sa_family = AF_UNSPEC;
                   1027:                                sa.sa_len = sizeof(sa);
                   1028:                                eh2 = (struct ether_header *)sa.sa_data;
                   1029:                                for (i = 0; i < 6; i++) {
1.120     perry    1030:                                        eh2->ether_shost[i] = c =
1.22      is       1031:                                            eh->ether_dhost[i];
1.120     perry    1032:                                        eh2->ether_dhost[i] =
1.22      is       1033:                                            eh->ether_dhost[i] =
                   1034:                                            eh->ether_shost[i];
1.8       mycroft  1035:                                        eh->ether_shost[i] = c;
                   1036:                                }
                   1037:                                ifp->if_output(ifp, m, &sa, NULL);
                   1038:                                return;
                   1039:                        }
                   1040:                        default:
                   1041:                                m_freem(m);
                   1042:                                return;
                   1043:                        }
                   1044:                        break;
                   1045: #endif /* ISO */
                   1046: #ifdef LLC
                   1047:                case LLC_X25_LSAP:
                   1048:                {
1.11      mycroft  1049:                        if (m->m_pkthdr.len > etype)
                   1050:                                m_adj(m, etype - m->m_pkthdr.len);
1.8       mycroft  1051:                        M_PREPEND(m, sizeof(struct sdl_hdr) , M_DONTWAIT);
1.1       cgd      1052:                        if (m == 0)
                   1053:                                return;
1.8       mycroft  1054:                        if ( !sdl_sethdrif(ifp, eh->ether_shost, LLC_X25_LSAP,
1.120     perry    1055:                                            eh->ether_dhost, LLC_X25_LSAP, 6,
1.8       mycroft  1056:                                            mtod(m, struct sdl_hdr *)))
                   1057:                                panic("ETHER cons addr failure");
1.11      mycroft  1058:                        mtod(m, struct sdl_hdr *)->sdlhdr_len = etype;
1.8       mycroft  1059: #ifdef LLC_DEBUG
1.21      christos 1060:                                printf("llc packet\n");
1.8       mycroft  1061: #endif /* LLC_DEBUG */
                   1062:                        schednetisr(NETISR_CCITT);
                   1063:                        inq = &llcintrq;
1.1       cgd      1064:                        break;
                   1065:                }
1.8       mycroft  1066: #endif /* LLC */
1.1       cgd      1067:                dropanyway:
                   1068:                default:
1.8       mycroft  1069:                        m_freem(m);
                   1070:                        return;
                   1071:                }
1.23      christos 1072: #else /* ISO || LLC  || NETATALK*/
1.1       cgd      1073:            m_freem(m);
                   1074:            return;
1.23      christos 1075: #endif /* ISO || LLC || NETATALK*/
1.1       cgd      1076:        }
                   1077:
                   1078:        if (IF_QFULL(inq)) {
                   1079:                IF_DROP(inq);
                   1080:                m_freem(m);
                   1081:        } else
                   1082:                IF_ENQUEUE(inq, m);
                   1083: }
                   1084:
                   1085: /*
                   1086:  * Convert Ethernet address to printable (loggable) representation.
                   1087:  */
                   1088: char *
1.58      matt     1089: ether_sprintf(const u_char *ap)
1.1       cgd      1090: {
                   1091:        static char etherbuf[18];
1.29      mrg      1092:        char *cp = etherbuf;
                   1093:        int i;
1.1       cgd      1094:
                   1095:        for (i = 0; i < 6; i++) {
1.124     christos 1096:                *cp++ = hexdigits[*ap >> 4];
                   1097:                *cp++ = hexdigits[*ap++ & 0xf];
1.1       cgd      1098:                *cp++ = ':';
                   1099:        }
                   1100:        *--cp = 0;
                   1101:        return (etherbuf);
                   1102: }
1.8       mycroft  1103:
                   1104: /*
                   1105:  * Perform common duties while attaching to interface list
                   1106:  */
                   1107: void
1.58      matt     1108: ether_ifattach(struct ifnet *ifp, const u_int8_t *lla)
1.8       mycroft  1109: {
1.104     matt     1110:        struct ethercom *ec = (struct ethercom *)ifp;
1.8       mycroft  1111:
                   1112:        ifp->if_type = IFT_ETHER;
1.75      thorpej  1113:        ifp->if_addrlen = ETHER_ADDR_LEN;
1.94      enami    1114:        ifp->if_hdrlen = ETHER_HDR_LEN;
1.73      thorpej  1115:        ifp->if_dlt = DLT_EN10MB;
1.8       mycroft  1116:        ifp->if_mtu = ETHERMTU;
1.12      mycroft  1117:        ifp->if_output = ether_output;
1.42      thorpej  1118:        ifp->if_input = ether_input;
1.54      thorpej  1119:        if (ifp->if_baudrate == 0)
                   1120:                ifp->if_baudrate = IF_Mbps(10);         /* just a default */
1.75      thorpej  1121:
                   1122:        if_alloc_sadl(ifp);
                   1123:        memcpy(LLADDR(ifp->if_sadl), lla, ifp->if_addrlen);
                   1124:
1.104     matt     1125:        LIST_INIT(&ec->ec_multiaddrs);
1.26      is       1126:        ifp->if_broadcastaddr = etherbroadcastaddr;
1.69      thorpej  1127: #if NBPFILTER > 0
1.71      thorpej  1128:        bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
1.69      thorpej  1129: #endif
1.104     matt     1130: #ifdef MBUFTRACE
1.108     itojun   1131:        strlcpy(ec->ec_tx_mowner.mo_name, ifp->if_xname,
                   1132:            sizeof(ec->ec_tx_mowner.mo_name));
                   1133:        strlcpy(ec->ec_tx_mowner.mo_descr, "tx",
                   1134:            sizeof(ec->ec_tx_mowner.mo_descr));
                   1135:        strlcpy(ec->ec_rx_mowner.mo_name, ifp->if_xname,
                   1136:            sizeof(ec->ec_rx_mowner.mo_name));
                   1137:        strlcpy(ec->ec_rx_mowner.mo_descr, "rx",
                   1138:            sizeof(ec->ec_rx_mowner.mo_descr));
1.104     matt     1139:        MOWNER_ATTACH(&ec->ec_tx_mowner);
                   1140:        MOWNER_ATTACH(&ec->ec_rx_mowner);
                   1141:        ifp->if_mowner = &ec->ec_tx_mowner;
                   1142: #endif
1.52      thorpej  1143: }
                   1144:
                   1145: void
1.58      matt     1146: ether_ifdetach(struct ifnet *ifp)
1.52      thorpej  1147: {
1.63      thorpej  1148:        struct ethercom *ec = (void *) ifp;
                   1149:        struct ether_multi *enm;
                   1150:        int s;
1.69      thorpej  1151:
1.115     dyoung   1152: #if NBRIDGE > 0
                   1153:        if (ifp->if_bridge)
                   1154:                bridge_ifdetach(ifp);
                   1155: #endif
                   1156:
1.69      thorpej  1157: #if NBPFILTER > 0
                   1158:        bpfdetach(ifp);
                   1159: #endif
1.64      thorpej  1160:
                   1161: #if NVLAN > 0
                   1162:        if (ec->ec_nvlans)
                   1163:                vlan_ifdetach(ifp);
                   1164: #endif
1.63      thorpej  1165:
1.79      thorpej  1166:        s = splnet();
1.63      thorpej  1167:        while ((enm = LIST_FIRST(&ec->ec_multiaddrs)) != NULL) {
                   1168:                LIST_REMOVE(enm, enm_list);
1.100     jdolecek 1169:                free(enm, M_IFMADDR);
1.63      thorpej  1170:                ec->ec_multicnt--;
                   1171:        }
                   1172:        splx(s);
1.52      thorpej  1173:
1.109     itojun   1174: #if 0  /* done in if_detach() */
1.75      thorpej  1175:        if_free_sadl(ifp);
1.109     itojun   1176: #endif
1.104     matt     1177:
                   1178:        MOWNER_DETACH(&ec->ec_rx_mowner);
                   1179:        MOWNER_DETACH(&ec->ec_tx_mowner);
1.53      thorpej  1180: }
                   1181:
1.56      thorpej  1182: #if 0
                   1183: /*
                   1184:  * This is for reference.  We have a table-driven version
                   1185:  * of the little-endian crc32 generator, which is faster
                   1186:  * than the double-loop.
                   1187:  */
1.53      thorpej  1188: u_int32_t
1.58      matt     1189: ether_crc32_le(const u_int8_t *buf, size_t len)
1.53      thorpej  1190: {
                   1191:        u_int32_t c, crc, carry;
                   1192:        size_t i, j;
                   1193:
                   1194:        crc = 0xffffffffU;      /* initial value */
                   1195:
                   1196:        for (i = 0; i < len; i++) {
                   1197:                c = buf[i];
                   1198:                for (j = 0; j < 8; j++) {
                   1199:                        carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
                   1200:                        crc >>= 1;
                   1201:                        c >>= 1;
                   1202:                        if (carry)
1.56      thorpej  1203:                                crc = (crc ^ ETHER_CRC_POLY_LE);
1.53      thorpej  1204:                }
                   1205:        }
                   1206:
                   1207:        return (crc);
                   1208: }
1.56      thorpej  1209: #else
                   1210: u_int32_t
1.58      matt     1211: ether_crc32_le(const u_int8_t *buf, size_t len)
1.56      thorpej  1212: {
                   1213:        static const u_int32_t crctab[] = {
                   1214:                0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
                   1215:                0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
                   1216:                0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
                   1217:                0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
                   1218:        };
                   1219:        u_int32_t crc;
1.98      thorpej  1220:        size_t i;
1.56      thorpej  1221:
                   1222:        crc = 0xffffffffU;      /* initial value */
                   1223:
                   1224:        for (i = 0; i < len; i++) {
                   1225:                crc ^= buf[i];
                   1226:                crc = (crc >> 4) ^ crctab[crc & 0xf];
                   1227:                crc = (crc >> 4) ^ crctab[crc & 0xf];
                   1228:        }
                   1229:
                   1230:        return (crc);
                   1231: }
                   1232: #endif
1.53      thorpej  1233:
                   1234: u_int32_t
1.58      matt     1235: ether_crc32_be(const u_int8_t *buf, size_t len)
1.53      thorpej  1236: {
                   1237:        u_int32_t c, crc, carry;
                   1238:        size_t i, j;
                   1239:
                   1240:        crc = 0xffffffffU;      /* initial value */
                   1241:
                   1242:        for (i = 0; i < len; i++) {
                   1243:                c = buf[i];
                   1244:                for (j = 0; j < 8; j++) {
                   1245:                        carry = ((crc & 0x80000000U) ? 1 : 0) ^ (c & 0x01);
                   1246:                        crc <<= 1;
                   1247:                        c >>= 1;
                   1248:                        if (carry)
                   1249:                                crc = (crc ^ ETHER_CRC_POLY_BE) | carry;
                   1250:                }
                   1251:        }
                   1252:
                   1253:        return (crc);
1.8       mycroft  1254: }
                   1255:
1.48      is       1256: #ifdef INET
1.118     yamt     1257: const uint8_t ether_ipmulticast_min[ETHER_ADDR_LEN] =
                   1258:     { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
                   1259: const uint8_t ether_ipmulticast_max[ETHER_ADDR_LEN] =
                   1260:     { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
1.48      is       1261: #endif
1.44      itojun   1262: #ifdef INET6
1.118     yamt     1263: const uint8_t ether_ip6multicast_min[ETHER_ADDR_LEN] =
                   1264:     { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
                   1265: const uint8_t ether_ip6multicast_max[ETHER_ADDR_LEN] =
                   1266:     { 0x33, 0x33, 0xff, 0xff, 0xff, 0xff };
1.44      itojun   1267: #endif
1.60      enami    1268:
1.3       hpeyerl  1269: /*
1.60      enami    1270:  * Convert a sockaddr into an Ethernet address or range of Ethernet
                   1271:  * addresses.
1.3       hpeyerl  1272:  */
                   1273: int
1.60      enami    1274: ether_multiaddr(struct sockaddr *sa, u_int8_t addrlo[ETHER_ADDR_LEN],
                   1275:     u_int8_t addrhi[ETHER_ADDR_LEN])
1.3       hpeyerl  1276: {
1.24      christos 1277: #ifdef INET
1.3       hpeyerl  1278:        struct sockaddr_in *sin;
1.24      christos 1279: #endif /* INET */
1.44      itojun   1280: #ifdef INET6
                   1281:        struct sockaddr_in6 *sin6;
                   1282: #endif /* INET6 */
1.3       hpeyerl  1283:
1.60      enami    1284:        switch (sa->sa_family) {
1.3       hpeyerl  1285:
                   1286:        case AF_UNSPEC:
1.60      enami    1287:                bcopy(sa->sa_data, addrlo, ETHER_ADDR_LEN);
                   1288:                bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
1.3       hpeyerl  1289:                break;
                   1290:
                   1291: #ifdef INET
                   1292:        case AF_INET:
1.60      enami    1293:                sin = satosin(sa);
1.3       hpeyerl  1294:                if (sin->sin_addr.s_addr == INADDR_ANY) {
                   1295:                        /*
1.60      enami    1296:                         * An IP address of INADDR_ANY means listen to
                   1297:                         * or stop listening to all of the Ethernet
                   1298:                         * multicast addresses used for IP.
1.3       hpeyerl  1299:                         * (This is for the sake of IP multicast routers.)
                   1300:                         */
1.60      enami    1301:                        bcopy(ether_ipmulticast_min, addrlo, ETHER_ADDR_LEN);
                   1302:                        bcopy(ether_ipmulticast_max, addrhi, ETHER_ADDR_LEN);
1.3       hpeyerl  1303:                }
                   1304:                else {
                   1305:                        ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
1.60      enami    1306:                        bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
1.3       hpeyerl  1307:                }
                   1308:                break;
                   1309: #endif
1.44      itojun   1310: #ifdef INET6
                   1311:        case AF_INET6:
1.60      enami    1312:                sin6 = satosin6(sa);
1.47      itojun   1313:                if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
1.44      itojun   1314:                        /*
1.60      enami    1315:                         * An IP6 address of 0 means listen to or stop
                   1316:                         * listening to all of the Ethernet multicast
                   1317:                         * address used for IP6.
1.44      itojun   1318:                         * (This is used for multicast routers.)
                   1319:                         */
                   1320:                        bcopy(ether_ip6multicast_min, addrlo, ETHER_ADDR_LEN);
                   1321:                        bcopy(ether_ip6multicast_max, addrhi, ETHER_ADDR_LEN);
                   1322:                } else {
                   1323:                        ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, addrlo);
                   1324:                        bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
                   1325:                }
                   1326:                break;
                   1327: #endif
1.3       hpeyerl  1328:
                   1329:        default:
1.60      enami    1330:                return (EAFNOSUPPORT);
                   1331:        }
                   1332:        return (0);
                   1333: }
                   1334:
                   1335: /*
                   1336:  * Add an Ethernet multicast address or range of addresses to the list for a
                   1337:  * given interface.
                   1338:  */
                   1339: int
                   1340: ether_addmulti(struct ifreq *ifr, struct ethercom *ec)
                   1341: {
                   1342:        struct ether_multi *enm;
                   1343:        u_char addrlo[ETHER_ADDR_LEN];
                   1344:        u_char addrhi[ETHER_ADDR_LEN];
1.79      thorpej  1345:        int s = splnet(), error;
1.60      enami    1346:
                   1347:        error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
                   1348:        if (error != 0) {
1.3       hpeyerl  1349:                splx(s);
1.60      enami    1350:                return (error);
1.3       hpeyerl  1351:        }
                   1352:
                   1353:        /*
                   1354:         * Verify that we have valid Ethernet multicast addresses.
                   1355:         */
                   1356:        if ((addrlo[0] & 0x01) != 1 || (addrhi[0] & 0x01) != 1) {
                   1357:                splx(s);
                   1358:                return (EINVAL);
                   1359:        }
                   1360:        /*
                   1361:         * See if the address range is already in the list.
                   1362:         */
1.22      is       1363:        ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
1.3       hpeyerl  1364:        if (enm != NULL) {
                   1365:                /*
                   1366:                 * Found it; just increment the reference count.
                   1367:                 */
                   1368:                ++enm->enm_refcount;
                   1369:                splx(s);
                   1370:                return (0);
                   1371:        }
                   1372:        /*
                   1373:         * New address or range; malloc a new multicast record
                   1374:         * and link it into the interface's multicast list.
                   1375:         */
                   1376:        enm = (struct ether_multi *)malloc(sizeof(*enm), M_IFMADDR, M_NOWAIT);
                   1377:        if (enm == NULL) {
                   1378:                splx(s);
                   1379:                return (ENOBUFS);
                   1380:        }
                   1381:        bcopy(addrlo, enm->enm_addrlo, 6);
                   1382:        bcopy(addrhi, enm->enm_addrhi, 6);
                   1383:        enm->enm_refcount = 1;
1.22      is       1384:        LIST_INSERT_HEAD(&ec->ec_multiaddrs, enm, enm_list);
                   1385:        ec->ec_multicnt++;
1.3       hpeyerl  1386:        splx(s);
                   1387:        /*
                   1388:         * Return ENETRESET to inform the driver that the list has changed
                   1389:         * and its reception filter should be adjusted accordingly.
                   1390:         */
                   1391:        return (ENETRESET);
                   1392: }
                   1393:
                   1394: /*
                   1395:  * Delete a multicast address record.
                   1396:  */
                   1397: int
1.58      matt     1398: ether_delmulti(struct ifreq *ifr, struct ethercom *ec)
1.3       hpeyerl  1399: {
1.29      mrg      1400:        struct ether_multi *enm;
1.60      enami    1401:        u_char addrlo[ETHER_ADDR_LEN];
                   1402:        u_char addrhi[ETHER_ADDR_LEN];
1.79      thorpej  1403:        int s = splnet(), error;
1.3       hpeyerl  1404:
1.60      enami    1405:        error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
                   1406:        if (error != 0) {
1.3       hpeyerl  1407:                splx(s);
1.60      enami    1408:                return (error);
1.3       hpeyerl  1409:        }
                   1410:
                   1411:        /*
1.66      thorpej  1412:         * Look ur the address in our list.
1.3       hpeyerl  1413:         */
1.22      is       1414:        ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
1.3       hpeyerl  1415:        if (enm == NULL) {
                   1416:                splx(s);
                   1417:                return (ENXIO);
                   1418:        }
                   1419:        if (--enm->enm_refcount != 0) {
                   1420:                /*
                   1421:                 * Still some claims to this record.
                   1422:                 */
                   1423:                splx(s);
                   1424:                return (0);
                   1425:        }
                   1426:        /*
                   1427:         * No remaining claims to this record; unlink and free it.
                   1428:         */
1.13      mycroft  1429:        LIST_REMOVE(enm, enm_list);
1.3       hpeyerl  1430:        free(enm, M_IFMADDR);
1.22      is       1431:        ec->ec_multicnt--;
1.3       hpeyerl  1432:        splx(s);
                   1433:        /*
                   1434:         * Return ENETRESET to inform the driver that the list has changed
                   1435:         * and its reception filter should be adjusted accordingly.
                   1436:         */
                   1437:        return (ENETRESET);
1.66      thorpej  1438: }
                   1439:
                   1440: /*
                   1441:  * Common ioctls for Ethernet interfaces.  Note, we must be
                   1442:  * called at splnet().
                   1443:  */
                   1444: int
                   1445: ether_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
                   1446: {
                   1447:        struct ethercom *ec = (void *) ifp;
                   1448:        struct ifreq *ifr = (struct ifreq *)data;
                   1449:        struct ifaddr *ifa = (struct ifaddr *)data;
                   1450:        int error = 0;
                   1451:
                   1452:        switch (cmd) {
                   1453:        case SIOCSIFADDR:
                   1454:                ifp->if_flags |= IFF_UP;
                   1455:                switch (ifa->ifa_addr->sa_family) {
1.75      thorpej  1456:                case AF_LINK:
                   1457:                    {
                   1458:                        struct sockaddr_dl *sdl =
                   1459:                            (struct sockaddr_dl *) ifa->ifa_addr;
                   1460:
                   1461:                        if (sdl->sdl_type != IFT_ETHER ||
                   1462:                            sdl->sdl_alen != ifp->if_addrlen) {
                   1463:                                error = EINVAL;
                   1464:                                break;
                   1465:                        }
                   1466:
                   1467:                        memcpy(LLADDR(ifp->if_sadl), LLADDR(sdl),
                   1468:                            ifp->if_addrlen);
                   1469:
                   1470:                        /* Set new address. */
                   1471:                        error = (*ifp->if_init)(ifp);
                   1472:                        break;
                   1473:                    }
1.66      thorpej  1474: #ifdef INET
                   1475:                case AF_INET:
1.86      thorpej  1476:                        if ((ifp->if_flags & IFF_RUNNING) == 0 &&
                   1477:                            (error = (*ifp->if_init)(ifp)) != 0)
1.66      thorpej  1478:                                break;
                   1479:                        arp_ifinit(ifp, ifa);
                   1480:                        break;
                   1481: #endif /* INET */
                   1482: #ifdef NS
                   1483:                case AF_NS:
                   1484:                    {
                   1485:                        struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
                   1486:
                   1487:                        if (ns_nullhost(*ina))
                   1488:                                ina->x_host = *(union ns_host *)
                   1489:                                    LLADDR(ifp->if_sadl);
                   1490:                        else
                   1491:                                memcpy(LLADDR(ifp->if_sadl),
                   1492:                                    ina->x_host.c_host, ifp->if_addrlen);
                   1493:                        /* Set new address. */
                   1494:                        error = (*ifp->if_init)(ifp);
                   1495:                        break;
                   1496:                    }
                   1497: #endif /* NS */
                   1498:                default:
1.86      thorpej  1499:                        if ((ifp->if_flags & IFF_RUNNING) == 0)
                   1500:                                error = (*ifp->if_init)(ifp);
1.66      thorpej  1501:                        break;
                   1502:                }
                   1503:                break;
                   1504:
                   1505:        case SIOCGIFADDR:
                   1506:                memcpy(((struct sockaddr *)&ifr->ifr_data)->sa_data,
                   1507:                    LLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
                   1508:                break;
                   1509:
                   1510:        case SIOCSIFMTU:
1.82      thorpej  1511:            {
                   1512:                int maxmtu;
                   1513:
                   1514:                if (ec->ec_capabilities & ETHERCAP_JUMBO_MTU)
                   1515:                        maxmtu = ETHERMTU_JUMBO;
                   1516:                else
                   1517:                        maxmtu = ETHERMTU;
                   1518:
                   1519:                if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > maxmtu)
1.66      thorpej  1520:                        error = EINVAL;
1.88      thorpej  1521:                else {
1.66      thorpej  1522:                        ifp->if_mtu = ifr->ifr_mtu;
1.87      thorpej  1523:
1.88      thorpej  1524:                        /* Make sure the device notices the MTU change. */
                   1525:                        if (ifp->if_flags & IFF_UP)
                   1526:                                error = (*ifp->if_init)(ifp);
                   1527:                }
1.66      thorpej  1528:                break;
1.82      thorpej  1529:            }
1.66      thorpej  1530:
                   1531:        case SIOCSIFFLAGS:
                   1532:                if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_RUNNING) {
                   1533:                        /*
                   1534:                         * If interface is marked down and it is running,
                   1535:                         * then stop and disable it.
                   1536:                         */
                   1537:                        (*ifp->if_stop)(ifp, 1);
                   1538:                } else if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_UP) {
                   1539:                        /*
                   1540:                         * If interface is marked up and it is stopped, then
                   1541:                         * start it.
                   1542:                         */
                   1543:                        error = (*ifp->if_init)(ifp);
                   1544:                } else if ((ifp->if_flags & IFF_UP) != 0) {
                   1545:                        /*
                   1546:                         * Reset the interface to pick up changes in any other
                   1547:                         * flags that affect the hardware state.
                   1548:                         */
                   1549:                        error = (*ifp->if_init)(ifp);
                   1550:                }
                   1551:                break;
                   1552:
                   1553:        case SIOCADDMULTI:
1.74      augustss 1554:                error = ether_addmulti(ifr, ec);
                   1555:                break;
                   1556:
1.66      thorpej  1557:        case SIOCDELMULTI:
1.74      augustss 1558:                error = ether_delmulti(ifr, ec);
1.66      thorpej  1559:                break;
                   1560:
                   1561:        default:
                   1562:                error = ENOTTY;
                   1563:        }
                   1564:
                   1565:        return (error);
1.3       hpeyerl  1566: }

CVSweb <webmaster@jp.NetBSD.org>