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