![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ether.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netinet|
Return to if_ether.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netinet |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)if_ether.c 7.12 (Berkeley) 6/28/90 ! 21: */ ! 22: ! 23: /* ! 24: * Ethernet address resolution protocol. ! 25: * TODO: ! 26: * run at splnet (add ARP protocol intr.) ! 27: * link entries onto hash chains, keep free list ! 28: * add "inuse/lock" bit (or ref. count) along with valid bit ! 29: */ ! 30: ! 31: #include "param.h" ! 32: #include "systm.h" ! 33: #include "malloc.h" ! 34: #include "mbuf.h" ! 35: #include "socket.h" ! 36: #include "time.h" ! 37: #include "kernel.h" ! 38: #include "errno.h" ! 39: #include "ioctl.h" ! 40: #include "syslog.h" ! 41: ! 42: #include "../net/if.h" ! 43: #include "in.h" ! 44: #include "in_systm.h" ! 45: #include "in_var.h" ! 46: #include "ip.h" ! 47: #include "if_ether.h" ! 48: ! 49: #ifdef GATEWAY ! 50: #define ARPTAB_BSIZ 16 /* bucket size */ ! 51: #define ARPTAB_NB 37 /* number of buckets */ ! 52: #else ! 53: #define ARPTAB_BSIZ 9 /* bucket size */ ! 54: #define ARPTAB_NB 19 /* number of buckets */ ! 55: #endif ! 56: #define ARPTAB_SIZE (ARPTAB_BSIZ * ARPTAB_NB) ! 57: struct arptab arptab[ARPTAB_SIZE]; ! 58: int arptab_size = ARPTAB_SIZE; /* for arp command */ ! 59: ! 60: /* ! 61: * ARP trailer negotiation. Trailer protocol is not IP specific, ! 62: * but ARP request/response use IP addresses. ! 63: */ ! 64: #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL ! 65: ! 66: #define ARPTAB_HASH(a) \ ! 67: ((u_long)(a) % ARPTAB_NB) ! 68: ! 69: #define ARPTAB_LOOK(at,addr) { \ ! 70: register n; \ ! 71: at = &arptab[ARPTAB_HASH(addr) * ARPTAB_BSIZ]; \ ! 72: for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) \ ! 73: if (at->at_iaddr.s_addr == addr) \ ! 74: break; \ ! 75: if (n >= ARPTAB_BSIZ) \ ! 76: at = 0; \ ! 77: } ! 78: ! 79: /* timer values */ ! 80: #define ARPT_AGE (60*1) /* aging timer, 1 min. */ ! 81: #define ARPT_KILLC 20 /* kill completed entry in 20 mins. */ ! 82: #define ARPT_KILLI 3 /* kill incomplete entry in 3 minutes */ ! 83: ! 84: extern struct ifnet loif; ! 85: ! 86: /* ! 87: * Timeout routine. Age arp_tab entries once a minute. ! 88: */ ! 89: arptimer() ! 90: { ! 91: register struct arptab *at; ! 92: register i; ! 93: ! 94: timeout(arptimer, (caddr_t)0, ARPT_AGE * hz); ! 95: at = &arptab[0]; ! 96: for (i = 0; i < ARPTAB_SIZE; i++, at++) { ! 97: if (at->at_flags == 0 || (at->at_flags & ATF_PERM)) ! 98: continue; ! 99: if (++at->at_timer < ((at->at_flags&ATF_COM) ? ! 100: ARPT_KILLC : ARPT_KILLI)) ! 101: continue; ! 102: /* timer has expired, clear entry */ ! 103: arptfree(at); ! 104: } ! 105: } ! 106: ! 107: /* ! 108: * Broadcast an ARP packet, asking who has addr on interface ac. ! 109: */ ! 110: arpwhohas(ac, addr) ! 111: register struct arpcom *ac; ! 112: struct in_addr *addr; ! 113: { ! 114: register struct mbuf *m; ! 115: register struct ether_header *eh; ! 116: register struct ether_arp *ea; ! 117: struct sockaddr sa; ! 118: ! 119: if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) ! 120: return; ! 121: m->m_len = sizeof(*ea); ! 122: m->m_pkthdr.len = sizeof(*ea); ! 123: MH_ALIGN(m, sizeof(*ea)); ! 124: ea = mtod(m, struct ether_arp *); ! 125: eh = (struct ether_header *)sa.sa_data; ! 126: bzero((caddr_t)ea, sizeof (*ea)); ! 127: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost, ! 128: sizeof(eh->ether_dhost)); ! 129: eh->ether_type = ETHERTYPE_ARP; /* if_output will swap */ ! 130: ea->arp_hrd = htons(ARPHRD_ETHER); ! 131: ea->arp_pro = htons(ETHERTYPE_IP); ! 132: ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */ ! 133: ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */ ! 134: ea->arp_op = htons(ARPOP_REQUEST); ! 135: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, ! 136: sizeof(ea->arp_sha)); ! 137: bcopy((caddr_t)&ac->ac_ipaddr, (caddr_t)ea->arp_spa, ! 138: sizeof(ea->arp_spa)); ! 139: bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa)); ! 140: sa.sa_family = AF_UNSPEC; ! 141: sa.sa_len = sizeof(sa); ! 142: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0); ! 143: } ! 144: ! 145: int useloopback = 1; /* use loopback interface for local traffic */ ! 146: ! 147: /* ! 148: * Resolve an IP address into an ethernet address. If success, ! 149: * desten is filled in. If there is no entry in arptab, ! 150: * set one up and broadcast a request for the IP address. ! 151: * Hold onto this mbuf and resend it once the address ! 152: * is finally resolved. A return value of 1 indicates ! 153: * that desten has been filled in and the packet should be sent ! 154: * normally; a 0 return indicates that the packet has been ! 155: * taken over here, either now or for later transmission. ! 156: * ! 157: * We do some (conservative) locking here at splimp, since ! 158: * arptab is also altered from input interrupt service (ecintr/ilintr ! 159: * calls arpinput when ETHERTYPE_ARP packets come in). ! 160: */ ! 161: arpresolve(ac, m, destip, desten, usetrailers) ! 162: register struct arpcom *ac; ! 163: struct mbuf *m; ! 164: register struct in_addr *destip; ! 165: register u_char *desten; ! 166: int *usetrailers; ! 167: { ! 168: register struct arptab *at; ! 169: struct sockaddr_in sin; ! 170: register struct in_ifaddr *ia; ! 171: u_long lna; ! 172: int s; ! 173: ! 174: *usetrailers = 0; ! 175: if (m->m_flags & M_BCAST) { /* broadcast */ ! 176: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten, ! 177: sizeof(etherbroadcastaddr)); ! 178: return (1); ! 179: } ! 180: lna = in_lnaof(*destip); ! 181: /* if for us, use software loopback driver if up */ ! 182: for (ia = in_ifaddr; ia; ia = ia->ia_next) ! 183: if ((ia->ia_ifp == &ac->ac_if) && ! 184: (destip->s_addr == ia->ia_addr.sin_addr.s_addr)) { ! 185: /* ! 186: * This test used to be ! 187: * if (loif.if_flags & IFF_UP) ! 188: * It allowed local traffic to be forced ! 189: * through the hardware by configuring the loopback down. ! 190: * However, it causes problems during network configuration ! 191: * for boards that can't receive packets they send. ! 192: * It is now necessary to clear "useloopback" ! 193: * to force traffic out to the hardware. ! 194: */ ! 195: if (useloopback) { ! 196: sin.sin_family = AF_INET; ! 197: sin.sin_addr = *destip; ! 198: (void) looutput(&loif, m, (struct sockaddr *)&sin); ! 199: /* ! 200: * The packet has already been sent and freed. ! 201: */ ! 202: return (0); ! 203: } else { ! 204: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, ! 205: sizeof(ac->ac_enaddr)); ! 206: return (1); ! 207: } ! 208: } ! 209: s = splimp(); ! 210: ARPTAB_LOOK(at, destip->s_addr); ! 211: if (at == 0) { /* not found */ ! 212: if (ac->ac_if.if_flags & IFF_NOARP) { ! 213: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3); ! 214: desten[3] = (lna >> 16) & 0x7f; ! 215: desten[4] = (lna >> 8) & 0xff; ! 216: desten[5] = lna & 0xff; ! 217: splx(s); ! 218: return (1); ! 219: } else { ! 220: at = arptnew(destip); ! 221: if (at == 0) ! 222: panic("arpresolve: no free entry"); ! 223: at->at_hold = m; ! 224: arpwhohas(ac, destip); ! 225: splx(s); ! 226: return (0); ! 227: } ! 228: } ! 229: at->at_timer = 0; /* restart the timer */ ! 230: if (at->at_flags & ATF_COM) { /* entry IS complete */ ! 231: bcopy((caddr_t)at->at_enaddr, (caddr_t)desten, ! 232: sizeof(at->at_enaddr)); ! 233: if (at->at_flags & ATF_USETRAILERS) ! 234: *usetrailers = 1; ! 235: splx(s); ! 236: return (1); ! 237: } ! 238: /* ! 239: * There is an arptab entry, but no ethernet address ! 240: * response yet. Replace the held mbuf with this ! 241: * latest one. ! 242: */ ! 243: if (at->at_hold) ! 244: m_freem(at->at_hold); ! 245: at->at_hold = m; ! 246: arpwhohas(ac, destip); /* ask again */ ! 247: splx(s); ! 248: return (0); ! 249: } ! 250: ! 251: /* ! 252: * Called from 10 Mb/s Ethernet interrupt handlers ! 253: * when ether packet type ETHERTYPE_ARP ! 254: * is received. Common length and type checks are done here, ! 255: * then the protocol-specific routine is called. ! 256: */ ! 257: arpinput(ac, m) ! 258: struct arpcom *ac; ! 259: struct mbuf *m; ! 260: { ! 261: register struct arphdr *ar; ! 262: ! 263: if (ac->ac_if.if_flags & IFF_NOARP) ! 264: goto out; ! 265: if (m->m_len < sizeof(struct arphdr)) ! 266: goto out; ! 267: ar = mtod(m, struct arphdr *); ! 268: if (ntohs(ar->ar_hrd) != ARPHRD_ETHER) ! 269: goto out; ! 270: if (m->m_len < sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln) ! 271: goto out; ! 272: ! 273: switch (ntohs(ar->ar_pro)) { ! 274: ! 275: case ETHERTYPE_IP: ! 276: case ETHERTYPE_IPTRAILERS: ! 277: in_arpinput(ac, m); ! 278: return; ! 279: ! 280: default: ! 281: break; ! 282: } ! 283: out: ! 284: m_freem(m); ! 285: } ! 286: ! 287: /* ! 288: * ARP for Internet protocols on 10 Mb/s Ethernet. ! 289: * Algorithm is that given in RFC 826. ! 290: * In addition, a sanity check is performed on the sender ! 291: * protocol address, to catch impersonators. ! 292: * We also handle negotiations for use of trailer protocol: ! 293: * ARP replies for protocol type ETHERTYPE_TRAIL are sent ! 294: * along with IP replies if we want trailers sent to us, ! 295: * and also send them in response to IP replies. ! 296: * This allows either end to announce the desire to receive ! 297: * trailer packets. ! 298: * We reply to requests for ETHERTYPE_TRAIL protocol as well, ! 299: * but don't normally send requests. ! 300: */ ! 301: in_arpinput(ac, m) ! 302: register struct arpcom *ac; ! 303: struct mbuf *m; ! 304: { ! 305: register struct ether_arp *ea; ! 306: struct ether_header *eh; ! 307: register struct arptab *at; /* same as "merge" flag */ ! 308: register struct in_ifaddr *ia; ! 309: struct in_ifaddr *maybe_ia = 0; ! 310: struct mbuf *mcopy = 0; ! 311: struct sockaddr_in sin; ! 312: struct sockaddr sa; ! 313: struct in_addr isaddr, itaddr, myaddr; ! 314: int proto, op, s, completed = 0; ! 315: ! 316: ea = mtod(m, struct ether_arp *); ! 317: proto = ntohs(ea->arp_pro); ! 318: op = ntohs(ea->arp_op); ! 319: bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr)); ! 320: bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr)); ! 321: for (ia = in_ifaddr; ia; ia = ia->ia_next) ! 322: if (ia->ia_ifp == &ac->ac_if) { ! 323: maybe_ia = ia; ! 324: if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) || ! 325: (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr)) ! 326: break; ! 327: } ! 328: if (maybe_ia == 0) ! 329: goto out; ! 330: myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr; ! 331: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr, ! 332: sizeof (ea->arp_sha))) ! 333: goto out; /* it's from me, ignore it. */ ! 334: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr, ! 335: sizeof (ea->arp_sha))) { ! 336: log(LOG_ERR, ! 337: "arp: ether address is broadcast for IP address %x!\n", ! 338: ntohl(isaddr.s_addr)); ! 339: goto out; ! 340: } ! 341: if (isaddr.s_addr == myaddr.s_addr) { ! 342: log(LOG_ERR, ! 343: "duplicate IP address %x!! sent from ethernet address: %s\n", ! 344: ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha)); ! 345: itaddr = myaddr; ! 346: if (op == ARPOP_REQUEST) ! 347: goto reply; ! 348: goto out; ! 349: } ! 350: s = splimp(); ! 351: ARPTAB_LOOK(at, isaddr.s_addr); ! 352: if (at) { ! 353: bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, ! 354: sizeof(ea->arp_sha)); ! 355: if ((at->at_flags & ATF_COM) == 0) ! 356: completed = 1; ! 357: at->at_flags |= ATF_COM; ! 358: if (at->at_hold) { ! 359: sin.sin_family = AF_INET; ! 360: sin.sin_addr = isaddr; ! 361: (*ac->ac_if.if_output)(&ac->ac_if, at->at_hold, ! 362: (struct sockaddr *)&sin, (struct rtentry *)0); ! 363: at->at_hold = 0; ! 364: } ! 365: } ! 366: if (at == 0 && itaddr.s_addr == myaddr.s_addr) { ! 367: /* ensure we have a table entry */ ! 368: if (at = arptnew(&isaddr)) { ! 369: bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, ! 370: sizeof(ea->arp_sha)); ! 371: completed = 1; ! 372: at->at_flags |= ATF_COM; ! 373: } ! 374: } ! 375: splx(s); ! 376: reply: ! 377: switch (proto) { ! 378: ! 379: case ETHERTYPE_IPTRAILERS: ! 380: /* partner says trailers are OK */ ! 381: if (at) ! 382: at->at_flags |= ATF_USETRAILERS; ! 383: /* ! 384: * Reply to request iff we want trailers. ! 385: */ ! 386: if (op != ARPOP_REQUEST || ac->ac_if.if_flags & IFF_NOTRAILERS) ! 387: goto out; ! 388: break; ! 389: ! 390: case ETHERTYPE_IP: ! 391: /* ! 392: * Reply if this is an IP request, ! 393: * or if we want to send a trailer response. ! 394: * Send the latter only to the IP response ! 395: * that completes the current ARP entry. ! 396: */ ! 397: if (op != ARPOP_REQUEST && ! 398: (completed == 0 || ac->ac_if.if_flags & IFF_NOTRAILERS)) ! 399: goto out; ! 400: } ! 401: if (itaddr.s_addr == myaddr.s_addr) { ! 402: /* I am the target */ ! 403: bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, ! 404: sizeof(ea->arp_sha)); ! 405: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, ! 406: sizeof(ea->arp_sha)); ! 407: } else { ! 408: ARPTAB_LOOK(at, itaddr.s_addr); ! 409: if (at == NULL || (at->at_flags & ATF_PUBL) == 0) ! 410: goto out; ! 411: bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, ! 412: sizeof(ea->arp_sha)); ! 413: bcopy((caddr_t)at->at_enaddr, (caddr_t)ea->arp_sha, ! 414: sizeof(ea->arp_sha)); ! 415: } ! 416: ! 417: bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, ! 418: sizeof(ea->arp_spa)); ! 419: bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa, ! 420: sizeof(ea->arp_spa)); ! 421: ea->arp_op = htons(ARPOP_REPLY); ! 422: /* ! 423: * If incoming packet was an IP reply, ! 424: * we are sending a reply for type IPTRAILERS. ! 425: * If we are sending a reply for type IP ! 426: * and we want to receive trailers, ! 427: * send a trailer reply as well. ! 428: */ ! 429: if (op == ARPOP_REPLY) ! 430: ea->arp_pro = htons(ETHERTYPE_IPTRAILERS); ! 431: else if (proto == ETHERTYPE_IP && ! 432: (ac->ac_if.if_flags & IFF_NOTRAILERS) == 0) ! 433: mcopy = m_copy(m, 0, (int)M_COPYALL); ! 434: eh = (struct ether_header *)sa.sa_data; ! 435: bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost, ! 436: sizeof(eh->ether_dhost)); ! 437: eh->ether_type = ETHERTYPE_ARP; ! 438: sa.sa_family = AF_UNSPEC; ! 439: sa.sa_len = sizeof(sa); ! 440: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0); ! 441: if (mcopy) { ! 442: ea = mtod(mcopy, struct ether_arp *); ! 443: ea->arp_pro = htons(ETHERTYPE_IPTRAILERS); ! 444: (*ac->ac_if.if_output)(&ac->ac_if, ! 445: mcopy, &sa, (struct rtentry *)0); ! 446: } ! 447: return; ! 448: out: ! 449: m_freem(m); ! 450: return; ! 451: } ! 452: ! 453: /* ! 454: * Free an arptab entry. ! 455: */ ! 456: arptfree(at) ! 457: register struct arptab *at; ! 458: { ! 459: int s = splimp(); ! 460: ! 461: if (at->at_hold) ! 462: m_freem(at->at_hold); ! 463: at->at_hold = 0; ! 464: at->at_timer = at->at_flags = 0; ! 465: at->at_iaddr.s_addr = 0; ! 466: splx(s); ! 467: } ! 468: ! 469: /* ! 470: * Enter a new address in arptab, pushing out the oldest entry ! 471: * from the bucket if there is no room. ! 472: * This always succeeds since no bucket can be completely filled ! 473: * with permanent entries (except from arpioctl when testing whether ! 474: * another permanent entry will fit). ! 475: * MUST BE CALLED AT SPLIMP. ! 476: */ ! 477: struct arptab * ! 478: arptnew(addr) ! 479: struct in_addr *addr; ! 480: { ! 481: register n; ! 482: int oldest = -1; ! 483: register struct arptab *at, *ato = NULL; ! 484: static int first = 1; ! 485: ! 486: if (first) { ! 487: first = 0; ! 488: timeout(arptimer, (caddr_t)0, hz); ! 489: } ! 490: at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ]; ! 491: for (n = 0; n < ARPTAB_BSIZ; n++,at++) { ! 492: if (at->at_flags == 0) ! 493: goto out; /* found an empty entry */ ! 494: if (at->at_flags & ATF_PERM) ! 495: continue; ! 496: if ((int) at->at_timer > oldest) { ! 497: oldest = at->at_timer; ! 498: ato = at; ! 499: } ! 500: } ! 501: if (ato == NULL) ! 502: return (NULL); ! 503: at = ato; ! 504: arptfree(at); ! 505: out: ! 506: at->at_iaddr = *addr; ! 507: at->at_flags = ATF_INUSE; ! 508: return (at); ! 509: } ! 510: ! 511: arpioctl(cmd, data) ! 512: int cmd; ! 513: caddr_t data; ! 514: { ! 515: register struct arpreq *ar = (struct arpreq *)data; ! 516: register struct arptab *at; ! 517: register struct sockaddr_in *sin; ! 518: int s; ! 519: ! 520: sin = (struct sockaddr_in *)&ar->arp_ha; ! 521: #if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN ! 522: if (sin->sin_family == 0 && sin->sin_len < 16) ! 523: sin->sin_family = sin->sin_len; ! 524: #endif ! 525: sin->sin_len = sizeof(ar->arp_ha); ! 526: sin = (struct sockaddr_in *)&ar->arp_pa; ! 527: #if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN ! 528: if (sin->sin_family == 0 && sin->sin_len < 16) ! 529: sin->sin_family = sin->sin_len; ! 530: #endif ! 531: sin->sin_len = sizeof(ar->arp_pa); ! 532: if (ar->arp_pa.sa_family != AF_INET || ! 533: ar->arp_ha.sa_family != AF_UNSPEC) ! 534: return (EAFNOSUPPORT); ! 535: s = splimp(); ! 536: ARPTAB_LOOK(at, sin->sin_addr.s_addr); ! 537: if (at == NULL) { /* not found */ ! 538: if (cmd != SIOCSARP) { ! 539: splx(s); ! 540: return (ENXIO); ! 541: } ! 542: if (ifa_ifwithnet(&ar->arp_pa) == NULL) { ! 543: splx(s); ! 544: return (ENETUNREACH); ! 545: } ! 546: } ! 547: switch (cmd) { ! 548: ! 549: case SIOCSARP: /* set entry */ ! 550: if (at == NULL) { ! 551: at = arptnew(&sin->sin_addr); ! 552: if (at == NULL) { ! 553: splx(s); ! 554: return (EADDRNOTAVAIL); ! 555: } ! 556: if (ar->arp_flags & ATF_PERM) { ! 557: /* never make all entries in a bucket permanent */ ! 558: register struct arptab *tat; ! 559: ! 560: /* try to re-allocate */ ! 561: tat = arptnew(&sin->sin_addr); ! 562: if (tat == NULL) { ! 563: arptfree(at); ! 564: splx(s); ! 565: return (EADDRNOTAVAIL); ! 566: } ! 567: arptfree(tat); ! 568: } ! 569: } ! 570: bcopy((caddr_t)ar->arp_ha.sa_data, (caddr_t)at->at_enaddr, ! 571: sizeof(at->at_enaddr)); ! 572: at->at_flags = ATF_COM | ATF_INUSE | ! 573: (ar->arp_flags & (ATF_PERM|ATF_PUBL|ATF_USETRAILERS)); ! 574: at->at_timer = 0; ! 575: break; ! 576: ! 577: case SIOCDARP: /* delete entry */ ! 578: arptfree(at); ! 579: break; ! 580: ! 581: case SIOCGARP: /* get entry */ ! 582: case OSIOCGARP: ! 583: bcopy((caddr_t)at->at_enaddr, (caddr_t)ar->arp_ha.sa_data, ! 584: sizeof(at->at_enaddr)); ! 585: #ifdef COMPAT_43 ! 586: if (cmd == OSIOCGARP) ! 587: *(u_short *)&ar->arp_ha = ar->arp_ha.sa_family; ! 588: #endif ! 589: ar->arp_flags = at->at_flags; ! 590: break; ! 591: } ! 592: splx(s); ! 593: return (0); ! 594: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.