/*      $NetBSD: rtsock.c,v 1.256 2022/08/27 08:36:41 skrll Exp $       */

/*
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/*
* Copyright (c) 1988, 1991, 1993
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*      @(#)rtsock.c    8.7 (Berkeley) 10/12/95
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rtsock.c,v 1.256 2022/08/27 08:36:41 skrll Exp $");

#ifdef _KERNEL_OPT
#include "opt_inet.h"
#include "opt_compat_netbsd.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/domain.h>
#include <sys/protosw.h>
#include <sys/sysctl.h>
#include <sys/kauth.h>
#include <sys/kmem.h>
#include <sys/intr.h>
#include <sys/condvar.h>
#include <sys/compat_stub.h>

#include <net/if.h>
#include <net/if_llatbl.h>
#include <net/if_types.h>
#include <net/route.h>
#include <net/raw_cb.h>

#include <netinet/in_var.h>
#include <netinet/if_inarp.h>

#include <netmpls/mpls.h>

#include <compat/net/if.h>
#include <compat/net/route.h>

#ifdef COMPAT_RTSOCK
#undef COMPAT_RTSOCK
#endif

static int if_addrflags(struct ifaddr *);

#include <net/rtsock_shared.c>

/*
* XXX avoid using void * once msghdr compat disappears.
*/
void
rt_setmetrics(void *in, struct rtentry *out)
{
       const struct rt_xmsghdr *rtm = in;

       _rt_setmetrics(rtm->rtm_inits, rtm, out);
}

int
rt_msg3(int type, struct rt_addrinfo *rtinfo, void *cpv, struct rt_walkarg *w,
       int *lenp)
{
       return rt_msg2(type, rtinfo, cpv, w, lenp);
}

static int
if_addrflags(struct ifaddr *ifa)
{

       switch (ifa->ifa_addr->sa_family) {
#ifdef INET
       case AF_INET:
               return ifatoia(ifa)->ia4_flags;
#endif
#ifdef INET6
       case AF_INET6:
               return ifatoia6(ifa)->ia6_flags;
#endif
       default:
               return 0;
       }
}


/*
* Send a routing message as mimicing that a cloned route is added.
*/
void
rt_clonedmsg(int type, const struct sockaddr *src, const struct sockaddr *dst,
   const uint8_t *lladdr, const struct ifnet *ifp)
{
       struct rt_addrinfo info;
       /* Mimic flags exactly */
#define RTF_LLINFO      0x400
#define RTF_CLONED      0x2000
       int flags = RTF_DONE;
       union {
               struct sockaddr sa;
               struct sockaddr_storage ss;
               struct sockaddr_dl sdl;
       } u;

       if (type != RTM_MISS)
               flags |= RTF_HOST | RTF_CLONED | RTF_LLINFO;
       if (type == RTM_ADD || type == RTM_CHANGE)
               flags |= RTF_UP;
       memset(&info, 0, sizeof(info));
       info.rti_info[RTAX_AUTHOR] = src;
       info.rti_info[RTAX_DST] = dst;
       sockaddr_dl_init(&u.sdl, sizeof(u.ss), ifp->if_index, ifp->if_type,
           NULL, 0, lladdr, ifp->if_addrlen);
       info.rti_info[RTAX_GATEWAY] = &u.sa;

       rt_missmsg(type, &info, flags, 0);
#undef RTF_LLINFO
#undef RTF_CLONED
}


/*
* The remaining code implements the routing-table sysctl node.  It is
* compiled only for the non-COMPAT case.
*/

/*
* This is used in dumping the kernel table via sysctl().
*/
static int
sysctl_dumpentry(struct rtentry *rt, void *v)
{
       struct rt_walkarg *w = v;
       int error = 0, size;
       struct rt_addrinfo info;

       if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
               return 0;
       memset(&info, 0, sizeof(info));
       info.rti_info[RTAX_DST] = rt_getkey(rt);
       info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
       info.rti_info[RTAX_NETMASK] = rt_mask(rt);
       info.rti_info[RTAX_TAG] = rt_gettag(rt);
       if (rt->rt_ifp) {
               const struct ifaddr *rtifa;
               info.rti_info[RTAX_IFP] = rt->rt_ifp->if_dl->ifa_addr;
               /* rtifa used to be simply rt->rt_ifa.  If rt->rt_ifa != NULL,
                * then rt_get_ifa() != NULL.  So this ought to still be safe.
                * --dyoung
                */
               rtifa = rt_get_ifa(rt);
               info.rti_info[RTAX_IFA] = rtifa->ifa_addr;
               if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
                       info.rti_info[RTAX_BRD] = rtifa->ifa_dstaddr;
       }
       if ((error = rt_msg2(RTM_GET, &info, 0, w, &size)))
               return error;
       if (w->w_where && w->w_tmem && w->w_needed <= 0) {
               struct rt_xmsghdr *rtm = (struct rt_xmsghdr *)w->w_tmem;

               rtm->rtm_flags = rt->rt_flags;
               rtm->rtm_use = rt->rt_use;
               rtm_setmetrics(rt, rtm);
               KASSERT(rt->rt_ifp != NULL);
               rtm->rtm_index = rt->rt_ifp->if_index;
               rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
               rtm->rtm_addrs = info.rti_addrs;
               if ((error = copyout(rtm, w->w_where, size)) != 0)
                       w->w_where = NULL;
               else
                       w->w_where = (char *)w->w_where + size;
       }
       return error;
}

static int
sysctl_iflist_if(struct ifnet *ifp, struct rt_walkarg *w,
   struct rt_addrinfo *info, size_t len)
{
       struct if_xmsghdr *ifm;
       int error;

       ifm = (struct if_xmsghdr *)w->w_tmem;
       ifm->ifm_index = ifp->if_index;
       ifm->ifm_flags = ifp->if_flags;
       if_export_if_data(ifp, &ifm->ifm_data, false);
       ifm->ifm_addrs = info->rti_addrs;
       if ((error = copyout(ifm, w->w_where, len)) == 0)
               w->w_where = (char *)w->w_where + len;
       return error;
}

static int
sysctl_iflist_addr(struct rt_walkarg *w, struct ifaddr *ifa,
    struct rt_addrinfo *info)
{
       int len, error;

       if ((error = rt_msg2(RTM_XNEWADDR, info, 0, w, &len)))
               return error;
       if (w->w_where && w->w_tmem && w->w_needed <= 0) {
               struct ifa_xmsghdr *ifam;

               ifam = (struct ifa_xmsghdr *)w->w_tmem;
               ifam->ifam_index = ifa->ifa_ifp->if_index;
               ifam->ifam_flags = ifa->ifa_flags;
               ifam->ifam_metric = ifa->ifa_metric;
               ifam->ifam_addrs = info->rti_addrs;
               ifam->ifam_pid = 0;
               ifam->ifam_addrflags = if_addrflags(ifa);
               if ((error = copyout(w->w_tmem, w->w_where, len)) == 0)
                       w->w_where = (char *)w->w_where + len;
       }
       return error;
}

static int
sysctl_iflist(int af, struct rt_walkarg *w, int type)
{
       struct ifnet *ifp;
       struct ifaddr *ifa;
       struct  rt_addrinfo info;
       int     cmd, len, error = 0;
       int s;
       struct psref psref;
       int bound;

       switch (type) {
       case NET_RT_IFLIST:
               cmd = RTM_IFINFO;
               break;
       case NET_RT_OOOIFLIST:
               cmd = RTM_OOIFINFO;
               break;
       case NET_RT_OOIFLIST:
               cmd = RTM_OIFINFO;
               break;
       case NET_RT_OIFLIST:
               cmd = RTM_IFINFO;
               break;
       default:
#ifdef RTSOCK_DEBUG
               printf("%s: unsupported IFLIST type %d\n", __func__, type);
#endif
               return EINVAL;
       }

       memset(&info, 0, sizeof(info));

       bound = curlwp_bind();
       s = pserialize_read_enter();
       IFNET_READER_FOREACH(ifp) {
               int _s;
               if (w->w_arg && w->w_arg != ifp->if_index)
                       continue;
               if (IFADDR_READER_EMPTY(ifp))
                       continue;

               if_acquire(ifp, &psref);
               pserialize_read_exit(s);

               info.rti_info[RTAX_IFP] = ifp->if_dl->ifa_addr;
               if ((error = rt_msg2(cmd, &info, NULL, w, &len)) != 0)
                       goto release_exit;
               info.rti_info[RTAX_IFP] = NULL;
               if (w->w_where && w->w_tmem && w->w_needed <= 0) {
                       switch (type) {
                       case NET_RT_OIFLIST: /* old _70 */
                               if (!rtsock_iflist_70_hook.hooked) {
                                       error = EINVAL;
                                       break;
                               }
                               /* FALLTHROUGH */
                       case NET_RT_IFLIST: /* current */
                               error = sysctl_iflist_if(ifp, w, &info, len);
                               break;
                       case NET_RT_OOIFLIST: /* old _50 */
                               MODULE_HOOK_CALL(rtsock_iflist_50_hook,
                                   (ifp, w, &info, len), enosys(), error);
                               break;
                       case NET_RT_OOOIFLIST: /* old _14 */
                               MODULE_HOOK_CALL(rtsock_iflist_14_hook,
                                  (ifp, w, &info, len), enosys(), error);
                               break;
                       default:
                               error = EINVAL;
                       }
                       if (error != 0) {
                               if (error == ENOSYS)
                                       error = EINVAL;
                               goto release_exit;
                       }
               }
               _s = pserialize_read_enter();
               IFADDR_READER_FOREACH(ifa, ifp) {
                       struct psref _psref;
                       if (af && af != ifa->ifa_addr->sa_family)
                               continue;
                       ifa_acquire(ifa, &_psref);
                       pserialize_read_exit(_s);

                       info.rti_info[RTAX_IFA] = ifa->ifa_addr;
                       info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
                       info.rti_info[RTAX_BRD] = ifa->ifa_dstaddr;
                       switch (type) {
                       case NET_RT_IFLIST:
                               error = sysctl_iflist_addr(w, ifa, &info);
                               break;
                       case NET_RT_OIFLIST:
                       case NET_RT_OOIFLIST:
                       case NET_RT_OOOIFLIST:
                               MODULE_HOOK_CALL(rtsock_iflist_70_hook,
                                   (w, ifa, &info), enosys(), error);
                               break;
                       default:
                               error = EINVAL;
                       }

                       _s = pserialize_read_enter();
                       ifa_release(ifa, &_psref);
                       if (error != 0) {
                               pserialize_read_exit(_s);
                               goto release_exit;
                       }
               }
               pserialize_read_exit(_s);
               info.rti_info[RTAX_IFA] = info.rti_info[RTAX_NETMASK] =
                   info.rti_info[RTAX_BRD] = NULL;

               s = pserialize_read_enter();
               if_release(ifp, &psref);
       }
       pserialize_read_exit(s);
       curlwp_bindx(bound);

       return 0;

release_exit:
       if_release(ifp, &psref);
       curlwp_bindx(bound);
       return error;
}

static int
sysctl_rtable(SYSCTLFN_ARGS)
{
       void    *where = oldp;
       size_t  *given = oldlenp;
       int     i, error = EINVAL;
       u_char  af;
       struct  rt_walkarg w;

       if (namelen == 1 && name[0] == CTL_QUERY)
               return sysctl_query(SYSCTLFN_CALL(rnode));

       if (newp)
               return EPERM;
       if (namelen != 3)
               return EINVAL;
       af = name[0];
       w.w_tmemneeded = 0;
       w.w_tmemsize = 0;
       w.w_tmem = NULL;
again:
       /* we may return here if a later [re]alloc of the t_mem buffer fails */
       if (w.w_tmemneeded) {
               w.w_tmem = kmem_zalloc(w.w_tmemneeded, KM_SLEEP);
               w.w_tmemsize = w.w_tmemneeded;
               w.w_tmemneeded = 0;
       }
       w.w_op = name[1];
       w.w_arg = name[2];
       w.w_given = *given;
       w.w_needed = 0 - w.w_given;
       w.w_where = where;

       KERNEL_LOCK_UNLESS_NET_MPSAFE();
       const int s = splsoftnet();
       switch (w.w_op) {

       case NET_RT_DUMP:
       case NET_RT_FLAGS:
#if defined(INET) || defined(INET6)
               /*
                * take care of llinfo entries, the caller must
                * specify an AF
                */
               if (w.w_op == NET_RT_FLAGS &&
                   (w.w_arg == 0 || w.w_arg & RTF_LLDATA)) {
                       if (af != 0)
                               error = lltable_sysctl_dump(af, &w);
                       else
                               error = EINVAL;
                       break;
               }
#endif

               for (i = 1; i <= AF_MAX; i++) {
                       if (af == 0 || af == i) {
                               error = rt_walktree(i, sysctl_dumpentry, &w);
                               if (error != 0)
                                       break;
#if defined(INET) || defined(INET6)
                               /*
                                * Return ARP/NDP entries too for
                                * backward compatibility.
                                */
                               error = lltable_sysctl_dump(i, &w);
                               if (error != 0)
                                       break;
#endif
                       }
               }
               break;

       case NET_RT_OOOIFLIST:          /* compat_14 */
       case NET_RT_OOIFLIST:           /* compat_50 */
       case NET_RT_OIFLIST:            /* compat_70 */
       case NET_RT_IFLIST:             /* current */
               error = sysctl_iflist(af, &w, w.w_op);
               break;
       }
       splx(s);
       KERNEL_UNLOCK_UNLESS_NET_MPSAFE();

       /* check to see if we couldn't allocate memory with NOWAIT */
       if (error == ENOBUFS && w.w_tmem == 0 && w.w_tmemneeded)
               goto again;

       if (w.w_tmem)
               kmem_free(w.w_tmem, w.w_tmemsize);
       w.w_needed += w.w_given;
       if (where) {
               *given = (char *)w.w_where - (char *)where;
               if (*given < w.w_needed)
                       return ENOMEM;
       } else {
               *given = (11 * w.w_needed) / 10;
       }
       return error;
}

void
sysctl_net_route_setup(struct sysctllog **clog, int pf, const char *name)
{
       const struct sysctlnode *rnode = NULL;

       sysctl_createv(clog, 0, NULL, &rnode,
                      CTLFLAG_PERMANENT,
                      CTLTYPE_NODE, name,
                      SYSCTL_DESCR("PF_ROUTE information"),
                      NULL, 0, NULL, 0,
                      CTL_NET, pf, CTL_EOL);

       sysctl_createv(clog, 0, NULL, NULL,
                      CTLFLAG_PERMANENT,
                      CTLTYPE_NODE, "rtable",
                      SYSCTL_DESCR("Routing table information"),
                      sysctl_rtable, 0, NULL, 0,
                      CTL_NET, pf, 0 /* any protocol */, CTL_EOL);

       sysctl_createv(clog, 0, &rnode, NULL,
                      CTLFLAG_PERMANENT,
                      CTLTYPE_STRUCT, "stats",
                      SYSCTL_DESCR("Routing statistics"),
                      NULL, 0, &rtstat, sizeof(rtstat),
                      CTL_CREATE, CTL_EOL);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.