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