1 /* 2 * Copyright (c) 1982 Regents of the University of California. 3 * All rights reserved. The Berkeley software License Agreement 4 * specifies the terms and conditions for redistribution. 5 * 6 * @(#)if_ether.c 6.13 (Berkeley) 09/16/85 7 */ 8 9 /* 10 * Ethernet address resolution protocol. 11 */ 12 13 #include "param.h" 14 #include "systm.h" 15 #include "mbuf.h" 16 #include "socket.h" 17 #include "time.h" 18 #include "kernel.h" 19 #include "errno.h" 20 #include "ioctl.h" 21 22 #include "../net/if.h" 23 #include "in.h" 24 #include "in_systm.h" 25 #include "ip.h" 26 #include "if_ether.h" 27 28 #define ARPTAB_BSIZ 9 /* bucket size */ 29 #define ARPTAB_NB 19 /* number of buckets */ 30 #define ARPTAB_SIZE (ARPTAB_BSIZ * ARPTAB_NB) 31 struct arptab arptab[ARPTAB_SIZE]; 32 int arptab_size = ARPTAB_SIZE; /* for arp command */ 33 34 #define ARPTAB_HASH(a) \ 35 ((short)((((a) >> 16) ^ (a)) & 0x7fff) % ARPTAB_NB) 36 37 #define ARPTAB_LOOK(at,addr) { \ 38 register n; \ 39 at = &arptab[ARPTAB_HASH(addr) * ARPTAB_BSIZ]; \ 40 for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) \ 41 if (at->at_iaddr.s_addr == addr) \ 42 break; \ 43 if (n >= ARPTAB_BSIZ) \ 44 at = 0; } 45 46 int arpt_age; /* aging timer */ 47 48 /* timer values */ 49 #define ARPT_AGE (60*1) /* aging timer, 1 min. */ 50 #define ARPT_KILLC 20 /* kill completed entry in 20 mins. */ 51 #define ARPT_KILLI 3 /* kill incomplete entry in 3 minutes */ 52 53 u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 54 extern struct ifnet loif; 55 56 /* 57 * Timeout routine. Age arp_tab entries once a minute. 58 */ 59 arptimer() 60 { 61 register struct arptab *at; 62 register i; 63 64 timeout(arptimer, (caddr_t)0, hz); 65 if (++arpt_age > ARPT_AGE) { 66 arpt_age = 0; 67 at = &arptab[0]; 68 for (i = 0; i < ARPTAB_SIZE; i++, at++) { 69 if (at->at_flags == 0 || (at->at_flags & ATF_PERM)) 70 continue; 71 if (++at->at_timer < ((at->at_flags&ATF_COM) ? 72 ARPT_KILLC : ARPT_KILLI)) 73 continue; 74 /* timer has expired, clear entry */ 75 arptfree(at); 76 } 77 } 78 } 79 80 /* 81 * Broadcast an ARP packet, asking who has addr on interface ac. 82 */ 83 arpwhohas(ac, addr) 84 register struct arpcom *ac; 85 struct in_addr *addr; 86 { 87 register struct mbuf *m; 88 register struct ether_header *eh; 89 register struct ether_arp *ea; 90 struct sockaddr sa; 91 92 if ((m = m_get(M_DONTWAIT, MT_DATA)) == NULL) 93 return (1); 94 m->m_len = sizeof *ea; 95 m->m_off = MMAXOFF - m->m_len; 96 ea = mtod(m, struct ether_arp *); 97 eh = (struct ether_header *)sa.sa_data; 98 bzero((caddr_t)ea, sizeof (*ea)); 99 bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost, 100 sizeof(eh->ether_dhost)); 101 eh->ether_type = ETHERTYPE_ARP; /* if_output will swap */ 102 ea->arp_hrd = htons(ARPHRD_ETHER); 103 ea->arp_pro = htons(ETHERTYPE_IP); 104 ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */ 105 ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */ 106 ea->arp_op = htons(ARPOP_REQUEST); 107 bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, 108 sizeof(ea->arp_sha)); 109 bcopy((caddr_t)&ac->ac_ipaddr, (caddr_t)ea->arp_spa, 110 sizeof(ea->arp_spa)); 111 bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa)); 112 sa.sa_family = AF_UNSPEC; 113 return ((*ac->ac_if.if_output)(&ac->ac_if, m, &sa)); 114 } 115 116 /* 117 * Resolve an IP address into an ethernet address. If success, 118 * desten is filled in and 1 is returned. If there is no entry 119 * in arptab, set one up and broadcast a request 120 * for the IP address; return 0. Hold onto this mbuf and 121 * resend it once the address is finally resolved. 122 * 123 * We do some (conservative) locking here at splimp, since 124 * arptab is also altered from input interrupt service (ecintr/ilintr 125 * calls arpinput when ETHERTYPE_ARP packets come in). 126 */ 127 arpresolve(ac, m, destip, desten) 128 register struct arpcom *ac; 129 struct mbuf *m; 130 register struct in_addr *destip; 131 register u_char *desten; 132 { 133 register struct arptab *at; 134 register struct ifnet *ifp; 135 struct sockaddr_in sin; 136 int s, lna; 137 138 if (in_broadcast(*destip)) { /* broadcast address */ 139 bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten, 140 sizeof(etherbroadcastaddr)); 141 return (1); 142 } 143 lna = in_lnaof(*destip); 144 ifp = &ac->ac_if; 145 /* if for us, then use software loopback driver */ 146 if (destip->s_addr == ac->ac_ipaddr.s_addr && 147 (loif.if_flags & IFF_UP)) { 148 sin.sin_family = AF_INET; 149 sin.sin_addr = *destip; 150 (void) looutput(&loif, m, (struct sockaddr *)&sin); 151 /* 152 * We really don't want to indicate failure, 153 * but the packet has already been sent and freed. 154 */ 155 return (0); 156 } 157 s = splimp(); 158 ARPTAB_LOOK(at, destip->s_addr); 159 if (at == 0) { /* not found */ 160 if (ifp->if_flags & IFF_NOARP) { 161 bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3); 162 desten[3] = (lna >> 16) & 0x7f; 163 desten[4] = (lna >> 8) & 0xff; 164 desten[5] = lna & 0xff; 165 splx(s); 166 return (1); 167 } else { 168 at = arptnew(destip); 169 at->at_hold = m; 170 arpwhohas(ac, destip); 171 splx(s); 172 return (0); 173 } 174 } 175 at->at_timer = 0; /* restart the timer */ 176 if (at->at_flags & ATF_COM) { /* entry IS complete */ 177 bcopy((caddr_t)at->at_enaddr, (caddr_t)desten, 178 sizeof(at->at_enaddr)); 179 splx(s); 180 return (1); 181 } 182 /* 183 * There is an arptab entry, but no ethernet address 184 * response yet. Replace the held mbuf with this 185 * latest one. 186 */ 187 if (at->at_hold) 188 m_freem(at->at_hold); 189 at->at_hold = m; 190 arpwhohas(ac, destip); /* ask again */ 191 splx(s); 192 return (0); 193 } 194 195 /* 196 * Called from 10 Mb/s Ethernet interrupt handlers 197 * when ether packet type ETHERTYPE_ARP 198 * is received. Algorithm is that given in RFC 826. 199 * In addition, a sanity check is performed on the sender 200 * protocol address, to catch impersonators. 201 */ 202 arpinput(ac, m) 203 register struct arpcom *ac; 204 struct mbuf *m; 205 { 206 register struct ether_arp *ea; 207 struct ether_header *eh; 208 register struct arptab *at; /* same as "merge" flag */ 209 struct sockaddr_in sin; 210 struct sockaddr sa; 211 struct in_addr isaddr,itaddr,myaddr; 212 213 IF_ADJ(m); 214 at = 0; 215 if (m->m_len < sizeof *ea) 216 goto out; 217 if (ac->ac_if.if_flags & IFF_NOARP) 218 goto out; 219 myaddr = ac->ac_ipaddr; 220 ea = mtod(m, struct ether_arp *); 221 if (ntohs(ea->arp_pro) != ETHERTYPE_IP) 222 goto out; 223 isaddr.s_addr = ((struct in_addr *)ea->arp_spa)->s_addr; 224 itaddr.s_addr = ((struct in_addr *)ea->arp_tpa)->s_addr; 225 if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr, 226 sizeof (ea->arp_sha))) 227 goto out; /* it's from me, ignore it. */ 228 if (isaddr.s_addr == myaddr.s_addr) { 229 printf("duplicate IP address!! sent from ethernet address: "); 230 printf("%x %x %x %x %x %x\n", ea->arp_sha[0], ea->arp_sha[1], 231 ea->arp_sha[2], ea->arp_sha[3], 232 ea->arp_sha[4], ea->arp_sha[5]); 233 itaddr = myaddr; 234 if (ntohs(ea->arp_op) == ARPOP_REQUEST) { 235 bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha, 236 sizeof(ea->arp_sha)); 237 goto reply; 238 } 239 goto out; 240 } 241 ARPTAB_LOOK(at, isaddr.s_addr); 242 if (at && (at->at_flags & ATF_COM) == 0) { 243 bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, 244 sizeof(ea->arp_sha)); 245 at->at_flags |= ATF_COM; 246 if (at->at_hold) { 247 sin.sin_family = AF_INET; 248 sin.sin_addr = isaddr; 249 (*ac->ac_if.if_output)(&ac->ac_if, 250 at->at_hold, (struct sockaddr *)&sin); 251 at->at_hold = 0; 252 } 253 } 254 if (at == 0 && itaddr.s_addr == myaddr.s_addr) { 255 /* ensure we have a table entry */ 256 at = arptnew(&isaddr); 257 bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr, 258 sizeof(ea->arp_sha)); 259 at->at_flags |= ATF_COM; 260 } 261 if (ntohs(ea->arp_op) != ARPOP_REQUEST) 262 goto out; 263 ARPTAB_LOOK(at, itaddr.s_addr); 264 if (at == NULL) { 265 if (itaddr.s_addr != myaddr.s_addr) 266 goto out; /* if I am not the target */ 267 at = arptnew(&myaddr); 268 bcopy((caddr_t)ac->ac_enaddr, (caddr_t)at->at_enaddr, 269 sizeof(at->at_enaddr)); 270 at->at_flags |= ATF_COM; 271 } 272 if (itaddr.s_addr != myaddr.s_addr && (at->at_flags & ATF_PUBL) == 0) 273 goto out; 274 275 reply: 276 bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha, 277 sizeof(ea->arp_sha)); 278 bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, 279 sizeof(ea->arp_spa)); 280 if (at) /* done above if at == 0 */ 281 bcopy((caddr_t)at->at_enaddr, (caddr_t)ea->arp_sha, 282 sizeof(ea->arp_sha)); 283 bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa, 284 sizeof(ea->arp_spa)); 285 ea->arp_op = htons(ARPOP_REPLY); 286 eh = (struct ether_header *)sa.sa_data; 287 bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost, 288 sizeof(eh->ether_dhost)); 289 eh->ether_type = ETHERTYPE_ARP; 290 sa.sa_family = AF_UNSPEC; 291 (*ac->ac_if.if_output)(&ac->ac_if, m, &sa); 292 return; 293 out: 294 m_freem(m); 295 return; 296 } 297 298 /* 299 * Free an arptab entry. 300 */ 301 arptfree(at) 302 register struct arptab *at; 303 { 304 int s = splimp(); 305 306 if (at->at_hold) 307 m_freem(at->at_hold); 308 at->at_hold = 0; 309 at->at_timer = at->at_flags = 0; 310 at->at_iaddr.s_addr = 0; 311 splx(s); 312 } 313 314 /* 315 * Enter a new address in arptab, pushing out the oldest entry 316 * from the bucket if there is no room. 317 * This always succeeds since no bucket can be completely filled 318 * with permanent entries (except from arpioctl when testing whether 319 * another permanent entry will fit). 320 */ 321 struct arptab * 322 arptnew(addr) 323 struct in_addr *addr; 324 { 325 register n; 326 int oldest = -1; 327 register struct arptab *at, *ato = NULL; 328 static int first = 1; 329 330 if (first) { 331 first = 0; 332 timeout(arptimer, (caddr_t)0, hz); 333 } 334 at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ]; 335 for (n = 0; n < ARPTAB_BSIZ; n++,at++) { 336 if (at->at_flags == 0) 337 goto out; /* found an empty entry */ 338 if (at->at_flags & ATF_PERM) 339 continue; 340 if (at->at_timer > oldest) { 341 oldest = at->at_timer; 342 ato = at; 343 } 344 } 345 if (ato == NULL) 346 return (NULL); 347 at = ato; 348 arptfree(at); 349 out: 350 at->at_iaddr = *addr; 351 at->at_flags = ATF_INUSE; 352 return (at); 353 } 354 355 arpioctl(cmd, data) 356 int cmd; 357 caddr_t data; 358 { 359 register struct arpreq *ar = (struct arpreq *)data; 360 register struct arptab *at; 361 register struct sockaddr_in *sin; 362 int s; 363 364 if (ar->arp_pa.sa_family != AF_INET || 365 ar->arp_ha.sa_family != AF_UNSPEC) 366 return (EAFNOSUPPORT); 367 sin = (struct sockaddr_in *)&ar->arp_pa; 368 s = splimp(); 369 ARPTAB_LOOK(at, sin->sin_addr.s_addr); 370 if (at == NULL) { /* not found */ 371 if (cmd != SIOCSARP) { 372 splx(s); 373 return (ENXIO); 374 } 375 if (ifa_ifwithnet(&ar->arp_pa) == NULL) { 376 splx(s); 377 return (ENETUNREACH); 378 } 379 } 380 switch (cmd) { 381 382 case SIOCSARP: /* set entry */ 383 if (at == NULL) { 384 at = arptnew(&sin->sin_addr); 385 if (ar->arp_flags & ATF_PERM) { 386 /* never make all entries in a bucket permanent */ 387 register struct arptab *tat; 388 389 /* try to re-allocate */ 390 tat = arptnew(&sin->sin_addr); 391 if (tat == NULL) { 392 arptfree(at); 393 splx(s); 394 return (EADDRNOTAVAIL); 395 } 396 arptfree(tat); 397 } 398 } 399 bcopy((caddr_t)ar->arp_ha.sa_data, (caddr_t)at->at_enaddr, 400 sizeof(at->at_enaddr)); 401 at->at_flags = ATF_COM | ATF_INUSE | 402 (ar->arp_flags & (ATF_PERM|ATF_PUBL)); 403 at->at_timer = 0; 404 break; 405 406 case SIOCDARP: /* delete entry */ 407 arptfree(at); 408 break; 409 410 case SIOCGARP: /* get entry */ 411 bcopy((caddr_t)at->at_enaddr, (caddr_t)ar->arp_ha.sa_data, 412 sizeof(at->at_enaddr)); 413 ar->arp_flags = at->at_flags; 414 break; 415 } 416 splx(s); 417 return (0); 418 } 419