sys/net/route.h

   1 /*      $NetBSD: route.h,v 1.96 2015/09/02 11:35:11 ozaki-r Exp $       */
   2
   3 /*
   4  * Copyright (c) 1980, 1986, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   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 University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)route.h     8.5 (Berkeley) 2/8/95
  32  */
  33
  34 #ifndef _NET_ROUTE_H_
  35 #define _NET_ROUTE_H_
  36
  37 #include <sys/queue.h>
  38 #include <sys/socket.h>
  39 #include <sys/types.h>
  40 #include <net/if.h>
  41
  42 #if !(defined(_KERNEL) || defined(_STANDALONE))
  43 #include <stdbool.h>
  44 #endif
  45
  46 /*
  47  * Kernel resident routing tables.
  48  *
  49  * The routing tables are initialized when interface addresses
  50  * are set by making entries for all directly connected interfaces.
  51  */
  52
  53 /*
  54  * A route consists of a destination address and a reference
  55  * to a routing entry.  These are often held by protocols
  56  * in their control blocks, e.g. inpcb.
  57  */
  58 struct route {
  59         struct  rtentry         *_ro_rt;
  60         struct  sockaddr        *ro_sa;
  61         LIST_ENTRY(route)       ro_rtcache_next;
  62         bool                    ro_invalid;
  63 };
  64
  65 /*
  66  * These numbers are used by reliable protocols for determining
  67  * retransmission behavior and are included in the routing structure.
  68  */
  69 struct rt_metrics {
  70         uint64_t rmx_locks;     /* Kernel must leave these values alone */
  71         uint64_t rmx_mtu;       /* MTU for this path */
  72         uint64_t rmx_hopcount;  /* max hops expected */
  73         uint64_t rmx_recvpipe;  /* inbound delay-bandwidth product */
  74         uint64_t rmx_sendpipe;  /* outbound delay-bandwidth product */
  75         uint64_t rmx_ssthresh;  /* outbound gateway buffer limit */
  76         uint64_t rmx_rtt;       /* estimated round trip time */
  77         uint64_t rmx_rttvar;    /* estimated rtt variance */
  78         time_t  rmx_expire;     /* lifetime for route, e.g. redirect */
  79         time_t  rmx_pksent;     /* packets sent using this route */
  80 };
  81
  82 /*
  83  * rmx_rtt and rmx_rttvar are stored as microseconds;
  84  * RTTTOPRHZ(rtt) converts to a value suitable for use
  85  * by a protocol slowtimo counter.
  86  */
  87 #define RTM_RTTUNIT     1000000 /* units for rtt, rttvar, as units per sec */
  88 #define RTTTOPRHZ(r)    ((r) / (RTM_RTTUNIT / PR_SLOWHZ))
  89
  90 /*
  91  * We distinguish between routes to hosts and routes to networks,
  92  * preferring the former if available.  For each route we infer
  93  * the interface to use from the gateway address supplied when
  94  * the route was entered.  Routes that forward packets through
  95  * gateways are marked so that the output routines know to address the
  96  * gateway rather than the ultimate destination.
  97  */
  98 #ifndef RNF_NORMAL
  99 #include <net/radix.h>
 100 #endif
 101 struct rtentry {
 102         struct  radix_node rt_nodes[2]; /* tree glue, and other values */
 103 #define rt_mask(r)      ((const struct sockaddr *)((r)->rt_nodes->rn_mask))
 104         struct  sockaddr *rt_gateway;   /* value */
 105         int     rt_flags;               /* up/down?, host/net */
 106         int     rt_refcnt;              /* # held references */
 107         uint64_t rt_use;                        /* raw # packets forwarded */
 108         struct  ifnet *rt_ifp;          /* the answer: interface to use */
 109         struct  ifaddr *rt_ifa;         /* the answer: interface to use */
 110         uint32_t rt_ifa_seqno;
 111         void *  rt_llinfo;              /* pointer to link level info cache */
 112         struct  rt_metrics rt_rmx;      /* metrics used by rx'ing protocols */
 113         struct  rtentry *rt_gwroute;    /* implied entry for gatewayed routes */
 114         LIST_HEAD(, rttimer) rt_timer;  /* queue of timeouts for misc funcs */
 115         struct  rtentry *rt_parent;     /* parent of cloned route */
 116         struct  sockaddr *_rt_key;
 117         struct  sockaddr *rt_tag;       /* route tagging info */
 118 };
 119
 120 static inline const struct sockaddr *
 121 rt_getkey(const struct rtentry *rt)
 122 {
 123         return rt->_rt_key;
 124 }
 125
 126 /*
 127  * Following structure necessary for 4.3 compatibility;
 128  * We should eventually move it to a compat file.
 129  */
 130 struct ortentry {
 131         uint32_t rt_hash;               /* to speed lookups */
 132         struct  sockaddr rt_dst;        /* key */
 133         struct  sockaddr rt_gateway;    /* value */
 134         int16_t rt_flags;               /* up/down?, host/net */
 135         int16_t rt_refcnt;              /* # held references */
 136         uint32_t rt_use;                /* raw # packets forwarded */
 137         struct  ifnet *rt_ifp;          /* the answer: interface to use */
 138 };
 139
 140 #define RTF_UP          0x1             /* route usable */
 141 #define RTF_GATEWAY     0x2             /* destination is a gateway */
 142 #define RTF_HOST        0x4             /* host entry (net otherwise) */
 143 #define RTF_REJECT      0x8             /* host or net unreachable */
 144 #define RTF_DYNAMIC     0x10            /* created dynamically (by redirect) */
 145 #define RTF_MODIFIED    0x20            /* modified dynamically (by redirect) */
 146 #define RTF_DONE        0x40            /* message confirmed */
 147 #define RTF_MASK        0x80            /* subnet mask present */
 148 #define RTF_CLONING     0x100           /* generate new routes on use */
 149 #define RTF_XRESOLVE    0x200           /* external daemon resolves name */
 150 #define RTF_LLINFO      0x400           /* generated by ARP or NDP */
 151 #define RTF_LLDATA      0x400           /* used by apps to add/del L2 entries */
 152 #define RTF_STATIC      0x800           /* manually added */
 153 #define RTF_BLACKHOLE   0x1000          /* just discard pkts (during updates) */
 154 #define RTF_CLONED      0x2000          /* this is a cloned route */
 155 #define RTF_PROTO2      0x4000          /* protocol specific routing flag */
 156 #define RTF_PROTO1      0x8000          /* protocol specific routing flag */
 157 #define RTF_SRC         0x10000         /* route has fixed source address */
 158 #define RTF_ANNOUNCE    0x20000         /* announce new ARP or NDP entry */
 159 #define RTF_LOCAL       0x40000         /* route represents a local address */
 160 #define RTF_BROADCAST   0x80000         /* route represents a bcast address */
 161
 162 /*
 163  * Routing statistics.
 164  */
 165 struct  rtstat {
 166         uint64_t rts_badredirect;       /* bogus redirect calls */
 167         uint64_t rts_dynamic;           /* routes created by redirects */
 168         uint64_t rts_newgateway;        /* routes modified by redirects */
 169         uint64_t rts_unreach;           /* lookups which failed */
 170         uint64_t rts_wildcard;          /* lookups satisfied by a wildcard */
 171 };
 172
 173 /*
 174  * Structures for routing messages.  By forcing the first member to be aligned
 175  * at a 64-bit boundary, we also force the size to be a multiple of 64-bits.
 176  */
 177
 178 #if !defined(_KERNEL) || !defined(COMPAT_RTSOCK)
 179 /*
 180  * If we aren't being compiled for backwards compatiblity, enforce 64-bit
 181  * alignment so any routing message is the same regardless if the kernel
 182  * is an ILP32 or LP64 kernel.
 183  */
 184 #define __align64       __aligned(sizeof(uint64_t))
 185 #else
 186 #define __align64
 187 #endif
 188
 189 struct rt_msghdr {
 190         u_short rtm_msglen __align64;
 191                                 /* to skip over non-understood messages */
 192         u_char  rtm_version;    /* future binary compatibility */
 193         u_char  rtm_type;       /* message type */
 194         u_short rtm_index;      /* index for associated ifp */
 195         int     rtm_flags;      /* flags, incl. kern & message, e.g. DONE */
 196         int     rtm_addrs;      /* bitmask identifying sockaddrs in msg */
 197         pid_t   rtm_pid;        /* identify sender */
 198         int     rtm_seq;        /* for sender to identify action */
 199         int     rtm_errno;      /* why failed */
 200         int     rtm_use;        /* from rtentry */
 201         int     rtm_inits;      /* which metrics we are initializing */
 202         struct  rt_metrics rtm_rmx __align64;
 203                                 /* metrics themselves */
 204 };
 205
 206 #undef __align64
 207
 208 #define RTM_VERSION     4       /* Up the ante and ignore older versions */
 209
 210 #define RTM_ADD         0x1     /* Add Route */
 211 #define RTM_DELETE      0x2     /* Delete Route */
 212 #define RTM_CHANGE      0x3     /* Change Metrics or flags */
 213 #define RTM_GET         0x4     /* Report Metrics */
 214 #define RTM_LOSING      0x5     /* Kernel Suspects Partitioning */
 215 #define RTM_REDIRECT    0x6     /* Told to use different route */
 216 #define RTM_MISS        0x7     /* Lookup failed on this address */
 217 #define RTM_LOCK        0x8     /* fix specified metrics */
 218 #define RTM_OLDADD      0x9     /* caused by SIOCADDRT */
 219 #define RTM_OLDDEL      0xa     /* caused by SIOCDELRT */
 220 #define RTM_RESOLVE     0xb     /* req to resolve dst to LL addr */
 221 #define RTM_NEWADDR     0xc     /* address being added to iface */
 222 #define RTM_DELADDR     0xd     /* address being removed from iface */
 223 #define RTM_OOIFINFO    0xe     /* Old (pre-1.5) RTM_IFINFO message */
 224 #define RTM_OIFINFO     0xf     /* Old (pre-64bit time) RTM_IFINFO message */
 225 #define RTM_IFANNOUNCE  0x10    /* iface arrival/departure */
 226 #define RTM_IEEE80211   0x11    /* IEEE80211 wireless event */
 227 #define RTM_SETGATE     0x12    /* set prototype gateway for clones
 228                                  * (see example in arp_rtrequest).
 229                                  */
 230 #define RTM_LLINFO_UPD  0x13    /* indication to ARP/NDP/etc. that link-layer
 231                                  * address has changed
 232                                  */
 233 #define RTM_IFINFO      0x14    /* iface/link going up/down etc. */
 234 #define RTM_CHGADDR     0x15    /* address properties changed */
 235
 236 #define RTV_MTU         0x1     /* init or lock _mtu */
 237 #define RTV_HOPCOUNT    0x2     /* init or lock _hopcount */
 238 #define RTV_EXPIRE      0x4     /* init or lock _expire */
 239 #define RTV_RPIPE       0x8     /* init or lock _recvpipe */
 240 #define RTV_SPIPE       0x10    /* init or lock _sendpipe */
 241 #define RTV_SSTHRESH    0x20    /* init or lock _ssthresh */
 242 #define RTV_RTT         0x40    /* init or lock _rtt */
 243 #define RTV_RTTVAR      0x80    /* init or lock _rttvar */
 244
 245 /*
 246  * Bitmask values for rtm_addr.
 247  */
 248 #define RTA_DST         0x1     /* destination sockaddr present */
 249 #define RTA_GATEWAY     0x2     /* gateway sockaddr present */
 250 #define RTA_NETMASK     0x4     /* netmask sockaddr present */
 251 #define RTA_GENMASK     0x8     /* cloning mask sockaddr present */
 252 #define RTA_IFP         0x10    /* interface name sockaddr present */
 253 #define RTA_IFA         0x20    /* interface addr sockaddr present */
 254 #define RTA_AUTHOR      0x40    /* sockaddr for author of redirect */
 255 #define RTA_BRD         0x80    /* for NEWADDR, broadcast or p-p dest addr */
 256 #define RTA_TAG         0x100   /* route tag */
 257
 258 /*
 259  * Index offsets for sockaddr array for alternate internal encoding.
 260  */
 261 #define RTAX_DST        0       /* destination sockaddr present */
 262 #define RTAX_GATEWAY    1       /* gateway sockaddr present */
 263 #define RTAX_NETMASK    2       /* netmask sockaddr present */
 264 #define RTAX_GENMASK    3       /* cloning mask sockaddr present */
 265 #define RTAX_IFP        4       /* interface name sockaddr present */
 266 #define RTAX_IFA        5       /* interface addr sockaddr present */
 267 #define RTAX_AUTHOR     6       /* sockaddr for author of redirect */
 268 #define RTAX_BRD        7       /* for NEWADDR, broadcast or p-p dest addr */
 269 #define RTAX_TAG        8       /* route tag */
 270 #define RTAX_MAX        9       /* size of array to allocate */
 271
 272 #define RT_ROUNDUP2(a, n)       ((a) > 0 ? (1 + (((a) - 1) | ((n) - 1))) : (n))
 273 #define RT_ROUNDUP(a)           RT_ROUNDUP2((a), sizeof(uint64_t))
 274 #define RT_ADVANCE(x, n)        (x += RT_ROUNDUP((n)->sa_len))
 275
 276 struct rt_addrinfo {
 277         int     rti_addrs;
 278         const struct    sockaddr *rti_info[RTAX_MAX];
 279         int     rti_flags;
 280         struct  ifaddr *rti_ifa;
 281         struct  ifnet *rti_ifp;
 282 };
 283
 284 struct route_cb {
 285         int     ip_count;
 286         int     ip6_count;
 287         int     unused1;
 288         int     mpls_count;
 289         int     any_count;
 290 };
 291
 292 /*
 293  * This structure, and the prototypes for the rt_timer_{init,remove_all,
 294  * add,timer} functions all used with the kind permission of BSDI.
 295  * These allow functions to be called for routes at specific times.
 296  */
 297
 298 struct rttimer {
 299         TAILQ_ENTRY(rttimer)    rtt_next;  /* entry on timer queue */
 300         LIST_ENTRY(rttimer)     rtt_link;  /* multiple timers per rtentry */
 301         struct rttimer_queue   *rtt_queue; /* back pointer to queue */
 302         struct rtentry         *rtt_rt;    /* Back pointer to the route */
 303         void                  (*rtt_func)(struct rtentry *, struct rttimer *);
 304         time_t                  rtt_time;  /* When this timer was registered */
 305 };
 306
 307 struct rttimer_queue {
 308         long                            rtq_timeout;
 309         unsigned long                   rtq_count;
 310         TAILQ_HEAD(, rttimer)           rtq_head;
 311         LIST_ENTRY(rttimer_queue)       rtq_link;
 312 };
 313
 314
 315 struct rtbl;
 316 typedef struct rtbl rtbl_t;
 317
 318 #ifdef _KERNEL
 319
 320 struct rtbl {
 321         struct radix_node_head t_rnh;
 322 };
 323
 324 struct rt_walkarg {
 325         int     w_op;
 326         int     w_arg;
 327         int     w_given;
 328         int     w_needed;
 329         void *  w_where;
 330         int     w_tmemsize;
 331         int     w_tmemneeded;
 332         void *  w_tmem;
 333 };
 334
 335 #if 0
 336 #define RT_DPRINTF(__fmt, ...)  do { } while (/*CONSTCOND*/0)
 337 #else
 338 #define RT_DPRINTF(__fmt, ...)  /* do nothing */
 339 #endif
 340
 341 struct rtwalk {
 342         int (*rw_f)(struct rtentry *, void *);
 343         void *rw_v;
 344 };
 345
 346 /*
 347  * Global data specific to the routing socket.
 348  */
 349 struct route_info {
 350         struct sockaddr ri_dst;
 351         struct sockaddr ri_src;
 352         struct route_cb ri_cb;
 353         int ri_maxqlen;
 354         struct ifqueue ri_intrq;
 355         void *ri_sih;
 356 };
 357
 358 extern  struct  route_info route_info;
 359 extern  struct  rtstat  rtstat;
 360
 361 struct socket;
 362
 363 void    rt_init(void);
 364
 365 int     rt_timer_add(struct rtentry *,
 366             void(*)(struct rtentry *, struct rttimer *),
 367             struct rttimer_queue *);
 368 unsigned long
 369         rt_timer_count(struct rttimer_queue *);
 370 void    rt_timer_init(void);
 371 void    rt_timer_queue_change(struct rttimer_queue *, long);
 372 struct rttimer_queue *
 373         rt_timer_queue_create(u_int);
 374 void    rt_timer_queue_destroy(struct rttimer_queue *, int);
 375 void    rt_timer_queue_remove_all(struct rttimer_queue *, int);
 376 void    rt_timer_remove_all(struct rtentry *, int);
 377 void    rt_timer_timer(void *);
 378
 379 void    rt_newmsg(int, struct rtentry *);
 380 struct rtentry *
 381         rtalloc1(const struct sockaddr *, int);
 382 void    rtfree(struct rtentry *);
 383 int     rtinit(struct ifaddr *, int, int);
 384 void    rtredirect(const struct sockaddr *, const struct sockaddr *,
 385             const struct sockaddr *, int, const struct sockaddr *,
 386             struct rtentry **);
 387 int     rtrequest(int, const struct sockaddr *,
 388             const struct sockaddr *, const struct sockaddr *, int,
 389             struct rtentry **);
 390 int     rtrequest1(int, struct rt_addrinfo *, struct rtentry **);
 391 int     rtrequest_newmsg(const int, const struct sockaddr *,
 392             const struct sockaddr *, const struct sockaddr *, const int);
 393
 394 int     rt_ifa_addlocal(struct ifaddr *);
 395 int     rt_ifa_remlocal(struct ifaddr *, struct ifaddr *);
 396 struct ifaddr *
 397         rt_get_ifa(struct rtentry *);
 398 int     rt_getifa(struct rt_addrinfo *);
 399 void    rt_replace_ifa(struct rtentry *, struct ifaddr *);
 400 int     rt_setgate(struct rtentry *, const struct sockaddr *);
 401
 402 const struct sockaddr *
 403         rt_settag(struct rtentry *, const struct sockaddr *);
 404 struct sockaddr *
 405         rt_gettag(struct rtentry *);
 406
 407 static inline struct rtentry *
 408 rt_get_gwroute(struct rtentry *rt)
 409 {
 410         if (rt->rt_gwroute == NULL)
 411                 return NULL;
 412         rt->rt_gwroute->rt_refcnt++;
 413         return rt->rt_gwroute;
 414 }
 415
 416 static inline void
 417 rt_set_gwroute(struct rtentry *rt, struct rtentry *gwrt)
 418 {
 419
 420         rt->rt_gwroute = gwrt;
 421         if (rt->rt_gwroute != NULL)
 422                 rt->rt_gwroute->rt_refcnt++;
 423 }
 424
 425 static inline void
 426 rt_assert_referenced(const struct rtentry *rt)
 427 {
 428
 429         KASSERT(rt->rt_refcnt > 0);
 430 }
 431
 432 void    rtcache_copy(struct route *, const struct route *);
 433 void    rtcache_free(struct route *);
 434 struct rtentry *
 435         rtcache_init(struct route *);
 436 struct rtentry *
 437         rtcache_init_noclone(struct route *);
 438 struct rtentry *
 439         rtcache_lookup2(struct route *, const struct sockaddr *, int,
 440             int *);
 441 int     rtcache_setdst(struct route *, const struct sockaddr *);
 442 struct rtentry *
 443         rtcache_update(struct route *, int);
 444
 445 static inline void
 446 rtcache_invariants(const struct route *ro)
 447 {
 448         KASSERT(ro->ro_sa != NULL || ro->_ro_rt == NULL);
 449         KASSERT(!ro->ro_invalid || ro->_ro_rt != NULL);
 450         KASSERT(ro->_ro_rt == NULL || ro->_ro_rt->rt_refcnt > 0);
 451 }
 452
 453 static inline struct rtentry *
 454 rtcache_lookup1(struct route *ro, const struct sockaddr *dst, int clone)
 455 {
 456         int hit;
 457
 458         return rtcache_lookup2(ro, dst, clone, &hit);
 459 }
 460
 461 static inline struct rtentry *
 462 rtcache_lookup_noclone(struct route *ro, const struct sockaddr *dst)
 463 {
 464         return rtcache_lookup1(ro, dst, 0);
 465 }
 466
 467 static inline struct rtentry *
 468 rtcache_lookup(struct route *ro, const struct sockaddr *dst)
 469 {
 470         return rtcache_lookup1(ro, dst, 1);
 471 }
 472
 473 static inline const struct sockaddr *
 474 rtcache_getdst(const struct route *ro)
 475 {
 476         rtcache_invariants(ro);
 477         return ro->ro_sa;
 478 }
 479
 480 /* If the cache is not empty, and the cached route is still present
 481  * in the routing table, return the cached route.  Otherwise, return
 482  * NULL.
 483  */
 484 static inline struct rtentry *
 485 rtcache_validate(const struct route *ro)
 486 {
 487         struct rtentry *rt = ro->_ro_rt;
 488
 489         rtcache_invariants(ro);
 490
 491         if (ro->ro_invalid)
 492                 return NULL;
 493
 494         if (rt != NULL && (rt->rt_flags & RTF_UP) != 0 && rt->rt_ifp != NULL)
 495                 return rt;
 496         return NULL;
 497
 498 }
 499
 500 /* rtsock */
 501 void    rt_ieee80211msg(struct ifnet *, int, void *, size_t);
 502 void    rt_ifannouncemsg(struct ifnet *, int);
 503 void    rt_ifmsg(struct ifnet *);
 504 void    rt_missmsg(int, const struct rt_addrinfo *, int, int);
 505 struct mbuf *
 506         rt_msg1(int, struct rt_addrinfo *, void *, int);
 507 void    rt_newaddrmsg(int, struct ifaddr *, int, struct rtentry *);
 508 void    route_enqueue(struct mbuf *, int);
 509
 510 /* rtbl */
 511 int     rt_addaddr(rtbl_t *, struct rtentry *, const struct sockaddr *);
 512 void    rt_assert_inactive(const struct rtentry *);
 513 struct rtentry *
 514         rt_deladdr(rtbl_t *, const struct sockaddr *,
 515             const struct sockaddr *);
 516 rtbl_t *rt_gettable(sa_family_t);
 517 int     rt_inithead(rtbl_t **, int);
 518 struct rtentry *
 519         rt_lookup(rtbl_t *, const struct sockaddr *,
 520             const struct sockaddr *);
 521 struct rtentry *
 522         rt_matchaddr(rtbl_t *, const struct sockaddr *);
 523 int     rt_walktree(sa_family_t, int (*)(struct rtentry *, void *), void *);
 524 void    rtbl_init(void);
 525
 526 #endif /* _KERNEL */
 527
 528 #endif /* !_NET_ROUTE_H_ */