sys/net/if_arcsubr.c

   1 /*      $NetBSD: if_arcsubr.c,v 1.36 2001/06/14 05:44:23 itojun Exp $   */
   2 /*      $FreeBSD$ */
   3
   4 /*-
   5  * Copyright (c) 1994, 1995 Ignatios Souvatzis
   6  * Copyright (c) 1982, 1989, 1993
   7  *      The Regents of the University of California.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  * from: NetBSD: if_ethersubr.c,v 1.9 1994/06/29 06:36:11 cgd Exp
  38  *       @(#)if_ethersubr.c     8.1 (Berkeley) 6/10/93
  39  *
  40  */
  41 #include "opt_inet.h"
  42 #include "opt_inet6.h"
  43 #include "opt_ipx.h"
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/kernel.h>
  48 #include <sys/module.h>
  49 #include <sys/malloc.h>
  50 #include <sys/mbuf.h>
  51 #include <sys/protosw.h>
  52 #include <sys/socket.h>
  53 #include <sys/sockio.h>
  54 #include <sys/errno.h>
  55 #include <sys/syslog.h>
  56
  57 #include <machine/cpu.h>
  58
  59 #include <net/if.h>
  60 #include <net/netisr.h>
  61 #include <net/route.h>
  62 #include <net/if_dl.h>
  63 #include <net/if_types.h>
  64 #include <net/if_arc.h>
  65 #include <net/if_arp.h>
  66 #include <net/bpf.h>
  67 #include <net/if_llatbl.h>
  68
  69 #if defined(INET) || defined(INET6)
  70 #include <netinet/in.h>
  71 #include <netinet/in_var.h>
  72 #include <netinet/if_ether.h>
  73 #endif
  74
  75 #ifdef INET6
  76 #include <netinet6/nd6.h>
  77 #endif
  78
  79 #ifdef IPX
  80 #include <netipx/ipx.h>
  81 #include <netipx/ipx_if.h>
  82 #endif
  83
  84 #define ARCNET_ALLOW_BROKEN_ARP
  85
  86 static struct mbuf *arc_defrag(struct ifnet *, struct mbuf *);
  87 static int arc_resolvemulti(struct ifnet *, struct sockaddr **,
  88                             struct sockaddr *);
  89
  90 u_int8_t  arcbroadcastaddr = 0;
  91
  92 #define ARC_LLADDR(ifp) (*(u_int8_t *)IF_LLADDR(ifp))
  93
  94 #define senderr(e) { error = (e); goto bad;}
  95 #define SIN(s)  ((const struct sockaddr_in *)(s))
  96 #define SIPX(s) ((const struct sockaddr_ipx *)(s))
  97
  98 /*
  99  * ARCnet output routine.
 100  * Encapsulate a packet of type family for the local net.
 101  * Assumes that ifp is actually pointer to arccom structure.
 102  */
 103 int
 104 arc_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
 105     struct route *ro)
 106 {
 107         struct arc_header       *ah;
 108         int                     error;
 109         u_int8_t                atype, adst;
 110         int                     loop_copy = 0;
 111         int                     isphds;
 112 #if defined(INET) || defined(INET6)
 113         struct llentry          *lle;
 114 #endif
 115
 116         if (!((ifp->if_flags & IFF_UP) &&
 117             (ifp->if_drv_flags & IFF_DRV_RUNNING)))
 118                 return(ENETDOWN); /* m, m1 aren't initialized yet */
 119
 120         error = 0;
 121
 122         switch (dst->sa_family) {
 123 #ifdef INET
 124         case AF_INET:
 125
 126                 /*
 127                  * For now, use the simple IP addr -> ARCnet addr mapping
 128                  */
 129                 if (m->m_flags & (M_BCAST|M_MCAST))
 130                         adst = arcbroadcastaddr; /* ARCnet broadcast address */
 131                 else if (ifp->if_flags & IFF_NOARP)
 132                         adst = ntohl(SIN(dst)->sin_addr.s_addr) & 0xFF;
 133                 else {
 134                         error = arpresolve(ifp, ro ? ro->ro_rt : NULL,
 135                                            m, dst, &adst, &lle);
 136                         if (error)
 137                                 return (error == EWOULDBLOCK ? 0 : error);
 138                 }
 139
 140                 atype = (ifp->if_flags & IFF_LINK0) ?
 141                         ARCTYPE_IP_OLD : ARCTYPE_IP;
 142                 break;
 143         case AF_ARP:
 144         {
 145                 struct arphdr *ah;
 146                 ah = mtod(m, struct arphdr *);
 147                 ah->ar_hrd = htons(ARPHRD_ARCNET);
 148
 149                 loop_copy = -1; /* if this is for us, don't do it */
 150
 151                 switch(ntohs(ah->ar_op)) {
 152                 case ARPOP_REVREQUEST:
 153                 case ARPOP_REVREPLY:
 154                         atype = ARCTYPE_REVARP;
 155                         break;
 156                 case ARPOP_REQUEST:
 157                 case ARPOP_REPLY:
 158                 default:
 159                         atype = ARCTYPE_ARP;
 160                         break;
 161                 }
 162
 163                 if (m->m_flags & M_BCAST)
 164                         bcopy(ifp->if_broadcastaddr, &adst, ARC_ADDR_LEN);
 165                 else
 166                         bcopy(ar_tha(ah), &adst, ARC_ADDR_LEN);
 167
 168         }
 169         break;
 170 #endif
 171 #ifdef INET6
 172         case AF_INET6:
 173                 error = nd6_storelladdr(ifp, m, dst, (u_char *)&adst, &lle);
 174                 if (error)
 175                         return (error);
 176                 atype = ARCTYPE_INET6;
 177                 break;
 178 #endif
 179 #ifdef IPX
 180         case AF_IPX:
 181                 adst = SIPX(dst)->sipx_addr.x_host.c_host[5];
 182                 atype = ARCTYPE_IPX;
 183                 if (adst == 0xff)
 184                         adst = arcbroadcastaddr;
 185                 break;
 186 #endif
 187
 188         case AF_UNSPEC:
 189             {
 190                 const struct arc_header *ah;
 191
 192                 loop_copy = -1;
 193                 ah = (const struct arc_header *)dst->sa_data;
 194                 adst = ah->arc_dhost;
 195                 atype = ah->arc_type;
 196
 197                 if (atype == ARCTYPE_ARP) {
 198                         atype = (ifp->if_flags & IFF_LINK0) ?
 199                             ARCTYPE_ARP_OLD: ARCTYPE_ARP;
 200
 201 #ifdef ARCNET_ALLOW_BROKEN_ARP
 202                         /*
 203                          * XXX It's not clear per RFC826 if this is needed, but
 204                          * "assigned numbers" say this is wrong.
 205                          * However, e.g., AmiTCP 3.0Beta used it... we make this
 206                          * switchable for emergency cases. Not perfect, but...
 207                          */
 208                         if (ifp->if_flags & IFF_LINK2)
 209                                 mtod(m, struct arphdr *)->ar_pro = atype - 1;
 210 #endif
 211                 }
 212                 break;
 213             }
 214         default:
 215                 if_printf(ifp, "can't handle af%d\n", dst->sa_family);
 216                 senderr(EAFNOSUPPORT);
 217         }
 218
 219         isphds = arc_isphds(atype);
 220         M_PREPEND(m, isphds ? ARC_HDRNEWLEN : ARC_HDRLEN, M_NOWAIT);
 221         if (m == 0)
 222                 senderr(ENOBUFS);
 223         ah = mtod(m, struct arc_header *);
 224         ah->arc_type = atype;
 225         ah->arc_dhost = adst;
 226         ah->arc_shost = ARC_LLADDR(ifp);
 227         if (isphds) {
 228                 ah->arc_flag = 0;
 229                 ah->arc_seqid = 0;
 230         }
 231
 232         if ((ifp->if_flags & IFF_SIMPLEX) && (loop_copy != -1)) {
 233                 if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
 234                         struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
 235
 236                         (void) if_simloop(ifp, n, dst->sa_family, ARC_HDRLEN);
 237                 } else if (ah->arc_dhost == ah->arc_shost) {
 238                         (void) if_simloop(ifp, m, dst->sa_family, ARC_HDRLEN);
 239                         return (0);     /* XXX */
 240                 }
 241         }
 242
 243         BPF_MTAP(ifp, m);
 244
 245         error = ifp->if_transmit(ifp, m);
 246
 247         return (error);
 248
 249 bad:
 250         if (m)
 251                 m_freem(m);
 252         return (error);
 253 }
 254
 255 void
 256 arc_frag_init(struct ifnet *ifp)
 257 {
 258         struct arccom *ac;
 259
 260         ac = (struct arccom *)ifp->if_l2com;
 261         ac->curr_frag = 0;
 262 }
 263
 264 struct mbuf *
 265 arc_frag_next(struct ifnet *ifp)
 266 {
 267         struct arccom *ac;
 268         struct mbuf *m;
 269         struct arc_header *ah;
 270
 271         ac = (struct arccom *)ifp->if_l2com;
 272         if ((m = ac->curr_frag) == 0) {
 273                 int tfrags;
 274
 275                 /* dequeue new packet */
 276                 IF_DEQUEUE(&ifp->if_snd, m);
 277                 if (m == 0)
 278                         return 0;
 279
 280                 ah = mtod(m, struct arc_header *);
 281                 if (!arc_isphds(ah->arc_type))
 282                         return m;
 283
 284                 ++ac->ac_seqid;         /* make the seqid unique */
 285                 tfrags = (m->m_pkthdr.len + ARC_MAX_DATA - 1) / ARC_MAX_DATA;
 286                 ac->fsflag = 2 * tfrags - 3;
 287                 ac->sflag = 0;
 288                 ac->rsflag = ac->fsflag;
 289                 ac->arc_dhost = ah->arc_dhost;
 290                 ac->arc_shost = ah->arc_shost;
 291                 ac->arc_type = ah->arc_type;
 292
 293                 m_adj(m, ARC_HDRNEWLEN);
 294                 ac->curr_frag = m;
 295         }
 296
 297         /* split out next fragment and return it */
 298         if (ac->sflag < ac->fsflag) {
 299                 /* we CAN'T have short packets here */
 300                 ac->curr_frag = m_split(m, ARC_MAX_DATA, M_NOWAIT);
 301                 if (ac->curr_frag == 0) {
 302                         m_freem(m);
 303                         return 0;
 304                 }
 305
 306                 M_PREPEND(m, ARC_HDRNEWLEN, M_NOWAIT);
 307                 if (m == 0) {
 308                         m_freem(ac->curr_frag);
 309                         ac->curr_frag = 0;
 310                         return 0;
 311                 }
 312
 313                 ah = mtod(m, struct arc_header *);
 314                 ah->arc_flag = ac->rsflag;
 315                 ah->arc_seqid = ac->ac_seqid;
 316
 317                 ac->sflag += 2;
 318                 ac->rsflag = ac->sflag;
 319         } else if ((m->m_pkthdr.len >=
 320             ARC_MIN_FORBID_LEN - ARC_HDRNEWLEN + 2) &&
 321             (m->m_pkthdr.len <=
 322             ARC_MAX_FORBID_LEN - ARC_HDRNEWLEN + 2)) {
 323                 ac->curr_frag = 0;
 324
 325                 M_PREPEND(m, ARC_HDRNEWLEN_EXC, M_NOWAIT);
 326                 if (m == 0)
 327                         return 0;
 328
 329                 ah = mtod(m, struct arc_header *);
 330                 ah->arc_flag = 0xFF;
 331                 ah->arc_seqid = 0xFFFF;
 332                 ah->arc_type2 = ac->arc_type;
 333                 ah->arc_flag2 = ac->sflag;
 334                 ah->arc_seqid2 = ac->ac_seqid;
 335         } else {
 336                 ac->curr_frag = 0;
 337
 338                 M_PREPEND(m, ARC_HDRNEWLEN, M_NOWAIT);
 339                 if (m == 0)
 340                         return 0;
 341
 342                 ah = mtod(m, struct arc_header *);
 343                 ah->arc_flag = ac->sflag;
 344                 ah->arc_seqid = ac->ac_seqid;
 345         }
 346
 347         ah->arc_dhost = ac->arc_dhost;
 348         ah->arc_shost = ac->arc_shost;
 349         ah->arc_type = ac->arc_type;
 350
 351         return m;
 352 }
 353
 354 /*
 355  * Defragmenter. Returns mbuf if last packet found, else
 356  * NULL. frees imcoming mbuf as necessary.
 357  */
 358
 359 static __inline struct mbuf *
 360 arc_defrag(struct ifnet *ifp, struct mbuf *m)
 361 {
 362         struct arc_header *ah, *ah1;
 363         struct arccom *ac;
 364         struct ac_frag *af;
 365         struct mbuf *m1;
 366         char *s;
 367         int newflen;
 368         u_char src,dst,typ;
 369
 370         ac = (struct arccom *)ifp->if_l2com;
 371
 372         if (m->m_len < ARC_HDRNEWLEN) {
 373                 m = m_pullup(m, ARC_HDRNEWLEN);
 374                 if (m == NULL) {
 375                         ++ifp->if_ierrors;
 376                         return NULL;
 377                 }
 378         }
 379
 380         ah = mtod(m, struct arc_header *);
 381         typ = ah->arc_type;
 382
 383         if (!arc_isphds(typ))
 384                 return m;
 385
 386         src = ah->arc_shost;
 387         dst = ah->arc_dhost;
 388
 389         if (ah->arc_flag == 0xff) {
 390                 m_adj(m, 4);
 391
 392                 if (m->m_len < ARC_HDRNEWLEN) {
 393                         m = m_pullup(m, ARC_HDRNEWLEN);
 394                         if (m == NULL) {
 395                                 ++ifp->if_ierrors;
 396                                 return NULL;
 397                         }
 398                 }
 399
 400                 ah = mtod(m, struct arc_header *);
 401         }
 402
 403         af = &ac->ac_fragtab[src];
 404         m1 = af->af_packet;
 405         s = "debug code error";
 406
 407         if (ah->arc_flag & 1) {
 408                 /*
 409                  * first fragment. We always initialize, which is
 410                  * about the right thing to do, as we only want to
 411                  * accept one fragmented packet per src at a time.
 412                  */
 413                 if (m1 != NULL)
 414                         m_freem(m1);
 415
 416                 af->af_packet = m;
 417                 m1 = m;
 418                 af->af_maxflag = ah->arc_flag;
 419                 af->af_lastseen = 0;
 420                 af->af_seqid = ah->arc_seqid;
 421
 422                 return NULL;
 423                 /* notreached */
 424         } else {
 425                 /* check for unfragmented packet */
 426                 if (ah->arc_flag == 0)
 427                         return m;
 428
 429                 /* do we have a first packet from that src? */
 430                 if (m1 == NULL) {
 431                         s = "no first frag";
 432                         goto outofseq;
 433                 }
 434
 435                 ah1 = mtod(m1, struct arc_header *);
 436
 437                 if (ah->arc_seqid != ah1->arc_seqid) {
 438                         s = "seqid differs";
 439                         goto outofseq;
 440                 }
 441
 442                 if (typ != ah1->arc_type) {
 443                         s = "type differs";
 444                         goto outofseq;
 445                 }
 446
 447                 if (dst != ah1->arc_dhost) {
 448                         s = "dest host differs";
 449                         goto outofseq;
 450                 }
 451
 452                 /* typ, seqid and dst are ok here. */
 453
 454                 if (ah->arc_flag == af->af_lastseen) {
 455                         m_freem(m);
 456                         return NULL;
 457                 }
 458
 459                 if (ah->arc_flag == af->af_lastseen + 2) {
 460                         /* ok, this is next fragment */
 461                         af->af_lastseen = ah->arc_flag;
 462                         m_adj(m,ARC_HDRNEWLEN);
 463
 464                         /*
 465                          * m_cat might free the first mbuf (with pkthdr)
 466                          * in 2nd chain; therefore:
 467                          */
 468
 469                         newflen = m->m_pkthdr.len;
 470
 471                         m_cat(m1,m);
 472
 473                         m1->m_pkthdr.len += newflen;
 474
 475                         /* is it the last one? */
 476                         if (af->af_lastseen > af->af_maxflag) {
 477                                 af->af_packet = NULL;
 478                                 return(m1);
 479                         } else
 480                                 return NULL;
 481                 }
 482                 s = "other reason";
 483                 /* if all else fails, it is out of sequence, too */
 484         }
 485 outofseq:
 486         if (m1) {
 487                 m_freem(m1);
 488                 af->af_packet = NULL;
 489         }
 490
 491         if (m)
 492                 m_freem(m);
 493
 494         log(LOG_INFO,"%s: got out of seq. packet: %s\n",
 495             ifp->if_xname, s);
 496
 497         return NULL;
 498 }
 499
 500 /*
 501  * return 1 if Packet Header Definition Standard, else 0.
 502  * For now: old IP, old ARP aren't obviously. Lacking correct information,
 503  * we guess that besides new IP and new ARP also IPX and APPLETALK are PHDS.
 504  * (Apple and Novell corporations were involved, among others, in PHDS work).
 505  * Easiest is to assume that everybody else uses that, too.
 506  */
 507 int
 508 arc_isphds(u_int8_t type)
 509 {
 510         return (type != ARCTYPE_IP_OLD &&
 511                 type != ARCTYPE_ARP_OLD &&
 512                 type != ARCTYPE_DIAGNOSE);
 513 }
 514
 515 /*
 516  * Process a received Arcnet packet;
 517  * the packet is in the mbuf chain m with
 518  * the ARCnet header.
 519  */
 520 void
 521 arc_input(struct ifnet *ifp, struct mbuf *m)
 522 {
 523         struct arc_header *ah;
 524         int isr;
 525         u_int8_t atype;
 526
 527         if ((ifp->if_flags & IFF_UP) == 0) {
 528                 m_freem(m);
 529                 return;
 530         }
 531
 532         /* possibly defragment: */
 533         m = arc_defrag(ifp, m);
 534         if (m == NULL)
 535                 return;
 536
 537         BPF_MTAP(ifp, m);
 538
 539         ah = mtod(m, struct arc_header *);
 540         /* does this belong to us? */
 541         if ((ifp->if_flags & IFF_PROMISC) == 0
 542             && ah->arc_dhost != arcbroadcastaddr
 543             && ah->arc_dhost != ARC_LLADDR(ifp)) {
 544                 m_freem(m);
 545                 return;
 546         }
 547
 548         ifp->if_ibytes += m->m_pkthdr.len;
 549
 550         if (ah->arc_dhost == arcbroadcastaddr) {
 551                 m->m_flags |= M_BCAST|M_MCAST;
 552                 ifp->if_imcasts++;
 553         }
 554
 555         atype = ah->arc_type;
 556         switch (atype) {
 557 #ifdef INET
 558         case ARCTYPE_IP:
 559                 m_adj(m, ARC_HDRNEWLEN);
 560                 if ((m = ip_fastforward(m)) == NULL)
 561                         return;
 562                 isr = NETISR_IP;
 563                 break;
 564
 565         case ARCTYPE_IP_OLD:
 566                 m_adj(m, ARC_HDRLEN);
 567                 if ((m = ip_fastforward(m)) == NULL)
 568                         return;
 569                 isr = NETISR_IP;
 570                 break;
 571
 572         case ARCTYPE_ARP:
 573                 if (ifp->if_flags & IFF_NOARP) {
 574                         /* Discard packet if ARP is disabled on interface */
 575                         m_freem(m);
 576                         return;
 577                 }
 578                 m_adj(m, ARC_HDRNEWLEN);
 579                 isr = NETISR_ARP;
 580 #ifdef ARCNET_ALLOW_BROKEN_ARP
 581                 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP);
 582 #endif
 583                 break;
 584
 585         case ARCTYPE_ARP_OLD:
 586                 if (ifp->if_flags & IFF_NOARP) {
 587                         /* Discard packet if ARP is disabled on interface */
 588                         m_freem(m);
 589                         return;
 590                 }
 591                 m_adj(m, ARC_HDRLEN);
 592                 isr = NETISR_ARP;
 593 #ifdef ARCNET_ALLOW_BROKEN_ARP
 594                 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP);
 595 #endif
 596                 break;
 597 #endif
 598 #ifdef INET6
 599         case ARCTYPE_INET6:
 600                 m_adj(m, ARC_HDRNEWLEN);
 601                 isr = NETISR_IPV6;
 602                 break;
 603 #endif
 604 #ifdef IPX
 605         case ARCTYPE_IPX:
 606                 m_adj(m, ARC_HDRNEWLEN);
 607                 isr = NETISR_IPX;
 608                 break;
 609 #endif
 610         default:
 611                 m_freem(m);
 612                 return;
 613         }
 614         M_SETFIB(m, ifp->if_fib);
 615         netisr_dispatch(isr, m);
 616 }
 617
 618 /*
 619  * Register (new) link level address.
 620  */
 621 void
 622 arc_storelladdr(struct ifnet *ifp, u_int8_t lla)
 623 {
 624         ARC_LLADDR(ifp) = lla;
 625 }
 626
 627 /*
 628  * Perform common duties while attaching to interface list
 629  */
 630 void
 631 arc_ifattach(struct ifnet *ifp, u_int8_t lla)
 632 {
 633         struct ifaddr *ifa;
 634         struct sockaddr_dl *sdl;
 635         struct arccom *ac;
 636
 637         if_attach(ifp);
 638         ifp->if_addrlen = 1;
 639         ifp->if_hdrlen = ARC_HDRLEN;
 640         ifp->if_mtu = 1500;
 641         ifp->if_resolvemulti = arc_resolvemulti;
 642         if (ifp->if_baudrate == 0)
 643                 ifp->if_baudrate = 2500000;
 644         ifa = ifp->if_addr;
 645         KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__));
 646         sdl = (struct sockaddr_dl *)ifa->ifa_addr;
 647         sdl->sdl_type = IFT_ARCNET;
 648         sdl->sdl_alen = ifp->if_addrlen;
 649
 650         if (ifp->if_flags & IFF_BROADCAST)
 651                 ifp->if_flags |= IFF_MULTICAST|IFF_ALLMULTI;
 652
 653         ac = (struct arccom *)ifp->if_l2com;
 654         ac->ac_seqid = (time_second) & 0xFFFF; /* try to make seqid unique */
 655         if (lla == 0) {
 656                 /* XXX this message isn't entirely clear, to me -- cgd */
 657                 log(LOG_ERR,"%s: link address 0 reserved for broadcasts.  Please change it and ifconfig %s down up\n",
 658                    ifp->if_xname, ifp->if_xname);
 659         }
 660         arc_storelladdr(ifp, lla);
 661
 662         ifp->if_broadcastaddr = &arcbroadcastaddr;
 663
 664         bpfattach(ifp, DLT_ARCNET, ARC_HDRLEN);
 665 }
 666
 667 void
 668 arc_ifdetach(struct ifnet *ifp)
 669 {
 670         bpfdetach(ifp);
 671         if_detach(ifp);
 672 }
 673
 674 int
 675 arc_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 676 {
 677         struct ifaddr *ifa = (struct ifaddr *) data;
 678         struct ifreq *ifr = (struct ifreq *) data;
 679         int error = 0;
 680
 681         switch (command) {
 682         case SIOCSIFADDR:
 683                 ifp->if_flags |= IFF_UP;
 684                 switch (ifa->ifa_addr->sa_family) {
 685 #ifdef INET
 686                 case AF_INET:
 687                         ifp->if_init(ifp->if_softc);    /* before arpwhohas */
 688                         arp_ifinit(ifp, ifa);
 689                         break;
 690 #endif
 691 #ifdef IPX
 692                 /*
 693                  * XXX This code is probably wrong
 694                  */
 695                 case AF_IPX:
 696                 {
 697                         struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
 698
 699                         if (ipx_nullhost(*ina))
 700                                 ina->x_host.c_host[5] = ARC_LLADDR(ifp);
 701                         else
 702                                 arc_storelladdr(ifp, ina->x_host.c_host[5]);
 703
 704                         /*
 705                          * Set new address
 706                          */
 707                         ifp->if_init(ifp->if_softc);
 708                         break;
 709                 }
 710 #endif
 711                 default:
 712                         ifp->if_init(ifp->if_softc);
 713                         break;
 714                 }
 715                 break;
 716
 717         case SIOCGIFADDR:
 718                 {
 719                         struct sockaddr *sa;
 720
 721                         sa = (struct sockaddr *) &ifr->ifr_data;
 722                         *(u_int8_t *)sa->sa_data = ARC_LLADDR(ifp);
 723                 }
 724                 break;
 725
 726         case SIOCADDMULTI:
 727         case SIOCDELMULTI:
 728                 if (ifr == NULL)
 729                         error = EAFNOSUPPORT;
 730                 else {
 731                         switch (ifr->ifr_addr.sa_family) {
 732                         case AF_INET:
 733                         case AF_INET6:
 734                                 error = 0;
 735                                 break;
 736                         default:
 737                                 error = EAFNOSUPPORT;
 738                                 break;
 739                         }
 740                 }
 741                 break;
 742
 743         case SIOCSIFMTU:
 744                 /*
 745                  * Set the interface MTU.
 746                  * mtu can't be larger than ARCMTU for RFC1051
 747                  * and can't be larger than ARC_PHDS_MTU
 748                  */
 749                 if (((ifp->if_flags & IFF_LINK0) && ifr->ifr_mtu > ARCMTU) ||
 750                     ifr->ifr_mtu > ARC_PHDS_MAXMTU)
 751                         error = EINVAL;
 752                 else
 753                         ifp->if_mtu = ifr->ifr_mtu;
 754                 break;
 755         }
 756
 757         return (error);
 758 }
 759
 760 /* based on ether_resolvemulti() */
 761 int
 762 arc_resolvemulti(struct ifnet *ifp, struct sockaddr **llsa,
 763     struct sockaddr *sa)
 764 {
 765         struct sockaddr_dl *sdl;
 766 #ifdef INET
 767         struct sockaddr_in *sin;
 768 #endif
 769 #ifdef INET6
 770         struct sockaddr_in6 *sin6;
 771 #endif
 772
 773         switch(sa->sa_family) {
 774         case AF_LINK:
 775                 /*
 776                 * No mapping needed. Just check that it's a valid MC address.
 777                 */
 778                 sdl = (struct sockaddr_dl *)sa;
 779                 if (*LLADDR(sdl) != arcbroadcastaddr)
 780                         return EADDRNOTAVAIL;
 781                 *llsa = 0;
 782                 return 0;
 783 #ifdef INET
 784         case AF_INET:
 785                 sin = (struct sockaddr_in *)sa;
 786                 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
 787                         return EADDRNOTAVAIL;
 788                 sdl = malloc(sizeof *sdl, M_IFMADDR,
 789                        M_NOWAIT | M_ZERO);
 790                 if (sdl == NULL)
 791                         return ENOMEM;
 792                 sdl->sdl_len = sizeof *sdl;
 793                 sdl->sdl_family = AF_LINK;
 794                 sdl->sdl_index = ifp->if_index;
 795                 sdl->sdl_type = IFT_ARCNET;
 796                 sdl->sdl_alen = ARC_ADDR_LEN;
 797                 *LLADDR(sdl) = 0;
 798                 *llsa = (struct sockaddr *)sdl;
 799                 return 0;
 800 #endif
 801 #ifdef INET6
 802         case AF_INET6:
 803                 sin6 = (struct sockaddr_in6 *)sa;
 804                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 805                         /*
 806                          * An IP6 address of 0 means listen to all
 807                          * of the Ethernet multicast address used for IP6.
 808                          * (This is used for multicast routers.)
 809                          */
 810                         ifp->if_flags |= IFF_ALLMULTI;
 811                         *llsa = 0;
 812                         return 0;
 813                 }
 814                 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
 815                         return EADDRNOTAVAIL;
 816                 sdl = malloc(sizeof *sdl, M_IFMADDR,
 817                        M_NOWAIT | M_ZERO);
 818                 if (sdl == NULL)
 819                         return ENOMEM;
 820                 sdl->sdl_len = sizeof *sdl;
 821                 sdl->sdl_family = AF_LINK;
 822                 sdl->sdl_index = ifp->if_index;
 823                 sdl->sdl_type = IFT_ARCNET;
 824                 sdl->sdl_alen = ARC_ADDR_LEN;
 825                 *LLADDR(sdl) = 0;
 826                 *llsa = (struct sockaddr *)sdl;
 827                 return 0;
 828 #endif
 829
 830         default:
 831                 /*
 832                  * Well, the text isn't quite right, but it's the name
 833                  * that counts...
 834                  */
 835                 return EAFNOSUPPORT;
 836         }
 837 }
 838
 839 static MALLOC_DEFINE(M_ARCCOM, "arccom", "ARCNET interface internals");
 840
 841 static void*
 842 arc_alloc(u_char type, struct ifnet *ifp)
 843 {
 844         struct arccom   *ac;
 845
 846         ac = malloc(sizeof(struct arccom), M_ARCCOM, M_WAITOK | M_ZERO);
 847         ac->ac_ifp = ifp;
 848
 849         return (ac);
 850 }
 851
 852 static void
 853 arc_free(void *com, u_char type)
 854 {
 855
 856         free(com, M_ARCCOM);
 857 }
 858
 859 static int
 860 arc_modevent(module_t mod, int type, void *data)
 861 {
 862
 863         switch (type) {
 864         case MOD_LOAD:
 865                 if_register_com_alloc(IFT_ARCNET, arc_alloc, arc_free);
 866                 break;
 867         case MOD_UNLOAD:
 868                 if_deregister_com_alloc(IFT_ARCNET);
 869                 break;
 870         default:
 871                 return EOPNOTSUPP;
 872         }
 873
 874         return (0);
 875 }
 876
 877 static moduledata_t arc_mod = {
 878         "arcnet",
 879         arc_modevent,
 880         0
 881 };
 882
 883 DECLARE_MODULE(arcnet, arc_mod, SI_SUB_INIT_IF, SI_ORDER_ANY);
 884 MODULE_VERSION(arcnet, 1);