sys/net/rtsock.c

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