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