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