![[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 [Net/2] / Net2 / net|
Return to route.c CVS log | Up to [Net/2] / Net2 / net |
1.1 root 1: /*
2: * Copyright (c) 1980, 1986, 1991 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)route.c 7.22 (Berkeley) 6/27/91
34: */
35: #include "param.h"
36: #include "systm.h"
37: #include "proc.h"
38: #include "mbuf.h"
39: #include "socket.h"
40: #include "socketvar.h"
41: #include "domain.h"
42: #include "protosw.h"
43: #include "ioctl.h"
44:
45: #include "if.h"
46: #include "af.h"
47: #include "route.h"
48: #include "raw_cb.h"
49:
50: #include "../netinet/in.h"
51: #include "../netinet/in_var.h"
52:
53: #ifdef NS
54: #include "../netns/ns.h"
55: #endif
56: #include "machine/mtpr.h"
57: #include "netisr.h"
58:
59: #define SA(p) ((struct sockaddr *)(p))
60:
61: int rttrash; /* routes not in table but not freed */
62: struct sockaddr wildcard; /* zero valued cookie for wildcard searches */
63: int rthashsize = RTHASHSIZ; /* for netstat, etc. */
64:
65: static int rtinits_done = 0;
66: struct radix_node_head *ns_rnhead, *in_rnhead;
67: struct radix_node *rn_match(), *rn_delete(), *rn_addroute();
68:
69: rtinitheads()
70: {
71: if (rtinits_done == 0 &&
72: #ifdef NS
73: rn_inithead(&ns_rnhead, 16, AF_NS) &&
74: #endif
75: rn_inithead(&in_rnhead, 32, AF_INET))
76: rtinits_done = 1;
77: }
78:
79: /*
80: * Packet routing routines.
81: */
82: rtalloc(ro)
83: register struct route *ro;
84: {
85: if (ro->ro_rt && ro->ro_rt->rt_ifp && (ro->ro_rt->rt_flags & RTF_UP))
86: return; /* XXX */
87: ro->ro_rt = rtalloc1(&ro->ro_dst, 1);
88: }
89:
90: struct rtentry *
91: rtalloc1(dst, report)
92: register struct sockaddr *dst;
93: int report;
94: {
95: register struct radix_node_head *rnh;
96: register struct rtentry *rt;
97: register struct radix_node *rn;
98: struct rtentry *newrt = 0;
99: int s = splnet(), err = 0, msgtype = RTM_MISS;
100:
101: for (rnh = radix_node_head; rnh && (dst->sa_family != rnh->rnh_af); )
102: rnh = rnh->rnh_next;
103: if (rnh && rnh->rnh_treetop &&
104: (rn = rn_match((caddr_t)dst, rnh->rnh_treetop)) &&
105: ((rn->rn_flags & RNF_ROOT) == 0)) {
106: newrt = rt = (struct rtentry *)rn;
107: if (report && (rt->rt_flags & RTF_CLONING)) {
108: if ((err = rtrequest(RTM_RESOLVE, dst, SA(0),
109: SA(0), 0, &newrt)) ||
110: ((rt->rt_flags & RTF_XRESOLVE)
111: && (msgtype = RTM_RESOLVE))) /* intended! */
112: goto miss;
113: } else
114: rt->rt_refcnt++;
115: } else {
116: rtstat.rts_unreach++;
117: miss: if (report)
118: rt_missmsg(msgtype, dst, SA(0), SA(0), SA(0), 0, err);
119: }
120: splx(s);
121: return (newrt);
122: }
123:
124: rtfree(rt)
125: register struct rtentry *rt;
126: {
127: register struct ifaddr *ifa;
128: if (rt == 0)
129: panic("rtfree");
130: rt->rt_refcnt--;
131: if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
132: rttrash--;
133: if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
134: panic ("rtfree 2");
135: free((caddr_t)rt, M_RTABLE);
136: }
137: }
138:
139: /*
140: * Force a routing table entry to the specified
141: * destination to go through the given gateway.
142: * Normally called as a result of a routing redirect
143: * message from the network layer.
144: *
145: * N.B.: must be called at splnet
146: *
147: */
148: rtredirect(dst, gateway, netmask, flags, src, rtp)
149: struct sockaddr *dst, *gateway, *netmask, *src;
150: int flags;
151: struct rtentry **rtp;
152: {
153: register struct rtentry *rt;
154: int error = 0;
155: short *stat = 0;
156:
157: /* verify the gateway is directly reachable */
158: if (ifa_ifwithnet(gateway) == 0) {
159: error = ENETUNREACH;
160: goto done;
161: }
162: rt = rtalloc1(dst, 0);
163: /*
164: * If the redirect isn't from our current router for this dst,
165: * it's either old or wrong. If it redirects us to ourselves,
166: * we have a routing loop, perhaps as a result of an interface
167: * going down recently.
168: */
169: #define equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
170: if (!(flags & RTF_DONE) && rt && !equal(src, rt->rt_gateway))
171: error = EINVAL;
172: else if (ifa_ifwithaddr(gateway))
173: error = EHOSTUNREACH;
174: if (error)
175: goto done;
176: /*
177: * Create a new entry if we just got back a wildcard entry
178: * or the the lookup failed. This is necessary for hosts
179: * which use routing redirects generated by smart gateways
180: * to dynamically build the routing tables.
181: */
182: if ((rt == 0) || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
183: goto create;
184: /*
185: * Don't listen to the redirect if it's
186: * for a route to an interface.
187: */
188: if (rt->rt_flags & RTF_GATEWAY) {
189: if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
190: /*
191: * Changing from route to net => route to host.
192: * Create new route, rather than smashing route to net.
193: */
194: create:
195: flags |= RTF_GATEWAY | RTF_DYNAMIC;
196: error = rtrequest((int)RTM_ADD, dst, gateway,
197: SA(0), flags,
198: (struct rtentry **)0);
199: stat = &rtstat.rts_dynamic;
200: } else {
201: /*
202: * Smash the current notion of the gateway to
203: * this destination. Should check about netmask!!!
204: */
205: if (gateway->sa_len <= rt->rt_gateway->sa_len) {
206: Bcopy(gateway, rt->rt_gateway, gateway->sa_len);
207: rt->rt_flags |= RTF_MODIFIED;
208: flags |= RTF_MODIFIED;
209: stat = &rtstat.rts_newgateway;
210: } else
211: error = ENOSPC;
212: }
213: } else
214: error = EHOSTUNREACH;
215: done:
216: if (rt) {
217: if (rtp && !error)
218: *rtp = rt;
219: else
220: rtfree(rt);
221: }
222: if (error)
223: rtstat.rts_badredirect++;
224: else
225: (stat && (*stat)++);
226: rt_missmsg(RTM_REDIRECT, dst, gateway, netmask, src, flags, error);
227: }
228:
229: /*
230: * Routing table ioctl interface.
231: */
232: rtioctl(req, data, p)
233: int req;
234: caddr_t data;
235: struct proc *p;
236: {
237: #ifndef COMPAT_43
238: return (EOPNOTSUPP);
239: #else
240: register struct ortentry *entry = (struct ortentry *)data;
241: int error;
242: struct sockaddr *netmask = 0;
243:
244: if (req == SIOCADDRT)
245: req = RTM_ADD;
246: else if (req == SIOCDELRT)
247: req = RTM_DELETE;
248: else
249: return (EINVAL);
250:
251: if (error = suser(p->p_ucred, &p->p_acflag))
252: return (error);
253: #if BYTE_ORDER != BIG_ENDIAN
254: if (entry->rt_dst.sa_family == 0 && entry->rt_dst.sa_len < 16) {
255: entry->rt_dst.sa_family = entry->rt_dst.sa_len;
256: entry->rt_dst.sa_len = 16;
257: }
258: if (entry->rt_gateway.sa_family == 0 && entry->rt_gateway.sa_len < 16) {
259: entry->rt_gateway.sa_family = entry->rt_gateway.sa_len;
260: entry->rt_gateway.sa_len = 16;
261: }
262: #else
263: if (entry->rt_dst.sa_len == 0)
264: entry->rt_dst.sa_len = 16;
265: if (entry->rt_gateway.sa_len == 0)
266: entry->rt_gateway.sa_len = 16;
267: #endif
268: if ((entry->rt_flags & RTF_HOST) == 0)
269: switch (entry->rt_dst.sa_family) {
270: #ifdef INET
271: case AF_INET:
272: {
273: extern struct sockaddr_in icmpmask;
274: struct sockaddr_in *dst_in =
275: (struct sockaddr_in *)&entry->rt_dst;
276:
277: in_sockmaskof(dst_in->sin_addr, &icmpmask);
278: netmask = (struct sockaddr *)&icmpmask;
279: }
280: break;
281: #endif
282: #ifdef NS
283: case AF_NS:
284: {
285: extern struct sockaddr_ns ns_netmask;
286: netmask = (struct sockaddr *)&ns_netmask;
287: }
288: #endif
289: }
290: error = rtrequest(req, &(entry->rt_dst), &(entry->rt_gateway), netmask,
291: entry->rt_flags, (struct rtentry **)0);
292: rt_missmsg((req == RTM_ADD ? RTM_OLDADD : RTM_OLDDEL),
293: &(entry->rt_dst), &(entry->rt_gateway),
294: netmask, SA(0), entry->rt_flags, error);
295: return (error);
296: #endif
297: }
298:
299: struct ifaddr *
300: ifa_ifwithroute(flags, dst, gateway)
301: int flags;
302: struct sockaddr *dst, *gateway;
303: {
304: register struct ifaddr *ifa;
305: if ((flags & RTF_GATEWAY) == 0) {
306: /*
307: * If we are adding a route to an interface,
308: * and the interface is a pt to pt link
309: * we should search for the destination
310: * as our clue to the interface. Otherwise
311: * we can use the local address.
312: */
313: ifa = 0;
314: if (flags & RTF_HOST)
315: ifa = ifa_ifwithdstaddr(dst);
316: if (ifa == 0)
317: ifa = ifa_ifwithaddr(gateway);
318: } else {
319: /*
320: * If we are adding a route to a remote net
321: * or host, the gateway may still be on the
322: * other end of a pt to pt link.
323: */
324: ifa = ifa_ifwithdstaddr(gateway);
325: }
326: if (ifa == 0)
327: ifa = ifa_ifwithnet(gateway);
328: if (ifa == 0) {
329: struct rtentry *rt = rtalloc1(dst, 0);
330: if (rt == 0)
331: return (0);
332: rt->rt_refcnt--;
333: if ((ifa = rt->rt_ifa) == 0)
334: return (0);
335: }
336: if (ifa->ifa_addr->sa_family != dst->sa_family) {
337: struct ifaddr *oifa = ifa, *ifaof_ifpforaddr();
338: ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
339: if (ifa == 0)
340: ifa = oifa;
341: }
342: return (ifa);
343: }
344:
345: #define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
346:
347: rtrequest(req, dst, gateway, netmask, flags, ret_nrt)
348: int req, flags;
349: struct sockaddr *dst, *gateway, *netmask;
350: struct rtentry **ret_nrt;
351: {
352: int s = splnet(), len, error = 0;
353: register struct rtentry *rt;
354: register struct radix_node *rn;
355: register struct radix_node_head *rnh;
356: struct ifaddr *ifa, *ifa_ifwithdstaddr();
357: struct sockaddr *ndst;
358: u_char af = dst->sa_family;
359: #define senderr(x) { error = x ; goto bad; }
360:
361: if (rtinits_done == 0)
362: rtinitheads();
363: for (rnh = radix_node_head; rnh && (af != rnh->rnh_af); )
364: rnh = rnh->rnh_next;
365: if (rnh == 0)
366: senderr(ESRCH);
367: if (flags & RTF_HOST)
368: netmask = 0;
369: switch (req) {
370: case RTM_DELETE:
371: if (ret_nrt && (rt = *ret_nrt)) {
372: RTFREE(rt);
373: *ret_nrt = 0;
374: }
375: if ((rn = rn_delete((caddr_t)dst, (caddr_t)netmask,
376: rnh->rnh_treetop)) == 0)
377: senderr(ESRCH);
378: if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
379: panic ("rtrequest delete");
380: rt = (struct rtentry *)rn;
381: rt->rt_flags &= ~RTF_UP;
382: if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
383: ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0));
384: rttrash++;
385: if (rt->rt_refcnt <= 0)
386: rtfree(rt);
387: break;
388:
389: case RTM_RESOLVE:
390: if (ret_nrt == 0 || (rt = *ret_nrt) == 0)
391: senderr(EINVAL);
392: ifa = rt->rt_ifa;
393: flags = rt->rt_flags & ~RTF_CLONING;
394: gateway = rt->rt_gateway;
395: if ((netmask = rt->rt_genmask) == 0)
396: flags |= RTF_HOST;
397: goto makeroute;
398:
399: case RTM_ADD:
400: if ((ifa = ifa_ifwithroute(flags, dst, gateway)) == 0)
401: senderr(ENETUNREACH);
402: makeroute:
403: len = sizeof (*rt) + ROUNDUP(gateway->sa_len)
404: + ROUNDUP(dst->sa_len);
405: R_Malloc(rt, struct rtentry *, len);
406: if (rt == 0)
407: senderr(ENOBUFS);
408: Bzero(rt, len);
409: ndst = (struct sockaddr *)(rt + 1);
410: if (netmask) {
411: rt_maskedcopy(dst, ndst, netmask);
412: } else
413: Bcopy(dst, ndst, dst->sa_len);
414: rn = rn_addroute((caddr_t)ndst, (caddr_t)netmask,
415: rnh->rnh_treetop, rt->rt_nodes);
416: if (rn == 0) {
417: free((caddr_t)rt, M_RTABLE);
418: senderr(EEXIST);
419: }
420: rt->rt_ifa = ifa;
421: rt->rt_ifp = ifa->ifa_ifp;
422: rt->rt_flags = RTF_UP | flags;
423: rt->rt_gateway = (struct sockaddr *)
424: (rn->rn_key + ROUNDUP(dst->sa_len));
425: Bcopy(gateway, rt->rt_gateway, gateway->sa_len);
426: if (req == RTM_RESOLVE)
427: rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
428: if (ifa->ifa_rtrequest)
429: ifa->ifa_rtrequest(req, rt, SA(ret_nrt ? *ret_nrt : 0));
430: if (ret_nrt) {
431: *ret_nrt = rt;
432: rt->rt_refcnt++;
433: }
434: break;
435: }
436: bad:
437: splx(s);
438: return (error);
439: }
440:
441: rt_maskedcopy(src, dst, netmask)
442: struct sockaddr *src, *dst, *netmask;
443: {
444: register u_char *cp1 = (u_char *)src;
445: register u_char *cp2 = (u_char *)dst;
446: register u_char *cp3 = (u_char *)netmask;
447: u_char *cplim = cp2 + *cp3;
448: u_char *cplim2 = cp2 + *cp1;
449:
450: *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
451: cp3 += 2;
452: if (cplim > cplim2)
453: cplim = cplim2;
454: while (cp2 < cplim)
455: *cp2++ = *cp1++ & *cp3++;
456: if (cp2 < cplim2)
457: bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
458: }
459: /*
460: * Set up a routing table entry, normally
461: * for an interface.
462: */
463: rtinit(ifa, cmd, flags)
464: register struct ifaddr *ifa;
465: int cmd, flags;
466: {
467: register struct rtentry *rt;
468: register struct sockaddr *dst;
469: register struct sockaddr *deldst;
470: struct mbuf *m = 0;
471: int error;
472:
473: dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
474: if (ifa->ifa_flags & IFA_ROUTE) {
475: if ((rt = ifa->ifa_rt) && (rt->rt_flags & RTF_UP) == 0) {
476: RTFREE(rt);
477: ifa->ifa_rt = 0;
478: }
479: }
480: if (cmd == RTM_DELETE) {
481: if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
482: m = m_get(M_WAIT, MT_SONAME);
483: deldst = mtod(m, struct sockaddr *);
484: rt_maskedcopy(dst, deldst, ifa->ifa_netmask);
485: dst = deldst;
486: }
487: if (rt = rtalloc1(dst, 0)) {
488: rt->rt_refcnt--;
489: if (rt->rt_ifa != ifa) {
490: if (m)
491: (void) m_free(m);
492: return (flags & RTF_HOST ? EHOSTUNREACH
493: : ENETUNREACH);
494: }
495: }
496: }
497: error = rtrequest(cmd, dst, ifa->ifa_addr, ifa->ifa_netmask,
498: flags | ifa->ifa_flags, &ifa->ifa_rt);
499: if (m)
500: (void) m_free(m);
501: if (cmd == RTM_ADD && error == 0 && (rt = ifa->ifa_rt)
502: && rt->rt_ifa != ifa) {
503: rt->rt_ifa = ifa;
504: rt->rt_ifp = ifa->ifa_ifp;
505: }
506: return (error);
507: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.