![[BACK]](/icons/back.gif){kind=icon}
Return to if_ether.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet|
Return to if_ether.c CVS log | Up to [local] / sys / netinet |
1.1 nbrk 1: /* $OpenBSD: if_ether.c,v 1.68 2007/03/25 16:43:22 claudio Exp $ */
2: /* $NetBSD: if_ether.c,v 1.31 1996/05/11 12:59:58 mycroft Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1988, 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: * @(#)if_ether.c 8.1 (Berkeley) 6/10/93
33: */
34:
35: /*
36: * Ethernet address resolution protocol.
37: * TODO:
38: * add "inuse/lock" bit (or ref. count) along with valid bit
39: */
40:
41: #ifdef INET
42: #include "carp.h"
43:
44: #include "bridge.h"
45:
46: #include <sys/param.h>
47: #include <sys/systm.h>
48: #include <sys/mbuf.h>
49: #include <sys/socket.h>
50: #include <sys/kernel.h>
51: #include <sys/syslog.h>
52: #include <sys/proc.h>
53:
54: #include <net/if.h>
55: #include <net/if_dl.h>
56: #include <net/route.h>
57: #include <net/if_fddi.h>
58: #include <net/if_types.h>
59:
60: #include <netinet/in.h>
61: #include <netinet/in_var.h>
62: #include <netinet/if_ether.h>
63: #if NCARP > 0
64: #include <netinet/ip_carp.h>
65: #endif
66:
67: #define SIN(s) ((struct sockaddr_in *)s)
68: #define SDL(s) ((struct sockaddr_dl *)s)
69: #define SRP(s) ((struct sockaddr_inarp *)s)
70:
71: /*
72: * ARP trailer negotiation. Trailer protocol is not IP specific,
73: * but ARP request/response use IP addresses.
74: */
75: #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
76:
77: /* timer values */
78: int arpt_prune = (5*60*1); /* walk list every 5 minutes */
79: int arpt_keep = (20*60); /* once resolved, good for 20 more minutes */
80: int arpt_down = 20; /* once declared down, don't send for 20 secs */
81: #define rt_expire rt_rmx.rmx_expire
82:
83: void arptfree(struct llinfo_arp *);
84: void arptimer(void *);
85: struct llinfo_arp *arplookup(u_int32_t, int, int);
86: void in_arpinput(struct mbuf *);
87:
88: LIST_HEAD(, llinfo_arp) llinfo_arp;
89: struct ifqueue arpintrq = {0, 0, 0, 50};
90: int arp_inuse, arp_allocated, arp_intimer;
91: int arp_maxtries = 5;
92: int useloopback = 1; /* use loopback interface for local traffic */
93: int arpinit_done = 0;
94:
95: /* revarp state */
96: struct in_addr myip, srv_ip;
97: int myip_initialized = 0;
98: int revarp_in_progress = 0;
99: struct ifnet *myip_ifp = NULL;
100:
101: #ifdef DDB
102: #include <uvm/uvm_extern.h>
103:
104: void db_print_sa(struct sockaddr *);
105: void db_print_ifa(struct ifaddr *);
106: void db_print_llinfo(caddr_t);
107: int db_show_radix_node(struct radix_node *, void *);
108: #endif
109:
110: /*
111: * Timeout routine. Age arp_tab entries periodically.
112: */
113: /* ARGSUSED */
114: void
115: arptimer(arg)
116: void *arg;
117: {
118: struct timeout *to = (struct timeout *)arg;
119: int s;
120: struct llinfo_arp *la, *nla;
121:
122: s = splsoftnet();
123: timeout_add(to, arpt_prune * hz);
124: for (la = LIST_FIRST(&llinfo_arp); la != LIST_END(&llinfo_arp);
125: la = nla) {
126: struct rtentry *rt = la->la_rt;
127:
128: nla = LIST_NEXT(la, la_list);
129: if (rt->rt_expire && rt->rt_expire <= time_second)
130: arptfree(la); /* timer has expired; clear */
131: }
132: splx(s);
133: }
134:
135: /*
136: * Parallel to llc_rtrequest.
137: */
138: void
139: arp_rtrequest(req, rt, info)
140: int req;
141: struct rtentry *rt;
142: struct rt_addrinfo *info;
143: {
144: struct sockaddr *gate = rt->rt_gateway;
145: struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
146: static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};
147: struct in_ifaddr *ia;
148: struct ifaddr *ifa;
149:
150: if (!arpinit_done) {
151: static struct timeout arptimer_to;
152:
153: arpinit_done = 1;
154: /*
155: * We generate expiration times from time.tv_sec
156: * so avoid accidently creating permanent routes.
157: */
158: if (time_second == 0) {
159: time_second++;
160: }
161:
162: timeout_set(&arptimer_to, arptimer, &arptimer_to);
163: timeout_add(&arptimer_to, hz);
164: }
165:
166: if (rt->rt_flags & RTF_GATEWAY) {
167: if (req != RTM_ADD)
168: return;
169:
170: /*
171: * linklayers with particular link MTU limitation. it is a bit
172: * awkward to have FDDI handling here, we should split ARP from
173: * netinet/if_ether.c like NetBSD does.
174: */
175: switch (rt->rt_ifp->if_type) {
176: case IFT_FDDI:
177: if (rt->rt_ifp->if_mtu > FDDIIPMTU)
178: rt->rt_rmx.rmx_mtu = FDDIIPMTU;
179: break;
180: }
181:
182: return;
183: }
184:
185: switch (req) {
186:
187: case RTM_ADD:
188: /*
189: * XXX: If this is a manually added route to interface
190: * such as older version of routed or gated might provide,
191: * restore cloning bit.
192: */
193: if ((rt->rt_flags & RTF_HOST) == 0 &&
194: SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
195: rt->rt_flags |= RTF_CLONING;
196: if (rt->rt_flags & RTF_CLONING) {
197: /*
198: * Case 1: This route should come from a route to iface.
199: */
200: rt_setgate(rt, rt_key(rt),
201: (struct sockaddr *)&null_sdl, 0);
202: gate = rt->rt_gateway;
203: SDL(gate)->sdl_type = rt->rt_ifp->if_type;
204: SDL(gate)->sdl_index = rt->rt_ifp->if_index;
205: /*
206: * Give this route an expiration time, even though
207: * it's a "permanent" route, so that routes cloned
208: * from it do not need their expiration time set.
209: */
210: rt->rt_expire = time_second;
211: /*
212: * linklayers with particular link MTU limitation.
213: */
214: switch (rt->rt_ifp->if_type) {
215: case IFT_FDDI:
216: if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
217: (rt->rt_rmx.rmx_mtu > FDDIIPMTU ||
218: (rt->rt_rmx.rmx_mtu == 0 &&
219: rt->rt_ifp->if_mtu > FDDIIPMTU)))
220: rt->rt_rmx.rmx_mtu = FDDIIPMTU;
221: break;
222: }
223: break;
224: }
225: /* Announce a new entry if requested. */
226: if (rt->rt_flags & RTF_ANNOUNCE)
227: arprequest(rt->rt_ifp,
228: &SIN(rt_key(rt))->sin_addr.s_addr,
229: &SIN(rt_key(rt))->sin_addr.s_addr,
230: (u_char *)LLADDR(SDL(gate)));
231: /*FALLTHROUGH*/
232: case RTM_RESOLVE:
233: if (gate->sa_family != AF_LINK ||
234: gate->sa_len < sizeof(null_sdl)) {
235: log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
236: break;
237: }
238: SDL(gate)->sdl_type = rt->rt_ifp->if_type;
239: SDL(gate)->sdl_index = rt->rt_ifp->if_index;
240: if (la != 0)
241: break; /* This happens on a route change */
242: /*
243: * Case 2: This route may come from cloning, or a manual route
244: * add with a LL address.
245: */
246: R_Malloc(la, struct llinfo_arp *, sizeof(*la));
247: rt->rt_llinfo = (caddr_t)la;
248: if (la == 0) {
249: log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
250: break;
251: }
252: arp_inuse++, arp_allocated++;
253: Bzero(la, sizeof(*la));
254: la->la_rt = rt;
255: rt->rt_flags |= RTF_LLINFO;
256: LIST_INSERT_HEAD(&llinfo_arp, la, la_list);
257:
258: TAILQ_FOREACH(ia, &in_ifaddr, ia_list) {
259: if (ia->ia_ifp == rt->rt_ifp &&
260: SIN(rt_key(rt))->sin_addr.s_addr ==
261: (IA_SIN(ia))->sin_addr.s_addr)
262: break;
263: }
264: if (ia) {
265: /*
266: * This test used to be
267: * if (lo0ifp->if_flags & IFF_UP)
268: * It allowed local traffic to be forced through
269: * the hardware by configuring the loopback down.
270: * However, it causes problems during network
271: * configuration for boards that can't receive
272: * packets they send. It is now necessary to clear
273: * "useloopback" and remove the route to force
274: * traffic out to the hardware.
275: *
276: * In 4.4BSD, the above "if" statement checked
277: * rt->rt_ifa against rt_key(rt). It was changed
278: * to the current form so that we can provide a
279: * better support for multiple IPv4 addresses on a
280: * interface.
281: */
282: rt->rt_expire = 0;
283: Bcopy(((struct arpcom *)rt->rt_ifp)->ac_enaddr,
284: LLADDR(SDL(gate)),
285: SDL(gate)->sdl_alen = ETHER_ADDR_LEN);
286: if (useloopback)
287: rt->rt_ifp = lo0ifp;
288: /*
289: * make sure to set rt->rt_ifa to the interface
290: * address we are using, otherwise we will have trouble
291: * with source address selection.
292: */
293: ifa = &ia->ia_ifa;
294: if (ifa != rt->rt_ifa) {
295: IFAFREE(rt->rt_ifa);
296: ifa->ifa_refcnt++;
297: rt->rt_ifa = ifa;
298: }
299: }
300: break;
301:
302: case RTM_DELETE:
303: if (la == 0)
304: break;
305: arp_inuse--;
306: LIST_REMOVE(la, la_list);
307: rt->rt_llinfo = 0;
308: rt->rt_flags &= ~RTF_LLINFO;
309: if (la->la_hold)
310: m_freem(la->la_hold);
311: Free((caddr_t)la);
312: }
313: }
314:
315: /*
316: * Broadcast an ARP request. Caller specifies:
317: * - arp header source ip address
318: * - arp header target ip address
319: * - arp header source ethernet address
320: */
321: void
322: arprequest(ifp, sip, tip, enaddr)
323: struct ifnet *ifp;
324: u_int32_t *sip, *tip;
325: u_int8_t *enaddr;
326: {
327: struct mbuf *m;
328: struct ether_header *eh;
329: struct ether_arp *ea;
330: struct sockaddr sa;
331:
332: if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
333: return;
334: m->m_len = sizeof(*ea);
335: m->m_pkthdr.len = sizeof(*ea);
336: MH_ALIGN(m, sizeof(*ea));
337: ea = mtod(m, struct ether_arp *);
338: eh = (struct ether_header *)sa.sa_data;
339: bzero((caddr_t)ea, sizeof (*ea));
340: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
341: sizeof(eh->ether_dhost));
342: eh->ether_type = htons(ETHERTYPE_ARP); /* if_output will not swap */
343: ea->arp_hrd = htons(ARPHRD_ETHER);
344: ea->arp_pro = htons(ETHERTYPE_IP);
345: ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */
346: ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */
347: ea->arp_op = htons(ARPOP_REQUEST);
348: bcopy((caddr_t)enaddr, (caddr_t)eh->ether_shost,
349: sizeof(eh->ether_shost));
350: bcopy((caddr_t)enaddr, (caddr_t)ea->arp_sha, sizeof(ea->arp_sha));
351: bcopy((caddr_t)sip, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa));
352: bcopy((caddr_t)tip, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa));
353: sa.sa_family = pseudo_AF_HDRCMPLT;
354: sa.sa_len = sizeof(sa);
355: (*ifp->if_output)(ifp, m, &sa, (struct rtentry *)0);
356: }
357:
358: /*
359: * Resolve an IP address into an ethernet address. If success,
360: * desten is filled in. If there is no entry in arptab,
361: * set one up and broadcast a request for the IP address.
362: * Hold onto this mbuf and resend it once the address
363: * is finally resolved. A return value of 1 indicates
364: * that desten has been filled in and the packet should be sent
365: * normally; a 0 return indicates that the packet has been
366: * taken over here, either now or for later transmission.
367: */
368: int
369: arpresolve(ac, rt, m, dst, desten)
370: struct arpcom *ac;
371: struct rtentry *rt;
372: struct mbuf *m;
373: struct sockaddr *dst;
374: u_char *desten;
375: {
376: struct llinfo_arp *la;
377: struct sockaddr_dl *sdl;
378:
379: if (m->m_flags & M_BCAST) { /* broadcast */
380: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten,
381: sizeof(etherbroadcastaddr));
382: return (1);
383: }
384: if (m->m_flags & M_MCAST) { /* multicast */
385: ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
386: return (1);
387: }
388: if (rt) {
389: la = (struct llinfo_arp *)rt->rt_llinfo;
390: if (la == NULL)
391: log(LOG_DEBUG, "arpresolve: %s: route without link "
392: "local address\n", inet_ntoa(SIN(dst)->sin_addr));
393: } else {
394: if ((la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0)) != NULL)
395: rt = la->la_rt;
396: else
397: log(LOG_DEBUG,
398: "arpresolve: %s: can't allocate llinfo\n",
399: inet_ntoa(SIN(dst)->sin_addr));
400: }
401: if (la == 0 || rt == 0) {
402: m_freem(m);
403: return (0);
404: }
405: sdl = SDL(rt->rt_gateway);
406: /*
407: * Check the address family and length is valid, the address
408: * is resolved; otherwise, try to resolve.
409: */
410: if ((rt->rt_expire == 0 || rt->rt_expire > time_second) &&
411: sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
412: bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
413: return 1;
414: }
415: if (((struct ifnet *)ac)->if_flags & IFF_NOARP)
416: return 0;
417:
418: /*
419: * There is an arptab entry, but no ethernet address
420: * response yet. Replace the held mbuf with this
421: * latest one.
422: */
423: if (la->la_hold)
424: m_freem(la->la_hold);
425: la->la_hold = m;
426: /*
427: * Re-send the ARP request when appropriate.
428: */
429: #ifdef DIAGNOSTIC
430: if (rt->rt_expire == 0) {
431: /* This should never happen. (Should it? -gwr) */
432: printf("arpresolve: unresolved and rt_expire == 0\n");
433: /* Set expiration time to now (expired). */
434: rt->rt_expire = time_second;
435: }
436: #endif
437: if (rt->rt_expire) {
438: rt->rt_flags &= ~RTF_REJECT;
439: if (la->la_asked == 0 || rt->rt_expire != time_second) {
440: rt->rt_expire = time_second;
441: if (la->la_asked++ < arp_maxtries)
442: arprequest(&ac->ac_if,
443: &(SIN(rt->rt_ifa->ifa_addr)->sin_addr.s_addr),
444: &(SIN(dst)->sin_addr.s_addr),
445: #if NCARP > 0
446: (rt->rt_ifp->if_type == IFT_CARP) ?
447: ((struct arpcom *) rt->rt_ifp->if_softc
448: )->ac_enaddr :
449: #endif
450: ac->ac_enaddr);
451: else {
452: rt->rt_flags |= RTF_REJECT;
453: rt->rt_expire += arpt_down;
454: la->la_asked = 0;
455: }
456: }
457: }
458: return (0);
459: }
460:
461: /*
462: * Common length and type checks are done here,
463: * then the protocol-specific routine is called.
464: */
465: void
466: arpintr()
467: {
468: struct mbuf *m;
469: struct arphdr *ar;
470: int s, len;
471:
472: while (arpintrq.ifq_head) {
473: s = splnet();
474: IF_DEQUEUE(&arpintrq, m);
475: splx(s);
476: if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
477: panic("arpintr");
478:
479: len = sizeof(struct arphdr);
480: if (m->m_len < len && (m = m_pullup(m, len)) == NULL)
481: continue;
482:
483: ar = mtod(m, struct arphdr *);
484: if (ntohs(ar->ar_hrd) != ARPHRD_ETHER) {
485: m_freem(m);
486: continue;
487: }
488:
489: len += 2 * (ar->ar_hln + ar->ar_pln);
490: if (m->m_len < len && (m = m_pullup(m, len)) == NULL)
491: continue;
492:
493: switch (ntohs(ar->ar_pro)) {
494: case ETHERTYPE_IP:
495: case ETHERTYPE_IPTRAILERS:
496: in_arpinput(m);
497: continue;
498: }
499: m_freem(m);
500: }
501: }
502:
503: /*
504: * ARP for Internet protocols on Ethernet.
505: * Algorithm is that given in RFC 826.
506: * In addition, a sanity check is performed on the sender
507: * protocol address, to catch impersonators.
508: * We no longer handle negotiations for use of trailer protocol:
509: * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
510: * along with IP replies if we wanted trailers sent to us,
511: * and also sent them in response to IP replies.
512: * This allowed either end to announce the desire to receive
513: * trailer packets.
514: * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
515: * but formerly didn't normally send requests.
516: */
517: void
518: in_arpinput(m)
519: struct mbuf *m;
520: {
521: struct ether_arp *ea;
522: struct arpcom *ac = (struct arpcom *)m->m_pkthdr.rcvif;
523: struct ether_header *eh;
524: struct llinfo_arp *la = 0;
525: struct rtentry *rt;
526: struct in_ifaddr *ia;
527: #if NBRIDGE > 0
528: struct in_ifaddr *bridge_ia = NULL;
529: #endif
530: #if NCARP > 0
531: u_int32_t count = 0, index = 0;
532: #endif
533: struct sockaddr_dl *sdl;
534: struct sockaddr sa;
535: struct in_addr isaddr, itaddr, myaddr;
536: u_int8_t *enaddr = NULL;
537: int op;
538:
539: ea = mtod(m, struct ether_arp *);
540: op = ntohs(ea->arp_op);
541: if ((op != ARPOP_REQUEST) && (op != ARPOP_REPLY))
542: goto out;
543: #if notyet
544: if ((op == ARPOP_REPLY) && (m->m_flags & (M_BCAST|M_MCAST))) {
545: log(LOG_ERR,
546: "arp: received reply to broadcast or multicast address\n");
547: goto out;
548: }
549: #endif
550:
551: bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof(itaddr));
552: bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof(isaddr));
553:
554: TAILQ_FOREACH(ia, &in_ifaddr, ia_list) {
555: if (itaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
556: continue;
557:
558: #if NCARP > 0
559: if (ia->ia_ifp->if_type == IFT_CARP &&
560: ((ia->ia_ifp->if_flags & (IFF_UP|IFF_RUNNING)) ==
561: (IFF_UP|IFF_RUNNING))) {
562: index++;
563: if (ia->ia_ifp == m->m_pkthdr.rcvif &&
564: carp_iamatch(ia, ea->arp_sha,
565: &count, index))
566: break;
567: } else
568: #endif
569: if (ia->ia_ifp == m->m_pkthdr.rcvif)
570: break;
571: #if NBRIDGE > 0
572: /*
573: * If the interface we received the packet on
574: * is part of a bridge, check to see if we need
575: * to "bridge" the packet to ourselves at this
576: * layer. Note we still prefer a perfect match,
577: * but allow this weaker match if necessary.
578: */
579: if (m->m_pkthdr.rcvif->if_bridge != NULL) {
580: if (m->m_pkthdr.rcvif->if_bridge ==
581: ia->ia_ifp->if_bridge)
582: bridge_ia = ia;
583: #if NCARP > 0
584: else if (ia->ia_ifp->if_carpdev != NULL &&
585: m->m_pkthdr.rcvif->if_bridge ==
586: ia->ia_ifp->if_carpdev->if_bridge &&
587: carp_iamatch(ia, ea->arp_sha,
588: &count, index))
589: bridge_ia = ia;
590: #endif
591: }
592: #endif
593: }
594:
595: #if NBRIDGE > 0
596: if (ia == NULL && bridge_ia != NULL) {
597: ia = bridge_ia;
598: ac = (struct arpcom *)bridge_ia->ia_ifp;
599: }
600: #endif
601:
602: if (ia == NULL) {
603: TAILQ_FOREACH(ia, &in_ifaddr, ia_list) {
604: if (isaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
605: continue;
606: if (ia->ia_ifp == m->m_pkthdr.rcvif)
607: break;
608: }
609: }
610:
611: if (ia == NULL && m->m_pkthdr.rcvif->if_type != IFT_CARP) {
612: struct ifaddr *ifa;
613:
614: TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrlist, ifa_list) {
615: if (ifa->ifa_addr->sa_family == AF_INET)
616: break;
617: }
618: if (ifa)
619: ia = (struct in_ifaddr *)ifa;
620: }
621:
622: if (ia == NULL)
623: goto out;
624:
625: if (!enaddr)
626: enaddr = ac->ac_enaddr;
627: myaddr = ia->ia_addr.sin_addr;
628:
629: if (!bcmp((caddr_t)ea->arp_sha, enaddr, sizeof (ea->arp_sha)))
630: goto out; /* it's from me, ignore it. */
631: if (ETHER_IS_MULTICAST (&ea->arp_sha[0]))
632: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr,
633: sizeof (ea->arp_sha))) {
634: log(LOG_ERR, "arp: ether address is broadcast for "
635: "IP address %s!\n", inet_ntoa(isaddr));
636: goto out;
637: }
638: if (myaddr.s_addr && isaddr.s_addr == myaddr.s_addr) {
639: log(LOG_ERR,
640: "duplicate IP address %s sent from ethernet address %s\n",
641: inet_ntoa(isaddr), ether_sprintf(ea->arp_sha));
642: itaddr = myaddr;
643: goto reply;
644: }
645: la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0);
646: if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
647: if (sdl->sdl_alen) {
648: if (bcmp(ea->arp_sha, LLADDR(sdl), sdl->sdl_alen)) {
649: if (rt->rt_flags & RTF_PERMANENT_ARP) {
650: log(LOG_WARNING,
651: "arp: attempt to overwrite permanent "
652: "entry for %s by %s on %s\n",
653: inet_ntoa(isaddr),
654: ether_sprintf(ea->arp_sha),
655: ac->ac_if.if_xname);
656: goto out;
657: } else if (rt->rt_ifp != &ac->ac_if) {
658: log(LOG_WARNING,
659: "arp: attempt to overwrite entry for %s "
660: "on %s by %s on %s\n",
661: inet_ntoa(isaddr), rt->rt_ifp->if_xname,
662: ether_sprintf(ea->arp_sha),
663: ac->ac_if.if_xname);
664: goto out;
665: } else {
666: log(LOG_INFO,
667: "arp info overwritten for %s by %s on %s\n",
668: inet_ntoa(isaddr),
669: ether_sprintf(ea->arp_sha),
670: ac->ac_if.if_xname);
671: rt->rt_expire = 1; /* no longer static */
672: }
673: }
674: } else if (rt->rt_ifp != &ac->ac_if && !(ac->ac_if.if_bridge &&
675: (rt->rt_ifp->if_bridge == ac->ac_if.if_bridge)) &&
676: !(rt->rt_ifp->if_type == IFT_CARP &&
677: rt->rt_ifp->if_carpdev == &ac->ac_if) &&
678: !(ac->ac_if.if_type == IFT_CARP &&
679: ac->ac_if.if_carpdev == rt->rt_ifp)) {
680: log(LOG_WARNING,
681: "arp: attempt to add entry for %s "
682: "on %s by %s on %s\n",
683: inet_ntoa(isaddr), rt->rt_ifp->if_xname,
684: ether_sprintf(ea->arp_sha),
685: ac->ac_if.if_xname);
686: goto out;
687: }
688: bcopy(ea->arp_sha, LLADDR(sdl),
689: sdl->sdl_alen = sizeof(ea->arp_sha));
690: if (rt->rt_expire)
691: rt->rt_expire = time_second + arpt_keep;
692: rt->rt_flags &= ~RTF_REJECT;
693: la->la_asked = 0;
694: if (la->la_hold) {
695: (*ac->ac_if.if_output)(&ac->ac_if, la->la_hold,
696: rt_key(rt), rt);
697: la->la_hold = 0;
698: }
699: }
700: reply:
701: if (op != ARPOP_REQUEST) {
702: out:
703: m_freem(m);
704: return;
705: }
706: if (itaddr.s_addr == myaddr.s_addr) {
707: /* I am the target */
708: bcopy(ea->arp_sha, ea->arp_tha, sizeof(ea->arp_sha));
709: bcopy(enaddr, ea->arp_sha, sizeof(ea->arp_sha));
710: } else {
711: la = arplookup(itaddr.s_addr, 0, SIN_PROXY);
712: if (la == 0)
713: goto out;
714: rt = la->la_rt;
715: if (rt->rt_ifp->if_type == IFT_CARP &&
716: m->m_pkthdr.rcvif->if_type != IFT_CARP)
717: goto out;
718: bcopy(ea->arp_sha, ea->arp_tha, sizeof(ea->arp_sha));
719: sdl = SDL(rt->rt_gateway);
720: bcopy(LLADDR(sdl), ea->arp_sha, sizeof(ea->arp_sha));
721: }
722:
723: bcopy(ea->arp_spa, ea->arp_tpa, sizeof(ea->arp_spa));
724: bcopy(&itaddr, ea->arp_spa, sizeof(ea->arp_spa));
725: ea->arp_op = htons(ARPOP_REPLY);
726: ea->arp_pro = htons(ETHERTYPE_IP); /* let's be sure! */
727: eh = (struct ether_header *)sa.sa_data;
728: bcopy(ea->arp_tha, eh->ether_dhost, sizeof(eh->ether_dhost));
729: #if NCARP > 0
730: if (ac->ac_if.if_type == IFT_CARP && ac->ac_if.if_flags & IFF_LINK1)
731: bcopy(((struct arpcom *)ac->ac_if.if_carpdev)->ac_enaddr,
732: eh->ether_shost, sizeof(eh->ether_shost));
733: else
734: #endif
735: bcopy(enaddr, eh->ether_shost, sizeof(eh->ether_shost));
736:
737: eh->ether_type = htons(ETHERTYPE_ARP);
738: sa.sa_family = pseudo_AF_HDRCMPLT;
739: sa.sa_len = sizeof(sa);
740: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
741: return;
742: }
743:
744: /*
745: * Free an arp entry.
746: */
747: void
748: arptfree(la)
749: struct llinfo_arp *la;
750: {
751: struct rtentry *rt = la->la_rt;
752: struct sockaddr_dl *sdl;
753:
754: if (rt == 0)
755: panic("arptfree");
756: if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) &&
757: sdl->sdl_family == AF_LINK) {
758: sdl->sdl_alen = 0;
759: la->la_asked = 0;
760: rt->rt_flags &= ~RTF_REJECT;
761: return;
762: }
763: rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt),
764: 0, (struct rtentry **)0, 0);
765: }
766:
767: /*
768: * Lookup or enter a new address in arptab.
769: */
770: struct llinfo_arp *
771: arplookup(addr, create, proxy)
772: u_int32_t addr;
773: int create, proxy;
774: {
775: struct rtentry *rt;
776: static struct sockaddr_inarp sin;
777:
778: sin.sin_len = sizeof(sin);
779: sin.sin_family = AF_INET;
780: sin.sin_addr.s_addr = addr;
781: sin.sin_other = proxy ? SIN_PROXY : 0;
782: rt = rtalloc1(sintosa(&sin), create, 0);
783: if (rt == 0)
784: return (0);
785: rt->rt_refcnt--;
786: if ((rt->rt_flags & RTF_GATEWAY) || (rt->rt_flags & RTF_LLINFO) == 0 ||
787: rt->rt_gateway->sa_family != AF_LINK) {
788: if (create) {
789: if (rt->rt_refcnt <= 0 &&
790: (rt->rt_flags & RTF_CLONED) != 0) {
791: rtrequest(RTM_DELETE,
792: (struct sockaddr *)rt_key(rt),
793: rt->rt_gateway, rt_mask(rt), rt->rt_flags,
794: 0, 0);
795: }
796: }
797: return (0);
798: }
799: return ((struct llinfo_arp *)rt->rt_llinfo);
800: }
801:
802: int
803: arpioctl(cmd, data)
804: u_long cmd;
805: caddr_t data;
806: {
807:
808: return (EOPNOTSUPP);
809: }
810:
811: void
812: arp_ifinit(ac, ifa)
813: struct arpcom *ac;
814: struct ifaddr *ifa;
815: {
816:
817: /* Warn the user if another station has this IP address. */
818: arprequest(&ac->ac_if,
819: &(IA_SIN(ifa)->sin_addr.s_addr),
820: &(IA_SIN(ifa)->sin_addr.s_addr),
821: ac->ac_enaddr);
822: ifa->ifa_rtrequest = arp_rtrequest;
823: ifa->ifa_flags |= RTF_CLONING;
824: }
825:
826: /*
827: * Called from Ethernet interrupt handlers
828: * when ether packet type ETHERTYPE_REVARP
829: * is received. Common length and type checks are done here,
830: * then the protocol-specific routine is called.
831: */
832: void
833: revarpinput(m)
834: struct mbuf *m;
835: {
836: struct arphdr *ar;
837:
838: if (m->m_len < sizeof(struct arphdr))
839: goto out;
840: ar = mtod(m, struct arphdr *);
841: if (ntohs(ar->ar_hrd) != ARPHRD_ETHER)
842: goto out;
843: if (m->m_len < sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln))
844: goto out;
845: switch (ntohs(ar->ar_pro)) {
846:
847: case ETHERTYPE_IP:
848: case ETHERTYPE_IPTRAILERS:
849: in_revarpinput(m);
850: return;
851:
852: default:
853: break;
854: }
855: out:
856: m_freem(m);
857: }
858:
859: /*
860: * RARP for Internet protocols on Ethernet.
861: * Algorithm is that given in RFC 903.
862: * We are only using for bootstrap purposes to get an ip address for one of
863: * our interfaces. Thus we support no user-interface.
864: *
865: * Since the contents of the RARP reply are specific to the interface that
866: * sent the request, this code must ensure that they are properly associated.
867: *
868: * Note: also supports ARP via RARP packets, per the RFC.
869: */
870: void
871: in_revarpinput(m)
872: struct mbuf *m;
873: {
874: struct ifnet *ifp;
875: struct ether_arp *ar;
876: int op;
877:
878: ar = mtod(m, struct ether_arp *);
879: op = ntohs(ar->arp_op);
880: switch (op) {
881: case ARPOP_REQUEST:
882: case ARPOP_REPLY: /* per RFC */
883: in_arpinput(m);
884: return;
885: case ARPOP_REVREPLY:
886: break;
887: case ARPOP_REVREQUEST: /* handled by rarpd(8) */
888: default:
889: goto out;
890: }
891: if (!revarp_in_progress)
892: goto out;
893: ifp = m->m_pkthdr.rcvif;
894: if (ifp != myip_ifp) /* !same interface */
895: goto out;
896: if (myip_initialized)
897: goto wake;
898: if (bcmp(ar->arp_tha, ((struct arpcom *)ifp)->ac_enaddr,
899: sizeof(ar->arp_tha)))
900: goto out;
901: bcopy((caddr_t)ar->arp_spa, (caddr_t)&srv_ip, sizeof(srv_ip));
902: bcopy((caddr_t)ar->arp_tpa, (caddr_t)&myip, sizeof(myip));
903: myip_initialized = 1;
904: wake: /* Do wakeup every time in case it was missed. */
905: wakeup((caddr_t)&myip);
906:
907: out:
908: m_freem(m);
909: }
910:
911: /*
912: * Send a RARP request for the ip address of the specified interface.
913: * The request should be RFC 903-compliant.
914: */
915: void
916: revarprequest(ifp)
917: struct ifnet *ifp;
918: {
919: struct sockaddr sa;
920: struct mbuf *m;
921: struct ether_header *eh;
922: struct ether_arp *ea;
923: struct arpcom *ac = (struct arpcom *)ifp;
924:
925: if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
926: return;
927: m->m_len = sizeof(*ea);
928: m->m_pkthdr.len = sizeof(*ea);
929: MH_ALIGN(m, sizeof(*ea));
930: ea = mtod(m, struct ether_arp *);
931: eh = (struct ether_header *)sa.sa_data;
932: bzero((caddr_t)ea, sizeof(*ea));
933: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
934: sizeof(eh->ether_dhost));
935: eh->ether_type = htons(ETHERTYPE_REVARP);
936: ea->arp_hrd = htons(ARPHRD_ETHER);
937: ea->arp_pro = htons(ETHERTYPE_IP);
938: ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */
939: ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */
940: ea->arp_op = htons(ARPOP_REVREQUEST);
941: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
942: sizeof(ea->arp_tha));
943: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
944: sizeof(ea->arp_sha));
945: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_tha,
946: sizeof(ea->arp_tha));
947: sa.sa_family = pseudo_AF_HDRCMPLT;
948: sa.sa_len = sizeof(sa);
949: ifp->if_output(ifp, m, &sa, (struct rtentry *)0);
950: }
951:
952: /*
953: * RARP for the ip address of the specified interface, but also
954: * save the ip address of the server that sent the answer.
955: * Timeout if no response is received.
956: */
957: int
958: revarpwhoarewe(ifp, serv_in, clnt_in)
959: struct ifnet *ifp;
960: struct in_addr *serv_in;
961: struct in_addr *clnt_in;
962: {
963: int result, count = 20;
964:
965: if (myip_initialized)
966: return EIO;
967:
968: myip_ifp = ifp;
969: revarp_in_progress = 1;
970: while (count--) {
971: revarprequest(ifp);
972: result = tsleep((caddr_t)&myip, PSOCK, "revarp", hz/2);
973: if (result != EWOULDBLOCK)
974: break;
975: }
976: revarp_in_progress = 0;
977: if (!myip_initialized)
978: return ENETUNREACH;
979:
980: bcopy((caddr_t)&srv_ip, serv_in, sizeof(*serv_in));
981: bcopy((caddr_t)&myip, clnt_in, sizeof(*clnt_in));
982: return 0;
983: }
984:
985: /* For compatibility: only saves interface address. */
986: int
987: revarpwhoami(in, ifp)
988: struct in_addr *in;
989: struct ifnet *ifp;
990: {
991: struct in_addr server;
992: return (revarpwhoarewe(ifp, &server, in));
993: }
994:
995:
996: #ifdef DDB
997:
998: #include <machine/db_machdep.h>
999: #include <ddb/db_interface.h>
1000: #include <ddb/db_output.h>
1001:
1002: void
1003: db_print_sa(sa)
1004: struct sockaddr *sa;
1005: {
1006: int len;
1007: u_char *p;
1008:
1009: if (sa == 0) {
1010: db_printf("[NULL]");
1011: return;
1012: }
1013:
1014: p = (u_char *)sa;
1015: len = sa->sa_len;
1016: db_printf("[");
1017: while (len > 0) {
1018: db_printf("%d", *p);
1019: p++;
1020: len--;
1021: if (len)
1022: db_printf(",");
1023: }
1024: db_printf("]\n");
1025: }
1026:
1027: void
1028: db_print_ifa(ifa)
1029: struct ifaddr *ifa;
1030: {
1031: if (ifa == 0)
1032: return;
1033: db_printf(" ifa_addr=");
1034: db_print_sa(ifa->ifa_addr);
1035: db_printf(" ifa_dsta=");
1036: db_print_sa(ifa->ifa_dstaddr);
1037: db_printf(" ifa_mask=");
1038: db_print_sa(ifa->ifa_netmask);
1039: db_printf(" flags=0x%x, refcnt=%d, metric=%d\n",
1040: ifa->ifa_flags, ifa->ifa_refcnt, ifa->ifa_metric);
1041: }
1042:
1043: void
1044: db_print_llinfo(li)
1045: caddr_t li;
1046: {
1047: struct llinfo_arp *la;
1048:
1049: if (li == 0)
1050: return;
1051: la = (struct llinfo_arp *)li;
1052: db_printf(" la_rt=%p la_hold=%p, la_asked=0x%lx\n",
1053: la->la_rt, la->la_hold, la->la_asked);
1054: }
1055:
1056: /*
1057: * Function to pass to rn_walktree().
1058: * Return non-zero error to abort walk.
1059: */
1060: int
1061: db_show_radix_node(rn, w)
1062: struct radix_node *rn;
1063: void *w;
1064: {
1065: struct rtentry *rt = (struct rtentry *)rn;
1066:
1067: db_printf("rtentry=%p", rt);
1068:
1069: db_printf(" flags=0x%x refcnt=%d use=%ld expire=%ld\n",
1070: rt->rt_flags, rt->rt_refcnt, rt->rt_use, rt->rt_expire);
1071:
1072: db_printf(" key="); db_print_sa(rt_key(rt));
1073: db_printf(" mask="); db_print_sa(rt_mask(rt));
1074: db_printf(" gw="); db_print_sa(rt->rt_gateway);
1075:
1076: db_printf(" ifp=%p ", rt->rt_ifp);
1077: if (rt->rt_ifp)
1078: db_printf("(%s)", rt->rt_ifp->if_xname);
1079: else
1080: db_printf("(NULL)");
1081:
1082: db_printf(" ifa=%p\n", rt->rt_ifa);
1083: db_print_ifa(rt->rt_ifa);
1084:
1085: db_printf(" genmask="); db_print_sa(rt->rt_genmask);
1086:
1087: db_printf(" gwroute=%p llinfo=%p\n", rt->rt_gwroute, rt->rt_llinfo);
1088: db_print_llinfo(rt->rt_llinfo);
1089: return (0);
1090: }
1091:
1092: /*
1093: * Function to print all the route trees.
1094: * Use this from ddb: "call db_show_arptab"
1095: */
1096: int
1097: db_show_arptab()
1098: {
1099: struct radix_node_head *rnh;
1100: rnh = rt_gettable(AF_INET, 0);
1101: db_printf("Route tree for AF_INET\n");
1102: if (rnh == NULL) {
1103: db_printf(" (not initialized)\n");
1104: return (0);
1105: }
1106: rn_walktree(rnh, db_show_radix_node, NULL);
1107: return (0);
1108: }
1109: #endif
1110: #endif /* INET */