Merge branch 'master' into mrtdump

	o  Static routes

	o  Inter-table protocol

	o  IPv6 router advertisements

	o  Bidirectional Forwarding Detection (BFD)

	o  Command-line interface (using the `birdc' client; to get

	   some help, just press `?')

	o  Soft reconfiguration -- no online commands for changing the

It also supports the community attributes

(RFC 1997<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc1997.txt">),

capability negotiation

(RFC 3392<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc3392.txt">),

(RFC 5492<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc5492.txt">),

MD5 password authentication

(RFC 2385<htmlurl url="ftp://ftp.rfc-editor.org/in-notes/rfc2385.txt">),

extended communities

	<cf/bgp_next_hop/ is used if it is directly reachable, otherwise the

	neighbor IP address is used. Recursive mode means that the gateway is

	computed by an IGP routing table lookup for the IP address from

	<cf/bgp_next_hop/. Recursive mode is the behavior specified by the BGP

	<cf/bgp_next_hop/. Note that there is just one level of indirection in

	recursive mode - the route obtained by the lookup must not be recursive

	itself, to prevent mutually recursive routes.

	Recursive mode is the behavior specified by the BGP

	standard. Direct mode is simpler, does not require any routes in a

	routing table, and was used in older versions of BIRD, but does not

	handle well nontrivial iBGP setups and multihop. Recursive mode is

<p><descrip>

	<tag>scan time <m/number/</tag>

	Time in seconds between two scans of the network interface list. On

	systems where we are notified about interface status changes

	asynchronously (such as newer versions of Linux), we need to scan the

	a graceful restart recovery is active, the Kernel protocol will defer

	synchronization of routing tables until the end of the recovery. Note

	that import of kernel routes to BIRD is not affected.

	<tag>merge paths <M>switch</M> [limit <M>number</M>]</tag>

	Usually, only best routes are exported to the kernel protocol. With path

	merging enabled, both best routes and equivalent non-best routes are

	merged during export to generate one ECMP (equal-cost multipath) route

	for each network. This is useful e.g. for BGP multipath. Note that best

	routes are still pivotal for route export (responsible for most

	properties of resulting ECMP routes), while exported non-best routes are

	responsible just for additional multipath next hops. This option also

	allows to specify a limit on maximal number of nexthops in one route. By

	default, multipath merging is disabled. If enabled, default value of the

	limit is 16.

</descrip>

<sect1>Attributes

	The realm of the route. Can be used for traffic classification.

</descrip>

<p>In Linux, there is also a plenty of obscure route attributes mostly focused

on tuning TCP performance of local connections. BIRD supports most of these

attributes, see Linux or iproute2 documentation for their meaning. Attributes

<cf/krt_lock_*/ and <cf/krt_feature_*/ have type bool, others have type int.

Supported attributes are:

<cf/krt_mtu/, <cf/krt_lock_mtu/, <cf/krt_window/, <cf/krt_lock_window/,

<cf/krt_rtt/, <cf/krt_lock_rtt/, <cf/krt_rttvar/, <cf/krt_lock_rttvar/,

<cf/krt_sstresh/, <cf/krt_lock_sstresh/, <cf/krt_cwnd/, <cf/krt_lock_cwnd/,

<cf/krt_advmss/, <cf/krt_lock_advmss/, <cf/krt_reordering/, <cf/krt_lock_reordering/,

<cf/krt_hoplimit/, <cf/krt_lock_hoplimit/, <cf/krt_rto_min/, <cf/krt_lock_rto_min/,

<cf/krt_initcwnd/, <cf/krt_initrwnd/, <cf/krt_quickack/,

<cf/krt_feature_ecn/, <cf/krt_feature_allfrag/

<sect1>Example

<p>A simple configuration can look this way:

<descrip>

	<tag>route <m/prefix/ via <m/ip/</tag>

	Static route through a neighboring router.

	Static route through a neighboring router. For link-local next hops,

	interface can be specified as a part of the address (e.g.,

	<cf/via fe80::1234%eth0/).

	<tag>route <m/prefix/ multipath via <m/ip/ [weight <m/num/] [via ...]</tag>

	Static multipath route. Contains several nexthops (gateways), possibly

static void

f_rta_cow(void)

{

  if ((*f_rte)->attrs->aflags & RTAF_CACHED) {

  if (!rta_is_cached((*f_rte)->attrs))

    return;

  /* Prepare to modify rte */

  f_rte_cow();

    /* Store old rta to free it later */

  /* Store old rta to free it later, it stores reference from rte_cow() */

  f_old_rta = (*f_rte)->attrs;

  /*

     * Alloc new rta, do shallow copy and update rte. Fields eattrs

     * and nexthops of rta are shared with f_old_rta (they will be

     * copied when the cached rta will be obtained at the end of

     * f_run()), also the lock of hostentry is inherited (we suppose

     * hostentry is not changed by filters).

   * Get shallow copy of rta. Fields eattrs and nexthops of rta are shared

   * with f_old_rta (they will be copied when the cached rta will be obtained

   * at the end of f_run()), also the lock of hostentry is inherited (we

   * suppose hostentry is not changed by filters).

   */

    rta *ra = lp_alloc(f_pool, sizeof(rta));

    memcpy(ra, f_old_rta, sizeof(rta));

    ra->aflags = 0;

    (*f_rte)->attrs = ra;

  }

  (*f_rte)->attrs = rta_do_cow((*f_rte)->attrs, f_pool);

}

static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;

  return res.val.i;

}

/* TODO: perhaps we could integrate f_eval(), f_eval_rte() and f_run() */

struct f_val

f_eval_rte(struct f_inst *expr, struct rte **rte, struct linpool *tmp_pool)

{

  struct ea_list *tmp_attrs = NULL;

  f_rte = rte;

  f_old_rta = NULL;

  f_tmp_attrs = &tmp_attrs;

  f_pool = tmp_pool;

  f_flags = 0;

  LOG_BUFFER_INIT(f_buf);

  /* Note that in this function we assume that rte->attrs is private / uncached */

  struct f_val res = interpret(expr);

  /* Hack to include EAF_TEMP attributes to the main list */

  (*rte)->attrs->eattrs = ea_append(tmp_attrs, (*rte)->attrs->eattrs);

  return res;

}

struct f_val

f_eval(struct f_inst *expr, struct linpool *tmp_pool)

{

struct rte;

int f_run(struct filter *filter, struct rte **rte, struct ea_list **tmp_attrs, struct linpool *tmp_pool, int flags);

struct f_val f_eval_rte(struct f_inst *expr, struct rte **rte, struct linpool *tmp_pool);

struct f_val f_eval(struct f_inst *expr, struct linpool *tmp_pool);

uint f_eval_int(struct f_inst *expr);

u32 f_eval_asn(struct f_inst *expr);

#endif

#define ABS(a)   ((a)>=0 ? (a) : -(a))

#define DELTA(a,b) (((a)>=(b))?(a)-(b):(b)-(a))

#define ARRAY_SIZE(a) (sizeof(a)/sizeof(*(a)))