sys/net/rtsock.c

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