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