![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to route.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to route.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1980, 1986, 1991, 1993
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52: * SUCH DAMAGE.
53: *
54: * @(#)route.c 8.2 (Berkeley) 11/15/93
55: */
56:
57: #if NOTFB31
58: #include "opt_inet.h"
59: #include "opt_mrouting.h"
60: #endif
61:
62: #include <sys/param.h>
63: #include <sys/systm.h>
64: #include <sys/malloc.h>
65: #include <sys/mbuf.h>
66: #include <sys/socket.h>
67: #include <sys/domain.h>
68:
69: #include <net/if.h>
70: #include <net/route.h>
71:
72: #include <netinet/in.h>
73: #include <netinet/ip_mroute.h>
74:
75: #define SA(p) ((struct sockaddr *)(p))
76:
77: struct route_cb route_cb;
78: static struct rtstat rtstat;
79: struct radix_node_head *rt_tables[AF_MAX+1];
80:
81: static int rttrash; /* routes not in table but not freed */
82:
83: static void rt_maskedcopy __P((struct sockaddr *,
84: struct sockaddr *, struct sockaddr *));
85: static void rtable_init __P((void **));
86:
87: static void
88: rtable_init(table)
89: void **table;
90: {
91: struct domain *dom;
92: for (dom = domains; dom; dom = dom->dom_next)
93: if (dom->dom_rtattach)
94: dom->dom_rtattach(&table[dom->dom_family],
95: dom->dom_rtoffset);
96: }
97:
98: void
99: route_init()
100: {
101: rn_init(); /* initialize all zeroes, all ones, mask table */
102: rtable_init((void **)rt_tables);
103: }
104:
105: /*
106: * Packet routing routines.
107: */
108: void
109: rtalloc(ro)
110: register struct route *ro;
111: {
112: if (ro->ro_rt && ro->ro_rt->rt_ifp && (ro->ro_rt->rt_flags & RTF_UP))
113: return; /* XXX */
114: ro->ro_rt = rtalloc1(&ro->ro_dst, 1, 0UL);
115: }
116:
117: void
118: rtalloc_ign(ro, ignore)
119: register struct route *ro;
120: u_long ignore;
121: {
122: if (ro->ro_rt && ro->ro_rt->rt_ifp && (ro->ro_rt->rt_flags & RTF_UP))
123: return; /* XXX */
124: ro->ro_rt = rtalloc1(&ro->ro_dst, 1, ignore);
125: }
126:
127: /*
128: * Look up the route that matches the address given
129: * Or, at least try.. Create a cloned route if needed.
130: */
131: struct rtentry *
132: rtalloc1(dst, report, ignflags)
133: register struct sockaddr *dst;
134: int report;
135: u_long ignflags;
136: {
137: register struct radix_node_head *rnh = rt_tables[dst->sa_family];
138: register struct rtentry *rt;
139: register struct radix_node *rn;
140: struct rtentry *newrt = 0;
141: struct rt_addrinfo info;
142: u_long nflags;
143: int s = splnet(), err = 0, msgtype = RTM_MISS;
144:
145: /*
146: * Look up the address in the table for that Address Family
147: */
148: if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
149: ((rn->rn_flags & RNF_ROOT) == 0)) {
150: /*
151: * If we find it and it's not the root node, then
152: * get a refernce on the rtentry associated.
153: */
154: newrt = rt = (struct rtentry *)rn;
155: nflags = rt->rt_flags & ~ignflags;
156: if (report && (nflags & (RTF_CLONING | RTF_PRCLONING))) {
157: /*
158: * We are apparently adding (report = 0 in delete).
159: * If it requires that it be cloned, do so.
160: * (This implies it wasn't a HOST route.)
161: */
162: err = rtrequest(RTM_RESOLVE, dst, SA(0),
163: SA(0), 0, &newrt);
164: if (err) {
165: /*
166: * If the cloning didn't succeed, maybe
167: * what we have will do. Return that.
168: */
169: newrt = rt;
170: rt->rt_refcnt++;
171: goto miss;
172: }
173: if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
174: /*
175: * If the new route specifies it be
176: * externally resolved, then go do that.
177: */
178: msgtype = RTM_RESOLVE;
179: goto miss;
180: }
181: } else
182: rt->rt_refcnt++;
183: } else {
184: /*
185: * Either we hit the root or couldn't find any match,
186: * Which basically means
187: * "caint get there frm here"
188: */
189: rtstat.rts_unreach++;
190: miss: if (report) {
191: /*
192: * If required, report the failure to the supervising
193: * Authorities.
194: * For a delete, this is not an error. (report == 0)
195: */
196: bzero((caddr_t)&info, sizeof(info));
197: info.rti_info[RTAX_DST] = dst;
198: rt_missmsg(msgtype, &info, 0, err);
199: }
200: }
201: splx(s);
202: return (newrt);
203: }
204:
205: /*
206: * Remove a reference count from an rtentry.
207: * If the count gets low enough, take it out of the routing table
208: */
209: void
210: rtfree(rt)
211: register struct rtentry *rt;
212: {
213: /*
214: * find the tree for that address family
215: */
216: register struct radix_node_head *rnh =
217: rt_tables[rt_key(rt)->sa_family];
218: register struct ifaddr *ifa;
219:
220: if (rt == 0 || rnh == 0)
221: panic("rtfree");
222:
223: /*
224: * decrement the reference count by one and if it reaches 0,
225: * and there is a close function defined, call the close function
226: */
227: rt->rt_refcnt--;
228: if(rnh->rnh_close && rt->rt_refcnt == 0) {
229: rnh->rnh_close((struct radix_node *)rt, rnh);
230: }
231:
232: /*
233: * If we are no longer "up" (and ref == 0)
234: * then we can free the resources associated
235: * with the route.
236: */
237: if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
238: if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
239: panic ("rtfree 2");
240: /*
241: * the rtentry must have been removed from the routing table
242: * so it is represented in rttrash.. remove that now.
243: */
244: rttrash--;
245:
246: #ifdef DIAGNOSTIC
247: if (rt->rt_refcnt < 0) {
248: printf("rtfree: %p not freed (neg refs)\n", rt);
249: return;
250: }
251: #endif
252:
253: /*
254: * release references on items we hold them on..
255: * e.g other routes and ifaddrs.
256: */
257: if((ifa = rt->rt_ifa))
258: IFAFREE(ifa);
259: if (rt->rt_parent) {
260: RTFREE(rt->rt_parent);
261: }
262:
263: /*
264: * The key is separatly alloc'd so free it (see rt_setgate()).
265: * This also frees the gateway, as they are always malloc'd
266: * together.
267: */
268: Free(rt_key(rt));
269:
270: /*
271: * and the rtentry itself of course
272: */
273: Free(rt);
274: }
275: }
276:
277: void
278: ifafree(ifa)
279: register struct ifaddr *ifa;
280: {
281: if (ifa == NULL)
282: panic("ifafree");
283: if (ifa->ifa_refcnt == 0)
284: FREE(ifa, M_IFADDR);
285: else
286: ifa->ifa_refcnt--;
287: }
288:
289: /*
290: * Force a routing table entry to the specified
291: * destination to go through the given gateway.
292: * Normally called as a result of a routing redirect
293: * message from the network layer.
294: *
295: * N.B.: must be called at splnet
296: *
297: */
298: void
299: rtredirect(dst, gateway, netmask, flags, src, rtp)
300: struct sockaddr *dst, *gateway, *netmask, *src;
301: int flags;
302: struct rtentry **rtp;
303: {
304: register struct rtentry *rt;
305: int error = 0;
306: short *stat = 0;
307: struct rt_addrinfo info;
308: struct ifaddr *ifa;
309:
310: /* verify the gateway is directly reachable */
311: if ((ifa = ifa_ifwithnet(gateway)) == 0) {
312: error = ENETUNREACH;
313: goto out;
314: }
315: rt = rtalloc1(dst, 0, 0UL);
316: /*
317: * If the redirect isn't from our current router for this dst,
318: * it's either old or wrong. If it redirects us to ourselves,
319: * we have a routing loop, perhaps as a result of an interface
320: * going down recently.
321: */
322: #define equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
323: if (!(flags & RTF_DONE) && rt &&
324: (!equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
325: error = EINVAL;
326: else if (ifa_ifwithaddr(gateway))
327: error = EHOSTUNREACH;
328: if (error)
329: goto done;
330: /*
331: * Create a new entry if we just got back a wildcard entry
332: * or the the lookup failed. This is necessary for hosts
333: * which use routing redirects generated by smart gateways
334: * to dynamically build the routing tables.
335: */
336: if ((rt == 0) || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
337: goto create;
338: /*
339: * Don't listen to the redirect if it's
340: * for a route to an interface.
341: */
342: if (rt->rt_flags & RTF_GATEWAY) {
343: if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
344: /*
345: * Changing from route to net => route to host.
346: * Create new route, rather than smashing route to net.
347: */
348: create:
349: flags |= RTF_GATEWAY | RTF_DYNAMIC;
350: error = rtrequest((int)RTM_ADD, dst, gateway,
351: netmask, flags,
352: (struct rtentry **)0);
353: stat = &rtstat.rts_dynamic;
354: } else {
355: /*
356: * Smash the current notion of the gateway to
357: * this destination. Should check about netmask!!!
358: */
359: rt->rt_flags |= RTF_MODIFIED;
360: flags |= RTF_MODIFIED;
361: stat = &rtstat.rts_newgateway;
362: /*
363: * add the key and gateway (in one malloc'd chunk).
364: */
365: rt_setgate(rt, rt_key(rt), gateway);
366: }
367: } else
368: error = EHOSTUNREACH;
369: done:
370: if (rt) {
371: if (rtp && !error)
372: *rtp = rt;
373: else
374: rtfree(rt);
375: }
376: out:
377: if (error)
378: rtstat.rts_badredirect++;
379: else if (stat != NULL)
380: (*stat)++;
381: bzero((caddr_t)&info, sizeof(info));
382: info.rti_info[RTAX_DST] = dst;
383: info.rti_info[RTAX_GATEWAY] = gateway;
384: info.rti_info[RTAX_NETMASK] = netmask;
385: info.rti_info[RTAX_AUTHOR] = src;
386: rt_missmsg(RTM_REDIRECT, &info, flags, error);
387: }
388:
389: /*
390: * Routing table ioctl interface.
391: */
392: int
393: rtioctl(req, data, p)
394: int req;
395: caddr_t data;
396: struct proc *p;
397: {
398: #if INET
399: /* Multicast goop, grrr... */
400: #if MROUTING
401: return mrt_ioctl(req, data);
402: #else
403: return mrt_ioctl(req, data, p);
404: #endif
405: #else /* INET */
406: return ENXIO;
407: #endif /* INET */
408: }
409:
410: struct ifaddr *
411: ifa_ifwithroute(flags, dst, gateway)
412: int flags;
413: struct sockaddr *dst, *gateway;
414: {
415: register struct ifaddr *ifa;
416: if ((flags & RTF_GATEWAY) == 0) {
417: /*
418: * If we are adding a route to an interface,
419: * and the interface is a pt to pt link
420: * we should search for the destination
421: * as our clue to the interface. Otherwise
422: * we can use the local address.
423: */
424: ifa = 0;
425: if (flags & RTF_HOST) {
426: ifa = ifa_ifwithdstaddr(dst);
427: }
428: if (ifa == 0)
429: ifa = ifa_ifwithaddr(gateway);
430: } else {
431: /*
432: * If we are adding a route to a remote net
433: * or host, the gateway may still be on the
434: * other end of a pt to pt link.
435: */
436: ifa = ifa_ifwithdstaddr(gateway);
437: }
438: if (ifa == 0)
439: ifa = ifa_ifwithnet(gateway);
440: if (ifa == 0) {
441: struct rtentry *rt = rtalloc1(dst, 0, 0UL);
442: if (rt == 0)
443: return (0);
444: rt->rt_refcnt--;
445: if ((ifa = rt->rt_ifa) == 0)
446: return (0);
447: }
448: if (ifa->ifa_addr->sa_family != dst->sa_family) {
449: struct ifaddr *oifa = ifa;
450: ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
451: if (ifa == 0)
452: ifa = oifa;
453: }
454: return (ifa);
455: }
456:
457: #define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
458:
459: static int rt_fixdelete __P((struct radix_node *, void *));
460: static int rt_fixchange __P((struct radix_node *, void *));
461:
462: struct rtfc_arg {
463: struct rtentry *rt0;
464: struct radix_node_head *rnh;
465: };
466:
467: /*
468: * Do appropriate manipulations of a routing tree given
469: * all the bits of info needed
470: */
471: int
472: rtrequest(req, dst, gateway, netmask, flags, ret_nrt)
473: int req, flags;
474: struct sockaddr *dst, *gateway, *netmask;
475: struct rtentry **ret_nrt;
476: {
477: int s = splnet(); int error = 0;
478: register struct rtentry *rt;
479: register struct radix_node *rn;
480: register struct radix_node_head *rnh;
481: struct ifaddr *ifa;
482: struct sockaddr *ndst;
483: #define senderr(x) { error = x ; goto bad; }
484:
485: /*
486: * Find the correct routing tree to use for this Address Family
487: */
488: if ((rnh = rt_tables[dst->sa_family]) == 0)
489: senderr(ESRCH);
490: /*
491: * If we are adding a host route then we don't want to put
492: * a netmask in the tree
493: */
494: if (flags & RTF_HOST)
495: netmask = 0;
496: switch (req) {
497: case RTM_DELETE:
498: /*
499: * Remove the item from the tree and return it.
500: * Complain if it is not there and do no more processing.
501: */
502: if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == 0)
503: senderr(ESRCH);
504: if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
505: panic ("rtrequest delete");
506: rt = (struct rtentry *)rn;
507:
508: /*
509: * Now search what's left of the subtree for any cloned
510: * routes which might have been formed from this node.
511: */
512: if ((rt->rt_flags & RTF_PRCLONING) && netmask) {
513: rnh->rnh_walktree_from(rnh, dst, netmask,
514: rt_fixdelete, rt);
515: }
516:
517: /*
518: * Remove any external references we may have.
519: * This might result in another rtentry being freed if
520: * we held its last reference.
521: */
522: if (rt->rt_gwroute) {
523: rt = rt->rt_gwroute;
524: RTFREE(rt);
525: (rt = (struct rtentry *)rn)->rt_gwroute = 0;
526: }
527:
528: /*
529: * NB: RTF_UP must be set during the search above,
530: * because we might delete the last ref, causing
531: * rt to get freed prematurely.
532: * eh? then why not just add a reference?
533: * I'm not sure how RTF_UP helps matters. (JRE)
534: */
535: rt->rt_flags &= ~RTF_UP;
536:
537: /*
538: * give the protocol a chance to keep things in sync.
539: */
540: if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
541: ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0));
542:
543: /*
544: * one more rtentry floating around that is not
545: * linked to the routing table.
546: */
547: rttrash++;
548:
549: /*
550: * If the caller wants it, then it can have it,
551: * but it's up to it to free the rtentry as we won't be
552: * doing it.
553: */
554: if (ret_nrt)
555: *ret_nrt = rt;
556: else if (rt->rt_refcnt <= 0) {
557: rt->rt_refcnt++;
558: rtfree(rt);
559: }
560: break;
561:
562: case RTM_RESOLVE:
563: if (ret_nrt == 0 || (rt = *ret_nrt) == 0)
564: senderr(EINVAL);
565: ifa = rt->rt_ifa;
566: flags = rt->rt_flags &
567: ~(RTF_CLONING | RTF_PRCLONING | RTF_STATIC);
568: flags |= RTF_WASCLONED;
569: gateway = rt->rt_gateway;
570: if ((netmask = rt->rt_genmask) == 0)
571: flags |= RTF_HOST;
572: goto makeroute;
573:
574: case RTM_ADD:
575: if ((flags & RTF_GATEWAY) && !gateway)
576: panic("rtrequest: GATEWAY but no gateway");
577:
578: if ((ifa = ifa_ifwithroute(flags, dst, gateway)) == 0)
579: senderr(ENETUNREACH);
580:
581: makeroute:
582: R_Malloc(rt, struct rtentry *, sizeof(*rt));
583: if (rt == 0)
584: senderr(ENOBUFS);
585: Bzero(rt, sizeof(*rt));
586: rt->rt_flags = RTF_UP | flags;
587: /*
588: * Add the gateway. Possibly re-malloc-ing the storage for it
589: * also add the rt_gwroute if possible.
590: */
591: if (error = rt_setgate(rt, dst, gateway)) {
592: Free(rt);
593: senderr(error);
594: }
595:
596: /*
597: * point to the (possibly newly malloc'd) dest address.
598: */
599: ndst = rt_key(rt);
600:
601: /*
602: * make sure it contains the value we want (masked if needed).
603: */
604: if (netmask) {
605: rt_maskedcopy(dst, ndst, netmask);
606: } else
607: Bcopy(dst, ndst, dst->sa_len);
608:
609: /*
610: * Note that we now have a reference to the ifa.
611: * This moved from below so that rnh->rnh_addaddr() can
612: * examine the ifa and ifa->ifa_ifp if it so desires.
613: */
614: ifa->ifa_refcnt++;
615: rt->rt_ifa = ifa;
616: rt->rt_ifp = ifa->ifa_ifp;
617: rt->rt_dlt = ifa->ifa_dlt;
618: rn = rnh->rnh_addaddr((caddr_t)ndst, (caddr_t)netmask,
619: rnh, rt->rt_nodes);
620: if (rn == 0) {
621: struct rtentry *rt2;
622: /*
623: * Uh-oh, we already have one of these in the tree.
624: * We do a special hack: if the route that's already
625: * there was generated by the protocol-cloning
626: * mechanism, then we just blow it away and retry
627: * the insertion of the new one.
628: */
629: rt2 = rtalloc1(dst, 0, RTF_PRCLONING);
630: if (rt2 && rt2->rt_parent) {
631: rtrequest(RTM_DELETE,
632: (struct sockaddr *)rt_key(rt2),
633: rt2->rt_gateway,
634: rt_mask(rt2), rt2->rt_flags, 0);
635: RTFREE(rt2);
636: rn = rnh->rnh_addaddr((caddr_t)ndst,
637: (caddr_t)netmask,
638: rnh, rt->rt_nodes);
639: } else if (rt2) {
640: /* undo the extra ref we got */
641: RTFREE(rt2);
642: }
643: }
644:
645: /*
646: * If it still failed to go into the tree,
647: * then un-make it (this should be a function)
648: */
649: if (rn == 0) {
650: if (rt->rt_gwroute)
651: rtfree(rt->rt_gwroute);
652: if (rt->rt_ifa) {
653: IFAFREE(rt->rt_ifa);
654: }
655: Free(rt_key(rt));
656: Free(rt);
657: senderr(EEXIST);
658: }
659:
660: rt->rt_parent = 0;
661:
662: /*
663: * If we got here from RESOLVE, then we are cloning
664: * so clone the rest, and note that we
665: * are a clone (and increment the parent's references)
666: */
667: if (req == RTM_RESOLVE) {
668: rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
669: if ((*ret_nrt)->rt_flags & RTF_PRCLONING) {
670: rt->rt_parent = (*ret_nrt);
671: (*ret_nrt)->rt_refcnt++;
672: }
673: }
674:
675: /*
676: * if this protocol has something to add to this then
677: * allow it to do that as well.
678: */
679: if (ifa->ifa_rtrequest)
680: ifa->ifa_rtrequest(req, rt, SA(ret_nrt ? *ret_nrt : 0));
681:
682: /*
683: * We repeat the same procedure from rt_setgate() here because
684: * it doesn't fire when we call it there because the node
685: * hasn't been added to the tree yet.
686: */
687: if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
688: struct rtfc_arg arg;
689: arg.rnh = rnh;
690: arg.rt0 = rt;
691: rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
692: rt_fixchange, &arg);
693: }
694:
695: /*
696: * actually return a resultant rtentry and
697: * give the caller a single reference.
698: */
699: if (ret_nrt) {
700: *ret_nrt = rt;
701: rt->rt_refcnt++;
702: }
703: break;
704: }
705: bad:
706: splx(s);
707: return (error);
708: }
709:
710: /*
711: * Called from rtrequest(RTM_DELETE, ...) to fix up the route's ``family''
712: * (i.e., the routes related to it by the operation of cloning). This
713: * routine is iterated over all potential former-child-routes by way of
714: * rnh->rnh_walktree_from() above, and those that actually are children of
715: * the late parent (passed in as VP here) are themselves deleted.
716: */
717: static int
718: rt_fixdelete(rn, vp)
719: struct radix_node *rn;
720: void *vp;
721: {
722: struct rtentry *rt = (struct rtentry *)rn;
723: struct rtentry *rt0 = vp;
724:
725: if (rt->rt_parent == rt0 && !(rt->rt_flags & RTF_PINNED)) {
726: return rtrequest(RTM_DELETE, rt_key(rt),
727: (struct sockaddr *)0, rt_mask(rt),
728: rt->rt_flags, (struct rtentry **)0);
729: }
730: return 0;
731: }
732:
733: /*
734: * This routine is called from rt_setgate() to do the analogous thing for
735: * adds and changes. There is the added complication in this case of a
736: * middle insert; i.e., insertion of a new network route between an older
737: * network route and (cloned) host routes. For this reason, a simple check
738: * of rt->rt_parent is insufficient; each candidate route must be tested
739: * against the (mask, value) of the new route (passed as before in vp)
740: * to see if the new route matches it. Unfortunately, this has the obnoxious
741: * property of also triggering for insertion /above/ a pre-existing network
742: * route and clones. Sigh. This may be fixed some day.
743: *
744: * XXX - it may be possible to do fixdelete() for changes and reserve this
745: * routine just for adds. I'm not sure why I thought it was necessary to do
746: * changes this way.
747: */
748: #ifdef DEBUG
749: static int rtfcdebug = 0;
750: #endif
751:
752: static int
753: rt_fixchange(rn, vp)
754: struct radix_node *rn;
755: void *vp;
756: {
757: struct rtentry *rt = (struct rtentry *)rn;
758: struct rtfc_arg *ap = vp;
759: struct rtentry *rt0 = ap->rt0;
760: struct radix_node_head *rnh = ap->rnh;
761: u_char *xk1, *xm1, *xk2;
762: int i, len;
763:
764: #ifdef DEBUG
765: if (rtfcdebug)
766: printf("rt_fixchange: rt %p, rt0 %p\n", rt, rt0);
767: #endif
768:
769: if (!rt->rt_parent || (rt->rt_flags & RTF_PINNED)) {
770: #ifdef DEBUG
771: if(rtfcdebug) printf("no parent or pinned\n");
772: #endif
773: return 0;
774: }
775:
776: if (rt->rt_parent == rt0) {
777: #ifdef DEBUG
778: if(rtfcdebug) printf("parent match\n");
779: #endif
780: return rtrequest(RTM_DELETE, rt_key(rt),
781: (struct sockaddr *)0, rt_mask(rt),
782: rt->rt_flags, (struct rtentry **)0);
783: }
784:
785: /*
786: * There probably is a function somewhere which does this...
787: * if not, there should be.
788: */
789: len = imin(((struct sockaddr *)rt_key(rt0))->sa_len,
790: ((struct sockaddr *)rt_key(rt))->sa_len);
791:
792: xk1 = (u_char *)rt_key(rt0);
793: xm1 = (u_char *)rt_mask(rt0);
794: xk2 = (u_char *)rt_key(rt);
795:
796: for (i = rnh->rnh_treetop->rn_off; i < len; i++) {
797: if ((xk2[i] & xm1[i]) != xk1[i]) {
798: #ifdef DEBUG
799: if(rtfcdebug) printf("no match\n");
800: #endif
801: return 0;
802: }
803: }
804:
805: /*
806: * OK, this node is a clone, and matches the node currently being
807: * changed/added under the node's mask. So, get rid of it.
808: */
809: #ifdef DEBUG
810: if(rtfcdebug) printf("deleting\n");
811: #endif
812: return rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0,
813: rt_mask(rt), rt->rt_flags, (struct rtentry **)0);
814: }
815:
816: int
817: rt_setgate(rt0, dst, gate)
818: struct rtentry *rt0;
819: struct sockaddr *dst, *gate;
820: {
821: caddr_t new, old;
822: int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
823: register struct rtentry *rt = rt0;
824: struct radix_node_head *rnh = rt_tables[dst->sa_family];
825:
826: /*
827: * A host route with the destination equal to the gateway
828: * will interfere with keeping LLINFO in the routing
829: * table, so disallow it.
830: */
831: if (((rt0->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) ==
832: (RTF_HOST|RTF_GATEWAY)) &&
833: (dst->sa_len == gate->sa_len) &&
834: (bcmp(dst, gate, dst->sa_len) == 0)) {
835: /*
836: * The route might already exist if this is an RTM_CHANGE
837: * or a routing redirect, so try to delete it.
838: */
839: if (rt_key(rt0))
840: rtrequest(RTM_DELETE, (struct sockaddr *)rt_key(rt0),
841: rt0->rt_gateway, rt_mask(rt0), rt0->rt_flags, 0);
842: return EADDRNOTAVAIL;
843: }
844:
845: /*
846: * Both dst and gateway are stored in the same malloc'd chunk
847: * (If I ever get my hands on....)
848: * if we need to malloc a new chunk, then keep the old one around
849: * till we don't need it any more.
850: */
851: if (rt->rt_gateway == 0 || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
852: old = (caddr_t)rt_key(rt);
853: R_Malloc(new, caddr_t, dlen + glen);
854: if (new == 0)
855: return ENOBUFS;
856: rt->rt_nodes->rn_key = new;
857: } else {
858: /*
859: * otherwise just overwrite the old one
860: */
861: new = rt->rt_nodes->rn_key;
862: old = 0;
863: }
864:
865: /*
866: * copy the new gateway value into the memory chunk
867: */
868: Bcopy(gate, (rt->rt_gateway = (struct sockaddr *)(new + dlen)), glen);
869:
870: /*
871: * if we are replacing the chunk (or it's new) we need to
872: * replace the dst as well
873: */
874: if (old) {
875: Bcopy(dst, new, dlen);
876: Free(old);
877: }
878:
879: /*
880: * If there is already a gwroute, it's now almost definitly wrong
881: * so drop it.
882: */
883: if (rt->rt_gwroute) {
884: rt = rt->rt_gwroute; RTFREE(rt);
885: rt = rt0; rt->rt_gwroute = 0;
886: }
887: /*
888: * Cloning loop avoidance:
889: * In the presence of protocol-cloning and bad configuration,
890: * it is possible to get stuck in bottomless mutual recursion
891: * (rtrequest rt_setgate rtalloc1). We avoid this by not allowing
892: * protocol-cloning to operate for gateways (which is probably the
893: * correct choice anyway), and avoid the resulting reference loops
894: * by disallowing any route to run through itself as a gateway.
895: * This is obviously mandatory when we get rt->rt_output().
896: */
897: if (rt->rt_flags & RTF_GATEWAY) {
898: rt->rt_gwroute = rtalloc1(gate, 1, RTF_PRCLONING);
899: if (rt->rt_gwroute == rt) {
900: RTFREE(rt->rt_gwroute);
901: rt->rt_gwroute = 0;
902: return EDQUOT; /* failure */
903: }
904: }
905:
906: /*
907: * This isn't going to do anything useful for host routes, so
908: * don't bother. Also make sure we have a reasonable mask
909: * (we don't yet have one during adds).
910: */
911: if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
912: struct rtfc_arg arg;
913: arg.rnh = rnh;
914: arg.rt0 = rt;
915: rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
916: rt_fixchange, &arg);
917: }
918:
919: return 0;
920: }
921:
922: static void
923: rt_maskedcopy(src, dst, netmask)
924: struct sockaddr *src, *dst, *netmask;
925: {
926: register u_char *cp1 = (u_char *)src;
927: register u_char *cp2 = (u_char *)dst;
928: register u_char *cp3 = (u_char *)netmask;
929: u_char *cplim = cp2 + *cp3;
930: u_char *cplim2 = cp2 + *cp1;
931:
932: *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
933: cp3 += 2;
934: if (cplim > cplim2)
935: cplim = cplim2;
936: while (cp2 < cplim)
937: *cp2++ = *cp1++ & *cp3++;
938: if (cp2 < cplim2)
939: bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
940: }
941:
942: /*
943: * Set up a routing table entry, normally
944: * for an interface.
945: */
946: int
947: rtinit(ifa, cmd, flags)
948: register struct ifaddr *ifa;
949: int cmd, flags;
950: {
951: register struct rtentry *rt;
952: register struct sockaddr *dst;
953: register struct sockaddr *deldst;
954: struct mbuf *m = 0;
955: struct rtentry *nrt = 0;
956: int error;
957:
958: dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
959: /*
960: * If it's a delete, check that if it exists, it's on the correct
961: * interface or we might scrub a route to another ifa which would
962: * be confusing at best and possibly worse.
963: */
964: if (cmd == RTM_DELETE) {
965: /*
966: * It's a delete, so it should already exist..
967: * If it's a net, mask off the host bits
968: * (Assuming we have a mask)
969: */
970: if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
971: m = m_get(M_WAIT, MT_SONAME);
972: deldst = mtod(m, struct sockaddr *);
973: rt_maskedcopy(dst, deldst, ifa->ifa_netmask);
974: dst = deldst;
975: }
976: /*
977: * Get an rtentry that is in the routing tree and
978: * contains the correct info. (if this fails, can't get there).
979: * We set "report" to FALSE so that if it doesn't exist,
980: * it doesn't report an error or clone a route, etc. etc.
981: */
982: rt = rtalloc1(dst, 0, 0UL);
983: if (rt) {
984: /*
985: * Ok so we found the rtentry. it has an extra reference
986: * for us at this stage. we won't need that so
987: * lop that off now.
988: */
989: rt->rt_refcnt--;
990: if (rt->rt_ifa != ifa) {
991: /*
992: * If the interface in the rtentry doesn't match
993: * the interface we are using, then we don't
994: * want to delete it, so return an error.
995: * This seems to be the only point of
996: * this whole RTM_DELETE clause.
997: */
998: if (m)
999: (void) m_free(m);
1000: return (flags & RTF_HOST ? EHOSTUNREACH
1001: : ENETUNREACH);
1002: }
1003: }
1004: /* XXX */
1005: #if 0
1006: else {
1007: /*
1008: * One would think that as we are deleting, and we know
1009: * it doesn't exist, we could just return at this point
1010: * with an "ELSE" clause, but apparently not..
1011: */
1012: return (flags & RTF_HOST ? EHOSTUNREACH
1013: : ENETUNREACH);
1014: }
1015: #endif
1016: }
1017: /*
1018: * Do the actual request
1019: */
1020: error = rtrequest(cmd, dst, ifa->ifa_addr, ifa->ifa_netmask,
1021: flags | ifa->ifa_flags, &nrt);
1022: if (m)
1023: (void) m_free(m);
1024: /*
1025: * If we are deleting, and we found an entry, then
1026: * it's been removed from the tree.. now throw it away.
1027: */
1028: if (cmd == RTM_DELETE && error == 0 && (rt = nrt)) {
1029: /*
1030: * notify any listenning routing agents of the change
1031: */
1032: rt_newaddrmsg(cmd, ifa, error, nrt);
1033: if (rt->rt_refcnt <= 0) {
1034: rt->rt_refcnt++;
1035: rtfree(rt);
1036: }
1037: }
1038:
1039: /*
1040: * We are adding, and we have a returned routing entry.
1041: * We need to sanity check the result.
1042: */
1043: if (cmd == RTM_ADD && error == 0 && (rt = nrt)) {
1044: /*
1045: * We just wanted to add it.. we don't actually need a reference
1046: */
1047: rt->rt_refcnt--;
1048: /*
1049: * If it came back with an unexpected interface, then it must
1050: * have already existed or something. (XXX)
1051: */
1052: if (rt->rt_ifa != ifa) {
1053: printf("rtinit: wrong ifa (%p) was (%p)\n", ifa,
1054: rt->rt_ifa);
1055: /*
1056: * Ask that the protocol in question
1057: * remove anything it has associated with
1058: * this route and ifaddr.
1059: */
1060: if (rt->rt_ifa->ifa_rtrequest)
1061: rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0));
1062: /*
1063: * Remove the referenve to the it's ifaddr.
1064: */
1065: IFAFREE(rt->rt_ifa);
1066: /*
1067: * And substitute in references to the ifaddr
1068: * we are adding.
1069: */
1070: rt->rt_ifa = ifa;
1071: rt->rt_ifp = ifa->ifa_ifp;
1072: rt->rt_dlt = ifa->ifa_dlt;
1073: ifa->ifa_refcnt++;
1074: /*
1075: * Now ask the protocol to check if it needs
1076: * any special processing in its new form.
1077: */
1078: if (ifa->ifa_rtrequest)
1079: ifa->ifa_rtrequest(RTM_ADD, rt, SA(0));
1080: }
1081: /*
1082: * notify any listenning routing agents of the change
1083: */
1084: rt_newaddrmsg(cmd, ifa, error, nrt);
1085: }
1086: return (error);
1087: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.