1 /* 2 * Copyright (c) 2004, 2005 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Jeffrey M. Hsu. 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. Neither the name of The DragonFly Project nor the names of its 16 * contributors may be used to endorse or promote products derived 17 * from this software without specific, prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 22 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 23 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 25 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 27 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 29 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 1988, 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 * @(#)rtsock.c 8.7 (Berkeley) 10/12/95 62 * $FreeBSD: src/sys/net/rtsock.c,v 1.44.2.11 2002/12/04 14:05:41 ru Exp $ 63 */ 64 65 #include "opt_sctp.h" 66 67 #include <sys/param.h> 68 #include <sys/systm.h> 69 #include <sys/kernel.h> 70 #include <sys/sysctl.h> 71 #include <sys/proc.h> 72 #include <sys/priv.h> 73 #include <sys/malloc.h> 74 #include <sys/mbuf.h> 75 #include <sys/protosw.h> 76 #include <sys/socket.h> 77 #include <sys/socketvar.h> 78 #include <sys/domain.h> 79 80 #include <sys/thread2.h> 81 #include <sys/socketvar2.h> 82 83 #include <net/if.h> 84 #include <net/route.h> 85 #include <net/raw_cb.h> 86 #include <net/netmsg2.h> 87 #include <net/netisr2.h> 88 89 #ifdef SCTP 90 extern void sctp_add_ip_address(struct ifaddr *ifa); 91 extern void sctp_delete_ip_address(struct ifaddr *ifa); 92 #endif /* SCTP */ 93 94 MALLOC_DEFINE(M_RTABLE, "routetbl", "routing tables"); 95 96 static struct route_cb { 97 int ip_count; 98 int ip6_count; 99 int ipx_count; 100 int ns_count; 101 int any_count; 102 } route_cb; 103 104 static const struct sockaddr route_src = { 2, PF_ROUTE, }; 105 106 struct walkarg { 107 int w_tmemsize; 108 int w_op, w_arg; 109 void *w_tmem; 110 struct sysctl_req *w_req; 111 }; 112 113 static struct mbuf * 114 rt_msg_mbuf (int, struct rt_addrinfo *); 115 static void rt_msg_buffer (int, struct rt_addrinfo *, void *buf, int len); 116 static int rt_msgsize (int type, struct rt_addrinfo *rtinfo); 117 static int rt_xaddrs (char *, char *, struct rt_addrinfo *); 118 static int sysctl_dumpentry (struct radix_node *rn, void *vw); 119 static int sysctl_iflist (int af, struct walkarg *w); 120 static int route_output(struct mbuf *, struct socket *, ...); 121 static void rt_setmetrics (u_long, struct rt_metrics *, 122 struct rt_metrics *); 123 124 /* 125 * It really doesn't make any sense at all for this code to share much 126 * with raw_usrreq.c, since its functionality is so restricted. XXX 127 */ 128 static void 129 rts_abort(netmsg_t msg) 130 { 131 crit_enter(); 132 raw_usrreqs.pru_abort(msg); 133 /* msg invalid now */ 134 crit_exit(); 135 } 136 137 /* pru_accept is EOPNOTSUPP */ 138 139 static void 140 rts_attach(netmsg_t msg) 141 { 142 struct socket *so = msg->base.nm_so; 143 struct pru_attach_info *ai = msg->attach.nm_ai; 144 struct rawcb *rp; 145 int proto = msg->attach.nm_proto; 146 int error; 147 148 crit_enter(); 149 if (sotorawcb(so) != NULL) { 150 error = EISCONN; 151 goto done; 152 } 153 154 rp = kmalloc(sizeof *rp, M_PCB, M_WAITOK | M_ZERO); 155 156 /* 157 * The critical section is necessary to block protocols from sending 158 * error notifications (like RTM_REDIRECT or RTM_LOSING) while 159 * this PCB is extant but incompletely initialized. 160 * Probably we should try to do more of this work beforehand and 161 * eliminate the critical section. 162 */ 163 so->so_pcb = rp; 164 soreference(so); /* so_pcb assignment */ 165 error = raw_attach(so, proto, ai->sb_rlimit); 166 rp = sotorawcb(so); 167 if (error) { 168 kfree(rp, M_PCB); 169 goto done; 170 } 171 switch(rp->rcb_proto.sp_protocol) { 172 case AF_INET: 173 route_cb.ip_count++; 174 break; 175 case AF_INET6: 176 route_cb.ip6_count++; 177 break; 178 case AF_IPX: 179 route_cb.ipx_count++; 180 break; 181 case AF_NS: 182 route_cb.ns_count++; 183 break; 184 } 185 rp->rcb_faddr = &route_src; 186 route_cb.any_count++; 187 soisconnected(so); 188 so->so_options |= SO_USELOOPBACK; 189 error = 0; 190 done: 191 crit_exit(); 192 lwkt_replymsg(&msg->lmsg, error); 193 } 194 195 static void 196 rts_bind(netmsg_t msg) 197 { 198 crit_enter(); 199 raw_usrreqs.pru_bind(msg); /* xxx just EINVAL */ 200 /* msg invalid now */ 201 crit_exit(); 202 } 203 204 static void 205 rts_connect(netmsg_t msg) 206 { 207 crit_enter(); 208 raw_usrreqs.pru_connect(msg); /* XXX just EINVAL */ 209 /* msg invalid now */ 210 crit_exit(); 211 } 212 213 /* pru_connect2 is EOPNOTSUPP */ 214 /* pru_control is EOPNOTSUPP */ 215 216 static void 217 rts_detach(netmsg_t msg) 218 { 219 struct socket *so = msg->base.nm_so; 220 struct rawcb *rp = sotorawcb(so); 221 222 crit_enter(); 223 if (rp != NULL) { 224 switch(rp->rcb_proto.sp_protocol) { 225 case AF_INET: 226 route_cb.ip_count--; 227 break; 228 case AF_INET6: 229 route_cb.ip6_count--; 230 break; 231 case AF_IPX: 232 route_cb.ipx_count--; 233 break; 234 case AF_NS: 235 route_cb.ns_count--; 236 break; 237 } 238 route_cb.any_count--; 239 } 240 raw_usrreqs.pru_detach(msg); 241 /* msg invalid now */ 242 crit_exit(); 243 } 244 245 static void 246 rts_disconnect(netmsg_t msg) 247 { 248 crit_enter(); 249 raw_usrreqs.pru_disconnect(msg); 250 /* msg invalid now */ 251 crit_exit(); 252 } 253 254 /* pru_listen is EOPNOTSUPP */ 255 256 static void 257 rts_peeraddr(netmsg_t msg) 258 { 259 crit_enter(); 260 raw_usrreqs.pru_peeraddr(msg); 261 /* msg invalid now */ 262 crit_exit(); 263 } 264 265 /* pru_rcvd is EOPNOTSUPP */ 266 /* pru_rcvoob is EOPNOTSUPP */ 267 268 static void 269 rts_send(netmsg_t msg) 270 { 271 crit_enter(); 272 raw_usrreqs.pru_send(msg); 273 /* msg invalid now */ 274 crit_exit(); 275 } 276 277 /* pru_sense is null */ 278 279 static void 280 rts_shutdown(netmsg_t msg) 281 { 282 crit_enter(); 283 raw_usrreqs.pru_shutdown(msg); 284 /* msg invalid now */ 285 crit_exit(); 286 } 287 288 static void 289 rts_sockaddr(netmsg_t msg) 290 { 291 crit_enter(); 292 raw_usrreqs.pru_sockaddr(msg); 293 /* msg invalid now */ 294 crit_exit(); 295 } 296 297 static struct pr_usrreqs route_usrreqs = { 298 .pru_abort = rts_abort, 299 .pru_accept = pr_generic_notsupp, 300 .pru_attach = rts_attach, 301 .pru_bind = rts_bind, 302 .pru_connect = rts_connect, 303 .pru_connect2 = pr_generic_notsupp, 304 .pru_control = pr_generic_notsupp, 305 .pru_detach = rts_detach, 306 .pru_disconnect = rts_disconnect, 307 .pru_listen = pr_generic_notsupp, 308 .pru_peeraddr = rts_peeraddr, 309 .pru_rcvd = pr_generic_notsupp, 310 .pru_rcvoob = pr_generic_notsupp, 311 .pru_send = rts_send, 312 .pru_sense = pru_sense_null, 313 .pru_shutdown = rts_shutdown, 314 .pru_sockaddr = rts_sockaddr, 315 .pru_sosend = sosend, 316 .pru_soreceive = soreceive 317 }; 318 319 static __inline sa_family_t 320 familyof(struct sockaddr *sa) 321 { 322 return (sa != NULL ? sa->sa_family : 0); 323 } 324 325 /* 326 * Routing socket input function. The packet must be serialized onto cpu 0. 327 * We use the cpu0_soport() netisr processing loop to handle it. 328 * 329 * This looks messy but it means that anyone, including interrupt code, 330 * can send a message to the routing socket. 331 */ 332 static void 333 rts_input_handler(netmsg_t msg) 334 { 335 static const struct sockaddr route_dst = { 2, PF_ROUTE, }; 336 struct sockproto route_proto; 337 struct netmsg_packet *pmsg = &msg->packet; 338 struct mbuf *m; 339 sa_family_t family; 340 struct rawcb *skip; 341 342 family = pmsg->base.lmsg.u.ms_result; 343 route_proto.sp_family = PF_ROUTE; 344 route_proto.sp_protocol = family; 345 346 m = pmsg->nm_packet; 347 M_ASSERTPKTHDR(m); 348 349 skip = m->m_pkthdr.header; 350 m->m_pkthdr.header = NULL; 351 352 raw_input(m, &route_proto, &route_src, &route_dst, skip); 353 } 354 355 static void 356 rts_input_skip(struct mbuf *m, sa_family_t family, struct rawcb *skip) 357 { 358 struct netmsg_packet *pmsg; 359 lwkt_port_t port; 360 361 M_ASSERTPKTHDR(m); 362 363 port = netisr_cpuport(0); /* XXX same as for routing socket */ 364 pmsg = &m->m_hdr.mh_netmsg; 365 netmsg_init(&pmsg->base, NULL, &netisr_apanic_rport, 366 0, rts_input_handler); 367 pmsg->nm_packet = m; 368 pmsg->base.lmsg.u.ms_result = family; 369 m->m_pkthdr.header = skip; /* XXX steal field in pkthdr */ 370 lwkt_sendmsg(port, &pmsg->base.lmsg); 371 } 372 373 static __inline void 374 rts_input(struct mbuf *m, sa_family_t family) 375 { 376 rts_input_skip(m, family, NULL); 377 } 378 379 static void * 380 reallocbuf_nofree(void *ptr, size_t len, size_t olen) 381 { 382 void *newptr; 383 384 newptr = kmalloc(len, M_RTABLE, M_INTWAIT | M_NULLOK); 385 if (newptr == NULL) 386 return NULL; 387 bcopy(ptr, newptr, olen); 388 return (newptr); 389 } 390 391 /* 392 * Internal helper routine for route_output(). 393 */ 394 static int 395 _fillrtmsg(struct rt_msghdr **prtm, struct rtentry *rt, 396 struct rt_addrinfo *rtinfo) 397 { 398 int msglen; 399 struct rt_msghdr *rtm = *prtm; 400 401 /* Fill in rt_addrinfo for call to rt_msg_buffer(). */ 402 rtinfo->rti_dst = rt_key(rt); 403 rtinfo->rti_gateway = rt->rt_gateway; 404 rtinfo->rti_netmask = rt_mask(rt); /* might be NULL */ 405 rtinfo->rti_genmask = rt->rt_genmask; /* might be NULL */ 406 if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) { 407 if (rt->rt_ifp != NULL) { 408 rtinfo->rti_ifpaddr = 409 TAILQ_FIRST(&rt->rt_ifp->if_addrheads[mycpuid]) 410 ->ifa->ifa_addr; 411 rtinfo->rti_ifaaddr = rt->rt_ifa->ifa_addr; 412 if (rt->rt_ifp->if_flags & IFF_POINTOPOINT) 413 rtinfo->rti_bcastaddr = rt->rt_ifa->ifa_dstaddr; 414 rtm->rtm_index = rt->rt_ifp->if_index; 415 } else { 416 rtinfo->rti_ifpaddr = NULL; 417 rtinfo->rti_ifaaddr = NULL; 418 } 419 } else if (rt->rt_ifp != NULL) { 420 rtm->rtm_index = rt->rt_ifp->if_index; 421 } 422 423 msglen = rt_msgsize(rtm->rtm_type, rtinfo); 424 if (rtm->rtm_msglen < msglen) { 425 /* NOTE: Caller will free the old rtm accordingly */ 426 rtm = reallocbuf_nofree(rtm, msglen, rtm->rtm_msglen); 427 if (rtm == NULL) 428 return (ENOBUFS); 429 *prtm = rtm; 430 } 431 rt_msg_buffer(rtm->rtm_type, rtinfo, rtm, msglen); 432 433 rtm->rtm_flags = rt->rt_flags; 434 rtm->rtm_rmx = rt->rt_rmx; 435 rtm->rtm_addrs = rtinfo->rti_addrs; 436 437 return (0); 438 } 439 440 struct rtm_arg { 441 struct rt_msghdr *bak_rtm; 442 struct rt_msghdr *new_rtm; 443 }; 444 445 static int 446 fillrtmsg(struct rtm_arg *arg, struct rtentry *rt, 447 struct rt_addrinfo *rtinfo) 448 { 449 struct rt_msghdr *rtm = arg->new_rtm; 450 int error; 451 452 error = _fillrtmsg(&rtm, rt, rtinfo); 453 if (!error) { 454 if (arg->new_rtm != rtm) { 455 /* 456 * _fillrtmsg() just allocated a new rtm; 457 * if the previously allocated rtm is not 458 * the backing rtm, it should be freed. 459 */ 460 if (arg->new_rtm != arg->bak_rtm) 461 kfree(arg->new_rtm, M_RTABLE); 462 arg->new_rtm = rtm; 463 } 464 } 465 return error; 466 } 467 468 static void route_output_add_callback(int, int, struct rt_addrinfo *, 469 struct rtentry *, void *); 470 static void route_output_delete_callback(int, int, struct rt_addrinfo *, 471 struct rtentry *, void *); 472 static int route_output_get_callback(int, struct rt_addrinfo *, 473 struct rtentry *, void *, int); 474 static int route_output_change_callback(int, struct rt_addrinfo *, 475 struct rtentry *, void *, int); 476 static int route_output_lock_callback(int, struct rt_addrinfo *, 477 struct rtentry *, void *, int); 478 479 /*ARGSUSED*/ 480 static int 481 route_output(struct mbuf *m, struct socket *so, ...) 482 { 483 struct rtm_arg arg; 484 struct rt_msghdr *rtm = NULL; 485 struct rawcb *rp = NULL; 486 struct pr_output_info *oi; 487 struct rt_addrinfo rtinfo; 488 sa_family_t family; 489 int len, error = 0; 490 __va_list ap; 491 492 M_ASSERTPKTHDR(m); 493 494 __va_start(ap, so); 495 oi = __va_arg(ap, struct pr_output_info *); 496 __va_end(ap); 497 498 family = familyof(NULL); 499 500 #define gotoerr(e) { error = e; goto flush;} 501 502 if (m == NULL || 503 (m->m_len < sizeof(long) && 504 (m = m_pullup(m, sizeof(long))) == NULL)) 505 return (ENOBUFS); 506 len = m->m_pkthdr.len; 507 if (len < sizeof(struct rt_msghdr) || 508 len != mtod(m, struct rt_msghdr *)->rtm_msglen) 509 gotoerr(EINVAL); 510 511 rtm = kmalloc(len, M_RTABLE, M_INTWAIT | M_NULLOK); 512 if (rtm == NULL) 513 gotoerr(ENOBUFS); 514 515 m_copydata(m, 0, len, (caddr_t)rtm); 516 if (rtm->rtm_version != RTM_VERSION) 517 gotoerr(EPROTONOSUPPORT); 518 519 rtm->rtm_pid = oi->p_pid; 520 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 521 rtinfo.rti_addrs = rtm->rtm_addrs; 522 if (rt_xaddrs((char *)(rtm + 1), (char *)rtm + len, &rtinfo) != 0) 523 gotoerr(EINVAL); 524 525 rtinfo.rti_flags = rtm->rtm_flags; 526 if (rtinfo.rti_dst == NULL || rtinfo.rti_dst->sa_family >= AF_MAX || 527 (rtinfo.rti_gateway && rtinfo.rti_gateway->sa_family >= AF_MAX)) 528 gotoerr(EINVAL); 529 530 family = familyof(rtinfo.rti_dst); 531 532 if (rtinfo.rti_genmask != NULL) { 533 error = rtmask_add_global(rtinfo.rti_genmask); 534 if (error) 535 goto flush; 536 } 537 538 /* 539 * Verify that the caller has the appropriate privilege; RTM_GET 540 * is the only operation the non-superuser is allowed. 541 */ 542 if (rtm->rtm_type != RTM_GET && 543 priv_check_cred(so->so_cred, PRIV_ROOT, 0) != 0) 544 gotoerr(EPERM); 545 546 switch (rtm->rtm_type) { 547 case RTM_ADD: 548 if (rtinfo.rti_gateway == NULL) { 549 error = EINVAL; 550 } else { 551 error = rtrequest1_global(RTM_ADD, &rtinfo, 552 route_output_add_callback, rtm); 553 } 554 break; 555 case RTM_DELETE: 556 /* 557 * Backing rtm (bak_rtm) could _not_ be freed during 558 * rtrequest1_global or rtsearch_global, even if the 559 * callback reallocates the rtm due to its size changes, 560 * since rtinfo points to the backing rtm's memory area. 561 * After rtrequest1_global or rtsearch_global returns, 562 * it is safe to free the backing rtm, since rtinfo will 563 * not be used anymore. 564 * 565 * new_rtm will be used to save the new rtm allocated 566 * by rtrequest1_global or rtsearch_global. 567 */ 568 arg.bak_rtm = rtm; 569 arg.new_rtm = rtm; 570 error = rtrequest1_global(RTM_DELETE, &rtinfo, 571 route_output_delete_callback, &arg); 572 rtm = arg.new_rtm; 573 if (rtm != arg.bak_rtm) 574 kfree(arg.bak_rtm, M_RTABLE); 575 break; 576 case RTM_GET: 577 /* See the comment in RTM_DELETE */ 578 arg.bak_rtm = rtm; 579 arg.new_rtm = rtm; 580 error = rtsearch_global(RTM_GET, &rtinfo, 581 route_output_get_callback, &arg, 582 RTS_NOEXACTMATCH); 583 rtm = arg.new_rtm; 584 if (rtm != arg.bak_rtm) 585 kfree(arg.bak_rtm, M_RTABLE); 586 break; 587 case RTM_CHANGE: 588 error = rtsearch_global(RTM_CHANGE, &rtinfo, 589 route_output_change_callback, rtm, 590 RTS_EXACTMATCH); 591 break; 592 case RTM_LOCK: 593 error = rtsearch_global(RTM_LOCK, &rtinfo, 594 route_output_lock_callback, rtm, 595 RTS_EXACTMATCH); 596 break; 597 default: 598 error = EOPNOTSUPP; 599 break; 600 } 601 flush: 602 if (rtm != NULL) { 603 if (error != 0) 604 rtm->rtm_errno = error; 605 else 606 rtm->rtm_flags |= RTF_DONE; 607 } 608 609 /* 610 * Check to see if we don't want our own messages. 611 */ 612 if (!(so->so_options & SO_USELOOPBACK)) { 613 if (route_cb.any_count <= 1) { 614 if (rtm != NULL) 615 kfree(rtm, M_RTABLE); 616 m_freem(m); 617 return (error); 618 } 619 /* There is another listener, so construct message */ 620 rp = sotorawcb(so); 621 } 622 if (rtm != NULL) { 623 m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm); 624 if (m->m_pkthdr.len < rtm->rtm_msglen) { 625 m_freem(m); 626 m = NULL; 627 } else if (m->m_pkthdr.len > rtm->rtm_msglen) 628 m_adj(m, rtm->rtm_msglen - m->m_pkthdr.len); 629 kfree(rtm, M_RTABLE); 630 } 631 if (m != NULL) 632 rts_input_skip(m, family, rp); 633 return (error); 634 } 635 636 static void 637 route_output_add_callback(int cmd, int error, struct rt_addrinfo *rtinfo, 638 struct rtentry *rt, void *arg) 639 { 640 struct rt_msghdr *rtm = arg; 641 642 if (error == 0 && rt != NULL) { 643 rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx, 644 &rt->rt_rmx); 645 rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits); 646 rt->rt_rmx.rmx_locks |= 647 (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks); 648 if (rtinfo->rti_genmask != NULL) { 649 rt->rt_genmask = rtmask_purelookup(rtinfo->rti_genmask); 650 if (rt->rt_genmask == NULL) { 651 /* 652 * This should not happen, since we 653 * have already installed genmask 654 * on each CPU before we reach here. 655 */ 656 panic("genmask is gone!?"); 657 } 658 } else { 659 rt->rt_genmask = NULL; 660 } 661 rtm->rtm_index = rt->rt_ifp->if_index; 662 } 663 } 664 665 static void 666 route_output_delete_callback(int cmd, int error, struct rt_addrinfo *rtinfo, 667 struct rtentry *rt, void *arg) 668 { 669 if (error == 0 && rt) { 670 ++rt->rt_refcnt; 671 if (fillrtmsg(arg, rt, rtinfo) != 0) { 672 error = ENOBUFS; 673 /* XXX no way to return the error */ 674 } 675 --rt->rt_refcnt; 676 } 677 if (rt && rt->rt_refcnt == 0) { 678 ++rt->rt_refcnt; 679 rtfree(rt); 680 } 681 } 682 683 static int 684 route_output_get_callback(int cmd, struct rt_addrinfo *rtinfo, 685 struct rtentry *rt, void *arg, int found_cnt) 686 { 687 int error, found = 0; 688 689 if (((rtinfo->rti_flags ^ rt->rt_flags) & RTF_HOST) == 0) 690 found = 1; 691 692 error = fillrtmsg(arg, rt, rtinfo); 693 if (!error && found) { 694 /* Got the exact match, we could return now! */ 695 error = EJUSTRETURN; 696 } 697 return error; 698 } 699 700 static int 701 route_output_change_callback(int cmd, struct rt_addrinfo *rtinfo, 702 struct rtentry *rt, void *arg, int found_cnt) 703 { 704 struct rt_msghdr *rtm = arg; 705 struct ifaddr *ifa; 706 int error = 0; 707 708 /* 709 * new gateway could require new ifaddr, ifp; 710 * flags may also be different; ifp may be specified 711 * by ll sockaddr when protocol address is ambiguous 712 */ 713 if (((rt->rt_flags & RTF_GATEWAY) && rtinfo->rti_gateway != NULL) || 714 rtinfo->rti_ifpaddr != NULL || 715 (rtinfo->rti_ifaaddr != NULL && 716 !sa_equal(rtinfo->rti_ifaaddr, rt->rt_ifa->ifa_addr))) { 717 error = rt_getifa(rtinfo); 718 if (error != 0) 719 goto done; 720 } 721 if (rtinfo->rti_gateway != NULL) { 722 /* 723 * We only need to generate rtmsg upon the 724 * first route to be changed. 725 */ 726 error = rt_setgate(rt, rt_key(rt), rtinfo->rti_gateway, 727 found_cnt == 1 ? RTL_REPORTMSG : RTL_DONTREPORT); 728 if (error != 0) 729 goto done; 730 } 731 if ((ifa = rtinfo->rti_ifa) != NULL) { 732 struct ifaddr *oifa = rt->rt_ifa; 733 734 if (oifa != ifa) { 735 if (oifa && oifa->ifa_rtrequest) 736 oifa->ifa_rtrequest(RTM_DELETE, rt, rtinfo); 737 IFAFREE(rt->rt_ifa); 738 IFAREF(ifa); 739 rt->rt_ifa = ifa; 740 rt->rt_ifp = rtinfo->rti_ifp; 741 } 742 } 743 rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx, &rt->rt_rmx); 744 if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest) 745 rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, rtinfo); 746 if (rtinfo->rti_genmask != NULL) { 747 rt->rt_genmask = rtmask_purelookup(rtinfo->rti_genmask); 748 if (rt->rt_genmask == NULL) { 749 /* 750 * This should not happen, since we 751 * have already installed genmask 752 * on each CPU before we reach here. 753 */ 754 panic("genmask is gone!?"); 755 } 756 } 757 rtm->rtm_index = rt->rt_ifp->if_index; 758 done: 759 return error; 760 } 761 762 static int 763 route_output_lock_callback(int cmd, struct rt_addrinfo *rtinfo, 764 struct rtentry *rt, void *arg, 765 int found_cnt __unused) 766 { 767 struct rt_msghdr *rtm = arg; 768 769 rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits); 770 rt->rt_rmx.rmx_locks |= 771 (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks); 772 return 0; 773 } 774 775 static void 776 rt_setmetrics(u_long which, struct rt_metrics *in, struct rt_metrics *out) 777 { 778 #define setmetric(flag, elt) if (which & (flag)) out->elt = in->elt; 779 setmetric(RTV_RPIPE, rmx_recvpipe); 780 setmetric(RTV_SPIPE, rmx_sendpipe); 781 setmetric(RTV_SSTHRESH, rmx_ssthresh); 782 setmetric(RTV_RTT, rmx_rtt); 783 setmetric(RTV_RTTVAR, rmx_rttvar); 784 setmetric(RTV_HOPCOUNT, rmx_hopcount); 785 setmetric(RTV_MTU, rmx_mtu); 786 setmetric(RTV_EXPIRE, rmx_expire); 787 setmetric(RTV_MSL, rmx_msl); 788 setmetric(RTV_IWMAXSEGS, rmx_iwmaxsegs); 789 setmetric(RTV_IWCAPSEGS, rmx_iwcapsegs); 790 #undef setmetric 791 } 792 793 #define ROUNDUP(a) \ 794 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) 795 796 /* 797 * Extract the addresses of the passed sockaddrs. 798 * Do a little sanity checking so as to avoid bad memory references. 799 * This data is derived straight from userland. 800 */ 801 static int 802 rt_xaddrs(char *cp, char *cplim, struct rt_addrinfo *rtinfo) 803 { 804 struct sockaddr *sa; 805 int i; 806 807 for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) { 808 if ((rtinfo->rti_addrs & (1 << i)) == 0) 809 continue; 810 sa = (struct sockaddr *)cp; 811 /* 812 * It won't fit. 813 */ 814 if ((cp + sa->sa_len) > cplim) { 815 return (EINVAL); 816 } 817 818 /* 819 * There are no more... Quit now. 820 * If there are more bits, they are in error. 821 * I've seen this. route(1) can evidently generate these. 822 * This causes kernel to core dump. 823 * For compatibility, if we see this, point to a safe address. 824 */ 825 if (sa->sa_len == 0) { 826 static struct sockaddr sa_zero = { 827 sizeof sa_zero, AF_INET, 828 }; 829 830 rtinfo->rti_info[i] = &sa_zero; 831 kprintf("rtsock: received more addr bits than sockaddrs.\n"); 832 return (0); /* should be EINVAL but for compat */ 833 } 834 835 /* Accept the sockaddr. */ 836 rtinfo->rti_info[i] = sa; 837 cp += ROUNDUP(sa->sa_len); 838 } 839 return (0); 840 } 841 842 static int 843 rt_msghdrsize(int type) 844 { 845 switch (type) { 846 case RTM_DELADDR: 847 case RTM_NEWADDR: 848 return sizeof(struct ifa_msghdr); 849 case RTM_DELMADDR: 850 case RTM_NEWMADDR: 851 return sizeof(struct ifma_msghdr); 852 case RTM_IFINFO: 853 return sizeof(struct if_msghdr); 854 case RTM_IFANNOUNCE: 855 case RTM_IEEE80211: 856 return sizeof(struct if_announcemsghdr); 857 default: 858 return sizeof(struct rt_msghdr); 859 } 860 } 861 862 static int 863 rt_msgsize(int type, struct rt_addrinfo *rtinfo) 864 { 865 int len, i; 866 867 len = rt_msghdrsize(type); 868 for (i = 0; i < RTAX_MAX; i++) { 869 if (rtinfo->rti_info[i] != NULL) 870 len += ROUNDUP(rtinfo->rti_info[i]->sa_len); 871 } 872 len = ALIGN(len); 873 return len; 874 } 875 876 /* 877 * Build a routing message in a buffer. 878 * Copy the addresses in the rtinfo->rti_info[] sockaddr array 879 * to the end of the buffer after the message header. 880 * 881 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[]. 882 * This side-effect can be avoided if we reorder the addrs bitmask field in all 883 * the route messages to line up so we can set it here instead of back in the 884 * calling routine. 885 */ 886 static void 887 rt_msg_buffer(int type, struct rt_addrinfo *rtinfo, void *buf, int msglen) 888 { 889 struct rt_msghdr *rtm; 890 char *cp; 891 int dlen, i; 892 893 rtm = (struct rt_msghdr *) buf; 894 rtm->rtm_version = RTM_VERSION; 895 rtm->rtm_type = type; 896 rtm->rtm_msglen = msglen; 897 898 cp = (char *)buf + rt_msghdrsize(type); 899 rtinfo->rti_addrs = 0; 900 for (i = 0; i < RTAX_MAX; i++) { 901 struct sockaddr *sa; 902 903 if ((sa = rtinfo->rti_info[i]) == NULL) 904 continue; 905 rtinfo->rti_addrs |= (1 << i); 906 dlen = ROUNDUP(sa->sa_len); 907 bcopy(sa, cp, dlen); 908 cp += dlen; 909 } 910 } 911 912 /* 913 * Build a routing message in a mbuf chain. 914 * Copy the addresses in the rtinfo->rti_info[] sockaddr array 915 * to the end of the mbuf after the message header. 916 * 917 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[]. 918 * This side-effect can be avoided if we reorder the addrs bitmask field in all 919 * the route messages to line up so we can set it here instead of back in the 920 * calling routine. 921 */ 922 static struct mbuf * 923 rt_msg_mbuf(int type, struct rt_addrinfo *rtinfo) 924 { 925 struct mbuf *m; 926 struct rt_msghdr *rtm; 927 int hlen, len; 928 int i; 929 930 hlen = rt_msghdrsize(type); 931 KASSERT(hlen <= MCLBYTES, ("rt_msg_mbuf: hlen %d doesn't fit", hlen)); 932 933 m = m_getl(hlen, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL); 934 if (m == NULL) 935 return (NULL); 936 mbuftrackid(m, 32); 937 m->m_pkthdr.len = m->m_len = hlen; 938 m->m_pkthdr.rcvif = NULL; 939 rtinfo->rti_addrs = 0; 940 len = hlen; 941 for (i = 0; i < RTAX_MAX; i++) { 942 struct sockaddr *sa; 943 int dlen; 944 945 if ((sa = rtinfo->rti_info[i]) == NULL) 946 continue; 947 rtinfo->rti_addrs |= (1 << i); 948 dlen = ROUNDUP(sa->sa_len); 949 m_copyback(m, len, dlen, (caddr_t)sa); /* can grow mbuf chain */ 950 len += dlen; 951 } 952 if (m->m_pkthdr.len != len) { /* one of the m_copyback() calls failed */ 953 m_freem(m); 954 return (NULL); 955 } 956 rtm = mtod(m, struct rt_msghdr *); 957 bzero(rtm, hlen); 958 rtm->rtm_msglen = len; 959 rtm->rtm_version = RTM_VERSION; 960 rtm->rtm_type = type; 961 return (m); 962 } 963 964 /* 965 * This routine is called to generate a message from the routing 966 * socket indicating that a redirect has occurred, a routing lookup 967 * has failed, or that a protocol has detected timeouts to a particular 968 * destination. 969 */ 970 void 971 rt_missmsg(int type, struct rt_addrinfo *rtinfo, int flags, int error) 972 { 973 struct sockaddr *dst = rtinfo->rti_info[RTAX_DST]; 974 struct rt_msghdr *rtm; 975 struct mbuf *m; 976 977 if (route_cb.any_count == 0) 978 return; 979 m = rt_msg_mbuf(type, rtinfo); 980 if (m == NULL) 981 return; 982 rtm = mtod(m, struct rt_msghdr *); 983 rtm->rtm_flags = RTF_DONE | flags; 984 rtm->rtm_errno = error; 985 rtm->rtm_addrs = rtinfo->rti_addrs; 986 rts_input(m, familyof(dst)); 987 } 988 989 void 990 rt_dstmsg(int type, struct sockaddr *dst, int error) 991 { 992 struct rt_msghdr *rtm; 993 struct rt_addrinfo addrs; 994 struct mbuf *m; 995 996 if (route_cb.any_count == 0) 997 return; 998 bzero(&addrs, sizeof(struct rt_addrinfo)); 999 addrs.rti_info[RTAX_DST] = dst; 1000 m = rt_msg_mbuf(type, &addrs); 1001 if (m == NULL) 1002 return; 1003 rtm = mtod(m, struct rt_msghdr *); 1004 rtm->rtm_flags = RTF_DONE; 1005 rtm->rtm_errno = error; 1006 rtm->rtm_addrs = addrs.rti_addrs; 1007 rts_input(m, familyof(dst)); 1008 } 1009 1010 /* 1011 * This routine is called to generate a message from the routing 1012 * socket indicating that the status of a network interface has changed. 1013 */ 1014 void 1015 rt_ifmsg(struct ifnet *ifp) 1016 { 1017 struct if_msghdr *ifm; 1018 struct mbuf *m; 1019 struct rt_addrinfo rtinfo; 1020 1021 if (route_cb.any_count == 0) 1022 return; 1023 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 1024 m = rt_msg_mbuf(RTM_IFINFO, &rtinfo); 1025 if (m == NULL) 1026 return; 1027 ifm = mtod(m, struct if_msghdr *); 1028 ifm->ifm_index = ifp->if_index; 1029 ifm->ifm_flags = ifp->if_flags; 1030 ifm->ifm_data = ifp->if_data; 1031 ifm->ifm_addrs = 0; 1032 rts_input(m, 0); 1033 } 1034 1035 static void 1036 rt_ifamsg(int cmd, struct ifaddr *ifa) 1037 { 1038 struct ifa_msghdr *ifam; 1039 struct rt_addrinfo rtinfo; 1040 struct mbuf *m; 1041 struct ifnet *ifp = ifa->ifa_ifp; 1042 1043 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 1044 rtinfo.rti_ifaaddr = ifa->ifa_addr; 1045 rtinfo.rti_ifpaddr = 1046 TAILQ_FIRST(&ifp->if_addrheads[mycpuid])->ifa->ifa_addr; 1047 rtinfo.rti_netmask = ifa->ifa_netmask; 1048 rtinfo.rti_bcastaddr = ifa->ifa_dstaddr; 1049 1050 m = rt_msg_mbuf(cmd, &rtinfo); 1051 if (m == NULL) 1052 return; 1053 1054 ifam = mtod(m, struct ifa_msghdr *); 1055 ifam->ifam_index = ifp->if_index; 1056 ifam->ifam_metric = ifa->ifa_metric; 1057 ifam->ifam_flags = ifa->ifa_flags; 1058 ifam->ifam_addrs = rtinfo.rti_addrs; 1059 1060 rts_input(m, familyof(ifa->ifa_addr)); 1061 } 1062 1063 void 1064 rt_rtmsg(int cmd, struct rtentry *rt, struct ifnet *ifp, int error) 1065 { 1066 struct rt_msghdr *rtm; 1067 struct rt_addrinfo rtinfo; 1068 struct mbuf *m; 1069 struct sockaddr *dst; 1070 1071 if (rt == NULL) 1072 return; 1073 1074 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 1075 rtinfo.rti_dst = dst = rt_key(rt); 1076 rtinfo.rti_gateway = rt->rt_gateway; 1077 rtinfo.rti_netmask = rt_mask(rt); 1078 if (ifp != NULL) { 1079 rtinfo.rti_ifpaddr = 1080 TAILQ_FIRST(&ifp->if_addrheads[mycpuid])->ifa->ifa_addr; 1081 } 1082 rtinfo.rti_ifaaddr = rt->rt_ifa->ifa_addr; 1083 1084 m = rt_msg_mbuf(cmd, &rtinfo); 1085 if (m == NULL) 1086 return; 1087 1088 rtm = mtod(m, struct rt_msghdr *); 1089 if (ifp != NULL) 1090 rtm->rtm_index = ifp->if_index; 1091 rtm->rtm_flags |= rt->rt_flags; 1092 rtm->rtm_errno = error; 1093 rtm->rtm_addrs = rtinfo.rti_addrs; 1094 1095 rts_input(m, familyof(dst)); 1096 } 1097 1098 /* 1099 * This is called to generate messages from the routing socket 1100 * indicating a network interface has had addresses associated with it. 1101 * if we ever reverse the logic and replace messages TO the routing 1102 * socket indicate a request to configure interfaces, then it will 1103 * be unnecessary as the routing socket will automatically generate 1104 * copies of it. 1105 */ 1106 void 1107 rt_newaddrmsg(int cmd, struct ifaddr *ifa, int error, struct rtentry *rt) 1108 { 1109 #ifdef SCTP 1110 /* 1111 * notify the SCTP stack 1112 * this will only get called when an address is added/deleted 1113 * XXX pass the ifaddr struct instead if ifa->ifa_addr... 1114 */ 1115 if (cmd == RTM_ADD) 1116 sctp_add_ip_address(ifa); 1117 else if (cmd == RTM_DELETE) 1118 sctp_delete_ip_address(ifa); 1119 #endif /* SCTP */ 1120 1121 if (route_cb.any_count == 0) 1122 return; 1123 1124 if (cmd == RTM_ADD) { 1125 rt_ifamsg(RTM_NEWADDR, ifa); 1126 rt_rtmsg(RTM_ADD, rt, ifa->ifa_ifp, error); 1127 } else { 1128 KASSERT((cmd == RTM_DELETE), ("unknown cmd %d", cmd)); 1129 rt_rtmsg(RTM_DELETE, rt, ifa->ifa_ifp, error); 1130 rt_ifamsg(RTM_DELADDR, ifa); 1131 } 1132 } 1133 1134 /* 1135 * This is the analogue to the rt_newaddrmsg which performs the same 1136 * function but for multicast group memberhips. This is easier since 1137 * there is no route state to worry about. 1138 */ 1139 void 1140 rt_newmaddrmsg(int cmd, struct ifmultiaddr *ifma) 1141 { 1142 struct rt_addrinfo rtinfo; 1143 struct mbuf *m = NULL; 1144 struct ifnet *ifp = ifma->ifma_ifp; 1145 struct ifma_msghdr *ifmam; 1146 1147 if (route_cb.any_count == 0) 1148 return; 1149 1150 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 1151 rtinfo.rti_ifaaddr = ifma->ifma_addr; 1152 if (ifp != NULL && !TAILQ_EMPTY(&ifp->if_addrheads[mycpuid])) { 1153 rtinfo.rti_ifpaddr = 1154 TAILQ_FIRST(&ifp->if_addrheads[mycpuid])->ifa->ifa_addr; 1155 } 1156 /* 1157 * If a link-layer address is present, present it as a ``gateway'' 1158 * (similarly to how ARP entries, e.g., are presented). 1159 */ 1160 rtinfo.rti_gateway = ifma->ifma_lladdr; 1161 1162 m = rt_msg_mbuf(cmd, &rtinfo); 1163 if (m == NULL) 1164 return; 1165 1166 ifmam = mtod(m, struct ifma_msghdr *); 1167 ifmam->ifmam_index = ifp->if_index; 1168 ifmam->ifmam_addrs = rtinfo.rti_addrs; 1169 1170 rts_input(m, familyof(ifma->ifma_addr)); 1171 } 1172 1173 static struct mbuf * 1174 rt_makeifannouncemsg(struct ifnet *ifp, int type, int what, 1175 struct rt_addrinfo *info) 1176 { 1177 struct if_announcemsghdr *ifan; 1178 struct mbuf *m; 1179 1180 if (route_cb.any_count == 0) 1181 return NULL; 1182 1183 bzero(info, sizeof(*info)); 1184 m = rt_msg_mbuf(type, info); 1185 if (m == NULL) 1186 return NULL; 1187 1188 ifan = mtod(m, struct if_announcemsghdr *); 1189 ifan->ifan_index = ifp->if_index; 1190 strlcpy(ifan->ifan_name, ifp->if_xname, sizeof ifan->ifan_name); 1191 ifan->ifan_what = what; 1192 return m; 1193 } 1194 1195 /* 1196 * This is called to generate routing socket messages indicating 1197 * IEEE80211 wireless events. 1198 * XXX we piggyback on the RTM_IFANNOUNCE msg format in a clumsy way. 1199 */ 1200 void 1201 rt_ieee80211msg(struct ifnet *ifp, int what, void *data, size_t data_len) 1202 { 1203 struct rt_addrinfo info; 1204 struct mbuf *m; 1205 1206 m = rt_makeifannouncemsg(ifp, RTM_IEEE80211, what, &info); 1207 if (m == NULL) 1208 return; 1209 1210 /* 1211 * Append the ieee80211 data. Try to stick it in the 1212 * mbuf containing the ifannounce msg; otherwise allocate 1213 * a new mbuf and append. 1214 * 1215 * NB: we assume m is a single mbuf. 1216 */ 1217 if (data_len > M_TRAILINGSPACE(m)) { 1218 /* XXX use m_getb(data_len, MB_DONTWAIT, MT_DATA, 0); */ 1219 struct mbuf *n = m_get(MB_DONTWAIT, MT_DATA); 1220 if (n == NULL) { 1221 m_freem(m); 1222 return; 1223 } 1224 KKASSERT(data_len <= M_TRAILINGSPACE(n)); 1225 bcopy(data, mtod(n, void *), data_len); 1226 n->m_len = data_len; 1227 m->m_next = n; 1228 } else if (data_len > 0) { 1229 bcopy(data, mtod(m, u_int8_t *) + m->m_len, data_len); 1230 m->m_len += data_len; 1231 } 1232 mbuftrackid(m, 33); 1233 if (m->m_flags & M_PKTHDR) 1234 m->m_pkthdr.len += data_len; 1235 mtod(m, struct if_announcemsghdr *)->ifan_msglen += data_len; 1236 rts_input(m, 0); 1237 } 1238 1239 /* 1240 * This is called to generate routing socket messages indicating 1241 * network interface arrival and departure. 1242 */ 1243 void 1244 rt_ifannouncemsg(struct ifnet *ifp, int what) 1245 { 1246 struct rt_addrinfo addrinfo; 1247 struct mbuf *m; 1248 1249 m = rt_makeifannouncemsg(ifp, RTM_IFANNOUNCE, what, &addrinfo); 1250 if (m != NULL) 1251 rts_input(m, 0); 1252 } 1253 1254 static int 1255 resizewalkarg(struct walkarg *w, int len) 1256 { 1257 void *newptr; 1258 1259 newptr = kmalloc(len, M_RTABLE, M_INTWAIT | M_NULLOK); 1260 if (newptr == NULL) 1261 return (ENOMEM); 1262 if (w->w_tmem != NULL) 1263 kfree(w->w_tmem, M_RTABLE); 1264 w->w_tmem = newptr; 1265 w->w_tmemsize = len; 1266 return (0); 1267 } 1268 1269 /* 1270 * This is used in dumping the kernel table via sysctl(). 1271 */ 1272 int 1273 sysctl_dumpentry(struct radix_node *rn, void *vw) 1274 { 1275 struct walkarg *w = vw; 1276 struct rtentry *rt = (struct rtentry *)rn; 1277 struct rt_addrinfo rtinfo; 1278 int error, msglen; 1279 1280 if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg)) 1281 return 0; 1282 1283 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 1284 rtinfo.rti_dst = rt_key(rt); 1285 rtinfo.rti_gateway = rt->rt_gateway; 1286 rtinfo.rti_netmask = rt_mask(rt); 1287 rtinfo.rti_genmask = rt->rt_genmask; 1288 if (rt->rt_ifp != NULL) { 1289 rtinfo.rti_ifpaddr = 1290 TAILQ_FIRST(&rt->rt_ifp->if_addrheads[mycpuid])->ifa->ifa_addr; 1291 rtinfo.rti_ifaaddr = rt->rt_ifa->ifa_addr; 1292 if (rt->rt_ifp->if_flags & IFF_POINTOPOINT) 1293 rtinfo.rti_bcastaddr = rt->rt_ifa->ifa_dstaddr; 1294 } 1295 msglen = rt_msgsize(RTM_GET, &rtinfo); 1296 if (w->w_tmemsize < msglen && resizewalkarg(w, msglen) != 0) 1297 return (ENOMEM); 1298 rt_msg_buffer(RTM_GET, &rtinfo, w->w_tmem, msglen); 1299 if (w->w_req != NULL) { 1300 struct rt_msghdr *rtm = w->w_tmem; 1301 1302 rtm->rtm_flags = rt->rt_flags; 1303 rtm->rtm_use = rt->rt_use; 1304 rtm->rtm_rmx = rt->rt_rmx; 1305 rtm->rtm_index = rt->rt_ifp->if_index; 1306 rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0; 1307 rtm->rtm_addrs = rtinfo.rti_addrs; 1308 error = SYSCTL_OUT(w->w_req, rtm, msglen); 1309 return (error); 1310 } 1311 return (0); 1312 } 1313 1314 static int 1315 sysctl_iflist(int af, struct walkarg *w) 1316 { 1317 struct ifnet *ifp; 1318 struct rt_addrinfo rtinfo; 1319 int msglen, error; 1320 1321 bzero(&rtinfo, sizeof(struct rt_addrinfo)); 1322 TAILQ_FOREACH(ifp, &ifnet, if_link) { 1323 struct ifaddr_container *ifac; 1324 struct ifaddr *ifa; 1325 1326 if (w->w_arg && w->w_arg != ifp->if_index) 1327 continue; 1328 ifac = TAILQ_FIRST(&ifp->if_addrheads[mycpuid]); 1329 ifa = ifac->ifa; 1330 rtinfo.rti_ifpaddr = ifa->ifa_addr; 1331 msglen = rt_msgsize(RTM_IFINFO, &rtinfo); 1332 if (w->w_tmemsize < msglen && resizewalkarg(w, msglen) != 0) 1333 return (ENOMEM); 1334 rt_msg_buffer(RTM_IFINFO, &rtinfo, w->w_tmem, msglen); 1335 rtinfo.rti_ifpaddr = NULL; 1336 if (w->w_req != NULL && w->w_tmem != NULL) { 1337 struct if_msghdr *ifm = w->w_tmem; 1338 1339 ifm->ifm_index = ifp->if_index; 1340 ifm->ifm_flags = ifp->if_flags; 1341 ifm->ifm_data = ifp->if_data; 1342 ifm->ifm_addrs = rtinfo.rti_addrs; 1343 error = SYSCTL_OUT(w->w_req, ifm, msglen); 1344 if (error) 1345 return (error); 1346 } 1347 while ((ifac = TAILQ_NEXT(ifac, ifa_link)) != NULL) { 1348 ifa = ifac->ifa; 1349 1350 if (af && af != ifa->ifa_addr->sa_family) 1351 continue; 1352 if (curproc->p_ucred->cr_prison && 1353 prison_if(curproc->p_ucred, ifa->ifa_addr)) 1354 continue; 1355 rtinfo.rti_ifaaddr = ifa->ifa_addr; 1356 rtinfo.rti_netmask = ifa->ifa_netmask; 1357 rtinfo.rti_bcastaddr = ifa->ifa_dstaddr; 1358 msglen = rt_msgsize(RTM_NEWADDR, &rtinfo); 1359 if (w->w_tmemsize < msglen && 1360 resizewalkarg(w, msglen) != 0) 1361 return (ENOMEM); 1362 rt_msg_buffer(RTM_NEWADDR, &rtinfo, w->w_tmem, msglen); 1363 if (w->w_req != NULL) { 1364 struct ifa_msghdr *ifam = w->w_tmem; 1365 1366 ifam->ifam_index = ifa->ifa_ifp->if_index; 1367 ifam->ifam_flags = ifa->ifa_flags; 1368 ifam->ifam_metric = ifa->ifa_metric; 1369 ifam->ifam_addrs = rtinfo.rti_addrs; 1370 error = SYSCTL_OUT(w->w_req, w->w_tmem, msglen); 1371 if (error) 1372 return (error); 1373 } 1374 } 1375 rtinfo.rti_netmask = NULL; 1376 rtinfo.rti_ifaaddr = NULL; 1377 rtinfo.rti_bcastaddr = NULL; 1378 } 1379 return (0); 1380 } 1381 1382 static int 1383 sysctl_rtsock(SYSCTL_HANDLER_ARGS) 1384 { 1385 int *name = (int *)arg1; 1386 u_int namelen = arg2; 1387 struct radix_node_head *rnh; 1388 int i, error = EINVAL; 1389 int origcpu; 1390 u_char af; 1391 struct walkarg w; 1392 1393 name ++; 1394 namelen--; 1395 if (req->newptr) 1396 return (EPERM); 1397 if (namelen != 3 && namelen != 4) 1398 return (EINVAL); 1399 af = name[0]; 1400 bzero(&w, sizeof w); 1401 w.w_op = name[1]; 1402 w.w_arg = name[2]; 1403 w.w_req = req; 1404 1405 /* 1406 * Optional third argument specifies cpu, used primarily for 1407 * debugging the route table. 1408 */ 1409 if (namelen == 4) { 1410 if (name[3] < 0 || name[3] >= ncpus) 1411 return (EINVAL); 1412 origcpu = mycpuid; 1413 lwkt_migratecpu(name[3]); 1414 } else { 1415 origcpu = -1; 1416 } 1417 crit_enter(); 1418 switch (w.w_op) { 1419 case NET_RT_DUMP: 1420 case NET_RT_FLAGS: 1421 for (i = 1; i <= AF_MAX; i++) 1422 if ((rnh = rt_tables[mycpuid][i]) && 1423 (af == 0 || af == i) && 1424 (error = rnh->rnh_walktree(rnh, 1425 sysctl_dumpentry, &w))) 1426 break; 1427 break; 1428 1429 case NET_RT_IFLIST: 1430 error = sysctl_iflist(af, &w); 1431 } 1432 crit_exit(); 1433 if (w.w_tmem != NULL) 1434 kfree(w.w_tmem, M_RTABLE); 1435 if (origcpu >= 0) 1436 lwkt_migratecpu(origcpu); 1437 return (error); 1438 } 1439 1440 SYSCTL_NODE(_net, PF_ROUTE, routetable, CTLFLAG_RD, sysctl_rtsock, ""); 1441 1442 /* 1443 * Definitions of protocols supported in the ROUTE domain. 1444 */ 1445 1446 static struct domain routedomain; /* or at least forward */ 1447 1448 static struct protosw routesw[] = { 1449 { 1450 .pr_type = SOCK_RAW, 1451 .pr_domain = &routedomain, 1452 .pr_protocol = 0, 1453 .pr_flags = PR_ATOMIC|PR_ADDR, 1454 .pr_input = NULL, 1455 .pr_output = route_output, 1456 .pr_ctlinput = raw_ctlinput, 1457 .pr_ctloutput = NULL, 1458 .pr_ctlport = cpu0_ctlport, 1459 1460 .pr_init = raw_init, 1461 .pr_usrreqs = &route_usrreqs 1462 } 1463 }; 1464 1465 static struct domain routedomain = { 1466 PF_ROUTE, "route", NULL, NULL, NULL, 1467 routesw, &routesw[(sizeof routesw)/(sizeof routesw[0])], 1468 }; 1469 1470 DOMAIN_SET(route); 1471 1472