sys/net/route.h

   1 /*      $NetBSD: route.h,v 1.80 2011/11/11 15:09:32 gdt 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 ESIS */
 151 #define RTF_STATIC      0x800           /* manually added */
 152 #define RTF_BLACKHOLE   0x1000          /* just discard pkts (during updates) */
 153 #define RTF_CLONED      0x2000          /* this is a cloned route */
 154 #define RTF_PROTO2      0x4000          /* protocol specific routing flag */
 155 #define RTF_PROTO1      0x8000          /* protocol specific routing flag */
 156 #define RTF_SRC         0x10000         /* route has fixed source address */
 157 #define RTF_ANNOUNCE    0x20000         /* announce new arp or ndp entry */
 158
 159
 160 /*
 161  * Routing statistics.
 162  */
 163 struct  rtstat {
 164         uint64_t rts_badredirect;       /* bogus redirect calls */
 165         uint64_t rts_dynamic;           /* routes created by redirects */
 166         uint64_t rts_newgateway;        /* routes modified by redirects */
 167         uint64_t rts_unreach;           /* lookups which failed */
 168         uint64_t rts_wildcard;          /* lookups satisfied by a wildcard */
 169 };
 170
 171 /*
 172  * Structures for routing messages.  By forcing the first member to be aligned
 173  * at a 64-bit boundary, we also force the size to be a multiple of 64-bits.
 174  */
 175
 176 #if !defined(_KERNEL) || !defined(COMPAT_RTSOCK)
 177 /*
 178  * If we aren't being compiled for backwards compatiblity, enforce 64-bit
 179  * alignment so any routing message is the same regardless if the kernel
 180  * is an ILP32 or LP64 kernel.
 181  */
 182 #define __align64       __aligned(sizeof(uint64_t))
 183 #else
 184 #define __align64
 185 #endif
 186
 187 struct rt_msghdr {
 188         u_short rtm_msglen __align64;
 189                                 /* to skip over non-understood messages */
 190         u_char  rtm_version;    /* future binary compatibility */
 191         u_char  rtm_type;       /* message type */
 192         u_short rtm_index;      /* index for associated ifp */
 193         int     rtm_flags;      /* flags, incl. kern & message, e.g. DONE */
 194         int     rtm_addrs;      /* bitmask identifying sockaddrs in msg */
 195         pid_t   rtm_pid;        /* identify sender */
 196         int     rtm_seq;        /* for sender to identify action */
 197         int     rtm_errno;      /* why failed */
 198         int     rtm_use;        /* from rtentry */
 199         int     rtm_inits;      /* which metrics we are initializing */
 200         struct  rt_metrics rtm_rmx __align64;
 201                                 /* metrics themselves */
 202 };
 203
 204 #undef __align64
 205
 206 #define RTM_VERSION     4       /* Up the ante and ignore older versions */
 207
 208 #define RTM_ADD         0x1     /* Add Route */
 209 #define RTM_DELETE      0x2     /* Delete Route */
 210 #define RTM_CHANGE      0x3     /* Change Metrics or flags */
 211 #define RTM_GET         0x4     /* Report Metrics */
 212 #define RTM_LOSING      0x5     /* Kernel Suspects Partitioning */
 213 #define RTM_REDIRECT    0x6     /* Told to use different route */
 214 #define RTM_MISS        0x7     /* Lookup failed on this address */
 215 #define RTM_LOCK        0x8     /* fix specified metrics */
 216 #define RTM_OLDADD      0x9     /* caused by SIOCADDRT */
 217 #define RTM_OLDDEL      0xa     /* caused by SIOCDELRT */
 218 #define RTM_RESOLVE     0xb     /* req to resolve dst to LL addr */
 219 #define RTM_NEWADDR     0xc     /* address being added to iface */
 220 #define RTM_DELADDR     0xd     /* address being removed from iface */
 221 #define RTM_OOIFINFO    0xe     /* Old (pre-1.5) RTM_IFINFO message */
 222 #define RTM_OIFINFO     0xf     /* Old (pre-64bit time) RTM_IFINFO message */
 223 #define RTM_IFANNOUNCE  0x10    /* iface arrival/departure */
 224 #define RTM_IEEE80211   0x11    /* IEEE80211 wireless event */
 225 #define RTM_SETGATE     0x12    /* set prototype gateway for clones
 226                                  * (see example in arp_rtrequest).
 227                                  */
 228 #define RTM_LLINFO_UPD  0x13    /* indication to ARP/NDP/etc. that link-layer
 229                                  * address has changed
 230                                  */
 231 #define RTM_IFINFO      0x14    /* iface/link going up/down etc. */
 232 #define RTM_CHGADDR     0x15    /* address properties changed */
 233
 234 #define RTV_MTU         0x1     /* init or lock _mtu */
 235 #define RTV_HOPCOUNT    0x2     /* init or lock _hopcount */
 236 #define RTV_EXPIRE      0x4     /* init or lock _expire */
 237 #define RTV_RPIPE       0x8     /* init or lock _recvpipe */
 238 #define RTV_SPIPE       0x10    /* init or lock _sendpipe */
 239 #define RTV_SSTHRESH    0x20    /* init or lock _ssthresh */
 240 #define RTV_RTT         0x40    /* init or lock _rtt */
 241 #define RTV_RTTVAR      0x80    /* init or lock _rttvar */
 242
 243 /*
 244  * Bitmask values for rtm_addr.
 245  */
 246 #define RTA_DST         0x1     /* destination sockaddr present */
 247 #define RTA_GATEWAY     0x2     /* gateway sockaddr present */
 248 #define RTA_NETMASK     0x4     /* netmask sockaddr present */
 249 #define RTA_GENMASK     0x8     /* cloning mask sockaddr present */
 250 #define RTA_IFP         0x10    /* interface name sockaddr present */
 251 #define RTA_IFA         0x20    /* interface addr sockaddr present */
 252 #define RTA_AUTHOR      0x40    /* sockaddr for author of redirect */
 253 #define RTA_BRD         0x80    /* for NEWADDR, broadcast or p-p dest addr */
 254 #define RTA_TAG         0x100   /* route tag */
 255
 256 /*
 257  * Index offsets for sockaddr array for alternate internal encoding.
 258  */
 259 #define RTAX_DST        0       /* destination sockaddr present */
 260 #define RTAX_GATEWAY    1       /* gateway sockaddr present */
 261 #define RTAX_NETMASK    2       /* netmask sockaddr present */
 262 #define RTAX_GENMASK    3       /* cloning mask sockaddr present */
 263 #define RTAX_IFP        4       /* interface name sockaddr present */
 264 #define RTAX_IFA        5       /* interface addr sockaddr present */
 265 #define RTAX_AUTHOR     6       /* sockaddr for author of redirect */
 266 #define RTAX_BRD        7       /* for NEWADDR, broadcast or p-p dest addr */
 267 #define RTAX_TAG        8       /* route tag */
 268 #define RTAX_MAX        9       /* size of array to allocate */
 269
 270 #define RT_ROUNDUP2(a, n)       ((a) > 0 ? (1 + (((a) - 1) | ((n) - 1))) : (n))
 271 #define RT_ROUNDUP(a)           RT_ROUNDUP2((a), sizeof(uint64_t))
 272 #define RT_ADVANCE(x, n)        (x += RT_ROUNDUP((n)->sa_len))
 273
 274 struct rt_addrinfo {
 275         int     rti_addrs;
 276         const struct    sockaddr *rti_info[RTAX_MAX];
 277         int     rti_flags;
 278         struct  ifaddr *rti_ifa;
 279         struct  ifnet *rti_ifp;
 280 };
 281
 282 struct route_cb {
 283         int     ip_count;
 284         int     ip6_count;
 285         int     iso_count;
 286         int     mpls_count;
 287         int     any_count;
 288 };
 289
 290 /*
 291  * This structure, and the prototypes for the rt_timer_{init,remove_all,
 292  * add,timer} functions all used with the kind permission of BSDI.
 293  * These allow functions to be called for routes at specific times.
 294  */
 295
 296 struct rttimer {
 297         TAILQ_ENTRY(rttimer)    rtt_next;  /* entry on timer queue */
 298         LIST_ENTRY(rttimer)     rtt_link;  /* multiple timers per rtentry */
 299         struct rttimer_queue   *rtt_queue; /* back pointer to queue */
 300         struct rtentry         *rtt_rt;    /* Back pointer to the route */
 301         void                  (*rtt_func)(struct rtentry *, struct rttimer *);
 302         time_t                  rtt_time;  /* When this timer was registered */
 303 };
 304
 305 struct rttimer_queue {
 306         long                            rtq_timeout;
 307         unsigned long                   rtq_count;
 308         TAILQ_HEAD(, rttimer)           rtq_head;
 309         LIST_ENTRY(rttimer_queue)       rtq_link;
 310 };
 311
 312
 313 struct rtbl;
 314 typedef struct rtbl rtbl_t;
 315
 316 #ifdef _KERNEL
 317
 318 struct rtbl {
 319         struct radix_node_head t_rnh;
 320 };
 321
 322 struct rt_walkarg {
 323         int     w_op;
 324         int     w_arg;
 325         int     w_given;
 326         int     w_needed;
 327         void *  w_where;
 328         int     w_tmemsize;
 329         int     w_tmemneeded;
 330         void *  w_tmem;
 331 };
 332
 333 #if 0
 334 #define RT_DPRINTF(__fmt, ...)  do { } while (/*CONSTCOND*/0)
 335 #else
 336 #define RT_DPRINTF(__fmt, ...)  /* do nothing */
 337 #endif
 338
 339 struct rtwalk {
 340         int (*rw_f)(struct rtentry *, void *);
 341         void *rw_v;
 342 };
 343
 344 /*
 345  * Global data specific to the routing socket.
 346  */
 347 struct route_info {
 348         struct sockaddr ri_dst;
 349         struct sockaddr ri_src;
 350         struct route_cb ri_cb;
 351         int ri_maxqlen;
 352         struct ifqueue ri_intrq;
 353         void *ri_sih;
 354 };
 355
 356 extern  struct  route_info route_info;
 357 extern  struct  rtstat  rtstat;
 358
 359 struct socket;
 360 struct dom_rtlist;
 361
 362 void     rt_init(void);
 363 void     rt_ifannouncemsg(struct ifnet *, int);
 364 void     rt_ieee80211msg(struct ifnet *, int, void *, size_t);
 365 void     rt_ifmsg(struct ifnet *);
 366 void     rt_missmsg(int, const struct rt_addrinfo *, int, int);
 367 struct mbuf *rt_msg1(int, struct rt_addrinfo *, void *, int);
 368 void     rt_newaddrmsg(int, struct ifaddr *, int, struct rtentry *);
 369
 370 void     rt_maskedcopy(const struct sockaddr *,
 371             struct sockaddr *, const struct sockaddr *);
 372 int      rt_setgate(struct rtentry *, const struct sockaddr *);
 373 int      rt_timer_add(struct rtentry *,
 374              void(*)(struct rtentry *, struct rttimer *),
 375              struct rttimer_queue *);
 376 void     rt_timer_init(void);
 377 struct rttimer_queue *
 378          rt_timer_queue_create(u_int);
 379 void     rt_timer_queue_change(struct rttimer_queue *, long);
 380 void     rt_timer_queue_remove_all(struct rttimer_queue *, int);
 381 void     rt_timer_queue_destroy(struct rttimer_queue *, int);
 382 void     rt_timer_remove_all(struct rtentry *, int);
 383 unsigned long   rt_timer_count(struct rttimer_queue *);
 384 void     rt_timer_timer(void *);
 385 void     rtcache(struct route *);
 386 void     rtflushall(int);
 387 struct rtentry *
 388          rtalloc1(const struct sockaddr *, int);
 389 void     rtfree(struct rtentry *);
 390 int      rt_getifa(struct rt_addrinfo *);
 391 int      rtinit(struct ifaddr *, int, int);
 392 int      rtioctl(u_long, void *, struct lwp *);
 393 void     rtredirect(const struct sockaddr *, const struct sockaddr *,
 394             const struct sockaddr *, int, const struct sockaddr *,
 395             struct rtentry **);
 396 int      rtrequest(int, const struct sockaddr *,
 397             const struct sockaddr *, const struct sockaddr *, int,
 398             struct rtentry **);
 399 int      rtrequest1(int, struct rt_addrinfo *, struct rtentry **);
 400
 401 struct ifaddr   *rt_get_ifa(struct rtentry *);
 402 void    rt_replace_ifa(struct rtentry *, struct ifaddr *);
 403
 404 const struct sockaddr *rt_settag(struct rtentry *, const struct sockaddr *);
 405 struct sockaddr *rt_gettag(struct rtentry *);
 406
 407 static inline void
 408 rt_destroy(struct rtentry *rt)
 409 {
 410         if (rt->_rt_key != NULL)
 411                 sockaddr_free(rt->_rt_key);
 412         if (rt->rt_gateway != NULL)
 413                 sockaddr_free(rt->rt_gateway);
 414         if (rt_gettag(rt) != NULL)
 415                 sockaddr_free(rt_gettag(rt));
 416         rt->_rt_key = rt->rt_gateway = rt->rt_tag = NULL;
 417 }
 418
 419 static inline const struct sockaddr *
 420 rt_setkey(struct rtentry *rt, const struct sockaddr *key, int flags)
 421 {
 422         if (rt->_rt_key == key)
 423                 goto out;
 424
 425         if (rt->_rt_key != NULL)
 426                 sockaddr_free(rt->_rt_key);
 427         rt->_rt_key = sockaddr_dup(key, flags);
 428 out:
 429         KASSERT(rt->_rt_key != NULL);
 430         rt->rt_nodes->rn_key = (const char *)rt->_rt_key;
 431         return rt->_rt_key;
 432 }
 433
 434 struct rtentry *rtcache_init(struct route *);
 435 struct rtentry *rtcache_init_noclone(struct route *);
 436 void    rtcache_copy(struct route *, const struct route *);
 437 void rtcache_invalidate(struct dom_rtlist *);
 438
 439 struct rtentry *rtcache_lookup2(struct route *, const struct sockaddr *, int,
 440     int *);
 441 void    rtcache_clear(struct route *);
 442 struct rtentry *rtcache_update(struct route *, int);
 443 void    rtcache_free(struct route *);
 444 int     rtcache_setdst(struct route *, const struct sockaddr *);
 445
 446 static inline void
 447 rtcache_invariants(const struct route *ro)
 448 {
 449         KASSERT(ro->ro_sa != NULL || ro->_ro_rt == NULL);
 450         KASSERT(!ro->ro_invalid || ro->_ro_rt != NULL);
 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 static inline void
 501 RTFREE(struct rtentry *rt)
 502 {
 503         if (rt->rt_refcnt <= 1)
 504                 rtfree(rt);
 505         else
 506                 rt->rt_refcnt--;
 507 }
 508
 509 int rt_walktree(sa_family_t, int (*)(struct rtentry *, void *), void *);
 510 void route_enqueue(struct mbuf *, int);
 511 int rt_inithead(rtbl_t **, int);
 512 struct rtentry *rt_matchaddr(rtbl_t *, const struct sockaddr *);
 513 int rt_addaddr(rtbl_t *, struct rtentry *, const struct sockaddr *);
 514 struct rtentry *rt_lookup(rtbl_t *, const struct sockaddr *,
 515     const struct sockaddr *);
 516 struct rtentry *rt_deladdr(rtbl_t *, const struct sockaddr *,
 517     const struct sockaddr *);
 518 void rtbl_init(void);
 519 rtbl_t *rt_gettable(sa_family_t);
 520 void rt_assert_inactive(const struct rtentry *);
 521
 522 #endif /* _KERNEL */
 523
 524 #endif /* !_NET_ROUTE_H_ */