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