sys/netinet/in_fib.c

   1 /*-
   2  * Copyright (c) 2015
   3  *      Alexander V. Chernikov <melifaro@FreeBSD.org>
   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  * 3. 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
  30 #include <sys/cdefs.h>
  31 #include "opt_inet.h"
  32 #include "opt_route.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/lock.h>
  37 #include <sys/rmlock.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mbuf.h>
  40 #include <sys/socket.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/kernel.h>
  43
  44 #include <net/if.h>
  45 #include <net/if_var.h>
  46 #include <net/if_dl.h>
  47 #include <net/route.h>
  48 #include <net/route/route_ctl.h>
  49 #include <net/route/route_var.h>
  50 #include <net/route/fib_algo.h>
  51 #include <net/route/nhop.h>
  52 #include <net/toeplitz.h>
  53 #include <net/vnet.h>
  54
  55 #include <netinet/in.h>
  56 #include <netinet/in_var.h>
  57 #include <netinet/in_fib.h>
  58
  59 #ifdef INET
  60
  61 /* Verify struct route compatiblity */
  62 /* Assert 'struct route_in' is compatible with 'struct route' */
  63 CHK_STRUCT_ROUTE_COMPAT(struct route_in, ro_dst4);
  64
  65 #ifdef FIB_ALGO
  66 VNET_DEFINE(struct fib_dp *, inet_dp);
  67 #endif
  68
  69 #ifdef ROUTE_MPATH
  70 struct _hash_5tuple_ipv4 {
  71         struct in_addr src;
  72         struct in_addr dst;
  73         unsigned short src_port;
  74         unsigned short dst_port;
  75         char proto;
  76         char spare[3];
  77 };
  78 _Static_assert(sizeof(struct _hash_5tuple_ipv4) == 16,
  79     "_hash_5tuple_ipv4 size is wrong");
  80
  81 uint32_t
  82 fib4_calc_software_hash(struct in_addr src, struct in_addr dst,
  83     unsigned short src_port, unsigned short dst_port, char proto,
  84     uint32_t *phashtype)
  85 {
  86         struct _hash_5tuple_ipv4 data;
  87
  88         data.src = src;
  89         data.dst = dst;
  90         data.src_port = src_port;
  91         data.dst_port = dst_port;
  92         data.proto = proto;
  93         data.spare[0] = data.spare[1] = data.spare[2] = 0;
  94
  95         *phashtype = M_HASHTYPE_OPAQUE;
  96
  97         return (toeplitz_hash(MPATH_ENTROPY_KEY_LEN, mpath_entropy_key,
  98           sizeof(data), (uint8_t *)&data));
  99 }
 100 #endif
 101
 102 /*
 103  * Looks up path in fib @fibnum specified by @dst.
 104  * Returns path nexthop on success. Nexthop is safe to use
 105  *  within the current network epoch. If longer lifetime is required,
 106  *  one needs to pass NHR_REF as a flag. This will return referenced
 107  *  nexthop.
 108  */
 109 #ifdef FIB_ALGO
 110 struct nhop_object *
 111 fib4_lookup(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
 112     uint32_t flags, uint32_t flowid)
 113 {
 114         struct nhop_object *nh;
 115         struct fib_dp *dp = &V_inet_dp[fibnum];
 116         struct flm_lookup_key key = {.addr4 = dst };
 117
 118         nh = dp->f(dp->arg, key, scopeid);
 119         if (nh != NULL) {
 120                 nh = nhop_select(nh, flowid);
 121                 /* Ensure route & ifp is UP */
 122                 if (RT_LINK_IS_UP(nh->nh_ifp)) {
 123                         if (flags & NHR_REF)
 124                                 nhop_ref_object(nh);
 125                         return (nh);
 126                 }
 127         }
 128         RTSTAT_INC(rts_unreach);
 129         return (NULL);
 130 }
 131 #else
 132 struct nhop_object *
 133 fib4_lookup(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
 134     uint32_t flags, uint32_t flowid)
 135 {
 136         RIB_RLOCK_TRACKER;
 137         struct rib_head *rh;
 138         struct radix_node *rn;
 139         struct nhop_object *nh;
 140
 141         KASSERT((fibnum < rt_numfibs), ("fib4_lookup: bad fibnum"));
 142         rh = rt_tables_get_rnh(fibnum, AF_INET);
 143         if (rh == NULL)
 144                 return (NULL);
 145
 146         /* Prepare lookup key */
 147         struct sockaddr_in sin4 = {
 148                 .sin_family = AF_INET,
 149                 .sin_len = sizeof(struct sockaddr_in),
 150                 .sin_addr = dst,
 151         };
 152
 153         nh = NULL;
 154         RIB_RLOCK(rh);
 155         rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
 156         if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
 157                 nh = nhop_select((RNTORT(rn))->rt_nhop, flowid);
 158                 /* Ensure route & ifp is UP */
 159                 if (RT_LINK_IS_UP(nh->nh_ifp)) {
 160                         if (flags & NHR_REF)
 161                                 nhop_ref_object(nh);
 162                         RIB_RUNLOCK(rh);
 163                         return (nh);
 164                 }
 165         }
 166         RIB_RUNLOCK(rh);
 167
 168         RTSTAT_INC(rts_unreach);
 169         return (NULL);
 170 }
 171 #endif
 172
 173 inline static int
 174 check_urpf_nhop(const struct nhop_object *nh, uint32_t flags,
 175     const struct ifnet *src_if)
 176 {
 177
 178         if (src_if != NULL && nh->nh_aifp == src_if) {
 179                 return (1);
 180         }
 181         if (src_if == NULL) {
 182                 if ((flags & NHR_NODEFAULT) == 0)
 183                         return (1);
 184                 else if ((nh->nh_flags & NHF_DEFAULT) == 0)
 185                         return (1);
 186         }
 187
 188         return (0);
 189 }
 190
 191 static int
 192 check_urpf(struct nhop_object *nh, uint32_t flags,
 193     const struct ifnet *src_if)
 194 {
 195 #ifdef ROUTE_MPATH
 196         if (NH_IS_NHGRP(nh)) {
 197                 const struct weightened_nhop *wn;
 198                 uint32_t num_nhops;
 199                 wn = nhgrp_get_nhops((struct nhgrp_object *)nh, &num_nhops);
 200                         for (int i = 0; i < num_nhops; i++) {
 201                                 if (check_urpf_nhop(wn[i].nh, flags, src_if) != 0)
 202                                 return (1);
 203                 }
 204                 return (0);
 205         } else
 206 #endif
 207                 return (check_urpf_nhop(nh, flags, src_if));
 208 }
 209
 210 #ifndef FIB_ALGO
 211 static struct nhop_object *
 212 lookup_nhop(uint32_t fibnum, struct in_addr dst, uint32_t scopeid)
 213 {
 214         RIB_RLOCK_TRACKER;
 215         struct rib_head *rh;
 216         struct radix_node *rn;
 217         struct nhop_object *nh;
 218
 219         KASSERT((fibnum < rt_numfibs), ("fib4_check_urpf: bad fibnum"));
 220         rh = rt_tables_get_rnh(fibnum, AF_INET);
 221         if (rh == NULL)
 222                 return (NULL);
 223
 224         /* Prepare lookup key */
 225         struct sockaddr_in sin4;
 226         memset(&sin4, 0, sizeof(sin4));
 227         sin4.sin_len = sizeof(struct sockaddr_in);
 228         sin4.sin_addr = dst;
 229
 230         nh = NULL;
 231         RIB_RLOCK(rh);
 232         rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
 233         if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0))
 234                 nh = RNTORT(rn)->rt_nhop;
 235         RIB_RUNLOCK(rh);
 236
 237         return (nh);
 238 }
 239 #endif
 240
 241 /*
 242  * Performs reverse path forwarding lookup.
 243  * If @src_if is non-zero, verifies that at least 1 path goes via
 244  *   this interface.
 245  * If @src_if is zero, verifies that route exist.
 246  * if @flags contains NHR_NOTDEFAULT, do not consider default route.
 247  *
 248  * Returns 1 if route matching conditions is found, 0 otherwise.
 249  */
 250 int
 251 fib4_check_urpf(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
 252   uint32_t flags, const struct ifnet *src_if)
 253 {
 254         struct nhop_object *nh;
 255 #ifdef FIB_ALGO
 256         struct fib_dp *dp = &V_inet_dp[fibnum];
 257         struct flm_lookup_key key = {.addr4 = dst };
 258
 259         nh = dp->f(dp->arg, key, scopeid);
 260 #else
 261         nh = lookup_nhop(fibnum, dst, scopeid);
 262 #endif
 263         if (nh != NULL)
 264                 return (check_urpf(nh, flags, src_if));
 265
 266         return (0);
 267 }
 268
 269 /*
 270  * Function returning prefix match data along with the nexthop data.
 271  * Intended to be used by the control plane code.
 272  * Supported flags:
 273  *  NHR_UNLOCKED: do not lock radix during lookup.
 274  * Returns pointer to rtentry and raw nexthop in @rnd. Both rtentry
 275  *  and nexthop are safe to use within current epoch. Note:
 276  * Note: rnd_nhop can actually be the nexthop group.
 277  */
 278 struct rtentry *
 279 fib4_lookup_rt(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
 280     uint32_t flags, struct route_nhop_data *rnd)
 281 {
 282         RIB_RLOCK_TRACKER;
 283         struct rib_head *rh;
 284         struct radix_node *rn;
 285         struct rtentry *rt;
 286
 287         KASSERT((fibnum < rt_numfibs), ("fib4_lookup_rt: bad fibnum"));
 288         rh = rt_tables_get_rnh(fibnum, AF_INET);
 289         if (rh == NULL)
 290                 return (NULL);
 291
 292         /* Prepare lookup key */
 293         struct sockaddr_in sin4 = {
 294                 .sin_family = AF_INET,
 295                 .sin_len = sizeof(struct sockaddr_in),
 296                 .sin_addr = dst,
 297         };
 298
 299         rt = NULL;
 300         if (!(flags & NHR_UNLOCKED))
 301                 RIB_RLOCK(rh);
 302         rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
 303         if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
 304                 rt = (struct rtentry *)rn;
 305                 rnd->rnd_nhop = rt->rt_nhop;
 306                 rnd->rnd_weight = rt->rt_weight;
 307         }
 308         if (!(flags & NHR_UNLOCKED))
 309                 RIB_RUNLOCK(rh);
 310
 311         return (rt);
 312 }
 313
 314 struct nhop_object *
 315 fib4_lookup_debugnet(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
 316     uint32_t flags)
 317 {
 318         struct rtentry *rt;
 319         struct route_nhop_data rnd;
 320
 321         rt = fib4_lookup_rt(fibnum, dst, scopeid, NHR_UNLOCKED, &rnd);
 322         if (rt != NULL) {
 323                 struct nhop_object *nh = nhop_select(rnd.rnd_nhop, 0);
 324                 /* Ensure route & ifp is UP */
 325                 if (RT_LINK_IS_UP(nh->nh_ifp))
 326                         return (nh);
 327         }
 328
 329         return (NULL);
 330 }
 331
 332 #endif