Annotation of sys/net/route.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: route.c,v 1.84 2007/06/14 18:31:49 reyk Exp $ */
! 2: /* $NetBSD: route.c,v 1.14 1996/02/13 22:00:46 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
! 6: * 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 project 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 PROJECT 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 PROJECT 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:
! 33: /*
! 34: * Copyright (c) 1980, 1986, 1991, 1993
! 35: * The Regents of the University of California. All rights reserved.
! 36: *
! 37: * Redistribution and use in source and binary forms, with or without
! 38: * modification, are permitted provided that the following conditions
! 39: * are met:
! 40: * 1. Redistributions of source code must retain the above copyright
! 41: * notice, this list of conditions and the following disclaimer.
! 42: * 2. Redistributions in binary form must reproduce the above copyright
! 43: * notice, this list of conditions and the following disclaimer in the
! 44: * documentation and/or other materials provided with the distribution.
! 45: * 3. Neither the name of the University nor the names of its contributors
! 46: * may be used to endorse or promote products derived from this software
! 47: * without specific prior written permission.
! 48: *
! 49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 59: * SUCH DAMAGE.
! 60: *
! 61: * @(#)route.c 8.2 (Berkeley) 11/15/93
! 62: */
! 63:
! 64: /*
! 65: * @(#)COPYRIGHT 1.1 (NRL) 17 January 1995
! 66: *
! 67: * NRL grants permission for redistribution and use in source and binary
! 68: * forms, with or without modification, of the software and documentation
! 69: * created at NRL provided that the following conditions are met:
! 70: *
! 71: * 1. Redistributions of source code must retain the above copyright
! 72: * notice, this list of conditions and the following disclaimer.
! 73: * 2. Redistributions in binary form must reproduce the above copyright
! 74: * notice, this list of conditions and the following disclaimer in the
! 75: * documentation and/or other materials provided with the distribution.
! 76: * 3. All advertising materials mentioning features or use of this software
! 77: * must display the following acknowledgements:
! 78: * This product includes software developed by the University of
! 79: * California, Berkeley and its contributors.
! 80: * This product includes software developed at the Information
! 81: * Technology Division, US Naval Research Laboratory.
! 82: * 4. Neither the name of the NRL nor the names of its contributors
! 83: * may be used to endorse or promote products derived from this software
! 84: * without specific prior written permission.
! 85: *
! 86: * THE SOFTWARE PROVIDED BY NRL IS PROVIDED BY NRL AND CONTRIBUTORS ``AS
! 87: * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 88: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
! 89: * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NRL OR
! 90: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
! 91: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 92: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
! 93: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
! 94: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
! 95: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
! 96: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 97: *
! 98: * The views and conclusions contained in the software and documentation
! 99: * are those of the authors and should not be interpreted as representing
! 100: * official policies, either expressed or implied, of the US Naval
! 101: * Research Laboratory (NRL).
! 102: */
! 103:
! 104: #include <sys/param.h>
! 105: #include <sys/systm.h>
! 106: #include <sys/proc.h>
! 107: #include <sys/mbuf.h>
! 108: #include <sys/socket.h>
! 109: #include <sys/socketvar.h>
! 110: #include <sys/domain.h>
! 111: #include <sys/protosw.h>
! 112: #include <sys/ioctl.h>
! 113: #include <sys/kernel.h>
! 114: #include <sys/queue.h>
! 115: #include <sys/pool.h>
! 116:
! 117: #include <net/if.h>
! 118: #include <net/route.h>
! 119: #include <net/raw_cb.h>
! 120:
! 121: #include <netinet/in.h>
! 122: #include <netinet/in_var.h>
! 123:
! 124: #ifdef IPSEC
! 125: #include <netinet/ip_ipsp.h>
! 126:
! 127: extern struct ifnet encif;
! 128: struct ifaddr *encap_findgwifa(struct sockaddr *);
! 129: #endif
! 130:
! 131: #define SA(p) ((struct sockaddr *)(p))
! 132:
! 133: struct route_cb route_cb;
! 134: struct rtstat rtstat;
! 135: struct radix_node_head ***rt_tables;
! 136: u_int8_t af2rtafidx[AF_MAX+1];
! 137: u_int8_t rtafidx_max;
! 138: u_int rtbl_id_max = 0;
! 139:
! 140: int rttrash; /* routes not in table but not freed */
! 141:
! 142: struct pool rtentry_pool; /* pool for rtentry structures */
! 143: struct pool rttimer_pool; /* pool for rttimer structures */
! 144:
! 145: int rtable_init(struct radix_node_head ***);
! 146: int okaytoclone(u_int, int);
! 147: int rtdeletemsg(struct rtentry *, u_int);
! 148: int rtflushclone1(struct radix_node *, void *);
! 149: void rtflushclone(struct radix_node_head *, struct rtentry *);
! 150: int rt_if_remove_rtdelete(struct radix_node *, void *);
! 151:
! 152: #define LABELID_MAX 50000
! 153:
! 154: struct rt_label {
! 155: TAILQ_ENTRY(rt_label) rtl_entry;
! 156: char rtl_name[RTLABEL_LEN];
! 157: u_int16_t rtl_id;
! 158: int rtl_ref;
! 159: };
! 160:
! 161: TAILQ_HEAD(rt_labels, rt_label) rt_labels = TAILQ_HEAD_INITIALIZER(rt_labels);
! 162:
! 163: #ifdef IPSEC
! 164: struct ifaddr *
! 165: encap_findgwifa(struct sockaddr *gw)
! 166: {
! 167: return (TAILQ_FIRST(&encif.if_addrlist));
! 168: }
! 169: #endif
! 170:
! 171: int
! 172: rtable_init(struct radix_node_head ***table)
! 173: {
! 174: void **p;
! 175: struct domain *dom;
! 176:
! 177: if ((p = malloc(sizeof(void *) * (rtafidx_max + 1), M_RTABLE,
! 178: M_NOWAIT)) == NULL)
! 179: return (-1);
! 180: bzero(p, sizeof(void *) * (rtafidx_max + 1));
! 181:
! 182: /* 2nd pass: attach */
! 183: for (dom = domains; dom != NULL; dom = dom->dom_next)
! 184: if (dom->dom_rtattach)
! 185: dom->dom_rtattach(&p[af2rtafidx[dom->dom_family]],
! 186: dom->dom_rtoffset);
! 187:
! 188: *table = (struct radix_node_head **)p;
! 189: return (0);
! 190: }
! 191:
! 192: void
! 193: route_init()
! 194: {
! 195: struct domain *dom;
! 196:
! 197: pool_init(&rtentry_pool, sizeof(struct rtentry), 0, 0, 0, "rtentpl",
! 198: NULL);
! 199: rn_init(); /* initialize all zeroes, all ones, mask table */
! 200:
! 201: bzero(af2rtafidx, sizeof(af2rtafidx));
! 202: rtafidx_max = 1; /* must have NULL at index 0, so start at 1 */
! 203:
! 204: /* find out how many tables to allocate */
! 205: for (dom = domains; dom != NULL; dom = dom->dom_next)
! 206: if (dom->dom_rtattach)
! 207: af2rtafidx[dom->dom_family] = rtafidx_max++;
! 208:
! 209: if (rtable_add(0) == -1)
! 210: panic("route_init rtable_add");
! 211: }
! 212:
! 213: int
! 214: rtable_add(u_int id) /* must be called at splsoftnet */
! 215: {
! 216: void *p;
! 217:
! 218: if (id > RT_TABLEID_MAX)
! 219: return (-1);
! 220:
! 221: if (id == 0 || id > rtbl_id_max) {
! 222: size_t newlen = sizeof(void *) * (id+1);
! 223:
! 224: if ((p = malloc(newlen, M_RTABLE, M_NOWAIT)) == NULL)
! 225: return (-1);
! 226: bzero(p, newlen);
! 227: if (id > 0) {
! 228: bcopy(rt_tables, p, sizeof(void *) * (rtbl_id_max+1));
! 229: free(rt_tables, M_RTABLE);
! 230: }
! 231: rt_tables = p;
! 232: rtbl_id_max = id;
! 233: }
! 234:
! 235: if (rt_tables[id] != NULL) /* already exists */
! 236: return (-1);
! 237:
! 238: return (rtable_init(&rt_tables[id]));
! 239: }
! 240:
! 241: int
! 242: rtable_exists(u_int id) /* verify table with that ID exists */
! 243: {
! 244: if (id > RT_TABLEID_MAX)
! 245: return (0);
! 246:
! 247: if (id > rtbl_id_max)
! 248: return (0);
! 249:
! 250: if (rt_tables[id] == NULL) /* should not happen */
! 251: return (0);
! 252:
! 253: return (1);
! 254: }
! 255:
! 256: #include "pf.h"
! 257: #if NPF > 0
! 258: void
! 259: rtalloc_noclone(struct route *ro, int howstrict)
! 260: {
! 261: if (ro->ro_rt && ro->ro_rt->rt_ifp && (ro->ro_rt->rt_flags & RTF_UP))
! 262: return; /* XXX */
! 263: ro->ro_rt = rtalloc2(&ro->ro_dst, 1, howstrict);
! 264: }
! 265:
! 266: int
! 267: okaytoclone(u_int flags, int howstrict)
! 268: {
! 269: if (howstrict == ALL_CLONING)
! 270: return (1);
! 271: if (howstrict == ONNET_CLONING && !(flags & RTF_GATEWAY))
! 272: return (1);
! 273: return (0);
! 274: }
! 275:
! 276: struct rtentry *
! 277: rtalloc2(struct sockaddr *dst, int report, int howstrict)
! 278: {
! 279: struct radix_node_head *rnh;
! 280: struct rtentry *rt;
! 281: struct radix_node *rn;
! 282: struct rtentry *newrt = 0;
! 283: struct rt_addrinfo info;
! 284: int s = splnet(), err = 0, msgtype = RTM_MISS;
! 285:
! 286: rnh = rt_gettable(dst->sa_family, 0);
! 287: if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
! 288: ((rn->rn_flags & RNF_ROOT) == 0)) {
! 289: newrt = rt = (struct rtentry *)rn;
! 290: if (report && (rt->rt_flags & RTF_CLONING) &&
! 291: okaytoclone(rt->rt_flags, howstrict)) {
! 292: err = rtrequest(RTM_RESOLVE, dst, SA(0), SA(0), 0,
! 293: &newrt, 0);
! 294: if (err) {
! 295: newrt = rt;
! 296: rt->rt_refcnt++;
! 297: goto miss;
! 298: }
! 299: if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
! 300: msgtype = RTM_RESOLVE;
! 301: goto miss;
! 302: }
! 303: } else
! 304: rt->rt_refcnt++;
! 305: } else {
! 306: rtstat.rts_unreach++;
! 307: miss:
! 308: if (report) {
! 309: bzero((caddr_t)&info, sizeof(info));
! 310: info.rti_info[RTAX_DST] = dst;
! 311: rt_missmsg(msgtype, &info, 0, NULL, err, 0);
! 312: }
! 313: }
! 314: splx(s);
! 315: return (newrt);
! 316: }
! 317: #endif /* NPF > 0 */
! 318:
! 319: /*
! 320: * Packet routing routines.
! 321: */
! 322: void
! 323: rtalloc(struct route *ro)
! 324: {
! 325: if (ro->ro_rt && ro->ro_rt->rt_ifp && (ro->ro_rt->rt_flags & RTF_UP))
! 326: return; /* XXX */
! 327: ro->ro_rt = rtalloc1(&ro->ro_dst, 1, 0);
! 328: }
! 329:
! 330: struct rtentry *
! 331: rtalloc1(struct sockaddr *dst, int report, u_int tableid)
! 332: {
! 333: struct radix_node_head *rnh;
! 334: struct rtentry *rt;
! 335: struct radix_node *rn;
! 336: struct rtentry *newrt = 0;
! 337: struct rt_addrinfo info;
! 338: int s = splsoftnet(), err = 0, msgtype = RTM_MISS;
! 339:
! 340: rnh = rt_gettable(dst->sa_family, tableid);
! 341: if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
! 342: ((rn->rn_flags & RNF_ROOT) == 0)) {
! 343: newrt = rt = (struct rtentry *)rn;
! 344: if (report && (rt->rt_flags & RTF_CLONING)) {
! 345: err = rtrequest(RTM_RESOLVE, dst, SA(NULL),
! 346: SA(NULL), 0, &newrt, tableid);
! 347: if (err) {
! 348: newrt = rt;
! 349: rt->rt_refcnt++;
! 350: goto miss;
! 351: }
! 352: if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
! 353: msgtype = RTM_RESOLVE;
! 354: goto miss;
! 355: }
! 356: /* Inform listeners of the new route */
! 357: bzero(&info, sizeof(info));
! 358: info.rti_info[RTAX_DST] = rt_key(rt);
! 359: info.rti_info[RTAX_NETMASK] = rt_mask(rt);
! 360: info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
! 361: if (rt->rt_ifp != NULL) {
! 362: info.rti_info[RTAX_IFP] =
! 363: TAILQ_FIRST(&rt->rt_ifp->if_addrlist)->ifa_addr;
! 364: info.rti_info[RTAX_IFA] = rt->rt_ifa->ifa_addr;
! 365: }
! 366: rt_missmsg(RTM_ADD, &info, rt->rt_flags,
! 367: rt->rt_ifp, 0, tableid);
! 368: } else
! 369: rt->rt_refcnt++;
! 370: } else {
! 371: if (dst->sa_family != PF_KEY)
! 372: rtstat.rts_unreach++;
! 373: /*
! 374: * IP encapsulation does lots of lookups where we don't need nor want
! 375: * the RTM_MISSes that would be generated. It causes RTM_MISS storms
! 376: * sent upward breaking user-level routing queries.
! 377: */
! 378: miss:
! 379: if (report && dst->sa_family != PF_KEY) {
! 380: bzero((caddr_t)&info, sizeof(info));
! 381: info.rti_info[RTAX_DST] = dst;
! 382: rt_missmsg(msgtype, &info, 0, NULL, err, tableid);
! 383: }
! 384: }
! 385: splx(s);
! 386: return (newrt);
! 387: }
! 388:
! 389: void
! 390: rtfree(struct rtentry *rt)
! 391: {
! 392: struct ifaddr *ifa;
! 393:
! 394: if (rt == NULL)
! 395: panic("rtfree");
! 396:
! 397: rt->rt_refcnt--;
! 398:
! 399: if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
! 400: if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
! 401: panic("rtfree 2");
! 402: rttrash--;
! 403: if (rt->rt_refcnt < 0) {
! 404: printf("rtfree: %p not freed (neg refs)\n", rt);
! 405: return;
! 406: }
! 407: rt_timer_remove_all(rt);
! 408: ifa = rt->rt_ifa;
! 409: if (ifa)
! 410: IFAFREE(ifa);
! 411: rtlabel_unref(rt->rt_labelid);
! 412: Free(rt_key(rt));
! 413: pool_put(&rtentry_pool, rt);
! 414: }
! 415: }
! 416:
! 417: void
! 418: ifafree(struct ifaddr *ifa)
! 419: {
! 420: if (ifa == NULL)
! 421: panic("ifafree");
! 422: if (ifa->ifa_refcnt == 0)
! 423: free(ifa, M_IFADDR);
! 424: else
! 425: ifa->ifa_refcnt--;
! 426: }
! 427:
! 428: /*
! 429: * Force a routing table entry to the specified
! 430: * destination to go through the given gateway.
! 431: * Normally called as a result of a routing redirect
! 432: * message from the network layer.
! 433: *
! 434: * N.B.: must be called at splsoftnet
! 435: */
! 436: void
! 437: rtredirect(struct sockaddr *dst, struct sockaddr *gateway,
! 438: struct sockaddr *netmask, int flags, struct sockaddr *src,
! 439: struct rtentry **rtp)
! 440: {
! 441: struct rtentry *rt;
! 442: int error = 0;
! 443: u_int32_t *stat = NULL;
! 444: struct rt_addrinfo info;
! 445: struct ifaddr *ifa;
! 446: struct ifnet *ifp = NULL;
! 447:
! 448: splassert(IPL_SOFTNET);
! 449:
! 450: /* verify the gateway is directly reachable */
! 451: if ((ifa = ifa_ifwithnet(gateway)) == NULL) {
! 452: error = ENETUNREACH;
! 453: goto out;
! 454: }
! 455: ifp = ifa->ifa_ifp;
! 456: rt = rtalloc1(dst, 0, 0);
! 457: /*
! 458: * If the redirect isn't from our current router for this dst,
! 459: * it's either old or wrong. If it redirects us to ourselves,
! 460: * we have a routing loop, perhaps as a result of an interface
! 461: * going down recently.
! 462: */
! 463: #define equal(a1, a2) \
! 464: ((a1)->sa_len == (a2)->sa_len && \
! 465: bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
! 466: if (!(flags & RTF_DONE) && rt &&
! 467: (!equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
! 468: error = EINVAL;
! 469: else if (ifa_ifwithaddr(gateway) != NULL)
! 470: error = EHOSTUNREACH;
! 471: if (error)
! 472: goto done;
! 473: /*
! 474: * Create a new entry if we just got back a wildcard entry
! 475: * or the lookup failed. This is necessary for hosts
! 476: * which use routing redirects generated by smart gateways
! 477: * to dynamically build the routing tables.
! 478: */
! 479: if ((rt == NULL) || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
! 480: goto create;
! 481: /*
! 482: * Don't listen to the redirect if it's
! 483: * for a route to an interface.
! 484: */
! 485: if (rt->rt_flags & RTF_GATEWAY) {
! 486: if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
! 487: /*
! 488: * Changing from route to net => route to host.
! 489: * Create new route, rather than smashing route to net.
! 490: */
! 491: create:
! 492: if (rt)
! 493: rtfree(rt);
! 494: flags |= RTF_GATEWAY | RTF_DYNAMIC;
! 495: bzero(&info, sizeof(info));
! 496: info.rti_info[RTAX_DST] = dst;
! 497: info.rti_info[RTAX_GATEWAY] = gateway;
! 498: info.rti_info[RTAX_NETMASK] = netmask;
! 499: info.rti_ifa = ifa;
! 500: info.rti_flags = flags;
! 501: rt = NULL;
! 502: error = rtrequest1(RTM_ADD, &info, &rt, 0);
! 503: if (rt != NULL)
! 504: flags = rt->rt_flags;
! 505: stat = &rtstat.rts_dynamic;
! 506: } else {
! 507: /*
! 508: * Smash the current notion of the gateway to
! 509: * this destination. Should check about netmask!!!
! 510: */
! 511: rt->rt_flags |= RTF_MODIFIED;
! 512: flags |= RTF_MODIFIED;
! 513: stat = &rtstat.rts_newgateway;
! 514: rt_setgate(rt, rt_key(rt), gateway, 0);
! 515: }
! 516: } else
! 517: error = EHOSTUNREACH;
! 518: done:
! 519: if (rt) {
! 520: if (rtp && !error)
! 521: *rtp = rt;
! 522: else
! 523: rtfree(rt);
! 524: }
! 525: out:
! 526: if (error)
! 527: rtstat.rts_badredirect++;
! 528: else if (stat != NULL)
! 529: (*stat)++;
! 530: bzero((caddr_t)&info, sizeof(info));
! 531: info.rti_info[RTAX_DST] = dst;
! 532: info.rti_info[RTAX_GATEWAY] = gateway;
! 533: info.rti_info[RTAX_NETMASK] = netmask;
! 534: info.rti_info[RTAX_AUTHOR] = src;
! 535: rt_missmsg(RTM_REDIRECT, &info, flags, ifp, error, 0);
! 536: }
! 537:
! 538: /*
! 539: * Delete a route and generate a message
! 540: */
! 541: int
! 542: rtdeletemsg(struct rtentry *rt, u_int tableid)
! 543: {
! 544: int error;
! 545: struct rt_addrinfo info;
! 546: struct ifnet *ifp;
! 547:
! 548: /*
! 549: * Request the new route so that the entry is not actually
! 550: * deleted. That will allow the information being reported to
! 551: * be accurate (and consistent with route_output()).
! 552: */
! 553: bzero((caddr_t)&info, sizeof(info));
! 554: info.rti_info[RTAX_DST] = rt_key(rt);
! 555: info.rti_info[RTAX_NETMASK] = rt_mask(rt);
! 556: info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
! 557: info.rti_flags = rt->rt_flags;
! 558: ifp = rt->rt_ifp;
! 559: error = rtrequest1(RTM_DELETE, &info, &rt, tableid);
! 560:
! 561: rt_missmsg(RTM_DELETE, &info, info.rti_flags, ifp, error, tableid);
! 562:
! 563: /* Adjust the refcount */
! 564: if (error == 0 && rt->rt_refcnt <= 0) {
! 565: rt->rt_refcnt++;
! 566: rtfree(rt);
! 567: }
! 568: return (error);
! 569: }
! 570:
! 571: int
! 572: rtflushclone1(struct radix_node *rn, void *arg)
! 573: {
! 574: struct rtentry *rt, *parent;
! 575:
! 576: rt = (struct rtentry *)rn;
! 577: parent = (struct rtentry *)arg;
! 578: if ((rt->rt_flags & RTF_CLONED) != 0 && rt->rt_parent == parent)
! 579: rtdeletemsg(rt, 0);
! 580: return 0;
! 581: }
! 582:
! 583: void
! 584: rtflushclone(struct radix_node_head *rnh, struct rtentry *parent)
! 585: {
! 586:
! 587: #ifdef DIAGNOSTIC
! 588: if (!parent || (parent->rt_flags & RTF_CLONING) == 0)
! 589: panic("rtflushclone: called with a non-cloning route");
! 590: if (!rnh->rnh_walktree)
! 591: panic("rtflushclone: no rnh_walktree");
! 592: #endif
! 593: rnh->rnh_walktree(rnh, rtflushclone1, (void *)parent);
! 594: }
! 595:
! 596: int
! 597: rtioctl(u_long req, caddr_t data, struct proc *p)
! 598: {
! 599: return (EOPNOTSUPP);
! 600: }
! 601:
! 602: struct ifaddr *
! 603: ifa_ifwithroute(int flags, struct sockaddr *dst, struct sockaddr *gateway)
! 604: {
! 605: struct ifaddr *ifa;
! 606:
! 607: #ifdef IPSEC
! 608: /*
! 609: * If the destination is a PF_KEY address, we'll look
! 610: * for the existence of a encap interface number or address
! 611: * in the options list of the gateway. By default, we'll return
! 612: * enc0.
! 613: */
! 614: if (dst && (dst->sa_family == PF_KEY))
! 615: return (encap_findgwifa(gateway));
! 616: #endif
! 617:
! 618: if ((flags & RTF_GATEWAY) == 0) {
! 619: /*
! 620: * If we are adding a route to an interface,
! 621: * and the interface is a pt to pt link
! 622: * we should search for the destination
! 623: * as our clue to the interface. Otherwise
! 624: * we can use the local address.
! 625: */
! 626: ifa = NULL;
! 627: if (flags & RTF_HOST)
! 628: ifa = ifa_ifwithdstaddr(dst);
! 629: if (ifa == NULL)
! 630: ifa = ifa_ifwithaddr(gateway);
! 631: } else {
! 632: /*
! 633: * If we are adding a route to a remote net
! 634: * or host, the gateway may still be on the
! 635: * other end of a pt to pt link.
! 636: */
! 637: ifa = ifa_ifwithdstaddr(gateway);
! 638: }
! 639: if (ifa == NULL)
! 640: ifa = ifa_ifwithnet(gateway);
! 641: if (ifa == NULL) {
! 642: struct rtentry *rt = rtalloc1(gateway, 0, 0);
! 643: if (rt == NULL)
! 644: return (NULL);
! 645: rt->rt_refcnt--;
! 646: /* The gateway must be local if the same address family. */
! 647: if ((rt->rt_flags & RTF_GATEWAY) &&
! 648: rt_key(rt)->sa_family == dst->sa_family)
! 649: return (0);
! 650: if ((ifa = rt->rt_ifa) == NULL)
! 651: return (NULL);
! 652: }
! 653: if (ifa->ifa_addr->sa_family != dst->sa_family) {
! 654: struct ifaddr *oifa = ifa;
! 655: ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
! 656: if (ifa == NULL)
! 657: ifa = oifa;
! 658: }
! 659: return (ifa);
! 660: }
! 661:
! 662: #define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
! 663:
! 664: int
! 665: rtrequest(int req, struct sockaddr *dst, struct sockaddr *gateway,
! 666: struct sockaddr *netmask, int flags, struct rtentry **ret_nrt,
! 667: u_int tableid)
! 668: {
! 669: struct rt_addrinfo info;
! 670:
! 671: bzero(&info, sizeof(info));
! 672: info.rti_flags = flags;
! 673: info.rti_info[RTAX_DST] = dst;
! 674: info.rti_info[RTAX_GATEWAY] = gateway;
! 675: info.rti_info[RTAX_NETMASK] = netmask;
! 676: return (rtrequest1(req, &info, ret_nrt, tableid));
! 677: }
! 678:
! 679: int
! 680: rt_getifa(struct rt_addrinfo *info)
! 681: {
! 682: struct ifaddr *ifa;
! 683: int error = 0;
! 684:
! 685: /*
! 686: * ifp may be specified by sockaddr_dl when protocol address
! 687: * is ambiguous
! 688: */
! 689: if (info->rti_ifp == NULL && info->rti_info[RTAX_IFP] != NULL
! 690: && info->rti_info[RTAX_IFP]->sa_family == AF_LINK &&
! 691: (ifa = ifa_ifwithnet((struct sockaddr *)info->rti_info[RTAX_IFP]))
! 692: != NULL)
! 693: info->rti_ifp = ifa->ifa_ifp;
! 694:
! 695: if (info->rti_ifa == NULL && info->rti_info[RTAX_IFA] != NULL)
! 696: info->rti_ifa = ifa_ifwithaddr(info->rti_info[RTAX_IFA]);
! 697:
! 698: if (info->rti_ifa == NULL) {
! 699: struct sockaddr *sa;
! 700:
! 701: if ((sa = info->rti_info[RTAX_IFA]) == NULL)
! 702: if ((sa = info->rti_info[RTAX_GATEWAY]) == NULL)
! 703: sa = info->rti_info[RTAX_DST];
! 704:
! 705: if (sa != NULL && info->rti_ifp != NULL)
! 706: info->rti_ifa = ifaof_ifpforaddr(sa, info->rti_ifp);
! 707: else if (info->rti_info[RTAX_DST] != NULL &&
! 708: info->rti_info[RTAX_GATEWAY] != NULL)
! 709: info->rti_ifa = ifa_ifwithroute(info->rti_flags,
! 710: info->rti_info[RTAX_DST],
! 711: info->rti_info[RTAX_GATEWAY]);
! 712: else if (sa != NULL)
! 713: info->rti_ifa = ifa_ifwithroute(info->rti_flags,
! 714: sa, sa);
! 715: }
! 716: if ((ifa = info->rti_ifa) != NULL) {
! 717: if (info->rti_ifp == NULL)
! 718: info->rti_ifp = ifa->ifa_ifp;
! 719: } else
! 720: error = ENETUNREACH;
! 721: return (error);
! 722: }
! 723:
! 724: int
! 725: rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt,
! 726: u_int tableid)
! 727: {
! 728: int s = splsoftnet(); int error = 0;
! 729: struct rtentry *rt, *crt;
! 730: struct radix_node *rn;
! 731: struct radix_node_head *rnh;
! 732: struct ifaddr *ifa;
! 733: struct sockaddr *ndst;
! 734: struct sockaddr_rtlabel *sa_rl;
! 735: #define senderr(x) { error = x ; goto bad; }
! 736:
! 737: if ((rnh = rt_gettable(info->rti_info[RTAX_DST]->sa_family, tableid)) ==
! 738: NULL)
! 739: senderr(EAFNOSUPPORT);
! 740: if (info->rti_flags & RTF_HOST)
! 741: info->rti_info[RTAX_NETMASK] = NULL;
! 742: switch (req) {
! 743: case RTM_DELETE:
! 744: if ((rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
! 745: info->rti_info[RTAX_NETMASK], rnh)) == NULL)
! 746: senderr(ESRCH);
! 747: rt = (struct rtentry *)rn;
! 748: #ifndef SMALL_KERNEL
! 749: /*
! 750: * if we got multipath routes, we require users to specify
! 751: * a matching RTAX_GATEWAY.
! 752: */
! 753: if (rn_mpath_capable(rnh)) {
! 754: rt = rt_mpath_matchgate(rt,
! 755: info->rti_info[RTAX_GATEWAY]);
! 756: rn = (struct radix_node *)rt;
! 757: if (!rt)
! 758: senderr(ESRCH);
! 759: }
! 760: #endif
! 761: if ((rn = rnh->rnh_deladdr(info->rti_info[RTAX_DST],
! 762: info->rti_info[RTAX_NETMASK], rnh, rn)) == NULL)
! 763: senderr(ESRCH);
! 764: rt = (struct rtentry *)rn;
! 765:
! 766: /* clean up any cloned children */
! 767: if ((rt->rt_flags & RTF_CLONING) != 0)
! 768: rtflushclone(rnh, rt);
! 769:
! 770: if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
! 771: panic ("rtrequest delete");
! 772:
! 773: if (rt->rt_gwroute) {
! 774: rt = rt->rt_gwroute; RTFREE(rt);
! 775: (rt = (struct rtentry *)rn)->rt_gwroute = NULL;
! 776: }
! 777:
! 778: if (rt->rt_parent) {
! 779: rt->rt_parent->rt_refcnt--;
! 780: rt->rt_parent = NULL;
! 781: }
! 782:
! 783: #ifndef SMALL_KERNEL
! 784: if (rn_mpath_capable(rnh)) {
! 785: if ((rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
! 786: info->rti_info[RTAX_NETMASK], rnh)) != NULL &&
! 787: rn_mpath_next(rn) == NULL)
! 788: ((struct rtentry *)rn)->rt_flags &= ~RTF_MPATH;
! 789: }
! 790: #endif
! 791:
! 792: rt->rt_flags &= ~RTF_UP;
! 793: if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
! 794: ifa->ifa_rtrequest(RTM_DELETE, rt, info);
! 795: rttrash++;
! 796:
! 797: if (ret_nrt)
! 798: *ret_nrt = rt;
! 799: else if (rt->rt_refcnt <= 0) {
! 800: rt->rt_refcnt++;
! 801: rtfree(rt);
! 802: }
! 803: break;
! 804:
! 805: case RTM_RESOLVE:
! 806: if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
! 807: senderr(EINVAL);
! 808: if ((rt->rt_flags & RTF_CLONING) == 0)
! 809: senderr(EINVAL);
! 810: ifa = rt->rt_ifa;
! 811: info->rti_flags = rt->rt_flags & ~(RTF_CLONING | RTF_STATIC);
! 812: info->rti_flags |= RTF_CLONED;
! 813: info->rti_info[RTAX_GATEWAY] = rt->rt_gateway;
! 814: if ((info->rti_info[RTAX_NETMASK] = rt->rt_genmask) == NULL)
! 815: info->rti_flags |= RTF_HOST;
! 816: goto makeroute;
! 817:
! 818: case RTM_ADD:
! 819: if (info->rti_ifa == 0 && (error = rt_getifa(info)))
! 820: senderr(error);
! 821: ifa = info->rti_ifa;
! 822: makeroute:
! 823: rt = pool_get(&rtentry_pool, PR_NOWAIT);
! 824: if (rt == NULL)
! 825: senderr(ENOBUFS);
! 826: Bzero(rt, sizeof(*rt));
! 827: rt->rt_flags = RTF_UP | info->rti_flags;
! 828: LIST_INIT(&rt->rt_timer);
! 829: if (rt_setgate(rt, info->rti_info[RTAX_DST],
! 830: info->rti_info[RTAX_GATEWAY], tableid)) {
! 831: pool_put(&rtentry_pool, rt);
! 832: senderr(ENOBUFS);
! 833: }
! 834: ndst = rt_key(rt);
! 835: if (info->rti_info[RTAX_NETMASK] != NULL) {
! 836: rt_maskedcopy(info->rti_info[RTAX_DST], ndst,
! 837: info->rti_info[RTAX_NETMASK]);
! 838: } else
! 839: Bcopy(info->rti_info[RTAX_DST], ndst,
! 840: info->rti_info[RTAX_DST]->sa_len);
! 841: #ifndef SMALL_KERNEL
! 842: /* do not permit exactly the same dst/mask/gw pair */
! 843: if (rn_mpath_capable(rnh) &&
! 844: rt_mpath_conflict(rnh, rt, info->rti_info[RTAX_NETMASK],
! 845: info->rti_flags & RTF_MPATH)) {
! 846: if (rt->rt_gwroute)
! 847: rtfree(rt->rt_gwroute);
! 848: Free(rt_key(rt));
! 849: pool_put(&rtentry_pool, rt);
! 850: senderr(EEXIST);
! 851: }
! 852: #endif
! 853:
! 854: if (info->rti_info[RTAX_LABEL] != NULL) {
! 855: sa_rl = (struct sockaddr_rtlabel *)
! 856: info->rti_info[RTAX_LABEL];
! 857: rt->rt_labelid = rtlabel_name2id(sa_rl->sr_label);
! 858: }
! 859:
! 860: ifa->ifa_refcnt++;
! 861: rt->rt_ifa = ifa;
! 862: rt->rt_ifp = ifa->ifa_ifp;
! 863: if (req == RTM_RESOLVE) {
! 864: /*
! 865: * Copy both metrics and a back pointer to the cloned
! 866: * route's parent.
! 867: */
! 868: rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
! 869: rt->rt_parent = *ret_nrt; /* Back ptr. to parent. */
! 870: rt->rt_parent->rt_refcnt++;
! 871: }
! 872: rn = rnh->rnh_addaddr((caddr_t)ndst,
! 873: (caddr_t)info->rti_info[RTAX_NETMASK], rnh, rt->rt_nodes);
! 874: if (rn == NULL && (crt = rtalloc1(ndst, 0, tableid)) != NULL) {
! 875: /* overwrite cloned route */
! 876: if ((crt->rt_flags & RTF_CLONED) != 0) {
! 877: rtdeletemsg(crt, tableid);
! 878: rn = rnh->rnh_addaddr((caddr_t)ndst,
! 879: (caddr_t)info->rti_info[RTAX_NETMASK],
! 880: rnh, rt->rt_nodes);
! 881: }
! 882: RTFREE(crt);
! 883: }
! 884: if (rn == 0) {
! 885: IFAFREE(ifa);
! 886: if ((rt->rt_flags & RTF_CLONED) != 0 && rt->rt_parent)
! 887: rtfree(rt->rt_parent);
! 888: if (rt->rt_gwroute)
! 889: rtfree(rt->rt_gwroute);
! 890: Free(rt_key(rt));
! 891: pool_put(&rtentry_pool, rt);
! 892: senderr(EEXIST);
! 893: }
! 894:
! 895: #ifndef SMALL_KERNEL
! 896: if (rn_mpath_capable(rnh) &&
! 897: (rn = rnh->rnh_lookup(info->rti_info[RTAX_DST],
! 898: info->rti_info[RTAX_NETMASK], rnh)) != NULL) {
! 899: if (rn_mpath_next(rn) == NULL)
! 900: ((struct rtentry *)rn)->rt_flags &= ~RTF_MPATH;
! 901: else
! 902: ((struct rtentry *)rn)->rt_flags |= RTF_MPATH;
! 903: }
! 904: #endif
! 905:
! 906: if (ifa->ifa_rtrequest)
! 907: ifa->ifa_rtrequest(req, rt, info);
! 908: if (ret_nrt) {
! 909: *ret_nrt = rt;
! 910: rt->rt_refcnt++;
! 911: }
! 912: if ((rt->rt_flags & RTF_CLONING) != 0) {
! 913: /* clean up any cloned children */
! 914: rtflushclone(rnh, rt);
! 915: }
! 916:
! 917: if_group_routechange(info->rti_info[RTAX_DST],
! 918: info->rti_info[RTAX_NETMASK]);
! 919: break;
! 920: }
! 921: bad:
! 922: splx(s);
! 923: return (error);
! 924: }
! 925:
! 926: int
! 927: rt_setgate(struct rtentry *rt0, struct sockaddr *dst, struct sockaddr *gate,
! 928: u_int tableid)
! 929: {
! 930: caddr_t new, old;
! 931: int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
! 932: struct rtentry *rt = rt0;
! 933:
! 934: if (rt->rt_gateway == NULL || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
! 935: old = (caddr_t)rt_key(rt);
! 936: R_Malloc(new, caddr_t, dlen + glen);
! 937: if (new == NULL)
! 938: return 1;
! 939: rt->rt_nodes->rn_key = new;
! 940: } else {
! 941: new = rt->rt_nodes->rn_key;
! 942: old = NULL;
! 943: }
! 944: Bcopy(gate, (rt->rt_gateway = (struct sockaddr *)(new + dlen)), glen);
! 945: if (old) {
! 946: Bcopy(dst, new, dlen);
! 947: Free(old);
! 948: }
! 949: if (rt->rt_gwroute != NULL) {
! 950: rt = rt->rt_gwroute;
! 951: RTFREE(rt);
! 952: rt = rt0;
! 953: rt->rt_gwroute = NULL;
! 954: }
! 955: if (rt->rt_flags & RTF_GATEWAY) {
! 956: rt->rt_gwroute = rtalloc1(gate, 1, tableid);
! 957: /*
! 958: * If we switched gateways, grab the MTU from the new
! 959: * gateway route if the current MTU is 0 or greater
! 960: * than the MTU of gateway.
! 961: * Note that, if the MTU of gateway is 0, we will reset the
! 962: * MTU of the route to run PMTUD again from scratch. XXX
! 963: */
! 964: if (rt->rt_gwroute && !(rt->rt_rmx.rmx_locks & RTV_MTU) &&
! 965: rt->rt_rmx.rmx_mtu &&
! 966: rt->rt_rmx.rmx_mtu > rt->rt_gwroute->rt_rmx.rmx_mtu) {
! 967: rt->rt_rmx.rmx_mtu = rt->rt_gwroute->rt_rmx.rmx_mtu;
! 968: }
! 969: }
! 970: return (0);
! 971: }
! 972:
! 973: void
! 974: rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst,
! 975: struct sockaddr *netmask)
! 976: {
! 977: u_char *cp1 = (u_char *)src;
! 978: u_char *cp2 = (u_char *)dst;
! 979: u_char *cp3 = (u_char *)netmask;
! 980: u_char *cplim = cp2 + *cp3;
! 981: u_char *cplim2 = cp2 + *cp1;
! 982:
! 983: *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
! 984: cp3 += 2;
! 985: if (cplim > cplim2)
! 986: cplim = cplim2;
! 987: while (cp2 < cplim)
! 988: *cp2++ = *cp1++ & *cp3++;
! 989: if (cp2 < cplim2)
! 990: bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
! 991: }
! 992:
! 993: /*
! 994: * Set up a routing table entry, normally
! 995: * for an interface.
! 996: */
! 997: int
! 998: rtinit(struct ifaddr *ifa, int cmd, int flags)
! 999: {
! 1000: struct rtentry *rt;
! 1001: struct sockaddr *dst, *deldst;
! 1002: struct mbuf *m = NULL;
! 1003: struct rtentry *nrt = NULL;
! 1004: int error;
! 1005: struct rt_addrinfo info;
! 1006: struct sockaddr_rtlabel sa_rl;
! 1007: const char *label;
! 1008:
! 1009: dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
! 1010: if (cmd == RTM_DELETE) {
! 1011: if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
! 1012: m = m_get(M_DONTWAIT, MT_SONAME);
! 1013: if (m == NULL)
! 1014: return (ENOBUFS);
! 1015: deldst = mtod(m, struct sockaddr *);
! 1016: rt_maskedcopy(dst, deldst, ifa->ifa_netmask);
! 1017: dst = deldst;
! 1018: }
! 1019: if ((rt = rtalloc1(dst, 0, 0)) != NULL) {
! 1020: rt->rt_refcnt--;
! 1021: if (rt->rt_ifa != ifa) {
! 1022: if (m != NULL)
! 1023: (void) m_free(m);
! 1024: return (flags & RTF_HOST ? EHOSTUNREACH
! 1025: : ENETUNREACH);
! 1026: }
! 1027: }
! 1028: }
! 1029: bzero(&info, sizeof(info));
! 1030: info.rti_ifa = ifa;
! 1031: info.rti_flags = flags | ifa->ifa_flags;
! 1032: info.rti_info[RTAX_DST] = dst;
! 1033: info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
! 1034: if (ifa->ifa_ifp->if_rtlabelid) {
! 1035: label = rtlabel_id2name(ifa->ifa_ifp->if_rtlabelid);
! 1036: bzero(&sa_rl, sizeof(sa_rl));
! 1037: sa_rl.sr_len = sizeof(sa_rl);
! 1038: sa_rl.sr_family = AF_UNSPEC;
! 1039: strlcpy(sa_rl.sr_label, label, sizeof(sa_rl.sr_label));
! 1040: info.rti_info[RTAX_LABEL] = (struct sockaddr *)&sa_rl;
! 1041: }
! 1042:
! 1043: /*
! 1044: * XXX here, it seems that we are assuming that ifa_netmask is NULL
! 1045: * for RTF_HOST. bsdi4 passes NULL explicitly (via intermediate
! 1046: * variable) when RTF_HOST is 1. still not sure if i can safely
! 1047: * change it to meet bsdi4 behavior.
! 1048: */
! 1049: info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
! 1050: error = rtrequest1(cmd, &info, &nrt, 0);
! 1051: if (cmd == RTM_DELETE && error == 0 && (rt = nrt) != NULL) {
! 1052: rt_newaddrmsg(cmd, ifa, error, nrt);
! 1053: if (rt->rt_refcnt <= 0) {
! 1054: rt->rt_refcnt++;
! 1055: rtfree(rt);
! 1056: }
! 1057: }
! 1058: if (cmd == RTM_ADD && error == 0 && (rt = nrt) != NULL) {
! 1059: rt->rt_refcnt--;
! 1060: if (rt->rt_ifa != ifa) {
! 1061: printf("rtinit: wrong ifa (%p) was (%p)\n",
! 1062: ifa, rt->rt_ifa);
! 1063: if (rt->rt_ifa->ifa_rtrequest)
! 1064: rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt, NULL);
! 1065: IFAFREE(rt->rt_ifa);
! 1066: rt->rt_ifa = ifa;
! 1067: rt->rt_ifp = ifa->ifa_ifp;
! 1068: ifa->ifa_refcnt++;
! 1069: if (ifa->ifa_rtrequest)
! 1070: ifa->ifa_rtrequest(RTM_ADD, rt, NULL);
! 1071: }
! 1072: rt_newaddrmsg(cmd, ifa, error, nrt);
! 1073: }
! 1074: return (error);
! 1075: }
! 1076:
! 1077: /*
! 1078: * Route timer routines. These routes allow functions to be called
! 1079: * for various routes at any time. This is useful in supporting
! 1080: * path MTU discovery and redirect route deletion.
! 1081: *
! 1082: * This is similar to some BSDI internal functions, but it provides
! 1083: * for multiple queues for efficiency's sake...
! 1084: */
! 1085:
! 1086: LIST_HEAD(, rttimer_queue) rttimer_queue_head;
! 1087: static int rt_init_done = 0;
! 1088:
! 1089: #define RTTIMER_CALLOUT(r) { \
! 1090: if (r->rtt_func != NULL) { \
! 1091: (*r->rtt_func)(r->rtt_rt, r); \
! 1092: } else { \
! 1093: rtrequest((int) RTM_DELETE, \
! 1094: (struct sockaddr *)rt_key(r->rtt_rt), \
! 1095: 0, 0, 0, 0, 0); \
! 1096: } \
! 1097: }
! 1098:
! 1099: /*
! 1100: * Some subtle order problems with domain initialization mean that
! 1101: * we cannot count on this being run from rt_init before various
! 1102: * protocol initializations are done. Therefore, we make sure
! 1103: * that this is run when the first queue is added...
! 1104: */
! 1105:
! 1106: void
! 1107: rt_timer_init()
! 1108: {
! 1109: static struct timeout rt_timer_timeout;
! 1110:
! 1111: if (rt_init_done)
! 1112: panic("rt_timer_init: already initialized");
! 1113:
! 1114: pool_init(&rttimer_pool, sizeof(struct rttimer), 0, 0, 0, "rttmrpl",
! 1115: NULL);
! 1116:
! 1117: LIST_INIT(&rttimer_queue_head);
! 1118: timeout_set(&rt_timer_timeout, rt_timer_timer, &rt_timer_timeout);
! 1119: timeout_add(&rt_timer_timeout, hz); /* every second */
! 1120: rt_init_done = 1;
! 1121: }
! 1122:
! 1123: struct rttimer_queue *
! 1124: rt_timer_queue_create(u_int timeout)
! 1125: {
! 1126: struct rttimer_queue *rtq;
! 1127:
! 1128: if (rt_init_done == 0)
! 1129: rt_timer_init();
! 1130:
! 1131: R_Malloc(rtq, struct rttimer_queue *, sizeof *rtq);
! 1132: if (rtq == NULL)
! 1133: return (NULL);
! 1134: Bzero(rtq, sizeof *rtq);
! 1135:
! 1136: rtq->rtq_timeout = timeout;
! 1137: rtq->rtq_count = 0;
! 1138: TAILQ_INIT(&rtq->rtq_head);
! 1139: LIST_INSERT_HEAD(&rttimer_queue_head, rtq, rtq_link);
! 1140:
! 1141: return (rtq);
! 1142: }
! 1143:
! 1144: void
! 1145: rt_timer_queue_change(struct rttimer_queue *rtq, long timeout)
! 1146: {
! 1147: rtq->rtq_timeout = timeout;
! 1148: }
! 1149:
! 1150: void
! 1151: rt_timer_queue_destroy(struct rttimer_queue *rtq, int destroy)
! 1152: {
! 1153: struct rttimer *r;
! 1154:
! 1155: while ((r = TAILQ_FIRST(&rtq->rtq_head)) != NULL) {
! 1156: LIST_REMOVE(r, rtt_link);
! 1157: TAILQ_REMOVE(&rtq->rtq_head, r, rtt_next);
! 1158: if (destroy)
! 1159: RTTIMER_CALLOUT(r);
! 1160: pool_put(&rttimer_pool, r);
! 1161: if (rtq->rtq_count > 0)
! 1162: rtq->rtq_count--;
! 1163: else
! 1164: printf("rt_timer_queue_destroy: rtq_count reached 0\n");
! 1165: }
! 1166:
! 1167: LIST_REMOVE(rtq, rtq_link);
! 1168:
! 1169: /*
! 1170: * Caller is responsible for freeing the rttimer_queue structure.
! 1171: */
! 1172: }
! 1173:
! 1174: unsigned long
! 1175: rt_timer_count(struct rttimer_queue *rtq)
! 1176: {
! 1177: return (rtq->rtq_count);
! 1178: }
! 1179:
! 1180: void
! 1181: rt_timer_remove_all(struct rtentry *rt)
! 1182: {
! 1183: struct rttimer *r;
! 1184:
! 1185: while ((r = LIST_FIRST(&rt->rt_timer)) != NULL) {
! 1186: LIST_REMOVE(r, rtt_link);
! 1187: TAILQ_REMOVE(&r->rtt_queue->rtq_head, r, rtt_next);
! 1188: if (r->rtt_queue->rtq_count > 0)
! 1189: r->rtt_queue->rtq_count--;
! 1190: else
! 1191: printf("rt_timer_remove_all: rtq_count reached 0\n");
! 1192: pool_put(&rttimer_pool, r);
! 1193: }
! 1194: }
! 1195:
! 1196: int
! 1197: rt_timer_add(struct rtentry *rt, void (*func)(struct rtentry *,
! 1198: struct rttimer *), struct rttimer_queue *queue)
! 1199: {
! 1200: struct rttimer *r;
! 1201: long current_time;
! 1202:
! 1203: current_time = time_uptime;
! 1204: rt->rt_rmx.rmx_expire = time_second + queue->rtq_timeout;
! 1205:
! 1206: /*
! 1207: * If there's already a timer with this action, destroy it before
! 1208: * we add a new one.
! 1209: */
! 1210: for (r = LIST_FIRST(&rt->rt_timer); r != NULL;
! 1211: r = LIST_NEXT(r, rtt_link)) {
! 1212: if (r->rtt_func == func) {
! 1213: LIST_REMOVE(r, rtt_link);
! 1214: TAILQ_REMOVE(&r->rtt_queue->rtq_head, r, rtt_next);
! 1215: if (r->rtt_queue->rtq_count > 0)
! 1216: r->rtt_queue->rtq_count--;
! 1217: else
! 1218: printf("rt_timer_add: rtq_count reached 0\n");
! 1219: pool_put(&rttimer_pool, r);
! 1220: break; /* only one per list, so we can quit... */
! 1221: }
! 1222: }
! 1223:
! 1224: r = pool_get(&rttimer_pool, PR_NOWAIT);
! 1225: if (r == NULL)
! 1226: return (ENOBUFS);
! 1227: Bzero(r, sizeof(*r));
! 1228:
! 1229: r->rtt_rt = rt;
! 1230: r->rtt_time = current_time;
! 1231: r->rtt_func = func;
! 1232: r->rtt_queue = queue;
! 1233: LIST_INSERT_HEAD(&rt->rt_timer, r, rtt_link);
! 1234: TAILQ_INSERT_TAIL(&queue->rtq_head, r, rtt_next);
! 1235: r->rtt_queue->rtq_count++;
! 1236:
! 1237: return (0);
! 1238: }
! 1239:
! 1240: struct radix_node_head *
! 1241: rt_gettable(sa_family_t af, u_int id)
! 1242: {
! 1243: return (rt_tables[id][af2rtafidx[af]]);
! 1244: }
! 1245:
! 1246: struct radix_node *
! 1247: rt_lookup(struct sockaddr *dst, struct sockaddr *mask, int tableid)
! 1248: {
! 1249: struct radix_node_head *rnh;
! 1250:
! 1251: if ((rnh = rt_gettable(dst->sa_family, tableid)) == NULL)
! 1252: return (NULL);
! 1253:
! 1254: return (rnh->rnh_lookup(dst, mask, rnh));
! 1255: }
! 1256:
! 1257: /* ARGSUSED */
! 1258: void
! 1259: rt_timer_timer(void *arg)
! 1260: {
! 1261: struct timeout *to = (struct timeout *)arg;
! 1262: struct rttimer_queue *rtq;
! 1263: struct rttimer *r;
! 1264: long current_time;
! 1265: int s;
! 1266:
! 1267: current_time = time_uptime;
! 1268:
! 1269: s = splsoftnet();
! 1270: for (rtq = LIST_FIRST(&rttimer_queue_head); rtq != NULL;
! 1271: rtq = LIST_NEXT(rtq, rtq_link)) {
! 1272: while ((r = TAILQ_FIRST(&rtq->rtq_head)) != NULL &&
! 1273: (r->rtt_time + rtq->rtq_timeout) < current_time) {
! 1274: LIST_REMOVE(r, rtt_link);
! 1275: TAILQ_REMOVE(&rtq->rtq_head, r, rtt_next);
! 1276: RTTIMER_CALLOUT(r);
! 1277: pool_put(&rttimer_pool, r);
! 1278: if (rtq->rtq_count > 0)
! 1279: rtq->rtq_count--;
! 1280: else
! 1281: printf("rt_timer_timer: rtq_count reached 0\n");
! 1282: }
! 1283: }
! 1284: splx(s);
! 1285:
! 1286: timeout_add(to, hz); /* every second */
! 1287: }
! 1288:
! 1289: u_int16_t
! 1290: rtlabel_name2id(char *name)
! 1291: {
! 1292: struct rt_label *label, *p = NULL;
! 1293: u_int16_t new_id = 1;
! 1294:
! 1295: if (!name[0])
! 1296: return (0);
! 1297:
! 1298: TAILQ_FOREACH(label, &rt_labels, rtl_entry)
! 1299: if (strcmp(name, label->rtl_name) == 0) {
! 1300: label->rtl_ref++;
! 1301: return (label->rtl_id);
! 1302: }
! 1303:
! 1304: /*
! 1305: * to avoid fragmentation, we do a linear search from the beginning
! 1306: * and take the first free slot we find. if there is none or the list
! 1307: * is empty, append a new entry at the end.
! 1308: */
! 1309:
! 1310: if (!TAILQ_EMPTY(&rt_labels))
! 1311: for (p = TAILQ_FIRST(&rt_labels); p != NULL &&
! 1312: p->rtl_id == new_id; p = TAILQ_NEXT(p, rtl_entry))
! 1313: new_id = p->rtl_id + 1;
! 1314:
! 1315: if (new_id > LABELID_MAX)
! 1316: return (0);
! 1317:
! 1318: label = (struct rt_label *)malloc(sizeof(struct rt_label),
! 1319: M_TEMP, M_NOWAIT);
! 1320: if (label == NULL)
! 1321: return (0);
! 1322: bzero(label, sizeof(struct rt_label));
! 1323: strlcpy(label->rtl_name, name, sizeof(label->rtl_name));
! 1324: label->rtl_id = new_id;
! 1325: label->rtl_ref++;
! 1326:
! 1327: if (p != NULL) /* insert new entry before p */
! 1328: TAILQ_INSERT_BEFORE(p, label, rtl_entry);
! 1329: else /* either list empty or no free slot in between */
! 1330: TAILQ_INSERT_TAIL(&rt_labels, label, rtl_entry);
! 1331:
! 1332: return (label->rtl_id);
! 1333: }
! 1334:
! 1335: const char *
! 1336: rtlabel_id2name(u_int16_t id)
! 1337: {
! 1338: struct rt_label *label;
! 1339:
! 1340: TAILQ_FOREACH(label, &rt_labels, rtl_entry)
! 1341: if (label->rtl_id == id)
! 1342: return (label->rtl_name);
! 1343:
! 1344: return (NULL);
! 1345: }
! 1346:
! 1347: void
! 1348: rtlabel_unref(u_int16_t id)
! 1349: {
! 1350: struct rt_label *p, *next;
! 1351:
! 1352: if (id == 0)
! 1353: return;
! 1354:
! 1355: for (p = TAILQ_FIRST(&rt_labels); p != NULL; p = next) {
! 1356: next = TAILQ_NEXT(p, rtl_entry);
! 1357: if (id == p->rtl_id) {
! 1358: if (--p->rtl_ref == 0) {
! 1359: TAILQ_REMOVE(&rt_labels, p, rtl_entry);
! 1360: free(p, M_TEMP);
! 1361: }
! 1362: break;
! 1363: }
! 1364: }
! 1365: }
! 1366:
! 1367: void
! 1368: rt_if_remove(struct ifnet *ifp)
! 1369: {
! 1370: int i;
! 1371: struct radix_node_head *rnh;
! 1372:
! 1373: for (i = 1; i <= AF_MAX; i++)
! 1374: if ((rnh = rt_gettable(i, 0)) != NULL)
! 1375: while ((*rnh->rnh_walktree)(rnh,
! 1376: rt_if_remove_rtdelete, ifp) == EAGAIN)
! 1377: ; /* nothing */
! 1378: }
! 1379:
! 1380: /*
! 1381: * Note that deleting a RTF_CLONING route can trigger the
! 1382: * deletion of more entries, so we need to cancel the walk
! 1383: * and return EAGAIN. The caller should restart the walk
! 1384: * as long as EAGAIN is returned.
! 1385: */
! 1386: int
! 1387: rt_if_remove_rtdelete(struct radix_node *rn, void *vifp)
! 1388: {
! 1389: struct ifnet *ifp = vifp;
! 1390: struct rtentry *rt = (struct rtentry *)rn;
! 1391:
! 1392: if (rt->rt_ifp == ifp) {
! 1393: int cloning = (rt->rt_flags & RTF_CLONING);
! 1394:
! 1395: if (rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway,
! 1396: rt_mask(rt), 0, NULL, 0) == 0 && cloning)
! 1397: return (EAGAIN);
! 1398: }
! 1399:
! 1400: /*
! 1401: * XXX There should be no need to check for rt_ifa belonging to this
! 1402: * interface, because then rt_ifp is set, right?
! 1403: */
! 1404:
! 1405: return (0);
! 1406: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to route.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net