if_arcsubr.c revision 1.59.22.1
1 /* $NetBSD: if_arcsubr.c,v 1.59.22.1 2009/11/21 19:56:35 snj 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.59.22.1 2009/11/21 19:56:35 snj 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 <sys/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(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 uint8_t arcbroadcastaddr = 0; 103 104 #define senderr(e) { error = (e); goto bad;} 105 106 static int arc_output(struct ifnet *, struct mbuf *, 107 const struct sockaddr *, struct rtentry *); 108 static void arc_input(struct ifnet *, struct mbuf *); 109 110 /* 111 * ARCnet output routine. 112 * Encapsulate a packet of type family for the local net. 113 * Assumes that ifp is actually pointer to arccom structure. 114 */ 115 static int 116 arc_output(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst, 117 struct rtentry *rt0) 118 { 119 struct mbuf *m, *m1, *mcopy; 120 struct rtentry *rt; 121 struct arccom *ac; 122 const struct arc_header *cah; 123 struct arc_header *ah; 124 struct arphdr *arph; 125 int error, newencoding; 126 uint8_t atype, adst, myself; 127 int tfrags, sflag, fsflag, rsflag; 128 ALTQ_DECL(struct altq_pktattr pktattr;) 129 130 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) 131 return (ENETDOWN); /* m, m1 aren't initialized yet */ 132 133 error = newencoding = 0; 134 ac = (struct arccom *)ifp; 135 m = m0; 136 mcopy = m1 = NULL; 137 138 myself = *CLLADDR(ifp->if_sadl); 139 140 if ((rt = rt0)) { 141 if ((rt->rt_flags & RTF_UP) == 0) { 142 if ((rt0 = rt = rtalloc1(dst, 1))) 143 rt->rt_refcnt--; 144 else 145 senderr(EHOSTUNREACH); 146 } 147 if (rt->rt_flags & RTF_GATEWAY) { 148 if (rt->rt_gwroute == 0) 149 goto lookup; 150 if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) { 151 rtfree(rt); rt = rt0; 152 lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1); 153 if ((rt = rt->rt_gwroute) == 0) 154 senderr(EHOSTUNREACH); 155 } 156 } 157 if (rt->rt_flags & RTF_REJECT) 158 if (rt->rt_rmx.rmx_expire == 0 || 159 time_second < rt->rt_rmx.rmx_expire) 160 senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH); 161 } 162 163 /* 164 * if the queueing discipline needs packet classification, 165 * do it before prepending link headers. 166 */ 167 IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family, &pktattr); 168 169 switch (dst->sa_family) { 170 #ifdef INET 171 case AF_INET: 172 173 /* 174 * For now, use the simple IP addr -> ARCnet addr mapping 175 */ 176 if (m->m_flags & (M_BCAST|M_MCAST)) 177 adst = arcbroadcastaddr; /* ARCnet broadcast address */ 178 else if (ifp->if_flags & IFF_NOARP) 179 adst = ntohl(satocsin(dst)->sin_addr.s_addr) & 0xFF; 180 else if (!arpresolve(ifp, rt, m, dst, &adst)) 181 return 0; /* not resolved yet */ 182 183 /* If broadcasting on a simplex interface, loopback a copy */ 184 if ((m->m_flags & (M_BCAST|M_MCAST)) && 185 (ifp->if_flags & IFF_SIMPLEX)) 186 mcopy = m_copy(m, 0, (int)M_COPYALL); 187 if (ifp->if_flags & IFF_LINK0) { 188 atype = ARCTYPE_IP; 189 newencoding = 1; 190 } else { 191 atype = ARCTYPE_IP_OLD; 192 newencoding = 0; 193 } 194 break; 195 196 case AF_ARP: 197 arph = mtod(m, struct arphdr *); 198 if (m->m_flags & M_BCAST) 199 adst = arcbroadcastaddr; 200 else { 201 uint8_t *tha = ar_tha(arph); 202 if (tha == NULL) 203 return 0; 204 adst = *tha; 205 } 206 207 arph->ar_hrd = htons(ARPHRD_ARCNET); 208 209 switch (ntohs(arph->ar_op)) { 210 case ARPOP_REVREQUEST: 211 case ARPOP_REVREPLY: 212 if (!(ifp->if_flags & IFF_LINK0)) { 213 printf("%s: can't handle af%d\n", 214 ifp->if_xname, dst->sa_family); 215 senderr(EAFNOSUPPORT); 216 } 217 218 atype = htons(ARCTYPE_REVARP); 219 newencoding = 1; 220 break; 221 222 case ARPOP_REQUEST: 223 case ARPOP_REPLY: 224 default: 225 if (ifp->if_flags & IFF_LINK0) { 226 atype = htons(ARCTYPE_ARP); 227 newencoding = 1; 228 } else { 229 atype = htons(ARCTYPE_ARP_OLD); 230 newencoding = 0; 231 } 232 } 233 #ifdef ARCNET_ALLOW_BROKEN_ARP 234 /* 235 * XXX It's not clear per RFC826 if this is needed, but 236 * "assigned numbers" say this is wrong. 237 * However, e.g., AmiTCP 3.0Beta used it... we make this 238 * switchable for emergency cases. Not perfect, but... 239 */ 240 if (ifp->if_flags & IFF_LINK2) 241 arph->ar_pro = atype - 1; 242 #endif 243 break; 244 #endif 245 #ifdef INET6 246 case AF_INET6: 247 if (!nd6_storelladdr(ifp, rt, m, dst, &adst, sizeof(adst))) 248 return (0); /* it must be impossible, but... */ 249 atype = htons(ARCTYPE_INET6); 250 newencoding = 1; 251 break; 252 #endif 253 254 case AF_UNSPEC: 255 cah = (const struct arc_header *)dst->sa_data; 256 adst = cah->arc_dhost; 257 atype = cah->arc_type; 258 break; 259 260 default: 261 printf("%s: can't handle af%d\n", ifp->if_xname, 262 dst->sa_family); 263 senderr(EAFNOSUPPORT); 264 } 265 266 if (mcopy) 267 (void) looutput(ifp, mcopy, dst, rt); 268 269 /* 270 * Add local net header. If no space in first mbuf, 271 * allocate another. 272 * 273 * For ARCnet, this is just symbolic. The header changes 274 * form and position on its way into the hardware and out of 275 * the wire. At this point, it contains source, destination and 276 * packet type. 277 */ 278 if (newencoding) { 279 ++ac->ac_seqid; /* make the seqid unique */ 280 281 tfrags = (m->m_pkthdr.len + 503) / 504; 282 fsflag = 2 * tfrags - 3; 283 sflag = 0; 284 rsflag = fsflag; 285 286 while (sflag < fsflag) { 287 /* we CAN'T have short packets here */ 288 m1 = m_split(m, 504, M_DONTWAIT); 289 if (m1 == 0) 290 senderr(ENOBUFS); 291 292 M_PREPEND(m, ARC_HDRNEWLEN, M_DONTWAIT); 293 if (m == 0) 294 senderr(ENOBUFS); 295 ah = mtod(m, struct arc_header *); 296 ah->arc_type = atype; 297 ah->arc_dhost = adst; 298 ah->arc_shost = myself; 299 ah->arc_flag = rsflag; 300 ah->arc_seqid = ac->ac_seqid; 301 302 if ((error = ifq_enqueue(ifp, m ALTQ_COMMA 303 ALTQ_DECL(&pktattr))) != 0) 304 return (error); 305 306 m = m1; 307 sflag += 2; 308 rsflag = sflag; 309 } 310 m1 = NULL; 311 312 313 /* here we can have small, especially forbidden packets */ 314 315 if ((m->m_pkthdr.len >= 316 ARC_MIN_FORBID_LEN - ARC_HDRNEWLEN + 2) && 317 (m->m_pkthdr.len <= 318 ARC_MAX_FORBID_LEN - ARC_HDRNEWLEN + 2)) { 319 320 M_PREPEND(m, ARC_HDRNEWLEN_EXC, M_DONTWAIT); 321 if (m == 0) 322 senderr(ENOBUFS); 323 ah = mtod(m, struct arc_header *); 324 ah->arc_flag = 0xFF; 325 ah->arc_seqid = 0xFFFF; 326 ah->arc_type2 = atype; 327 ah->arc_flag2 = sflag; 328 ah->arc_seqid2 = ac->ac_seqid; 329 } else { 330 M_PREPEND(m, ARC_HDRNEWLEN, M_DONTWAIT); 331 if (m == 0) 332 senderr(ENOBUFS); 333 ah = mtod(m, struct arc_header *); 334 ah->arc_flag = sflag; 335 ah->arc_seqid = ac->ac_seqid; 336 } 337 338 ah->arc_dhost = adst; 339 ah->arc_shost = myself; 340 ah->arc_type = atype; 341 } else { 342 M_PREPEND(m, ARC_HDRLEN, M_DONTWAIT); 343 if (m == 0) 344 senderr(ENOBUFS); 345 ah = mtod(m, struct arc_header *); 346 ah->arc_type = atype; 347 ah->arc_dhost = adst; 348 ah->arc_shost = myself; 349 } 350 351 return ifq_enqueue(ifp, m ALTQ_COMMA ALTQ_DECL(&pktattr)); 352 353 bad: 354 if (m1) 355 m_freem(m1); 356 if (m) 357 m_freem(m); 358 return (error); 359 } 360 361 /* 362 * Defragmenter. Returns mbuf if last packet found, else 363 * NULL. frees imcoming mbuf as necessary. 364 */ 365 366 static struct mbuf * 367 arc_defrag(struct ifnet *ifp, struct mbuf *m) 368 { 369 struct arc_header *ah, *ah1; 370 struct arccom *ac; 371 struct ac_frag *af; 372 struct mbuf *m1; 373 const char *s; 374 int newflen; 375 u_char src, dst, typ; 376 377 ac = (struct arccom *)ifp; 378 379 if (m->m_len < ARC_HDRNEWLEN) { 380 m = m_pullup(m, ARC_HDRNEWLEN); 381 if (m == NULL) { 382 ++ifp->if_ierrors; 383 return NULL; 384 } 385 } 386 387 ah = mtod(m, struct arc_header *); 388 typ = ah->arc_type; 389 390 if (!arc_isphds(typ)) 391 return m; 392 393 src = ah->arc_shost; 394 dst = ah->arc_dhost; 395 396 if (ah->arc_flag == 0xff) { 397 m_adj(m, 4); 398 399 if (m->m_len < ARC_HDRNEWLEN) { 400 m = m_pullup(m, ARC_HDRNEWLEN); 401 if (m == NULL) { 402 ++ifp->if_ierrors; 403 return NULL; 404 } 405 } 406 407 ah = mtod(m, struct arc_header *); 408 } 409 410 af = &ac->ac_fragtab[src]; 411 m1 = af->af_packet; 412 s = "debug code error"; 413 414 if (ah->arc_flag & 1) { 415 /* 416 * first fragment. We always initialize, which is 417 * about the right thing to do, as we only want to 418 * accept one fragmented packet per src at a time. 419 */ 420 if (m1 != NULL) 421 m_freem(m1); 422 423 af->af_packet = m; 424 m1 = m; 425 af->af_maxflag = ah->arc_flag; 426 af->af_lastseen = 0; 427 af->af_seqid = ah->arc_seqid; 428 429 return NULL; 430 /* notreached */ 431 } else { 432 /* check for unfragmented packet */ 433 if (ah->arc_flag == 0) 434 return m; 435 436 /* do we have a first packet from that src? */ 437 if (m1 == NULL) { 438 s = "no first frag"; 439 goto outofseq; 440 } 441 442 ah1 = mtod(m1, struct arc_header *); 443 444 if (ah->arc_seqid != ah1->arc_seqid) { 445 s = "seqid differs"; 446 goto outofseq; 447 } 448 449 if (typ != ah1->arc_type) { 450 s = "type differs"; 451 goto outofseq; 452 } 453 454 if (dst != ah1->arc_dhost) { 455 s = "dest host differs"; 456 goto outofseq; 457 } 458 459 /* typ, seqid and dst are ok here. */ 460 461 if (ah->arc_flag == af->af_lastseen) { 462 m_freem(m); 463 return NULL; 464 } 465 466 if (ah->arc_flag == af->af_lastseen + 2) { 467 /* ok, this is next fragment */ 468 af->af_lastseen = ah->arc_flag; 469 m_adj(m, ARC_HDRNEWLEN); 470 471 /* 472 * m_cat might free the first mbuf (with pkthdr) 473 * in 2nd chain; therefore: 474 */ 475 476 newflen = m->m_pkthdr.len; 477 478 m_cat(m1, m); 479 480 m1->m_pkthdr.len += newflen; 481 482 /* is it the last one? */ 483 if (af->af_lastseen > af->af_maxflag) { 484 af->af_packet = NULL; 485 return (m1); 486 } else 487 return NULL; 488 } 489 s = "other reason"; 490 /* if all else fails, it is out of sequence, too */ 491 } 492 outofseq: 493 if (m1) { 494 m_freem(m1); 495 af->af_packet = NULL; 496 } 497 498 if (m) 499 m_freem(m); 500 501 log(LOG_INFO,"%s: got out of seq. packet: %s\n", 502 ifp->if_xname, s); 503 504 return NULL; 505 } 506 507 /* 508 * return 1 if Packet Header Definition Standard, else 0. 509 * For now: old IP, old ARP aren't obviously. Lacking correct information, 510 * we guess that besides new IP and new ARP also IPX and APPLETALK are PHDS. 511 * (Apple and Novell corporations were involved, among others, in PHDS work). 512 * Easiest is to assume that everybody else uses that, too. 513 */ 514 int 515 arc_isphds(uint8_t type) 516 { 517 return (type != ARCTYPE_IP_OLD && 518 type != ARCTYPE_ARP_OLD && 519 type != ARCTYPE_DIAGNOSE); 520 } 521 522 /* 523 * Process a received Arcnet packet; 524 * the packet is in the mbuf chain m with 525 * the ARCnet header. 526 */ 527 static void 528 arc_input(struct ifnet *ifp, struct mbuf *m) 529 { 530 struct arc_header *ah; 531 struct ifqueue *inq; 532 uint8_t atype; 533 int s; 534 535 if ((ifp->if_flags & IFF_UP) == 0) { 536 m_freem(m); 537 return; 538 } 539 540 /* possibly defragment: */ 541 m = arc_defrag(ifp, m); 542 if (m == NULL) 543 return; 544 545 ah = mtod(m, struct arc_header *); 546 547 ifp->if_ibytes += m->m_pkthdr.len; 548 549 if (arcbroadcastaddr == ah->arc_dhost) { 550 m->m_flags |= M_BCAST|M_MCAST; 551 ifp->if_imcasts++; 552 } 553 554 atype = ah->arc_type; 555 switch (atype) { 556 #ifdef INET 557 case ARCTYPE_IP: 558 m_adj(m, ARC_HDRNEWLEN); 559 schednetisr(NETISR_IP); 560 inq = &ipintrq; 561 break; 562 563 case ARCTYPE_IP_OLD: 564 m_adj(m, ARC_HDRLEN); 565 schednetisr(NETISR_IP); 566 inq = &ipintrq; 567 break; 568 569 case ARCTYPE_ARP: 570 m_adj(m, ARC_HDRNEWLEN); 571 schednetisr(NETISR_ARP); 572 inq = &arpintrq; 573 #ifdef ARCNET_ALLOW_BROKEN_ARP 574 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP); 575 #endif 576 break; 577 578 case ARCTYPE_ARP_OLD: 579 m_adj(m, ARC_HDRLEN); 580 schednetisr(NETISR_ARP); 581 inq = &arpintrq; 582 #ifdef ARCNET_ALLOW_BROKEN_ARP 583 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP); 584 #endif 585 break; 586 #endif 587 #ifdef INET6 588 case ARCTYPE_INET6: 589 m_adj(m, ARC_HDRNEWLEN); 590 schednetisr(NETISR_IPV6); 591 inq = &ip6intrq; 592 break; 593 #endif 594 default: 595 m_freem(m); 596 return; 597 } 598 599 s = splnet(); 600 if (IF_QFULL(inq)) { 601 IF_DROP(inq); 602 m_freem(m); 603 } else 604 IF_ENQUEUE(inq, m); 605 splx(s); 606 } 607 608 /* 609 * Convert Arcnet address to printable (loggable) representation. 610 */ 611 char * 612 arc_sprintf(uint8_t *ap) 613 { 614 static char arcbuf[3]; 615 char *cp = arcbuf; 616 617 *cp++ = hexdigits[*ap >> 4]; 618 *cp++ = hexdigits[*ap++ & 0xf]; 619 *cp = 0; 620 return (arcbuf); 621 } 622 623 /* 624 * Perform common duties while attaching to interface list 625 */ 626 void 627 arc_ifattach(struct ifnet *ifp, uint8_t lla) 628 { 629 struct arccom *ac; 630 631 ifp->if_type = IFT_ARCNET; 632 ifp->if_addrlen = 1; 633 ifp->if_hdrlen = ARC_HDRLEN; 634 ifp->if_dlt = DLT_ARCNET; 635 if (ifp->if_flags & IFF_BROADCAST) 636 ifp->if_flags |= IFF_MULTICAST|IFF_ALLMULTI; 637 if (ifp->if_flags & IFF_LINK0 && arc_ipmtu > ARC_PHDS_MAXMTU) 638 log(LOG_ERR, 639 "%s: arc_ipmtu is %d, but must not exceed %d", 640 ifp->if_xname, arc_ipmtu, ARC_PHDS_MAXMTU); 641 642 ifp->if_output = arc_output; 643 ifp->if_input = arc_input; 644 ac = (struct arccom *)ifp; 645 ac->ac_seqid = (time_second) & 0xFFFF; /* try to make seqid unique */ 646 if (lla == 0) { 647 /* XXX this message isn't entirely clear, to me -- cgd */ 648 log(LOG_ERR,"%s: link address 0 reserved for broadcasts. Please change it and ifconfig %s down up\n", 649 ifp->if_xname, ifp->if_xname); 650 } 651 if_attach(ifp); 652 if_set_sadl(ifp, &lla, sizeof(lla)); 653 654 ifp->if_broadcastaddr = &arcbroadcastaddr; 655 656 #if NBPFILTER > 0 657 bpfattach(ifp, DLT_ARCNET, ARC_HDRLEN); 658 #endif 659 } 660
Indexes created Wed Oct 01 13:09:50 GMT 2025