![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rtsock.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 rtsock.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) 1988, 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: * @(#)rtsock.c 8.5 (Berkeley) 11/2/94 ! 55: */ ! 56: ! 57: ! 58: #include <sys/param.h> ! 59: #include <sys/systm.h> ! 60: #include <sys/kernel.h> ! 61: #include <sys/sysctl.h> ! 62: #include <sys/proc.h> ! 63: #include <sys/malloc.h> ! 64: #include <sys/mbuf.h> ! 65: #include <sys/socket.h> ! 66: #include <sys/socketvar.h> ! 67: #include <sys/domain.h> ! 68: #include <sys/protosw.h> ! 69: ! 70: #include <net/if.h> ! 71: #include <net/route.h> ! 72: #include <net/raw_cb.h> ! 73: ! 74: MALLOC_DEFINE(M_RTABLE, "routetbl", "routing tables"); ! 75: ! 76: static struct sockaddr route_dst = { 2, PF_ROUTE, }; ! 77: static struct sockaddr route_src = { 2, PF_ROUTE, }; ! 78: static struct sockaddr sa_zero = { sizeof(sa_zero), AF_INET, }; ! 79: static struct sockproto route_proto = { PF_ROUTE, }; ! 80: ! 81: ! 82: ! 83: struct walkarg { ! 84: int w_tmemsize; ! 85: int w_op, w_arg; ! 86: caddr_t w_tmem; ! 87: struct sysctl_req *w_req; ! 88: }; ! 89: ! 90: static struct mbuf * ! 91: rt_msg1 __P((int, struct rt_addrinfo *)); ! 92: static int rt_msg2 __P((int, ! 93: struct rt_addrinfo *, caddr_t, struct walkarg *)); ! 94: static int rt_xaddrs __P((caddr_t, caddr_t, struct rt_addrinfo *)); ! 95: static int sysctl_dumpentry __P((struct radix_node *rn, void *vw)); ! 96: static int sysctl_iflist __P((int af, struct walkarg *w)); ! 97: static int route_output __P((struct mbuf *, struct socket *)); ! 98: static void rt_setmetrics __P((u_long, struct rt_metrics *, struct rt_metrics *)); ! 99: ! 100: /* Sleazy use of local variables throughout file, warning!!!! */ ! 101: #define dst info.rti_info[RTAX_DST] ! 102: #define gate info.rti_info[RTAX_GATEWAY] ! 103: #define netmask info.rti_info[RTAX_NETMASK] ! 104: #define genmask info.rti_info[RTAX_GENMASK] ! 105: #define ifpaddr info.rti_info[RTAX_IFP] ! 106: #define ifaaddr info.rti_info[RTAX_IFA] ! 107: #define brdaddr info.rti_info[RTAX_BRD] ! 108: ! 109: /* ! 110: * It really doesn't make any sense at all for this code to share much ! 111: * with raw_usrreq.c, since its functionality is so restricted. XXX ! 112: */ ! 113: static int ! 114: rts_abort(struct socket *so) ! 115: { ! 116: int s, error; ! 117: s = splnet(); ! 118: error = raw_usrreqs.pru_abort(so); ! 119: splx(s); ! 120: return error; ! 121: } ! 122: ! 123: /* pru_accept is EOPNOTSUPP */ ! 124: ! 125: static int ! 126: rts_attach(struct socket *so, int proto, struct proc *p) ! 127: { ! 128: struct rawcb *rp; ! 129: int s, error; ! 130: ! 131: if (sotorawcb(so) != 0) ! 132: return EISCONN; /* XXX panic? */ ! 133: MALLOC(rp, struct rawcb *, sizeof *rp, M_PCB, M_WAITOK); /* XXX */ ! 134: if (rp == 0) ! 135: return ENOBUFS; ! 136: bzero(rp, sizeof *rp); ! 137: ! 138: /* ! 139: * The splnet() is necessary to block protocols from sending ! 140: * error notifications (like RTM_REDIRECT or RTM_LOSING) while ! 141: * this PCB is extant but incompletely initialized. ! 142: * Probably we should try to do more of this work beforehand and ! 143: * eliminate the spl. ! 144: */ ! 145: s = splnet(); ! 146: so->so_pcb = (caddr_t)rp; ! 147: error = raw_usrreqs.pru_attach(so, proto, p); ! 148: rp = sotorawcb(so); ! 149: if (error) { ! 150: splx(s); ! 151: FREE(rp, M_PCB); ! 152: return error; ! 153: } ! 154: switch(rp->rcb_proto.sp_protocol) { ! 155: case AF_INET: ! 156: route_cb.ip_count++; ! 157: break; ! 158: case AF_IPX: ! 159: route_cb.ipx_count++; ! 160: break; ! 161: case AF_NS: ! 162: route_cb.ns_count++; ! 163: break; ! 164: case AF_ISO: ! 165: route_cb.iso_count++; ! 166: break; ! 167: } ! 168: rp->rcb_faddr = &route_src; ! 169: route_cb.any_count++; ! 170: soisconnected(so); ! 171: so->so_options |= SO_USELOOPBACK; ! 172: splx(s); ! 173: return 0; ! 174: } ! 175: ! 176: static int ! 177: rts_bind(struct socket *so, struct sockaddr *nam, struct proc *p) ! 178: { ! 179: int s, error; ! 180: s = splnet(); ! 181: error = raw_usrreqs.pru_bind(so, nam, p); /* xxx just EINVAL */ ! 182: splx(s); ! 183: return error; ! 184: } ! 185: ! 186: static int ! 187: rts_connect(struct socket *so, struct sockaddr *nam, struct proc *p) ! 188: { ! 189: int s, error; ! 190: s = splnet(); ! 191: error = raw_usrreqs.pru_connect(so, nam, p); /* XXX just EINVAL */ ! 192: splx(s); ! 193: return error; ! 194: } ! 195: ! 196: /* pru_connect2 is EOPNOTSUPP */ ! 197: /* pru_control is EOPNOTSUPP */ ! 198: ! 199: static int ! 200: rts_detach(struct socket *so) ! 201: { ! 202: struct rawcb *rp = sotorawcb(so); ! 203: int s, error; ! 204: ! 205: s = splnet(); ! 206: if (rp != 0) { ! 207: switch(rp->rcb_proto.sp_protocol) { ! 208: case AF_INET: ! 209: route_cb.ip_count--; ! 210: break; ! 211: case AF_IPX: ! 212: route_cb.ipx_count--; ! 213: break; ! 214: case AF_NS: ! 215: route_cb.ns_count--; ! 216: break; ! 217: case AF_ISO: ! 218: route_cb.iso_count--; ! 219: break; ! 220: } ! 221: route_cb.any_count--; ! 222: } ! 223: error = raw_usrreqs.pru_detach(so); ! 224: splx(s); ! 225: return error; ! 226: } ! 227: ! 228: static int ! 229: rts_disconnect(struct socket *so) ! 230: { ! 231: int s, error; ! 232: s = splnet(); ! 233: error = raw_usrreqs.pru_disconnect(so); ! 234: splx(s); ! 235: return error; ! 236: } ! 237: ! 238: /* pru_listen is EOPNOTSUPP */ ! 239: ! 240: static int ! 241: rts_peeraddr(struct socket *so, struct sockaddr **nam) ! 242: { ! 243: int s, error; ! 244: s = splnet(); ! 245: error = raw_usrreqs.pru_peeraddr(so, nam); ! 246: splx(s); ! 247: return error; ! 248: } ! 249: ! 250: /* pru_rcvd is EOPNOTSUPP */ ! 251: /* pru_rcvoob is EOPNOTSUPP */ ! 252: ! 253: static int ! 254: rts_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, ! 255: struct mbuf *control, struct proc *p) ! 256: { ! 257: int s, error; ! 258: s = splnet(); ! 259: error = raw_usrreqs.pru_send(so, flags, m, nam, control, p); ! 260: splx(s); ! 261: return error; ! 262: } ! 263: ! 264: /* pru_sense is null */ ! 265: ! 266: static int ! 267: rts_shutdown(struct socket *so) ! 268: { ! 269: int s, error; ! 270: s = splnet(); ! 271: error = raw_usrreqs.pru_shutdown(so); ! 272: splx(s); ! 273: return error; ! 274: } ! 275: ! 276: static int ! 277: rts_sockaddr(struct socket *so, struct sockaddr **nam) ! 278: { ! 279: int s, error; ! 280: s = splnet(); ! 281: error = raw_usrreqs.pru_sockaddr(so, nam); ! 282: splx(s); ! 283: return error; ! 284: } ! 285: ! 286: static struct pr_usrreqs route_usrreqs = { ! 287: rts_abort, pru_accept_notsupp, rts_attach, rts_bind, rts_connect, ! 288: pru_connect2_notsupp, pru_control_notsupp, rts_detach, rts_disconnect, ! 289: pru_listen_notsupp, rts_peeraddr, pru_rcvd_notsupp, pru_rcvoob_notsupp, ! 290: rts_send, pru_sense_null, rts_shutdown, rts_sockaddr, ! 291: sosend, soreceive, sopoll ! 292: }; ! 293: ! 294: /*ARGSUSED*/ ! 295: static int ! 296: route_output(m, so) ! 297: register struct mbuf *m; ! 298: struct socket *so; ! 299: { ! 300: register struct rt_msghdr *rtm = 0; ! 301: register struct rtentry *rt = 0; ! 302: struct rtentry *saved_nrt = 0; ! 303: struct radix_node_head *rnh; ! 304: struct rt_addrinfo info; ! 305: int len, error = 0; ! 306: struct ifnet *ifp = 0; ! 307: struct ifaddr *ifa = 0; ! 308: struct proc *curproc = current_proc(); ! 309: ! 310: #define senderr(e) { error = e; goto flush;} ! 311: if (m == 0 || ((m->m_len < sizeof(long)) && ! 312: (m = m_pullup(m, sizeof(long))) == 0)) ! 313: return (ENOBUFS); ! 314: if ((m->m_flags & M_PKTHDR) == 0) ! 315: panic("route_output"); ! 316: len = m->m_pkthdr.len; ! 317: if (len < sizeof(*rtm) || ! 318: len != mtod(m, struct rt_msghdr *)->rtm_msglen) { ! 319: dst = 0; ! 320: senderr(EINVAL); ! 321: } ! 322: R_Malloc(rtm, struct rt_msghdr *, len); ! 323: if (rtm == 0) { ! 324: dst = 0; ! 325: senderr(ENOBUFS); ! 326: } ! 327: m_copydata(m, 0, len, (caddr_t)rtm); ! 328: if (rtm->rtm_version != RTM_VERSION) { ! 329: dst = 0; ! 330: senderr(EPROTONOSUPPORT); ! 331: } ! 332: rtm->rtm_pid = curproc->p_pid; ! 333: info.rti_addrs = rtm->rtm_addrs; ! 334: if (rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info)) { ! 335: dst = 0; ! 336: senderr(EINVAL); ! 337: } ! 338: if (dst == 0 || (dst->sa_family >= AF_MAX) ! 339: || (gate != 0 && (gate->sa_family >= AF_MAX))) ! 340: senderr(EINVAL); ! 341: if (genmask) { ! 342: struct radix_node *t; ! 343: t = rn_addmask((caddr_t)genmask, 0, 1); ! 344: if (t && Bcmp(genmask, t->rn_key, *(u_char *)genmask) == 0) ! 345: genmask = (struct sockaddr *)(t->rn_key); ! 346: else ! 347: senderr(ENOBUFS); ! 348: } ! 349: switch (rtm->rtm_type) { ! 350: ! 351: case RTM_ADD: ! 352: if (gate == 0) ! 353: senderr(EINVAL); ! 354: error = rtrequest(RTM_ADD, dst, gate, netmask, ! 355: rtm->rtm_flags, &saved_nrt); ! 356: if (error == 0 && saved_nrt) { ! 357: rt_setmetrics(rtm->rtm_inits, ! 358: &rtm->rtm_rmx, &saved_nrt->rt_rmx); ! 359: saved_nrt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits); ! 360: saved_nrt->rt_rmx.rmx_locks |= ! 361: (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks); ! 362: saved_nrt->rt_refcnt--; ! 363: saved_nrt->rt_genmask = genmask; ! 364: } ! 365: break; ! 366: ! 367: case RTM_DELETE: ! 368: error = rtrequest(RTM_DELETE, dst, gate, netmask, ! 369: rtm->rtm_flags, &saved_nrt); ! 370: if (error == 0) { ! 371: if ((rt = saved_nrt)) ! 372: rt->rt_refcnt++; ! 373: goto report; ! 374: } ! 375: break; ! 376: ! 377: case RTM_GET: ! 378: case RTM_CHANGE: ! 379: case RTM_LOCK: ! 380: if ((rnh = rt_tables[dst->sa_family]) == 0) { ! 381: senderr(EAFNOSUPPORT); ! 382: } else if (rt = (struct rtentry *) ! 383: rnh->rnh_lookup(dst, netmask, rnh)) ! 384: rt->rt_refcnt++; ! 385: else ! 386: senderr(ESRCH); ! 387: switch(rtm->rtm_type) { ! 388: ! 389: case RTM_GET: ! 390: report: ! 391: dst = rt_key(rt); ! 392: gate = rt->rt_gateway; ! 393: netmask = rt_mask(rt); ! 394: genmask = rt->rt_genmask; ! 395: if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) { ! 396: ifp = rt->rt_ifp; ! 397: if (ifp) { ! 398: ifpaddr = ifp->if_addrhead.tqh_first->ifa_addr; ! 399: ifaaddr = rt->rt_ifa->ifa_addr; ! 400: rtm->rtm_index = ifp->if_index; ! 401: } else { ! 402: ifpaddr = 0; ! 403: ifaaddr = 0; ! 404: } ! 405: } ! 406: len = rt_msg2(rtm->rtm_type, &info, (caddr_t)0, ! 407: (struct walkarg *)0); ! 408: if (len > rtm->rtm_msglen) { ! 409: struct rt_msghdr *new_rtm; ! 410: R_Malloc(new_rtm, struct rt_msghdr *, len); ! 411: if (new_rtm == 0) ! 412: senderr(ENOBUFS); ! 413: Bcopy(rtm, new_rtm, rtm->rtm_msglen); ! 414: Free(rtm); rtm = new_rtm; ! 415: } ! 416: (void)rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm, ! 417: (struct walkarg *)0); ! 418: rtm->rtm_flags = rt->rt_flags; ! 419: rtm->rtm_rmx = rt->rt_rmx; ! 420: rtm->rtm_addrs = info.rti_addrs; ! 421: break; ! 422: ! 423: case RTM_CHANGE: ! 424: if (gate && (error = rt_setgate(rt, rt_key(rt), gate))) ! 425: senderr(error); ! 426: ! 427: /* ! 428: * If they tried to change things but didn't specify ! 429: * the required gateway, then just use the old one. ! 430: * This can happen if the user tries to change the ! 431: * flags on the default route without changing the ! 432: * default gateway. Changing flags still doesn't work. ! 433: */ ! 434: if ((rt->rt_flags & RTF_GATEWAY) && !gate) ! 435: gate = rt->rt_gateway; ! 436: ! 437: /* new gateway could require new ifaddr, ifp; ! 438: flags may also be different; ifp may be specified ! 439: by ll sockaddr when protocol address is ambiguous */ ! 440: if (ifpaddr && (ifa = ifa_ifwithnet(ifpaddr)) && ! 441: (ifp = ifa->ifa_ifp) && (ifaaddr || gate)) ! 442: ifa = ifaof_ifpforaddr(ifaaddr ? ifaaddr : gate, ! 443: ifp); ! 444: else if ((ifaaddr && (ifa = ifa_ifwithaddr(ifaaddr))) || ! 445: (gate && (ifa = ifa_ifwithroute(rt->rt_flags, ! 446: rt_key(rt), gate)))) ! 447: ifp = ifa->ifa_ifp; ! 448: if (ifa) { ! 449: register struct ifaddr *oifa = rt->rt_ifa; ! 450: if (oifa != ifa) { ! 451: if (oifa && oifa->ifa_rtrequest) ! 452: oifa->ifa_rtrequest(RTM_DELETE, ! 453: rt, gate); ! 454: IFAFREE(rt->rt_ifa); ! 455: rt->rt_ifa = ifa; ! 456: ifa->ifa_refcnt++; ! 457: rt->rt_ifp = ifp; ! 458: rt->rt_dlt = ifa->ifa_dlt; ! 459: } ! 460: } ! 461: rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx, ! 462: &rt->rt_rmx); ! 463: if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest) ! 464: rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, gate); ! 465: if (genmask) ! 466: rt->rt_genmask = genmask; ! 467: /* ! 468: * Fall into ! 469: */ ! 470: case RTM_LOCK: ! 471: rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits); ! 472: rt->rt_rmx.rmx_locks |= ! 473: (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks); ! 474: break; ! 475: } ! 476: break; ! 477: ! 478: default: ! 479: senderr(EOPNOTSUPP); ! 480: } ! 481: ! 482: flush: ! 483: if (rtm) { ! 484: if (error) ! 485: rtm->rtm_errno = error; ! 486: else ! 487: rtm->rtm_flags |= RTF_DONE; ! 488: } ! 489: if (rt) ! 490: rtfree(rt); ! 491: { ! 492: register struct rawcb *rp = 0; ! 493: /* ! 494: * Check to see if we don't want our own messages. ! 495: */ ! 496: if ((so->so_options & SO_USELOOPBACK) == 0) { ! 497: if (route_cb.any_count <= 1) { ! 498: if (rtm) ! 499: Free(rtm); ! 500: m_freem(m); ! 501: return (error); ! 502: } ! 503: /* There is another listener, so construct message */ ! 504: rp = sotorawcb(so); ! 505: } ! 506: if (rtm) { ! 507: m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm); ! 508: Free(rtm); ! 509: } ! 510: if (rp) ! 511: rp->rcb_proto.sp_family = 0; /* Avoid us */ ! 512: if (dst) ! 513: route_proto.sp_protocol = dst->sa_family; ! 514: raw_input(m, &route_proto, &route_src, &route_dst); ! 515: if (rp) ! 516: rp->rcb_proto.sp_family = PF_ROUTE; ! 517: } ! 518: return (error); ! 519: } ! 520: ! 521: static void ! 522: rt_setmetrics(which, in, out) ! 523: u_long which; ! 524: register struct rt_metrics *in, *out; ! 525: { ! 526: #define metric(f, e) if (which & (f)) out->e = in->e; ! 527: metric(RTV_RPIPE, rmx_recvpipe); ! 528: metric(RTV_SPIPE, rmx_sendpipe); ! 529: metric(RTV_SSTHRESH, rmx_ssthresh); ! 530: metric(RTV_RTT, rmx_rtt); ! 531: metric(RTV_RTTVAR, rmx_rttvar); ! 532: metric(RTV_HOPCOUNT, rmx_hopcount); ! 533: metric(RTV_MTU, rmx_mtu); ! 534: metric(RTV_EXPIRE, rmx_expire); ! 535: #undef metric ! 536: } ! 537: ! 538: #define ROUNDUP(a) \ ! 539: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) ! 540: #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len)) ! 541: ! 542: ! 543: /* ! 544: * Extract the addresses of the passed sockaddrs. ! 545: * Do a little sanity checking so as to avoid bad memory references. ! 546: * This data is derived straight from userland. ! 547: */ ! 548: static int ! 549: rt_xaddrs(cp, cplim, rtinfo) ! 550: register caddr_t cp, cplim; ! 551: register struct rt_addrinfo *rtinfo; ! 552: { ! 553: register struct sockaddr *sa; ! 554: register int i; ! 555: ! 556: bzero(rtinfo->rti_info, sizeof(rtinfo->rti_info)); ! 557: for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) { ! 558: if ((rtinfo->rti_addrs & (1 << i)) == 0) ! 559: continue; ! 560: sa = (struct sockaddr *)cp; ! 561: /* ! 562: * It won't fit. ! 563: */ ! 564: if ( (cp + sa->sa_len) > cplim ) { ! 565: return (EINVAL); ! 566: } ! 567: ! 568: /* ! 569: * there are no more.. quit now ! 570: * If there are more bits, they are in error. ! 571: * I've seen this. route(1) can evidently generate these. ! 572: * This causes kernel to core dump. ! 573: * for compatibility, If we see this, point to a safe address. ! 574: */ ! 575: if (sa->sa_len == 0) { ! 576: rtinfo->rti_info[i] = &sa_zero; ! 577: return (0); /* should be EINVAL but for compat */ ! 578: } ! 579: ! 580: /* accept it */ ! 581: rtinfo->rti_info[i] = sa; ! 582: ADVANCE(cp, sa); ! 583: } ! 584: return (0); ! 585: } ! 586: ! 587: static struct mbuf * ! 588: rt_msg1(type, rtinfo) ! 589: int type; ! 590: register struct rt_addrinfo *rtinfo; ! 591: { ! 592: register struct rt_msghdr *rtm; ! 593: register struct mbuf *m; ! 594: register int i; ! 595: register struct sockaddr *sa; ! 596: int len, dlen; ! 597: ! 598: m = m_gethdr(M_DONTWAIT, MT_DATA); ! 599: if (m == 0) ! 600: return (m); ! 601: switch (type) { ! 602: ! 603: case RTM_DELADDR: ! 604: case RTM_NEWADDR: ! 605: len = sizeof(struct ifa_msghdr); ! 606: break; ! 607: ! 608: case RTM_DELMADDR: ! 609: case RTM_NEWMADDR: ! 610: len = sizeof(struct ifma_msghdr); ! 611: break; ! 612: ! 613: case RTM_IFINFO: ! 614: len = sizeof(struct if_msghdr); ! 615: break; ! 616: ! 617: default: ! 618: len = sizeof(struct rt_msghdr); ! 619: } ! 620: if (len > MHLEN) ! 621: panic("rt_msg1"); ! 622: m->m_pkthdr.len = m->m_len = len; ! 623: m->m_pkthdr.rcvif = 0; ! 624: rtm = mtod(m, struct rt_msghdr *); ! 625: bzero((caddr_t)rtm, len); ! 626: for (i = 0; i < RTAX_MAX; i++) { ! 627: if ((sa = rtinfo->rti_info[i]) == NULL) ! 628: continue; ! 629: rtinfo->rti_addrs |= (1 << i); ! 630: dlen = ROUNDUP(sa->sa_len); ! 631: m_copyback(m, len, dlen, (caddr_t)sa); ! 632: len += dlen; ! 633: } ! 634: if (m->m_pkthdr.len != len) { ! 635: m_freem(m); ! 636: return (NULL); ! 637: } ! 638: rtm->rtm_msglen = len; ! 639: rtm->rtm_version = RTM_VERSION; ! 640: rtm->rtm_type = type; ! 641: return (m); ! 642: } ! 643: ! 644: static int ! 645: rt_msg2(type, rtinfo, cp, w) ! 646: int type; ! 647: register struct rt_addrinfo *rtinfo; ! 648: caddr_t cp; ! 649: struct walkarg *w; ! 650: { ! 651: register int i; ! 652: int len, dlen, second_time = 0; ! 653: caddr_t cp0; ! 654: ! 655: rtinfo->rti_addrs = 0; ! 656: again: ! 657: switch (type) { ! 658: ! 659: case RTM_DELADDR: ! 660: case RTM_NEWADDR: ! 661: len = sizeof(struct ifa_msghdr); ! 662: break; ! 663: ! 664: case RTM_IFINFO: ! 665: len = sizeof(struct if_msghdr); ! 666: break; ! 667: ! 668: default: ! 669: len = sizeof(struct rt_msghdr); ! 670: } ! 671: cp0 = cp; ! 672: if (cp0) ! 673: cp += len; ! 674: for (i = 0; i < RTAX_MAX; i++) { ! 675: register struct sockaddr *sa; ! 676: ! 677: if ((sa = rtinfo->rti_info[i]) == 0) ! 678: continue; ! 679: rtinfo->rti_addrs |= (1 << i); ! 680: dlen = ROUNDUP(sa->sa_len); ! 681: if (cp) { ! 682: bcopy((caddr_t)sa, cp, (unsigned)dlen); ! 683: cp += dlen; ! 684: } ! 685: len += dlen; ! 686: } ! 687: if (cp == 0 && w != NULL && !second_time) { ! 688: register struct walkarg *rw = w; ! 689: ! 690: if (rw->w_req) { ! 691: if (rw->w_tmemsize < len) { ! 692: if (rw->w_tmem) ! 693: FREE(rw->w_tmem, M_RTABLE); ! 694: rw->w_tmem = (caddr_t) ! 695: _MALLOC(len, M_RTABLE, M_NOWAIT); ! 696: if (rw->w_tmem) ! 697: rw->w_tmemsize = len; ! 698: } ! 699: if (rw->w_tmem) { ! 700: cp = rw->w_tmem; ! 701: second_time = 1; ! 702: goto again; ! 703: } ! 704: } ! 705: } ! 706: if (cp) { ! 707: register struct rt_msghdr *rtm = (struct rt_msghdr *)cp0; ! 708: ! 709: rtm->rtm_version = RTM_VERSION; ! 710: rtm->rtm_type = type; ! 711: rtm->rtm_msglen = len; ! 712: } ! 713: return (len); ! 714: } ! 715: ! 716: /* ! 717: * This routine is called to generate a message from the routing ! 718: * socket indicating that a redirect has occured, a routing lookup ! 719: * has failed, or that a protocol has detected timeouts to a particular ! 720: * destination. ! 721: */ ! 722: void ! 723: rt_missmsg(type, rtinfo, flags, error) ! 724: int type, flags, error; ! 725: register struct rt_addrinfo *rtinfo; ! 726: { ! 727: register struct rt_msghdr *rtm; ! 728: register struct mbuf *m; ! 729: struct sockaddr *sa = rtinfo->rti_info[RTAX_DST]; ! 730: ! 731: if (route_cb.any_count == 0) ! 732: return; ! 733: m = rt_msg1(type, rtinfo); ! 734: if (m == 0) ! 735: return; ! 736: rtm = mtod(m, struct rt_msghdr *); ! 737: rtm->rtm_flags = RTF_DONE | flags; ! 738: rtm->rtm_errno = error; ! 739: rtm->rtm_addrs = rtinfo->rti_addrs; ! 740: route_proto.sp_protocol = sa ? sa->sa_family : 0; ! 741: raw_input(m, &route_proto, &route_src, &route_dst); ! 742: } ! 743: ! 744: /* ! 745: * This routine is called to generate a message from the routing ! 746: * socket indicating that the status of a network interface has changed. ! 747: */ ! 748: void ! 749: rt_ifmsg(ifp) ! 750: register struct ifnet *ifp; ! 751: { ! 752: register struct if_msghdr *ifm; ! 753: struct mbuf *m; ! 754: struct rt_addrinfo info; ! 755: ! 756: if (route_cb.any_count == 0) ! 757: return; ! 758: bzero((caddr_t)&info, sizeof(info)); ! 759: m = rt_msg1(RTM_IFINFO, &info); ! 760: if (m == 0) ! 761: return; ! 762: ifm = mtod(m, struct if_msghdr *); ! 763: ifm->ifm_index = ifp->if_index; ! 764: ifm->ifm_flags = (u_short)ifp->if_flags; ! 765: ifm->ifm_data = ifp->if_data; ! 766: ifm->ifm_addrs = 0; ! 767: route_proto.sp_protocol = 0; ! 768: raw_input(m, &route_proto, &route_src, &route_dst); ! 769: } ! 770: ! 771: /* ! 772: * This is called to generate messages from the routing socket ! 773: * indicating a network interface has had addresses associated with it. ! 774: * if we ever reverse the logic and replace messages TO the routing ! 775: * socket indicate a request to configure interfaces, then it will ! 776: * be unnecessary as the routing socket will automatically generate ! 777: * copies of it. ! 778: */ ! 779: void ! 780: rt_newaddrmsg(cmd, ifa, error, rt) ! 781: int cmd, error; ! 782: register struct ifaddr *ifa; ! 783: register struct rtentry *rt; ! 784: { ! 785: struct rt_addrinfo info; ! 786: struct sockaddr *sa = 0; ! 787: int pass; ! 788: struct mbuf *m = 0; ! 789: struct ifnet *ifp = ifa->ifa_ifp; ! 790: ! 791: if (route_cb.any_count == 0) ! 792: return; ! 793: for (pass = 1; pass < 3; pass++) { ! 794: bzero((caddr_t)&info, sizeof(info)); ! 795: if ((cmd == RTM_ADD && pass == 1) || ! 796: (cmd == RTM_DELETE && pass == 2)) { ! 797: register struct ifa_msghdr *ifam; ! 798: int ncmd = cmd == RTM_ADD ? RTM_NEWADDR : RTM_DELADDR; ! 799: ! 800: ifaaddr = sa = ifa->ifa_addr; ! 801: ifpaddr = ifp->if_addrhead.tqh_first->ifa_addr; ! 802: netmask = ifa->ifa_netmask; ! 803: brdaddr = ifa->ifa_dstaddr; ! 804: if ((m = rt_msg1(ncmd, &info)) == NULL) ! 805: continue; ! 806: ifam = mtod(m, struct ifa_msghdr *); ! 807: ifam->ifam_index = ifp->if_index; ! 808: ifam->ifam_metric = ifa->ifa_metric; ! 809: ifam->ifam_flags = ifa->ifa_flags; ! 810: ifam->ifam_addrs = info.rti_addrs; ! 811: } ! 812: if ((cmd == RTM_ADD && pass == 2) || ! 813: (cmd == RTM_DELETE && pass == 1)) { ! 814: register struct rt_msghdr *rtm; ! 815: ! 816: if (rt == 0) ! 817: continue; ! 818: netmask = rt_mask(rt); ! 819: dst = sa = rt_key(rt); ! 820: gate = rt->rt_gateway; ! 821: if ((m = rt_msg1(cmd, &info)) == NULL) ! 822: continue; ! 823: rtm = mtod(m, struct rt_msghdr *); ! 824: rtm->rtm_index = ifp->if_index; ! 825: rtm->rtm_flags |= rt->rt_flags; ! 826: rtm->rtm_errno = error; ! 827: rtm->rtm_addrs = info.rti_addrs; ! 828: } ! 829: route_proto.sp_protocol = sa ? sa->sa_family : 0; ! 830: raw_input(m, &route_proto, &route_src, &route_dst); ! 831: } ! 832: } ! 833: ! 834: /* ! 835: * This is the analogue to the rt_newaddrmsg which performs the same ! 836: * function but for multicast group memberhips. This is easier since ! 837: * there is no route state to worry about. ! 838: */ ! 839: void ! 840: rt_newmaddrmsg(cmd, ifma) ! 841: int cmd; ! 842: struct ifmultiaddr *ifma; ! 843: { ! 844: struct rt_addrinfo info; ! 845: struct mbuf *m = 0; ! 846: struct ifnet *ifp = ifma->ifma_ifp; ! 847: struct ifma_msghdr *ifmam; ! 848: ! 849: if (route_cb.any_count == 0) ! 850: return; ! 851: ! 852: bzero((caddr_t)&info, sizeof(info)); ! 853: ifaaddr = ifma->ifma_addr; ! 854: ifpaddr = ifp->if_addrhead.tqh_first->ifa_addr; ! 855: /* ! 856: * If a link-layer address is present, present it as a ``gateway'' ! 857: * (similarly to how ARP entries, e.g., are presented). ! 858: */ ! 859: gate = ifma->ifma_lladdr; ! 860: if ((m = rt_msg1(cmd, &info)) == NULL) ! 861: return; ! 862: ifmam = mtod(m, struct ifma_msghdr *); ! 863: ifmam->ifmam_index = ifp->if_index; ! 864: ifmam->ifmam_addrs = info.rti_addrs; ! 865: route_proto.sp_protocol = ifma->ifma_addr->sa_family; ! 866: raw_input(m, &route_proto, &route_src, &route_dst); ! 867: } ! 868: ! 869: /* ! 870: * This is used in dumping the kernel table via sysctl(). ! 871: */ ! 872: int ! 873: sysctl_dumpentry(rn, vw) ! 874: struct radix_node *rn; ! 875: void *vw; ! 876: { ! 877: register struct walkarg *w = vw; ! 878: register struct rtentry *rt = (struct rtentry *)rn; ! 879: int error = 0, size; ! 880: struct rt_addrinfo info; ! 881: ! 882: if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg)) ! 883: return 0; ! 884: bzero((caddr_t)&info, sizeof(info)); ! 885: dst = rt_key(rt); ! 886: gate = rt->rt_gateway; ! 887: netmask = rt_mask(rt); ! 888: genmask = rt->rt_genmask; ! 889: size = rt_msg2(RTM_GET, &info, 0, w); ! 890: if (w->w_req && w->w_tmem) { ! 891: register struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem; ! 892: ! 893: rtm->rtm_flags = rt->rt_flags; ! 894: rtm->rtm_use = rt->rt_use; ! 895: rtm->rtm_rmx = rt->rt_rmx; ! 896: rtm->rtm_index = rt->rt_ifp->if_index; ! 897: rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0; ! 898: rtm->rtm_addrs = info.rti_addrs; ! 899: error = SYSCTL_OUT(w->w_req, (caddr_t)rtm, size); ! 900: return (error); ! 901: } ! 902: return (error); ! 903: } ! 904: ! 905: int ! 906: sysctl_iflist(af, w) ! 907: int af; ! 908: register struct walkarg *w; ! 909: { ! 910: register struct ifnet *ifp; ! 911: register struct ifaddr *ifa; ! 912: struct rt_addrinfo info; ! 913: int len, error = 0; ! 914: ! 915: bzero((caddr_t)&info, sizeof(info)); ! 916: for (ifp = ifnet.tqh_first; ifp; ifp = ifp->if_link.tqe_next) { ! 917: if (w->w_arg && w->w_arg != ifp->if_index) ! 918: continue; ! 919: ifa = ifp->if_addrhead.tqh_first; ! 920: ifpaddr = ifa->ifa_addr; ! 921: len = rt_msg2(RTM_IFINFO, &info, (caddr_t)0, w); ! 922: ifpaddr = 0; ! 923: if (w->w_req && w->w_tmem) { ! 924: register struct if_msghdr *ifm; ! 925: ! 926: ifm = (struct if_msghdr *)w->w_tmem; ! 927: ifm->ifm_index = ifp->if_index; ! 928: ifm->ifm_flags = (u_short)ifp->if_flags; ! 929: ifm->ifm_data = ifp->if_data; ! 930: ifm->ifm_addrs = info.rti_addrs; ! 931: error = SYSCTL_OUT(w->w_req,(caddr_t)ifm, len); ! 932: if (error) ! 933: return (error); ! 934: } ! 935: while ((ifa = ifa->ifa_link.tqe_next) != 0) { ! 936: if (af && af != ifa->ifa_addr->sa_family) ! 937: continue; ! 938: ifaaddr = ifa->ifa_addr; ! 939: netmask = ifa->ifa_netmask; ! 940: brdaddr = ifa->ifa_dstaddr; ! 941: len = rt_msg2(RTM_NEWADDR, &info, 0, w); ! 942: if (w->w_req && w->w_tmem) { ! 943: register struct ifa_msghdr *ifam; ! 944: ! 945: ifam = (struct ifa_msghdr *)w->w_tmem; ! 946: ifam->ifam_index = ifa->ifa_ifp->if_index; ! 947: ifam->ifam_flags = ifa->ifa_flags; ! 948: ifam->ifam_metric = ifa->ifa_metric; ! 949: ifam->ifam_addrs = info.rti_addrs; ! 950: error = SYSCTL_OUT(w->w_req, w->w_tmem, len); ! 951: if (error) ! 952: return (error); ! 953: } ! 954: } ! 955: ifaaddr = netmask = brdaddr = 0; ! 956: } ! 957: return (0); ! 958: } ! 959: ! 960: ! 961: static int ! 962: sysctl_rtsock SYSCTL_HANDLER_ARGS ! 963: { ! 964: int *name = (int *)arg1; ! 965: u_int namelen = arg2; ! 966: register struct radix_node_head *rnh; ! 967: int i, s, error = EINVAL; ! 968: u_char af; ! 969: struct walkarg w; ! 970: ! 971: name ++; ! 972: namelen--; ! 973: if (req->newptr) ! 974: return (EPERM); ! 975: if (namelen != 3) ! 976: return (EINVAL); ! 977: af = name[0]; ! 978: Bzero(&w, sizeof(w)); ! 979: w.w_op = name[1]; ! 980: w.w_arg = name[2]; ! 981: w.w_req = req; ! 982: ! 983: s = splnet(); ! 984: switch (w.w_op) { ! 985: ! 986: case NET_RT_DUMP: ! 987: case NET_RT_FLAGS: ! 988: for (i = 1; i <= AF_MAX; i++) ! 989: if ((rnh = rt_tables[i]) && (af == 0 || af == i) && ! 990: (error = rnh->rnh_walktree(rnh, ! 991: sysctl_dumpentry, &w))) ! 992: break; ! 993: break; ! 994: ! 995: case NET_RT_IFLIST: ! 996: error = sysctl_iflist(af, &w); ! 997: } ! 998: splx(s); ! 999: if (w.w_tmem) ! 1000: FREE(w.w_tmem, M_RTABLE); ! 1001: return (error); ! 1002: } ! 1003: ! 1004: SYSCTL_NODE(_net, PF_ROUTE, routetable, CTLFLAG_RD, sysctl_rtsock, ""); ! 1005: ! 1006: ! 1007: ! 1008: /* ! 1009: * Definitions of protocols supported in the ROUTE domain. ! 1010: */ ! 1011: ! 1012: struct domain routedomain; /* or at least forward */ ! 1013: ! 1014: ! 1015: static struct protosw routesw[] = { ! 1016: { SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR, ! 1017: 0, route_output, raw_ctlinput, 0, ! 1018: 0, ! 1019: raw_init, 0, 0, 0, ! 1020: 0, &route_usrreqs, 0, 0 ! 1021: } ! 1022: }; ! 1023: ! 1024: struct domain routedomain = ! 1025: { PF_ROUTE, "route", route_init, 0, 0, ! 1026: routesw}; ! 1027: ! 1028: DOMAIN_SET(route);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.