![[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 Darwin 0.x] / kernel / bsd / net|
Return to rtsock.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / net |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1988, 1991, 1993 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the University of ! 41: * California, Berkeley and its contributors. ! 42: * 4. Neither the name of the University nor the names of its contributors ! 43: * may be used to endorse or promote products derived from this software ! 44: * without specific prior written permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: * ! 58: * @(#)rtsock.c 8.6 (Berkeley) 2/11/95 ! 59: */ ! 60: ! 61: #include <sys/param.h> ! 62: #include <sys/systm.h> ! 63: #include <sys/proc.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: #include <sys/malloc.h> ! 70: ! 71: #include <net/if.h> ! 72: #include <net/route.h> ! 73: #include <net/raw_cb.h> ! 74: ! 75: struct route_cb route_cb; ! 76: struct sockaddr route_dst = { 2, PF_ROUTE, }; ! 77: struct sockaddr route_src = { 2, PF_ROUTE, }; ! 78: struct sockproto route_proto = { PF_ROUTE, }; ! 79: ! 80: struct walkarg { ! 81: int w_op, w_arg, w_given, w_needed, w_tmemsize; ! 82: caddr_t w_where, w_tmem; ! 83: }; ! 84: ! 85: static struct mbuf * ! 86: rt_msg1 __P((int, struct rt_addrinfo *)); ! 87: static int rt_msg2 __P((int, ! 88: struct rt_addrinfo *, caddr_t, struct walkarg *)); ! 89: static void rt_xaddrs __P((caddr_t, caddr_t, struct rt_addrinfo *)); ! 90: ! 91: /* Sleazy use of local variables throughout file, warning!!!! */ ! 92: #define dst info.rti_info[RTAX_DST] ! 93: #define gate info.rti_info[RTAX_GATEWAY] ! 94: #define netmask info.rti_info[RTAX_NETMASK] ! 95: #define genmask info.rti_info[RTAX_GENMASK] ! 96: #define ifpaddr info.rti_info[RTAX_IFP] ! 97: #define ifaaddr info.rti_info[RTAX_IFA] ! 98: #define brdaddr info.rti_info[RTAX_BRD] ! 99: ! 100: /*ARGSUSED*/ ! 101: int ! 102: route_usrreq(so, req, m, nam, control) ! 103: register struct socket *so; ! 104: int req; ! 105: struct mbuf *m, *nam, *control; ! 106: { ! 107: register int error = 0; ! 108: register struct rawcb *rp = sotorawcb(so); ! 109: int s; ! 110: ! 111: if (req == PRU_ATTACH) { ! 112: MALLOC(rp, struct rawcb *, sizeof(*rp), M_PCB, M_WAITOK); ! 113: if (so->so_pcb = (caddr_t)rp) ! 114: bzero(so->so_pcb, sizeof(*rp)); ! 115: ! 116: } ! 117: if (req == PRU_DETACH && rp) { ! 118: int af = rp->rcb_proto.sp_protocol; ! 119: if (af == AF_INET) ! 120: route_cb.ip_count--; ! 121: else if (af == AF_NS) ! 122: route_cb.ns_count--; ! 123: else if (af == AF_ISO) ! 124: route_cb.iso_count--; ! 125: route_cb.any_count--; ! 126: } ! 127: s = splnet(); ! 128: error = raw_usrreq(so, req, m, nam, control); ! 129: rp = sotorawcb(so); ! 130: if (req == PRU_ATTACH && rp) { ! 131: int af = rp->rcb_proto.sp_protocol; ! 132: if (error) { ! 133: _FREE((caddr_t)rp, M_PCB); ! 134: splx(s); ! 135: return (error); ! 136: } ! 137: if (af == AF_INET) ! 138: route_cb.ip_count++; ! 139: else if (af == AF_NS) ! 140: route_cb.ns_count++; ! 141: else if (af == AF_ISO) ! 142: route_cb.iso_count++; ! 143: rp->rcb_faddr = &route_src; ! 144: route_cb.any_count++; ! 145: soisconnected(so); ! 146: so->so_options |= SO_USELOOPBACK; ! 147: } ! 148: splx(s); ! 149: return (error); ! 150: } ! 151: ! 152: void m_copyback(struct mbuf *, int, int, caddr_t); ! 153: ! 154: /*ARGSUSED*/ ! 155: int ! 156: route_output(m, so) ! 157: register struct mbuf *m; ! 158: struct socket *so; ! 159: { ! 160: register struct rt_msghdr *rtm = 0; ! 161: register struct rtentry *rt = 0; ! 162: struct rtentry *saved_nrt = 0; ! 163: struct radix_node_head *rnh; ! 164: struct rt_addrinfo info; ! 165: int len, error = 0; ! 166: struct ifnet *ifp = 0; ! 167: struct ifaddr *ifa = 0; ! 168: ! 169: #define senderr(e) { error = e; goto flush;} ! 170: if (m == 0 || ((m->m_len < sizeof(int32_t)) && ! 171: (m = m_pullup(m, sizeof(int32_t))) == 0)) ! 172: return (ENOBUFS); ! 173: if ((m->m_flags & M_PKTHDR) == 0) ! 174: panic("route_output"); ! 175: len = m->m_pkthdr.len; ! 176: if (len < sizeof(*rtm) || ! 177: len != mtod(m, struct rt_msghdr *)->rtm_msglen) { ! 178: dst = 0; ! 179: senderr(EINVAL); ! 180: } ! 181: R_Malloc(rtm, struct rt_msghdr *, len); ! 182: if (rtm == 0) { ! 183: dst = 0; ! 184: senderr(ENOBUFS); ! 185: } ! 186: m_copydata(m, 0, len, (caddr_t)rtm); ! 187: if (rtm->rtm_version != RTM_VERSION) { ! 188: dst = 0; ! 189: senderr(EPROTONOSUPPORT); ! 190: } ! 191: rtm->rtm_pid = current_proc()->p_pid; ! 192: info.rti_addrs = rtm->rtm_addrs; ! 193: rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info); ! 194: if (dst == 0) ! 195: senderr(EINVAL); ! 196: if (genmask) { ! 197: struct radix_node *t; ! 198: t = rn_addmask((caddr_t)genmask, 0, 1); ! 199: if (t && Bcmp(genmask, t->rn_key, *(u_char *)genmask) == 0) ! 200: genmask = (struct sockaddr *)(t->rn_key); ! 201: else ! 202: senderr(ENOBUFS); ! 203: } ! 204: switch (rtm->rtm_type) { ! 205: ! 206: case RTM_ADD: ! 207: if (gate == 0) ! 208: senderr(EINVAL); ! 209: error = rtrequest(RTM_ADD, dst, gate, netmask, ! 210: rtm->rtm_flags, &saved_nrt); ! 211: if (error == 0 && saved_nrt) { ! 212: rt_setmetrics(rtm->rtm_inits, ! 213: &rtm->rtm_rmx, &saved_nrt->rt_rmx); ! 214: saved_nrt->rt_refcnt--; ! 215: saved_nrt->rt_genmask = genmask; ! 216: } ! 217: break; ! 218: ! 219: case RTM_DELETE: ! 220: error = rtrequest(RTM_DELETE, dst, gate, netmask, ! 221: rtm->rtm_flags, &saved_nrt); ! 222: if (error == 0) { ! 223: (rt = saved_nrt)->rt_refcnt++; ! 224: goto report; ! 225: } ! 226: break; ! 227: ! 228: case RTM_GET: ! 229: case RTM_CHANGE: ! 230: case RTM_LOCK: ! 231: if ((rnh = rt_tables[dst->sa_family]) == 0) { ! 232: senderr(EAFNOSUPPORT); ! 233: } else if (rt = (struct rtentry *) ! 234: rnh->rnh_lookup(dst, netmask, rnh)) ! 235: rt->rt_refcnt++; ! 236: else ! 237: senderr(ESRCH); ! 238: switch(rtm->rtm_type) { ! 239: ! 240: case RTM_GET: ! 241: report: ! 242: dst = rt_key(rt); ! 243: gate = rt->rt_gateway; ! 244: netmask = rt_mask(rt); ! 245: genmask = rt->rt_genmask; ! 246: if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) { ! 247: if (ifp = rt->rt_ifp) { ! 248: ifpaddr = ifp->if_addrlist->ifa_addr; ! 249: ifaaddr = rt->rt_ifa->ifa_addr; ! 250: if (ifp->if_flags & IFF_POINTOPOINT) ! 251: brdaddr = rt->rt_ifa->ifa_dstaddr; ! 252: else ! 253: brdaddr = 0; ! 254: rtm->rtm_index = ifp->if_index; ! 255: } else { ! 256: ifpaddr = 0; ! 257: ifaaddr = 0; ! 258: } ! 259: } ! 260: len = rt_msg2(rtm->rtm_type, &info, (caddr_t)0, ! 261: (struct walkarg *)0); ! 262: if (len > rtm->rtm_msglen) { ! 263: struct rt_msghdr *new_rtm; ! 264: R_Malloc(new_rtm, struct rt_msghdr *, len); ! 265: if (new_rtm == 0) ! 266: senderr(ENOBUFS); ! 267: Bcopy(rtm, new_rtm, rtm->rtm_msglen); ! 268: Free(rtm); rtm = new_rtm; ! 269: } ! 270: (void)rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm, ! 271: (struct walkarg *)0); ! 272: rtm->rtm_flags = rt->rt_flags; ! 273: rtm->rtm_rmx = rt->rt_rmx; ! 274: rtm->rtm_addrs = info.rti_addrs; ! 275: break; ! 276: ! 277: case RTM_CHANGE: ! 278: if (gate && rt_setgate(rt, rt_key(rt), gate)) ! 279: senderr(EDQUOT); ! 280: /* new gateway could require new ifaddr, ifp; ! 281: flags may also be different; ifp may be specified ! 282: by ll sockaddr when protocol address is ambiguous */ ! 283: if (ifpaddr && (ifa = ifa_ifwithnet(ifpaddr)) && ! 284: (ifp = ifa->ifa_ifp)) ! 285: ifa = ifaof_ifpforaddr(ifaaddr ? ifaaddr : gate, ! 286: ifp); ! 287: else if ((ifaaddr && (ifa = ifa_ifwithaddr(ifaaddr))) || ! 288: (ifa = ifa_ifwithroute(rt->rt_flags, ! 289: rt_key(rt), gate))) ! 290: ifp = ifa->ifa_ifp; ! 291: if (ifa) { ! 292: register struct ifaddr *oifa = rt->rt_ifa; ! 293: if (oifa != ifa) { ! 294: if (oifa && oifa->ifa_rtrequest) ! 295: oifa->ifa_rtrequest(RTM_DELETE, ! 296: rt, gate); ! 297: IFAFREE(rt->rt_ifa); ! 298: rt->rt_ifa = ifa; ! 299: ifa->ifa_refcnt++; ! 300: rt->rt_ifp = ifp; ! 301: } ! 302: } ! 303: rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx, ! 304: &rt->rt_rmx); ! 305: if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest) ! 306: rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, gate); ! 307: if (genmask) ! 308: rt->rt_genmask = genmask; ! 309: /* ! 310: * Fall into ! 311: */ ! 312: case RTM_LOCK: ! 313: rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits); ! 314: rt->rt_rmx.rmx_locks |= ! 315: (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks); ! 316: break; ! 317: } ! 318: break; ! 319: ! 320: default: ! 321: senderr(EOPNOTSUPP); ! 322: } ! 323: ! 324: flush: ! 325: if (rtm) { ! 326: if (error) ! 327: rtm->rtm_errno = error; ! 328: else ! 329: rtm->rtm_flags |= RTF_DONE; ! 330: } ! 331: if (rt) ! 332: rtfree(rt); ! 333: { ! 334: register struct rawcb *rp = 0; ! 335: /* ! 336: * Check to see if we don't want our own messages. ! 337: */ ! 338: if ((so->so_options & SO_USELOOPBACK) == 0) { ! 339: if (route_cb.any_count <= 1) { ! 340: if (rtm) ! 341: Free(rtm); ! 342: m_freem(m); ! 343: return (error); ! 344: } ! 345: /* There is another listener, so construct message */ ! 346: rp = sotorawcb(so); ! 347: } ! 348: if (rtm) { ! 349: m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm); ! 350: Free(rtm); ! 351: } ! 352: if (rp) ! 353: rp->rcb_proto.sp_family = 0; /* Avoid us */ ! 354: if (dst) ! 355: route_proto.sp_protocol = dst->sa_family; ! 356: raw_input(m, &route_proto, &route_src, &route_dst); ! 357: if (rp) ! 358: rp->rcb_proto.sp_family = PF_ROUTE; ! 359: } ! 360: return (error); ! 361: } ! 362: ! 363: void ! 364: rt_setmetrics(which, in, out) ! 365: u_long which; ! 366: register struct rt_metrics *in, *out; ! 367: { ! 368: #define metric(f, e) if (which & (f)) out->e = in->e; ! 369: metric(RTV_RPIPE, rmx_recvpipe); ! 370: metric(RTV_SPIPE, rmx_sendpipe); ! 371: metric(RTV_SSTHRESH, rmx_ssthresh); ! 372: metric(RTV_RTT, rmx_rtt); ! 373: metric(RTV_RTTVAR, rmx_rttvar); ! 374: metric(RTV_HOPCOUNT, rmx_hopcount); ! 375: metric(RTV_MTU, rmx_mtu); ! 376: metric(RTV_EXPIRE, rmx_expire); ! 377: #undef metric ! 378: } ! 379: ! 380: #define ROUNDUP(a) \ ! 381: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) ! 382: #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len)) ! 383: ! 384: static void ! 385: rt_xaddrs(cp, cplim, rtinfo) ! 386: register caddr_t cp, cplim; ! 387: register struct rt_addrinfo *rtinfo; ! 388: { ! 389: register struct sockaddr *sa; ! 390: register int i; ! 391: ! 392: bzero(rtinfo->rti_info, sizeof(rtinfo->rti_info)); ! 393: for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) { ! 394: if ((rtinfo->rti_addrs & (1 << i)) == 0) ! 395: continue; ! 396: rtinfo->rti_info[i] = sa = (struct sockaddr *)cp; ! 397: ADVANCE(cp, sa); ! 398: } ! 399: } ! 400: ! 401: /* ! 402: * Copy data from a buffer back into the indicated mbuf chain, ! 403: * starting "off" bytes from the beginning, extending the mbuf ! 404: * chain if necessary. ! 405: */ ! 406: void ! 407: m_copyback(m0, off, len, cp) ! 408: struct mbuf *m0; ! 409: register int off; ! 410: register int len; ! 411: caddr_t cp; ! 412: { ! 413: register int mlen; ! 414: register struct mbuf *m = m0, *n; ! 415: int totlen = 0; ! 416: ! 417: if (m0 == 0) ! 418: return; ! 419: while (off > (mlen = m->m_len)) { ! 420: off -= mlen; ! 421: totlen += mlen; ! 422: if (m->m_next == 0) { ! 423: n = m_getclr(M_DONTWAIT, m->m_type); ! 424: if (n == 0) ! 425: goto out; ! 426: n->m_len = min(MLEN, len + off); ! 427: m->m_next = n; ! 428: } ! 429: m = m->m_next; ! 430: } ! 431: while (len > 0) { ! 432: mlen = min (m->m_len - off, len); ! 433: bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen); ! 434: cp += mlen; ! 435: len -= mlen; ! 436: mlen += off; ! 437: off = 0; ! 438: totlen += mlen; ! 439: if (len == 0) ! 440: break; ! 441: if (m->m_next == 0) { ! 442: n = m_get(M_DONTWAIT, m->m_type); ! 443: if (n == 0) ! 444: break; ! 445: n->m_len = min(MLEN, len); ! 446: m->m_next = n; ! 447: } ! 448: m = m->m_next; ! 449: } ! 450: out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen)) ! 451: m->m_pkthdr.len = totlen; ! 452: } ! 453: ! 454: static struct mbuf * ! 455: rt_msg1(type, rtinfo) ! 456: int type; ! 457: register struct rt_addrinfo *rtinfo; ! 458: { ! 459: register struct rt_msghdr *rtm; ! 460: register struct mbuf *m; ! 461: register int i; ! 462: register struct sockaddr *sa; ! 463: int len, dlen; ! 464: ! 465: m = m_gethdr(M_DONTWAIT, MT_DATA); ! 466: if (m == 0) ! 467: return (m); ! 468: switch (type) { ! 469: ! 470: case RTM_DELADDR: ! 471: case RTM_NEWADDR: ! 472: len = sizeof(struct ifa_msghdr); ! 473: break; ! 474: ! 475: case RTM_IFINFO: ! 476: len = sizeof(struct if_msghdr); ! 477: break; ! 478: ! 479: default: ! 480: len = sizeof(struct rt_msghdr); ! 481: } ! 482: if (len > MHLEN) ! 483: panic("rt_msg1"); ! 484: m->m_pkthdr.len = m->m_len = len; ! 485: m->m_pkthdr.rcvif = 0; ! 486: rtm = mtod(m, struct rt_msghdr *); ! 487: bzero((caddr_t)rtm, len); ! 488: for (i = 0; i < RTAX_MAX; i++) { ! 489: if ((sa = rtinfo->rti_info[i]) == NULL) ! 490: continue; ! 491: rtinfo->rti_addrs |= (1 << i); ! 492: dlen = ROUNDUP(sa->sa_len); ! 493: m_copyback(m, len, dlen, (caddr_t)sa); ! 494: len += dlen; ! 495: } ! 496: if (m->m_pkthdr.len != len) { ! 497: m_freem(m); ! 498: return (NULL); ! 499: } ! 500: rtm->rtm_msglen = len; ! 501: rtm->rtm_version = RTM_VERSION; ! 502: rtm->rtm_type = type; ! 503: return (m); ! 504: } ! 505: ! 506: static int ! 507: rt_msg2(type, rtinfo, cp, w) ! 508: int type; ! 509: register struct rt_addrinfo *rtinfo; ! 510: caddr_t cp; ! 511: struct walkarg *w; ! 512: { ! 513: register int i; ! 514: int len, dlen, second_time = 0; ! 515: caddr_t cp0; ! 516: ! 517: rtinfo->rti_addrs = 0; ! 518: again: ! 519: switch (type) { ! 520: ! 521: case RTM_DELADDR: ! 522: case RTM_NEWADDR: ! 523: len = sizeof(struct ifa_msghdr); ! 524: break; ! 525: ! 526: case RTM_IFINFO: ! 527: len = sizeof(struct if_msghdr); ! 528: break; ! 529: ! 530: default: ! 531: len = sizeof(struct rt_msghdr); ! 532: } ! 533: if (cp0 = cp) ! 534: cp += len; ! 535: for (i = 0; i < RTAX_MAX; i++) { ! 536: register struct sockaddr *sa; ! 537: ! 538: if ((sa = rtinfo->rti_info[i]) == 0) ! 539: continue; ! 540: rtinfo->rti_addrs |= (1 << i); ! 541: dlen = ROUNDUP(sa->sa_len); ! 542: if (cp) { ! 543: bcopy((caddr_t)sa, cp, (unsigned)dlen); ! 544: cp += dlen; ! 545: } ! 546: len += dlen; ! 547: } ! 548: if (cp == 0 && w != NULL && !second_time) { ! 549: register struct walkarg *rw = w; ! 550: ! 551: rw->w_needed += len; ! 552: if (rw->w_needed <= 0 && rw->w_where) { ! 553: if (rw->w_tmemsize < len) { ! 554: if (rw->w_tmem) ! 555: _FREE(rw->w_tmem, M_RTABLE); ! 556: if (rw->w_tmem = (caddr_t) ! 557: _MALLOC(len, M_RTABLE, M_NOWAIT)) ! 558: rw->w_tmemsize = len; ! 559: } ! 560: if (rw->w_tmem) { ! 561: cp = rw->w_tmem; ! 562: second_time = 1; ! 563: goto again; ! 564: } else ! 565: rw->w_where = 0; ! 566: } ! 567: } ! 568: if (cp) { ! 569: register struct rt_msghdr *rtm = (struct rt_msghdr *)cp0; ! 570: ! 571: rtm->rtm_version = RTM_VERSION; ! 572: rtm->rtm_type = type; ! 573: rtm->rtm_msglen = len; ! 574: } ! 575: return (len); ! 576: } ! 577: ! 578: /* ! 579: * This routine is called to generate a message from the routing ! 580: * socket indicating that a redirect has occured, a routing lookup ! 581: * has failed, or that a protocol has detected timeouts to a particular ! 582: * destination. ! 583: */ ! 584: void ! 585: rt_missmsg(type, rtinfo, flags, error) ! 586: int type, flags, error; ! 587: register struct rt_addrinfo *rtinfo; ! 588: { ! 589: register struct rt_msghdr *rtm; ! 590: register struct mbuf *m; ! 591: struct sockaddr *sa = rtinfo->rti_info[RTAX_DST]; ! 592: ! 593: if (route_cb.any_count == 0) ! 594: return; ! 595: m = rt_msg1(type, rtinfo); ! 596: if (m == 0) ! 597: return; ! 598: rtm = mtod(m, struct rt_msghdr *); ! 599: rtm->rtm_flags = RTF_DONE | flags; ! 600: rtm->rtm_errno = error; ! 601: rtm->rtm_addrs = rtinfo->rti_addrs; ! 602: route_proto.sp_protocol = sa ? sa->sa_family : 0; ! 603: raw_input(m, &route_proto, &route_src, &route_dst); ! 604: } ! 605: ! 606: /* ! 607: * This routine is called to generate a message from the routing ! 608: * socket indicating that the status of a network interface has changed. ! 609: */ ! 610: void ! 611: rt_ifmsg(ifp) ! 612: register struct ifnet *ifp; ! 613: { ! 614: register struct if_msghdr *ifm; ! 615: struct mbuf *m; ! 616: struct rt_addrinfo info; ! 617: ! 618: if (route_cb.any_count == 0) ! 619: return; ! 620: bzero((caddr_t)&info, sizeof(info)); ! 621: m = rt_msg1(RTM_IFINFO, &info); ! 622: if (m == 0) ! 623: return; ! 624: ifm = mtod(m, struct if_msghdr *); ! 625: ifm->ifm_index = ifp->if_index; ! 626: ifm->ifm_flags = ifp->if_flags; ! 627: ifm->ifm_data = ifp->if_data; ! 628: ifm->ifm_addrs = 0; ! 629: route_proto.sp_protocol = 0; ! 630: raw_input(m, &route_proto, &route_src, &route_dst); ! 631: } ! 632: ! 633: /* ! 634: * This is called to generate messages from the routing socket ! 635: * indicating a network interface has had addresses associated with it. ! 636: * if we ever reverse the logic and replace messages TO the routing ! 637: * socket indicate a request to configure interfaces, then it will ! 638: * be unnecessary as the routing socket will automatically generate ! 639: * copies of it. ! 640: */ ! 641: void ! 642: rt_newaddrmsg(cmd, ifa, error, rt) ! 643: int cmd, error; ! 644: register struct ifaddr *ifa; ! 645: register struct rtentry *rt; ! 646: { ! 647: struct rt_addrinfo info; ! 648: struct sockaddr *sa; ! 649: int pass; ! 650: struct mbuf *m; ! 651: struct ifnet *ifp = ifa->ifa_ifp; ! 652: ! 653: if (route_cb.any_count == 0) ! 654: return; ! 655: for (pass = 1; pass < 3; pass++) { ! 656: bzero((caddr_t)&info, sizeof(info)); ! 657: if ((cmd == RTM_ADD && pass == 1) || ! 658: (cmd == RTM_DELETE && pass == 2)) { ! 659: register struct ifa_msghdr *ifam; ! 660: int ncmd = cmd == RTM_ADD ? RTM_NEWADDR : RTM_DELADDR; ! 661: ! 662: ifaaddr = sa = ifa->ifa_addr; ! 663: ifpaddr = ifp->if_addrlist->ifa_addr; ! 664: netmask = ifa->ifa_netmask; ! 665: brdaddr = ifa->ifa_dstaddr; ! 666: if ((m = rt_msg1(ncmd, &info)) == NULL) ! 667: continue; ! 668: ifam = mtod(m, struct ifa_msghdr *); ! 669: ifam->ifam_index = ifp->if_index; ! 670: ifam->ifam_metric = ifa->ifa_metric; ! 671: ifam->ifam_flags = ifa->ifa_flags; ! 672: ifam->ifam_addrs = info.rti_addrs; ! 673: } ! 674: if ((cmd == RTM_ADD && pass == 2) || ! 675: (cmd == RTM_DELETE && pass == 1)) { ! 676: register struct rt_msghdr *rtm; ! 677: ! 678: if (rt == 0) ! 679: continue; ! 680: netmask = rt_mask(rt); ! 681: dst = sa = rt_key(rt); ! 682: gate = rt->rt_gateway; ! 683: if ((m = rt_msg1(cmd, &info)) == NULL) ! 684: continue; ! 685: rtm = mtod(m, struct rt_msghdr *); ! 686: rtm->rtm_index = ifp->if_index; ! 687: rtm->rtm_flags |= rt->rt_flags; ! 688: rtm->rtm_errno = error; ! 689: rtm->rtm_addrs = info.rti_addrs; ! 690: } ! 691: route_proto.sp_protocol = sa ? sa->sa_family : 0; ! 692: raw_input(m, &route_proto, &route_src, &route_dst); ! 693: } ! 694: } ! 695: ! 696: /* ! 697: * This is used in dumping the kernel table via sysctl(). ! 698: */ ! 699: int ! 700: sysctl_dumpentry(rn, w) ! 701: struct radix_node *rn; ! 702: register struct walkarg *w; ! 703: { ! 704: register struct rtentry *rt = (struct rtentry *)rn; ! 705: int error = 0, size; ! 706: struct rt_addrinfo info; ! 707: ! 708: if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg)) ! 709: return 0; ! 710: bzero((caddr_t)&info, sizeof(info)); ! 711: dst = rt_key(rt); ! 712: gate = rt->rt_gateway; ! 713: netmask = rt_mask(rt); ! 714: genmask = rt->rt_genmask; ! 715: if (rt->rt_ifp) { ! 716: ifpaddr = rt->rt_ifp->if_addrlist->ifa_addr; ! 717: ifaaddr = rt->rt_ifa->ifa_addr; ! 718: if (rt->rt_ifp->if_flags & IFF_POINTOPOINT) ! 719: brdaddr = rt->rt_ifa->ifa_dstaddr; ! 720: } ! 721: size = rt_msg2(RTM_GET, &info, 0, w); ! 722: if (w->w_where && w->w_tmem) { ! 723: register struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem; ! 724: ! 725: rtm->rtm_flags = rt->rt_flags; ! 726: rtm->rtm_use = rt->rt_use; ! 727: rtm->rtm_rmx = rt->rt_rmx; ! 728: rtm->rtm_index = rt->rt_ifp->if_index; ! 729: rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0; ! 730: rtm->rtm_addrs = info.rti_addrs; ! 731: if (error = copyout((caddr_t)rtm, w->w_where, size)) ! 732: w->w_where = NULL; ! 733: else ! 734: w->w_where += size; ! 735: } ! 736: return (error); ! 737: } ! 738: ! 739: int ! 740: sysctl_iflist(af, w) ! 741: int af; ! 742: register struct walkarg *w; ! 743: { ! 744: register struct ifnet *ifp; ! 745: register struct ifaddr *ifa; ! 746: struct rt_addrinfo info; ! 747: int len, error = 0; ! 748: ! 749: bzero((caddr_t)&info, sizeof(info)); ! 750: for (ifp = ifnet; ifp; ifp = ifp->if_next) { ! 751: if (w->w_arg && w->w_arg != ifp->if_index) ! 752: continue; ! 753: ifa = ifp->if_addrlist; ! 754: ifpaddr = ifa->ifa_addr; ! 755: len = rt_msg2(RTM_IFINFO, &info, (caddr_t)0, w); ! 756: ifpaddr = 0; ! 757: if (w->w_where && w->w_tmem) { ! 758: register struct if_msghdr *ifm; ! 759: ! 760: ifm = (struct if_msghdr *)w->w_tmem; ! 761: ifm->ifm_index = ifp->if_index; ! 762: ifm->ifm_flags = ifp->if_flags; ! 763: ifm->ifm_data = ifp->if_data; ! 764: ifm->ifm_addrs = info.rti_addrs; ! 765: if (error = copyout((caddr_t)ifm, w->w_where, len)) ! 766: return (error); ! 767: w->w_where += len; ! 768: } ! 769: while (ifa = ifa->ifa_next) { ! 770: if (af && af != ifa->ifa_addr->sa_family) ! 771: continue; ! 772: ifaaddr = ifa->ifa_addr; ! 773: netmask = ifa->ifa_netmask; ! 774: brdaddr = ifa->ifa_dstaddr; ! 775: len = rt_msg2(RTM_NEWADDR, &info, 0, w); ! 776: if (w->w_where && w->w_tmem) { ! 777: register struct ifa_msghdr *ifam; ! 778: ! 779: ifam = (struct ifa_msghdr *)w->w_tmem; ! 780: ifam->ifam_index = ifa->ifa_ifp->if_index; ! 781: ifam->ifam_flags = ifa->ifa_flags; ! 782: ifam->ifam_metric = ifa->ifa_metric; ! 783: ifam->ifam_addrs = info.rti_addrs; ! 784: if (error = copyout(w->w_tmem, w->w_where, len)) ! 785: return (error); ! 786: w->w_where += len; ! 787: } ! 788: } ! 789: ifaaddr = netmask = brdaddr = 0; ! 790: } ! 791: return (0); ! 792: } ! 793: ! 794: int ! 795: sysctl_rtable(name, namelen, where, given, new, newlen) ! 796: int *name; ! 797: int namelen; ! 798: caddr_t where; ! 799: size_t *given; ! 800: caddr_t *new; ! 801: size_t newlen; ! 802: { ! 803: register struct radix_node_head *rnh; ! 804: int i, s, error = EINVAL; ! 805: u_char af; ! 806: struct walkarg w; ! 807: ! 808: if (new) ! 809: return (EPERM); ! 810: if (namelen != 3) ! 811: return (EINVAL); ! 812: af = name[0]; ! 813: Bzero(&w, sizeof(w)); ! 814: w.w_where = where; ! 815: w.w_given = *given; ! 816: w.w_needed = 0 - w.w_given; ! 817: w.w_op = name[1]; ! 818: w.w_arg = name[2]; ! 819: ! 820: s = splnet(); ! 821: switch (w.w_op) { ! 822: ! 823: case NET_RT_DUMP: ! 824: case NET_RT_FLAGS: ! 825: for (i = 1; i <= AF_MAX; i++) ! 826: if ((rnh = rt_tables[i]) && (af == 0 || af == i) && ! 827: (error = rnh->rnh_walktree(rnh, ! 828: sysctl_dumpentry, &w))) ! 829: break; ! 830: break; ! 831: ! 832: case NET_RT_IFLIST: ! 833: error = sysctl_iflist(af, &w); ! 834: } ! 835: splx(s); ! 836: if (w.w_tmem) ! 837: _FREE(w.w_tmem, M_RTABLE); ! 838: w.w_needed += w.w_given; ! 839: if (where) { ! 840: *given = w.w_where - where; ! 841: if (*given < w.w_needed) ! 842: return (ENOMEM); ! 843: } else { ! 844: *given = (11 * w.w_needed) / 10; ! 845: } ! 846: return (error); ! 847: } ! 848: ! 849: /* ! 850: * Definitions of protocols supported in the ROUTE domain. ! 851: */ ! 852: ! 853: extern struct domain routedomain; /* or at least forward */ ! 854: ! 855: struct protosw routesw[] = { ! 856: { SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR, ! 857: raw_input, route_output, raw_ctlinput, 0, ! 858: route_usrreq, ! 859: raw_init, 0, 0, 0, ! 860: sysctl_rtable, ! 861: } ! 862: }; ! 863: ! 864: struct domain routedomain = ! 865: { PF_ROUTE, "route", route_init, 0, 0, ! 866: routesw, &routesw[sizeof(routesw)/sizeof(routesw[0])] };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.