![[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 [Apple Darwin 0.x] / kernel / bsd / netinet|
Return to if_ether.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1988, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)if_ether.c 8.2 (Berkeley) 9/26/94
59: */
60:
61: /*
62: * Ethernet address resolution protocol.
63: * TODO:
64: * add "inuse/lock" bit (or ref. count) along with valid bit
65: */
66:
67:
68: #include <sys/param.h>
69: #include <sys/systm.h>
70: #include <sys/malloc.h>
71: #include <sys/mbuf.h>
72: #include <sys/socket.h>
73: #include <sys/time.h>
74: #include <sys/kernel.h>
75: #include <sys/errno.h>
76: #include <sys/ioctl.h>
77: #include <sys/syslog.h>
78:
79: #include <net/if.h>
80: #include <net/if_dl.h>
81: #include <net/route.h>
82:
83: #include <netinet/in.h>
84: #include <netinet/in_systm.h>
85: #include <netinet/in_var.h>
86: #include <netinet/ip.h>
87: #include <netinet/if_ether.h>
88:
89: #if INET
90:
91: struct ifqueue arpintrq;
92:
93: struct llinfo_arp llinfo_arp; /* head of the llinfo queue */
94:
95: #define SIN(s) ((struct sockaddr_in *)s)
96: #define SDL(s) ((struct sockaddr_dl *)s)
97: #define SRP(s) ((struct sockaddr_inarp *)s)
98:
99: /*
100: * ARP trailer negotiation. Trailer protocol is not IP specific,
101: * but ARP request/response use IP addresses.
102: */
103: #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
104:
105: /* timer values */
106: int arpt_prune = (5*60*1); /* walk list every 5 minutes */
107: int arpt_keep = (20*60); /* once resolved, good for 20 more minutes */
108: int arpt_down = 20; /* once declared down, don't send for 20 secs */
109: #define rt_expire rt_rmx.rmx_expire
110:
111: static void arprequest __P((struct arpcom *, u_long *, u_long *, u_char *));
112: static void arptfree __P((struct llinfo_arp *));
113: static void arptimer __P((void *));
114: static struct llinfo_arp *arplookup __P((u_long, int, int));
115: static void in_arpinput __P((struct mbuf *));
116:
117: extern struct ifnet loif;
118: struct llinfo_arp llinfo_arp = {&llinfo_arp, &llinfo_arp};
119: struct ifqueue arpintrq = {0, 0, 0, 50};
120: int arp_inuse, arp_allocated, arp_intimer;
121: int arp_maxtries = 5;
122: int useloopback = 1; /* use loopback interface for local traffic */
123: int arpinit_done = 0;
124:
125: /* revarp state */
126: static struct in_addr myip, srv_ip;
127: static int myip_initialized = 0;
128: static int revarp_in_progress = 0;
129: static struct ifnet *myip_ifp = NULL;
130:
131: /* Should be in spl.h */
132: int splimp(void);
133: int splnet(void);
134: int splx(int);
135:
136: /*
137: * Timeout routine. Age arp_tab entries periodically.
138: */
139: /* ARGSUSED */
140: static void
141: arptimer(arg)
142: void *arg;
143: {
144: int s;
145: register struct llinfo_arp *la = llinfo_arp.la_next;
146:
147: s = splnet();
148: while (la != &llinfo_arp) {
149: register struct rtentry *rt = la->la_rt;
150: la = la->la_next;
151: if (rt->rt_expire && rt->rt_expire <= time.tv_sec)
152: arptfree(la->la_prev); /* timer has expired; clear */
153: }
154: timeout(arptimer, NULL, arpt_prune * hz);
155: splx(s);
156:
157: }
158:
159: /*
160: * Parallel to llc_rtrequest.
161: */
162: void
163: arp_rtrequest(req, rt, sa)
164: int req;
165: register struct rtentry *rt;
166: struct sockaddr *sa;
167: {
168: register struct sockaddr *gate = rt->rt_gateway;
169: register struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
170: static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};
171:
172: if (!arpinit_done) {
173: arpinit_done = 1;
174: timeout(arptimer, (caddr_t)0, hz);
175: }
176: if (rt->rt_flags & RTF_GATEWAY)
177: return;
178: switch (req) {
179:
180: case RTM_ADD:
181: /*
182: * XXX: If this is a manually added route to interface
183: * such as older version of routed or gated might provide,
184: * restore cloning bit.
185: */
186: if ((rt->rt_flags & RTF_HOST) == 0 &&
187: SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
188: rt->rt_flags |= RTF_CLONING;
189: if (rt->rt_flags & RTF_CLONING) {
190: /*
191: * Case 1: This route should come from a route to iface.
192: */
193: rt_setgate(rt, rt_key(rt),
194: (struct sockaddr *)&null_sdl);
195: gate = rt->rt_gateway;
196: SDL(gate)->sdl_type = rt->rt_ifp->if_type;
197: SDL(gate)->sdl_index = rt->rt_ifp->if_index;
198: /*
199: * Give this route an expiration time, even though
200: * it's a "permanent" route, so that routes cloned
201: * from it do not need their expiration time set.
202: */
203: rt->rt_expire = time.tv_sec;
204: break;
205: }
206: /* Announce a new entry if requested. */
207: if (rt->rt_flags & RTF_ANNOUNCE)
208: arprequest((struct arpcom *)rt->rt_ifp,
209: &SIN(rt_key(rt))->sin_addr.s_addr,
210: &SIN(rt_key(rt))->sin_addr.s_addr,
211: (u_char *)LLADDR(SDL(gate)));
212: /*FALLTHROUGH*/
213: case RTM_RESOLVE:
214: if (gate->sa_family != AF_LINK ||
215: gate->sa_len < sizeof(null_sdl)) {
216: log(LOG_DEBUG, "arp_rtrequest: bad gateway value");
217: break;
218: }
219: SDL(gate)->sdl_type = rt->rt_ifp->if_type;
220: SDL(gate)->sdl_index = rt->rt_ifp->if_index;
221: if (la != 0)
222: break; /* This happens on a route change */
223: /*
224: * Case 2: This route may come from cloning, or a manual route
225: * add with a LL address.
226: */
227: R_Malloc(la, struct llinfo_arp *, sizeof(*la));
228: rt->rt_llinfo = (caddr_t)la;
229: if (la == 0) {
230: log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
231: break;
232: }
233: arp_inuse++, arp_allocated++;
234: Bzero(la, sizeof(*la));
235: la->la_rt = rt;
236: rt->rt_flags |= RTF_LLINFO;
237: insque((queue_t)la, (queue_t)&llinfo_arp);
238: if (SIN(rt_key(rt))->sin_addr.s_addr ==
239: (IA_SIN(rt->rt_ifa))->sin_addr.s_addr) {
240: /*
241: * This test used to be
242: * if (loif.if_flags & IFF_UP)
243: * It allowed local traffic to be forced
244: * through the hardware by configuring the loopback down.
245: * However, it causes problems during network configuration
246: * for boards that can't receive packets they send.
247: * It is now necessary to clear "useloopback" and remove
248: * the route to force traffic out to the hardware.
249: */
250: rt->rt_expire = 0;
251: Bcopy(((struct arpcom *)rt->rt_ifp)->ac_enaddr,
252: LLADDR(SDL(gate)), SDL(gate)->sdl_alen = 6);
253: if (useloopback)
254: rt->rt_ifp = &loif;
255:
256: }
257: break;
258:
259: case RTM_DELETE:
260: if (la == 0)
261: break;
262: arp_inuse--;
263: remque((queue_t)la);
264: rt->rt_llinfo = 0;
265: rt->rt_flags &= ~RTF_LLINFO;
266: if (la->la_hold)
267: m_freem(la->la_hold);
268: Free((caddr_t)la);
269: }
270: }
271:
272: /*
273: * Broadcast an ARP packet, asking who has addr on interface ac.
274: */
275: void
276: arpwhohas(ac, addr)
277: register struct arpcom *ac;
278: register struct in_addr *addr;
279: { struct ifnet *ifp = (struct ifnet *)ac;
280: struct ifaddr *ifa = ifp->if_addrlist;
281:
282: while (ifa)
283: { if (ifa->ifa_addr->sa_family == AF_INET)
284: { arprequest(ac, &SIN(ifa->ifa_addr)->sin_addr.s_addr, &addr->s_addr, ac->ac_enaddr);
285: return;
286: }
287: ifa = ifa->ifa_next;
288: }
289: return; /* XXX */
290: }
291:
292: /*
293: * Broadcast an ARP request. Caller specifies:
294: * - arp header source ip address
295: * - arp header target ip address
296: * - arp header source ethernet address
297: */
298: static void
299: arprequest(ac, sip, tip, enaddr)
300: register struct arpcom *ac;
301: register u_long *sip, *tip;
302: register u_char *enaddr;
303: {
304: register struct mbuf *m;
305: register struct ether_header *eh;
306: register struct ether_arp *ea;
307: struct sockaddr sa;
308:
309: if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
310: return;
311: m->m_len = sizeof(*ea);
312: m->m_pkthdr.len = sizeof(*ea);
313: MH_ALIGN(m, sizeof(*ea));
314: ea = mtod(m, struct ether_arp *);
315: eh = (struct ether_header *)sa.sa_data;
316: bzero((caddr_t)ea, sizeof (*ea));
317: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
318: sizeof(eh->ether_dhost));
319: eh->ether_type = htons(ETHERTYPE_ARP);
320: ea->arp_hrd = htons(ARPHRD_ETHER);
321: ea->arp_pro = htons(ETHERTYPE_IP);
322: ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */
323: ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */
324: ea->arp_op = htons(ARPOP_REQUEST);
325: bcopy((caddr_t)enaddr, (caddr_t)ea->arp_sha, sizeof(ea->arp_sha));
326: bcopy((caddr_t)sip, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa));
327: bcopy((caddr_t)tip, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa));
328: sa.sa_family = AF_UNSPEC;
329: sa.sa_len = sizeof(sa);
330: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
331: }
332:
333: /*
334: * Resolve an IP address into an ethernet address. If success,
335: * desten is filled in. If there is no entry in arptab,
336: * set one up and broadcast a request for the IP address.
337: * Hold onto this mbuf and resend it once the address
338: * is finally resolved. A return value of 1 indicates
339: * that desten has been filled in and the packet should be sent
340: * normally; a 0 return indicates that the packet has been
341: * taken over here, either now or for later transmission.
342: */
343: int
344: arpresolve(ac, rt, m, dst, desten)
345: register struct arpcom *ac;
346: register struct rtentry *rt;
347: struct mbuf *m;
348: register struct sockaddr *dst;
349: register u_char *desten;
350: {
351: register struct llinfo_arp *la;
352: struct sockaddr_dl *sdl;
353:
354: if (m->m_flags & M_BCAST) { /* broadcast */
355: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten,
356: sizeof(etherbroadcastaddr));
357: return (1);
358: }
359: if (m->m_flags & M_MCAST) { /* multicast */
360: ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
361: return(1);
362: }
363: if (rt)
364: la = (struct llinfo_arp *)rt->rt_llinfo;
365: else {
366: if ((la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0)))
367: rt = la->la_rt;
368: }
369: if (la == 0 || rt == 0) {
370: log(LOG_DEBUG, "arpresolve: can't allocate llinfo");
371: m_freem(m);
372: return (0);
373: }
374: sdl = SDL(rt->rt_gateway);
375: /*
376: * Check the address family and length is valid, the address
377: * is resolved; otherwise, try to resolve.
378: */
379: if ((rt->rt_expire == 0 || rt->rt_expire > time.tv_sec) &&
380: sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
381: bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
382:
383: return 1;
384: }
385: /*
386: * There is an arptab entry, but no ethernet address
387: * response yet. Replace the held mbuf with this
388: * latest one.
389: */
390: if (la->la_hold)
391: m_freem(la->la_hold);
392: la->la_hold = m;
393: /*
394: * Re-send the ARP request when appropriate.
395: */
396: #if DIAGNOSTIC
397: if (rt->rt_expire == 0) {
398: /* This should never happen. (Should it? -gwr) */
399: printf("arpresolve: unresolved and rt_expire == 0\n");
400: /* Set expiration time to now (expired). */
401: rt->rt_expire = time.tv_sec;
402: }
403: #endif
404: if (rt->rt_expire) {
405: rt->rt_flags &= ~RTF_REJECT;
406: if (la->la_asked == 0 || rt->rt_expire != time.tv_sec) {
407: rt->rt_expire = time.tv_sec;
408: if (la->la_asked++ < arp_maxtries)
409: arpwhohas(ac, &(SIN(dst)->sin_addr));
410: else {
411: rt->rt_flags |= RTF_REJECT;
412: rt->rt_expire += arpt_down;
413: la->la_asked = 0;
414: }
415: }
416: }
417: return (0);
418: }
419:
420: /*
421: * Common length and type checks are done here,
422: * then the protocol-specific routine is called.
423: */
424: void
425: arpintr()
426: {
427: register struct mbuf *m;
428: register struct arphdr *ar;
429: int s;
430:
431: while (arpintrq.ifq_head) {
432: s = splimp();
433: IF_DEQUEUE(&arpintrq, m);
434: splx(s);
435: if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
436: panic("arpintr");
437: if (m->m_len >= sizeof(struct arphdr) &&
438: (ar = mtod(m, struct arphdr *)) &&
439: ntohs(ar->ar_hrd) == ARPHRD_ETHER &&
440: m->m_len >=
441: sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln))
442: switch (ntohs(ar->ar_pro)) {
443:
444: case ETHERTYPE_IP:
445: case ETHERTYPE_IPTRAILERS:
446: in_arpinput(m);
447: continue;
448: }
449:
450: m_freem(m);
451: }
452: }
453:
454: /*
455: * ARP for Internet protocols on 10 Mb/s Ethernet.
456: * Algorithm is that given in RFC 826.
457: * In addition, a sanity check is performed on the sender
458: * protocol address, to catch impersonators.
459: * We no longer handle negotiations for use of trailer protocol:
460: * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
461: * along with IP replies if we wanted trailers sent to us,
462: * and also sent them in response to IP replies.
463: * This allowed either end to announce the desire to receive
464: * trailer packets.
465: * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
466: * but formerly didn't normally send requests.
467: */
468: static void
469: in_arpinput(m)
470: struct mbuf *m;
471: {
472: register struct ether_arp *ea;
473: register struct arpcom *ac = (struct arpcom *)m->m_pkthdr.rcvif;
474: struct ether_header *eh;
475: register struct llinfo_arp *la = 0;
476: register struct rtentry *rt;
477: struct in_ifaddr *ia, *maybe_ia = 0;
478: struct sockaddr_dl *sdl;
479: struct sockaddr sa;
480: struct in_addr isaddr, itaddr, myaddr;
481: int op;
482: extern void kprintf( const char *, ...);
483:
484: ea = mtod(m, struct ether_arp *);
485: op = ntohs(ea->arp_op);
486: bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr));
487: bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr));
488: for (ia = in_ifaddr; ia; ia = ia->ia_next)
489: if (ia->ia_ifp == &ac->ac_if) {
490: maybe_ia = ia;
491: if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) ||
492: (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr))
493: break;
494: }
495: if (maybe_ia == 0)
496: goto out;
497: myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr;
498: #if 0
499: /*
500: * In order to support BlueBox networking, we need to allow
501: * "self-addressed" stamped envelopes
502: */
503: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr,
504: sizeof (ea->arp_sha)))
505: goto out; /* it's from me, ignore it. */
506: #endif
507: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr,
508: sizeof (ea->arp_sha))) {
509: log(LOG_ERR,
510: "arp: ether address is broadcast for IP address %x!\n",
511: ntohl(isaddr.s_addr));
512: goto out;
513: }
514: if (isaddr.s_addr == myaddr.s_addr) {
515: log(LOG_ERR,
516: "duplicate IP address %08x sent from ethernet address %s\n",
517: ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha));
518: itaddr = myaddr;
519: goto reply;
520: }
521: la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0);
522: if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
523: if (sdl->sdl_alen &&
524: bcmp((caddr_t)ea->arp_sha, LLADDR(sdl), sdl->sdl_alen))
525: log(LOG_INFO, "arp info overwritten for %08x by %s\n",
526: ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha));
527: bcopy((caddr_t)ea->arp_sha, LLADDR(sdl),
528: sdl->sdl_alen = sizeof(ea->arp_sha));
529: if (rt->rt_expire)
530: rt->rt_expire = time.tv_sec + arpt_keep;
531: rt->rt_flags &= ~RTF_REJECT;
532: la->la_asked = 0;
533: if (la->la_hold) {
534: (*ac->ac_if.if_output)(&ac->ac_if, la->la_hold,
535: rt_key(rt), rt);
536: la->la_hold = 0;
537: }
538: }
539: reply:
540: if (op != ARPOP_REQUEST) {
541: out:
542: m_freem(m);
543: return;
544: }
545: if (itaddr.s_addr == myaddr.s_addr) {
546: /* I am the target */
547: bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
548: sizeof(ea->arp_sha));
549: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
550: sizeof(ea->arp_sha));
551: } else {
552: la = arplookup(itaddr.s_addr, 0, SIN_PROXY);
553: if (la == NULL)
554: goto out;
555: rt = la->la_rt;
556: bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
557: sizeof(ea->arp_sha));
558: sdl = SDL(rt->rt_gateway);
559: bcopy(LLADDR(sdl), (caddr_t)ea->arp_sha, sizeof(ea->arp_sha));
560: }
561:
562: bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, sizeof(ea->arp_spa));
563: bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa));
564: ea->arp_op = htons(ARPOP_REPLY);
565: ea->arp_pro = htons(ETHERTYPE_IP); /* let's be sure! */
566: eh = (struct ether_header *)sa.sa_data;
567: bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost,
568: sizeof(eh->ether_dhost));
569: eh->ether_type = htons(ETHERTYPE_ARP);
570: sa.sa_family = AF_UNSPEC;
571: sa.sa_len = sizeof(sa);
572: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
573: return;
574: }
575:
576: /*
577: * Free an arp entry.
578: */
579: static void
580: arptfree(la)
581: register struct llinfo_arp *la;
582: {
583: register struct rtentry *rt = la->la_rt;
584: register struct sockaddr_dl *sdl;
585:
586: if (rt == 0)
587: panic("arptfree");
588: if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) &&
589: sdl->sdl_family == AF_LINK) {
590: sdl->sdl_alen = 0;
591: la->la_asked = 0;
592: rt->rt_flags &= ~RTF_REJECT;
593: return;
594: }
595: rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt),
596: 0, (struct rtentry **)0);
597: }
598:
599: /*
600: * Lookup or enter a new address in arptab.
601: */
602: static struct llinfo_arp *
603: arplookup(addr, create, proxy)
604: u_long addr;
605: int create, proxy;
606: {
607: register struct rtentry *rt;
608: static struct sockaddr_inarp sin = {sizeof(sin), AF_INET };
609:
610: sin.sin_addr.s_addr = addr;
611: sin.sin_other = proxy ? SIN_PROXY : 0;
612: rt = rtalloc1((struct sockaddr *)&sin, create);
613: if (rt == 0)
614: return (0);
615: rt->rt_refcnt--;
616: if ((rt->rt_flags & RTF_GATEWAY) || (rt->rt_flags & RTF_LLINFO) == 0 ||
617: rt->rt_gateway->sa_family != AF_LINK) {
618: if (create)
619: log(LOG_DEBUG, "arplookup: unable to enter address for %x\n", ntohl(addr));
620: return (0);
621: }
622: return ((struct llinfo_arp *)rt->rt_llinfo);
623: }
624:
625: int
626: arpioctl(cmd, data)
627: u_long cmd;
628: caddr_t data;
629: {
630:
631: return (EOPNOTSUPP);
632: }
633:
634: void
635: arp_ifinit(ac, ifa)
636: struct arpcom *ac;
637: struct ifaddr *ifa;
638: {
639: ac->ac_ipaddr = IA_SIN(ifa)->sin_addr;
640: /* Warn the user if another station has this IP address. */
641: arpwhohas(ac, &ac->ac_ipaddr);
642: ifa->ifa_rtrequest = arp_rtrequest;
643: ifa->ifa_flags |= RTF_CLONING;
644: }
645:
646: /*
647: * Called from 10 Mb/s Ethernet interrupt handlers
648: * when ether packet type ETHERTYPE_REVARP
649: * is received. Common length and type checks are done here,
650: * then the protocol-specific routine is called.
651: */
652: void
653: revarpinput(m)
654: struct mbuf *m;
655: {
656: struct arphdr *ar;
657: extern int in_revarpinput(struct mbuf *);
658:
659: if (m->m_len < sizeof(struct arphdr)) {
660: goto out;
661: }
662: ar = mtod(m, struct arphdr *);
663: if (ntohs(ar->ar_hrd) != ARPHRD_ETHER) {
664: goto out;
665: }
666: if (m->m_len < sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln)) {
667: goto out;
668: }
669: switch (ntohs(ar->ar_pro)) {
670:
671: case ETHERTYPE_IP:
672: case ETHERTYPE_IPTRAILERS:
673: in_revarpinput(m);
674: return;
675:
676: default:
677: break;
678: }
679: out:
680: m_freem(m);
681: }
682:
683: /*
684: * RARP for Internet protocols on 10 Mb/s Ethernet.
685: * Algorithm is that given in RFC 903.
686: * We are only using for bootstrap purposes to get an ip address for one of
687: * our interfaces. Thus we support no user-interface.
688: *
689: * Since the contents of the RARP reply are specific to the interface that
690: * sent the request, this code must ensure that they are properly associated.
691: *
692: * Note: also supports ARP via RARP packets, per the RFC.
693: */
694: int
695: in_revarpinput(m)
696: struct mbuf *m;
697: {
698: struct ifnet *ifp;
699: struct ether_arp *ar;
700: int op;
701: extern void wakeup (void *);
702:
703: ar = mtod(m, struct ether_arp *);
704: op = ntohs(ar->arp_op);
705: switch (op) {
706: case ARPOP_REQUEST:
707: case ARPOP_REPLY: /* per RFC */
708: in_arpinput(m);
709: return(0);
710: case ARPOP_REVREPLY:
711: break;
712: case ARPOP_REVREQUEST: /* handled by rarpd(8) */
713: default:
714: goto out;
715: }
716: if (!revarp_in_progress)
717: goto out;
718: ifp = m->m_pkthdr.rcvif;
719: if (ifp != myip_ifp) /* !same interface */
720: goto out;
721: if (myip_initialized)
722: goto wake;
723: if (bcmp(ar->arp_tha, ((struct arpcom *)ifp)->ac_enaddr,
724: sizeof(ar->arp_tha)))
725: goto out;
726: bcopy((caddr_t)ar->arp_spa, (caddr_t)&srv_ip, sizeof(srv_ip));
727: bcopy((caddr_t)ar->arp_tpa, (caddr_t)&myip, sizeof(myip));
728: myip_initialized = 1;
729: wake: /* Do wakeup every time in case it was missed. */
730: wakeup((caddr_t)&myip);
731:
732: out:
733: m_freem(m);
734: return(0);
735: }
736:
737: /*
738: * Send a RARP request for the ip address of the specified interface.
739: * The request should be RFC 903-compliant.
740: */
741: void
742: revarprequest(ifp)
743: struct ifnet *ifp;
744: {
745: struct sockaddr sa;
746: struct mbuf *m;
747: struct ether_header *eh;
748: struct ether_arp *ea;
749: struct arpcom *ac = (struct arpcom *)ifp;
750:
751: if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
752: return;
753: m->m_len = sizeof(*ea);
754: m->m_pkthdr.len = sizeof(*ea);
755: MH_ALIGN(m, sizeof(*ea));
756: ea = mtod(m, struct ether_arp *);
757: eh = (struct ether_header *)sa.sa_data;
758: bzero((caddr_t)ea, sizeof(*ea));
759: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
760: sizeof(eh->ether_dhost));
761: eh->ether_type = htons(ETHERTYPE_REVARP);
762: ea->arp_hrd = htons(ARPHRD_ETHER);
763: ea->arp_pro = htons(ETHERTYPE_IP);
764: ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */
765: ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */
766: ea->arp_op = htons(ARPOP_REVREQUEST);
767: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
768: sizeof(ea->arp_sha));
769: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_tha,
770: sizeof(ea->arp_tha));
771: sa.sa_family = AF_UNSPEC;
772: sa.sa_len = sizeof(sa);
773: ifp->if_output(ifp, m, &sa, (struct rtentry *)0);
774: }
775:
776: /*
777: * RARP for the ip address of the specified interface, but also
778: * save the ip address of the server that sent the answer.
779: * Timeout if no response is received.
780: */
781: int
782: revarpwhoarewe(ifp, serv_in, clnt_in)
783: struct ifnet *ifp;
784: struct in_addr *serv_in;
785: struct in_addr *clnt_in;
786: {
787: int result, count = 20;
788: extern int tsleep(void *, int, char *, int);
789:
790: if (myip_initialized)
791: return EIO;
792:
793: myip_ifp = ifp;
794: revarp_in_progress = 1;
795: while (count--) {
796: revarprequest(ifp);
797: result = tsleep((caddr_t)&myip, PSOCK, "revarp", hz/2);
798: if (result != EWOULDBLOCK)
799: break;
800: }
801: revarp_in_progress = 0;
802: if (!myip_initialized)
803: return ENETUNREACH;
804:
805: bcopy((caddr_t)&srv_ip, serv_in, sizeof(*serv_in));
806: bcopy((caddr_t)&myip, clnt_in, sizeof(*clnt_in));
807: return 0;
808: }
809:
810: /* For compatibility: only saves interface address. */
811: int
812: revarpwhoami(in, ifp)
813: struct in_addr *in;
814: struct ifnet *ifp;
815: {
816: struct in_addr server;
817: return (revarpwhoarewe(ifp, &server, in));
818: }
819:
820:
821: #ifdef DDB
822: static void
823: db_print_sa(sa)
824: struct sockaddr *sa;
825: {
826: int len;
827: u_char *p;
828:
829: if (sa == 0) {
830: db_printf("[NULL]");
831: return;
832: }
833:
834: p = (u_char*)sa;
835: len = sa->sa_len;
836: db_printf("[");
837: while (len > 0) {
838: db_printf("%d", *p);
839: p++; len--;
840: if (len) db_printf(",");
841: }
842: db_printf("]\n");
843: }
844: static void
845: db_print_ifa(ifa)
846: struct ifaddr *ifa;
847: {
848: if (ifa == 0)
849: return;
850: db_printf(" ifa_addr=");
851: db_print_sa(ifa->ifa_addr);
852: db_printf(" ifa_dsta=");
853: db_print_sa(ifa->ifa_dstaddr);
854: db_printf(" ifa_mask=");
855: db_print_sa(ifa->ifa_netmask);
856: db_printf(" flags=0x%x,refcnt=%d,metric=%d\n",
857: ifa->ifa_flags,
858: ifa->ifa_refcnt,
859: ifa->ifa_metric);
860: }
861: static void
862: db_print_llinfo(li)
863: caddr_t li;
864: {
865: struct llinfo_arp *la;
866:
867: if (li == 0)
868: return;
869: la = (struct llinfo_arp *)li;
870: db_printf(" la_rt=0x%x la_hold=0x%x, la_asked=0x%x\n",
871: la->la_rt, la->la_hold, la->la_asked);
872: }
873: /*
874: * Function to pass to rn_walktree().
875: * Return non-zero error to abort walk.
876: */
877: static int
878: db_show_radix_node(rn, w)
879: struct radix_node *rn;
880: void *w;
881: {
882: struct rtentry *rt = (struct rtentry *)rn;
883:
884: db_printf("rtentry=0x%x", rt);
885:
886: db_printf(" flags=0x%x refcnt=%d use=%d expire=%d\n",
887: rt->rt_flags, rt->rt_refcnt,
888: rt->rt_use, rt->rt_expire);
889:
890: db_printf(" key="); db_print_sa(rt_key(rt));
891: db_printf(" mask="); db_print_sa(rt_mask(rt));
892: db_printf(" gw="); db_print_sa(rt->rt_gateway);
893:
894: db_printf(" ifp=0x%x ", rt->rt_ifp);
895: if (rt->rt_ifp)
896: db_printf("(%s%d)",
897: rt->rt_ifp->if_name,
898: rt->rt_ifp->if_unit);
899: else
900: db_printf("(NULL)");
901:
902: db_printf(" ifa=0x%x\n", rt->rt_ifa);
903: db_print_ifa(rt->rt_ifa);
904:
905: db_printf(" genmask="); db_print_sa(rt->rt_genmask);
906:
907: db_printf(" gwroute=0x%x llinfo=0x%x\n",
908: rt->rt_gwroute, rt->rt_llinfo);
909: db_print_llinfo(rt->rt_llinfo);
910:
911: return (0);
912: }
913: /*
914: * Function to print all the route trees.
915: * Use this from ddb: "call db_show_arptab"
916: */
917: db_show_arptab()
918: {
919: struct radix_node_head *rnh;
920: rnh = rt_tables[AF_INET];
921: db_printf("Route tree for AF_INET\n");
922: if (rnh == NULL) {
923: db_printf(" (not initialized)\n");
924: return (0);
925: }
926: rn_walktree(rnh, db_show_radix_node, NULL);
927: return (0);
928: }
929: #endif
930: #endif /* INET */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.