The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net/if_arcsubr.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: if_arcsubr.c,v 1.45 2004/03/25 10:53:46 is Exp $       */
    2 
    3 /*
    4  * Copyright (c) 1994, 1995 Ignatios Souvatzis
    5  * Copyright (c) 1982, 1989, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  * from: NetBSD: if_ethersubr.c,v 1.9 1994/06/29 06:36:11 cgd Exp
   33  *       @(#)if_ethersubr.c     8.1 (Berkeley) 6/10/93
   34  *
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __KERNEL_RCSID(0, "$NetBSD: if_arcsubr.c,v 1.45 2004/03/25 10:53:46 is Exp $");
   39 
   40 #include "opt_inet.h"
   41 
   42 #include "bpfilter.h"
   43 
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/kernel.h>
   47 #include <sys/malloc.h>
   48 #include <sys/mbuf.h>
   49 #include <sys/protosw.h>
   50 #include <sys/socket.h>
   51 #include <sys/ioctl.h>
   52 #include <sys/errno.h>
   53 #include <sys/syslog.h>
   54 
   55 #include <machine/cpu.h>
   56 
   57 #include <net/if.h>
   58 #include <net/netisr.h>
   59 #include <net/route.h>
   60 #include <net/if_dl.h>
   61 #include <net/if_types.h>
   62 #include <net/if_arc.h>
   63 #include <net/if_arp.h>
   64 #include <net/if_ether.h>
   65 
   66 #if NBPFILTER > 0
   67 #include <net/bpf.h>
   68 #endif
   69 
   70 #ifdef INET
   71 #include <netinet/in.h>
   72 #include <netinet/in_var.h>
   73 #include <netinet/if_inarp.h>
   74 #endif
   75 
   76 #ifdef INET6
   77 #ifndef INET
   78 #include <netinet/in.h>
   79 #endif
   80 #include <netinet6/in6_var.h>
   81 #include <netinet6/nd6.h>
   82 #endif
   83 
   84 #define ARCNET_ALLOW_BROKEN_ARP
   85 
   86 #ifndef ARC_IPMTU
   87 #define ARC_IPMTU       1500
   88 #endif
   89 
   90 static struct mbuf *arc_defrag __P((struct ifnet *, struct mbuf *));
   91 
   92 /*
   93  * RC1201 requires us to have this configurable. We have it only per 
   94  * machine at the moment... there is no generic "set mtu" ioctl, AFAICS.
   95  * Anyway, it is possible to binpatch this or set it per kernel config
   96  * option.
   97  */
   98 #if ARC_IPMTU > 60480
   99 ERROR: The arc_ipmtu is ARC_IPMTU, but must not exceed 60480.
  100 #endif
  101 int arc_ipmtu = ARC_IPMTU;
  102 u_int8_t  arcbroadcastaddr = 0;
  103 
  104 #define senderr(e) { error = (e); goto bad;}
  105 #define SIN(s) ((struct sockaddr_in *)s)
  106 
  107 static  int arc_output __P((struct ifnet *, struct mbuf *,
  108             struct sockaddr *, struct rtentry *));
  109 static  void arc_input __P((struct ifnet *, struct mbuf *));
  110 
  111 /*
  112  * ARCnet output routine.
  113  * Encapsulate a packet of type family for the local net.
  114  * Assumes that ifp is actually pointer to arccom structure.
  115  */
  116 static int
  117 arc_output(ifp, m0, dst, rt0)
  118         struct ifnet *ifp;
  119         struct mbuf *m0;
  120         struct sockaddr *dst;
  121         struct rtentry *rt0;
  122 {
  123         struct mbuf             *m, *m1, *mcopy;
  124         struct rtentry          *rt;
  125         struct arccom           *ac;
  126         struct arc_header       *ah;
  127         struct arphdr           *arph;
  128         int                     s, error, newencoding, len;
  129         u_int8_t                atype, adst, myself;
  130         int                     tfrags, sflag, fsflag, rsflag;
  131         ALTQ_DECL(struct altq_pktattr pktattr;)
  132 
  133         if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) 
  134                 return (ENETDOWN); /* m, m1 aren't initialized yet */
  135 
  136         error = newencoding = 0;
  137         ac = (struct arccom *)ifp;
  138         m = m0;
  139         mcopy = m1 = NULL;
  140 
  141         myself = *LLADDR(ifp->if_sadl);
  142 
  143         if ((rt = rt0)) {
  144                 if ((rt->rt_flags & RTF_UP) == 0) {
  145                         if ((rt0 = rt = rtalloc1(dst, 1)))
  146                                 rt->rt_refcnt--;
  147                         else 
  148                                 senderr(EHOSTUNREACH);
  149                 }
  150                 if (rt->rt_flags & RTF_GATEWAY) {
  151                         if (rt->rt_gwroute == 0)
  152                                 goto lookup;
  153                         if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
  154                                 rtfree(rt); rt = rt0;
  155                         lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1);
  156                                 if ((rt = rt->rt_gwroute) == 0)
  157                                         senderr(EHOSTUNREACH);
  158                         }
  159                 }
  160                 if (rt->rt_flags & RTF_REJECT)
  161                         if (rt->rt_rmx.rmx_expire == 0 ||
  162                             time.tv_sec < rt->rt_rmx.rmx_expire)
  163                                 senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
  164         }
  165 
  166         /*
  167          * if the queueing discipline needs packet classification,
  168          * do it before prepending link headers.
  169          */
  170         IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family, &pktattr);
  171 
  172         switch (dst->sa_family) {
  173 #ifdef INET
  174         case AF_INET:
  175 
  176                 /*
  177                  * For now, use the simple IP addr -> ARCnet addr mapping
  178                  */
  179                 if (m->m_flags & (M_BCAST|M_MCAST)) 
  180                         adst = arcbroadcastaddr; /* ARCnet broadcast address */
  181                 else if (ifp->if_flags & IFF_NOARP)
  182                         adst = ntohl(SIN(dst)->sin_addr.s_addr) & 0xFF;
  183                 else if (!arpresolve(ifp, rt, m, dst, &adst))
  184                         return 0;       /* not resolved yet */
  185 
  186                 /* If broadcasting on a simplex interface, loopback a copy */
  187                 if ((m->m_flags & (M_BCAST|M_MCAST)) && 
  188                     (ifp->if_flags & IFF_SIMPLEX))
  189                         mcopy = m_copy(m, 0, (int)M_COPYALL);
  190                 if (ifp->if_flags & IFF_LINK0) {
  191                         atype = ARCTYPE_IP;
  192                         newencoding = 1;
  193                 } else {
  194                         atype = ARCTYPE_IP_OLD;
  195                         newencoding = 0;
  196                 }
  197                 break;
  198 
  199         case AF_ARP:
  200                 arph = mtod(m, struct arphdr *);
  201                 if (m->m_flags & M_BCAST)
  202                         adst = arcbroadcastaddr;
  203                 else
  204                         adst = *ar_tha(arph);
  205 
  206                 arph->ar_hrd = htons(ARPHRD_ARCNET);
  207 
  208                 switch (ntohs(arph->ar_op)) {
  209                 case ARPOP_REVREQUEST:
  210                 case ARPOP_REVREPLY:
  211                         if (!(ifp->if_flags & IFF_LINK0)) {
  212                                 printf("%s: can't handle af%d\n",
  213                                     ifp->if_xname, dst->sa_family);
  214                                 senderr(EAFNOSUPPORT);
  215                         }
  216 
  217                         atype = htons(ARCTYPE_REVARP);
  218                         newencoding = 1;
  219                         break;
  220 
  221                 case ARPOP_REQUEST:
  222                 case ARPOP_REPLY:
  223                 default:
  224                         if (ifp->if_flags & IFF_LINK0) {
  225                                 atype = htons(ARCTYPE_ARP);
  226                                 newencoding = 1;
  227                         } else {
  228                                 atype = htons(ARCTYPE_ARP_OLD);
  229                                 newencoding = 0;
  230                         }
  231                 }
  232 #ifdef ARCNET_ALLOW_BROKEN_ARP
  233                 /*
  234                  * XXX It's not clear per RFC826 if this is needed, but
  235                  * "assigned numbers" say this is wrong.
  236                  * However, e.g., AmiTCP 3.0Beta used it... we make this
  237                  * switchable for emergency cases. Not perfect, but...
  238                  */
  239                 if (ifp->if_flags & IFF_LINK2)
  240                         arph->ar_pro = atype - 1;
  241 #endif
  242                 break;
  243 #endif
  244 #ifdef INET6
  245         case AF_INET6:
  246                 if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)&adst))
  247                         return (0); /* it must be impossible, but... */
  248                 atype = htons(ARCTYPE_INET6);
  249                 newencoding = 1;
  250                 break;
  251 #endif
  252 
  253         case AF_UNSPEC:
  254                 ah = (struct arc_header *)dst->sa_data;
  255                 adst = ah->arc_dhost;
  256                 atype = ah->arc_type;
  257                 break;
  258 
  259         default:
  260                 printf("%s: can't handle af%d\n", ifp->if_xname,
  261                     dst->sa_family);
  262                 senderr(EAFNOSUPPORT);
  263         }
  264 
  265         if (mcopy)
  266                 (void) looutput(ifp, mcopy, dst, rt);
  267 
  268         /*
  269          * Add local net header.  If no space in first mbuf,
  270          * allocate another.
  271          * 
  272          * For ARCnet, this is just symbolic. The header changes
  273          * form and position on its way into the hardware and out of
  274          * the wire.  At this point, it contains source, destination and
  275          * packet type.
  276          */
  277         if (newencoding) {
  278                 ++ac->ac_seqid; /* make the seqid unique */
  279 
  280                 tfrags = (m->m_pkthdr.len + 503) / 504;
  281                 fsflag = 2 * tfrags - 3;
  282                 sflag = 0;
  283                 rsflag = fsflag;
  284 
  285                 while (sflag < fsflag) {
  286                         /* we CAN'T have short packets here */
  287                         m1 = m_split(m, 504, M_DONTWAIT);
  288                         if (m1 == 0)
  289                                 senderr(ENOBUFS);
  290 
  291                         M_PREPEND(m, ARC_HDRNEWLEN, M_DONTWAIT);
  292                         if (m == 0)
  293                                 senderr(ENOBUFS);
  294                         ah = mtod(m, struct arc_header *);
  295                         ah->arc_type = atype;
  296                         ah->arc_dhost = adst;
  297                         ah->arc_shost = myself;
  298                         ah->arc_flag = rsflag;
  299                         ah->arc_seqid = ac->ac_seqid;
  300 
  301                         len = m->m_pkthdr.len;
  302                         s = splnet();
  303                         /*
  304                          * Queue message on interface, and start output if 
  305                          * interface not yet active.
  306                          */
  307                         IFQ_ENQUEUE(&ifp->if_snd, m, &pktattr, error);
  308                         if (error) {
  309                                 /* mbuf is already freed */
  310                                 splx(s);
  311                                 return (error);
  312                         }
  313                         ifp->if_obytes += len;
  314                         if ((ifp->if_flags & IFF_OACTIVE) == 0)
  315                                 (*ifp->if_start)(ifp);
  316                         splx(s);
  317         
  318                         m = m1;
  319                         sflag += 2;
  320                         rsflag = sflag;
  321                 }
  322                 m1 = NULL;
  323 
  324 
  325                 /* here we can have small, especially forbidden packets */
  326 
  327                 if ((m->m_pkthdr.len >=
  328                     ARC_MIN_FORBID_LEN - ARC_HDRNEWLEN + 2) &&
  329                     (m->m_pkthdr.len <=
  330                     ARC_MAX_FORBID_LEN - ARC_HDRNEWLEN + 2)) {
  331 
  332                         M_PREPEND(m, ARC_HDRNEWLEN_EXC, M_DONTWAIT);
  333                         if (m == 0)
  334                                 senderr(ENOBUFS);
  335                         ah = mtod(m, struct arc_header *);
  336                         ah->arc_flag = 0xFF;
  337                         ah->arc_seqid = 0xFFFF;
  338                         ah->arc_type2 = atype;
  339                         ah->arc_flag2 = sflag;
  340                         ah->arc_seqid2 = ac->ac_seqid;
  341                 } else {
  342                         M_PREPEND(m, ARC_HDRNEWLEN, M_DONTWAIT);
  343                         if (m == 0)
  344                                 senderr(ENOBUFS);
  345                         ah = mtod(m, struct arc_header *);
  346                         ah->arc_flag = sflag;
  347                         ah->arc_seqid = ac->ac_seqid;
  348                 }
  349 
  350                 ah->arc_dhost = adst;
  351                 ah->arc_shost = myself;
  352                 ah->arc_type = atype;
  353         } else {
  354                 M_PREPEND(m, ARC_HDRLEN, M_DONTWAIT);
  355                 if (m == 0)
  356                         senderr(ENOBUFS);
  357                 ah = mtod(m, struct arc_header *);
  358                 ah->arc_type = atype;
  359                 ah->arc_dhost = adst;
  360                 ah->arc_shost = myself;
  361         }
  362 
  363         len = m->m_pkthdr.len;
  364         s = splnet();
  365         /*
  366          * Queue message on interface, and start output if interface
  367          * not yet active.
  368          */
  369         IFQ_ENQUEUE(&ifp->if_snd, m, &pktattr, error);
  370         if (error) {
  371                 /* mbuf is already freed */
  372                 splx(s);
  373                 return (error);
  374         }
  375         ifp->if_obytes += len;
  376         if ((ifp->if_flags & IFF_OACTIVE) == 0)
  377                 (*ifp->if_start)(ifp);
  378         splx(s);
  379 
  380         return (error);
  381 
  382 bad:
  383         if (m1)
  384                 m_freem(m1);
  385         if (m)
  386                 m_freem(m);
  387         return (error);
  388 }
  389 
  390 /*
  391  * Defragmenter. Returns mbuf if last packet found, else 
  392  * NULL. frees imcoming mbuf as necessary.
  393  */
  394 
  395 __inline struct mbuf *
  396 arc_defrag(ifp, m)
  397         struct ifnet *ifp;
  398         struct mbuf *m;
  399 {
  400         struct arc_header *ah, *ah1;
  401         struct arccom *ac;
  402         struct ac_frag *af;
  403         struct mbuf *m1;
  404         char *s;
  405         int newflen;
  406         u_char src, dst, typ;
  407         
  408         ac = (struct arccom *)ifp;
  409 
  410         if (m->m_len < ARC_HDRNEWLEN) {
  411                 m = m_pullup(m, ARC_HDRNEWLEN);
  412                 if (m == NULL) {
  413                         ++ifp->if_ierrors;
  414                         return NULL;
  415                 }
  416         }
  417 
  418         ah = mtod(m, struct arc_header *);
  419         typ = ah->arc_type;
  420 
  421         if (!arc_isphds(typ))
  422                 return m;
  423 
  424         src = ah->arc_shost;
  425         dst = ah->arc_dhost;
  426 
  427         if (ah->arc_flag == 0xff) {
  428                 m_adj(m, 4);
  429 
  430                 if (m->m_len < ARC_HDRNEWLEN) {
  431                         m = m_pullup(m, ARC_HDRNEWLEN);
  432                         if (m == NULL) {
  433                                 ++ifp->if_ierrors;
  434                                 return NULL;
  435                         }
  436                 }
  437 
  438                 ah = mtod(m, struct arc_header *);
  439         }
  440 
  441         af = &ac->ac_fragtab[src];
  442         m1 = af->af_packet;
  443         s = "debug code error";
  444 
  445         if (ah->arc_flag & 1) {
  446                 /* 
  447                  * first fragment. We always initialize, which is
  448                  * about the right thing to do, as we only want to
  449                  * accept one fragmented packet per src at a time.
  450                  */
  451                 if (m1 != NULL)
  452                         m_freem(m1);
  453 
  454                 af->af_packet = m;
  455                 m1 = m;
  456                 af->af_maxflag = ah->arc_flag;
  457                 af->af_lastseen = 0;
  458                 af->af_seqid = ah->arc_seqid;
  459 
  460                 return NULL;
  461                 /* notreached */
  462         } else {
  463                 /* check for unfragmented packet */
  464                 if (ah->arc_flag == 0)
  465                         return m;
  466 
  467                 /* do we have a first packet from that src? */
  468                 if (m1 == NULL) {
  469                         s = "no first frag";
  470                         goto outofseq;
  471                 }
  472 
  473                 ah1 = mtod(m1, struct arc_header *);
  474 
  475                 if (ah->arc_seqid != ah1->arc_seqid) {
  476                         s = "seqid differs";
  477                         goto outofseq;
  478                 }
  479 
  480                 if (typ != ah1->arc_type) {
  481                         s = "type differs";
  482                         goto outofseq;
  483                 }
  484 
  485                 if (dst != ah1->arc_dhost) {
  486                         s = "dest host differs";
  487                         goto outofseq;
  488                 }
  489 
  490                 /* typ, seqid and dst are ok here. */
  491 
  492                 if (ah->arc_flag == af->af_lastseen) {
  493                         m_freem(m);
  494                         return NULL;
  495                 }
  496 
  497                 if (ah->arc_flag == af->af_lastseen + 2) {
  498                         /* ok, this is next fragment */
  499                         af->af_lastseen = ah->arc_flag;
  500                         m_adj(m, ARC_HDRNEWLEN);
  501 
  502                         /* 
  503                          * m_cat might free the first mbuf (with pkthdr)
  504                          * in 2nd chain; therefore:
  505                          */
  506 
  507                         newflen = m->m_pkthdr.len;      
  508 
  509                         m_cat(m1, m);
  510 
  511                         m1->m_pkthdr.len += newflen;
  512 
  513                         /* is it the last one? */
  514                         if (af->af_lastseen > af->af_maxflag) {
  515                                 af->af_packet = NULL;
  516                                 return (m1);
  517                         } else
  518                                 return NULL;
  519                 }
  520                 s = "other reason";
  521                 /* if all else fails, it is out of sequence, too */
  522         }
  523 outofseq:
  524         if (m1) {
  525                 m_freem(m1);
  526                 af->af_packet = NULL;
  527         }
  528 
  529         if (m) 
  530                 m_freem(m);
  531 
  532         log(LOG_INFO,"%s: got out of seq. packet: %s\n",
  533             ifp->if_xname, s);
  534 
  535         return NULL;
  536 }
  537 
  538 /*
  539  * return 1 if Packet Header Definition Standard, else 0.
  540  * For now: old IP, old ARP aren't obviously. Lacking correct information,
  541  * we guess that besides new IP and new ARP also IPX and APPLETALK are PHDS.
  542  * (Apple and Novell corporations were involved, among others, in PHDS work).
  543  * Easiest is to assume that everybody else uses that, too.
  544  */
  545 int
  546 arc_isphds(type)
  547         u_int8_t type;
  548 {
  549         return (type != ARCTYPE_IP_OLD && 
  550                 type != ARCTYPE_ARP_OLD &&
  551                 type != ARCTYPE_DIAGNOSE);
  552 }
  553 
  554 /*
  555  * Process a received Arcnet packet;
  556  * the packet is in the mbuf chain m with
  557  * the ARCnet header.
  558  */
  559 static void
  560 arc_input(ifp, m)
  561         struct ifnet *ifp;
  562         struct mbuf *m;
  563 {
  564         struct arc_header *ah;
  565         struct ifqueue *inq;
  566         u_int8_t atype;
  567         int s;
  568 
  569         if ((ifp->if_flags & IFF_UP) == 0) {
  570                 m_freem(m);
  571                 return;
  572         }
  573 
  574         /* possibly defragment: */
  575         m = arc_defrag(ifp, m);
  576         if (m == NULL) 
  577                 return;
  578 
  579         ah = mtod(m, struct arc_header *);
  580 
  581         ifp->if_ibytes += m->m_pkthdr.len;
  582 
  583         if (arcbroadcastaddr == ah->arc_dhost) {
  584                 m->m_flags |= M_BCAST|M_MCAST;
  585                 ifp->if_imcasts++;
  586         }
  587 
  588         atype = ah->arc_type;
  589         switch (atype) {
  590 #ifdef INET
  591         case ARCTYPE_IP:
  592                 m_adj(m, ARC_HDRNEWLEN);
  593                 schednetisr(NETISR_IP);
  594                 inq = &ipintrq;
  595                 break;
  596 
  597         case ARCTYPE_IP_OLD:
  598                 m_adj(m, ARC_HDRLEN);
  599                 schednetisr(NETISR_IP);
  600                 inq = &ipintrq;
  601                 break;
  602 
  603         case ARCTYPE_ARP:
  604                 m_adj(m, ARC_HDRNEWLEN);
  605                 schednetisr(NETISR_ARP);
  606                 inq = &arpintrq;
  607 #ifdef ARCNET_ALLOW_BROKEN_ARP
  608                 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP);
  609 #endif
  610                 break;
  611 
  612         case ARCTYPE_ARP_OLD:
  613                 m_adj(m, ARC_HDRLEN);
  614                 schednetisr(NETISR_ARP);
  615                 inq = &arpintrq;
  616 #ifdef ARCNET_ALLOW_BROKEN_ARP
  617                 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP);
  618 #endif
  619                 break;
  620 #endif
  621 #ifdef INET6
  622         case ARCTYPE_INET6:
  623                 m_adj(m, ARC_HDRNEWLEN);
  624                 schednetisr(NETISR_IPV6);
  625                 inq = &ip6intrq;
  626                 break;
  627 #endif
  628         default:
  629                 m_freem(m);
  630                 return;
  631         }
  632 
  633         s = splnet();
  634         if (IF_QFULL(inq)) {
  635                 IF_DROP(inq);
  636                 m_freem(m);
  637         } else
  638                 IF_ENQUEUE(inq, m);
  639         splx(s);
  640 }
  641 
  642 /*
  643  * Convert Arcnet address to printable (loggable) representation.
  644  */
  645 static char digits[] = "0123456789abcdef";
  646 char *
  647 arc_sprintf(ap)
  648         u_int8_t *ap;
  649 {
  650         static char arcbuf[3];
  651         char *cp = arcbuf;
  652 
  653         *cp++ = digits[*ap >> 4];
  654         *cp++ = digits[*ap++ & 0xf];
  655         *cp   = 0;
  656         return (arcbuf);
  657 }
  658 
  659 /*
  660  * Register (new) link level address.
  661  */
  662 void
  663 arc_storelladdr(ifp, lla)
  664         struct ifnet *ifp;
  665         u_int8_t lla;
  666 {
  667 
  668         *(LLADDR(ifp->if_sadl)) = lla;
  669         ifp->if_mtu = ARC_PHDS_MAXMTU;
  670 }
  671 
  672 /*
  673  * Perform common duties while attaching to interface list
  674  */
  675 void
  676 arc_ifattach(ifp, lla)
  677         struct ifnet *ifp;
  678         u_int8_t lla;
  679 {
  680         struct arccom *ac;
  681 
  682         ifp->if_type = IFT_ARCNET;
  683         ifp->if_addrlen = 1;
  684         ifp->if_hdrlen = ARC_HDRLEN;
  685         ifp->if_dlt = DLT_ARCNET;
  686         if (ifp->if_flags & IFF_BROADCAST)
  687                 ifp->if_flags |= IFF_MULTICAST|IFF_ALLMULTI;
  688         if (ifp->if_flags & IFF_LINK0 && arc_ipmtu > ARC_PHDS_MAXMTU)
  689                 log(LOG_ERR,
  690                     "%s: arc_ipmtu is %d, but must not exceed %d",
  691                     ifp->if_xname, arc_ipmtu, ARC_PHDS_MAXMTU);
  692 
  693         ifp->if_output = arc_output;
  694         ifp->if_input = arc_input;
  695         ac = (struct arccom *)ifp;
  696         ac->ac_seqid = (time.tv_sec) & 0xFFFF; /* try to make seqid unique */
  697         if (lla == 0) {
  698                 /* XXX this message isn't entirely clear, to me -- cgd */
  699                 log(LOG_ERR,"%s: link address 0 reserved for broadcasts.  Please change it and ifconfig %s down up\n",
  700                    ifp->if_xname, ifp->if_xname); 
  701         }
  702         if_attach(ifp);
  703         if_alloc_sadl(ifp);
  704         arc_storelladdr(ifp, lla);
  705 
  706         ifp->if_broadcastaddr = &arcbroadcastaddr;
  707 
  708 #if NBPFILTER > 0
  709         bpfattach(ifp, DLT_ARCNET, ARC_HDRLEN);
  710 #endif
  711 }

Cache object: 592fde076834b3d8de4296a2440431be


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.