Merge branch 'master' into int-new-channels

<p><descrip>

	<tag>include "<m/filename/"</tag>

	This statement causes inclusion of a new file. <m/Filename/ could also

	be a wildcard. The maximal depth is 8. Note that this statement could be

	used anywhere in the config file, not just as a top-level option.

	be a wildcard, in that case matching files are included in alphabetic

	order. The maximal depth is 8. Note that this statement could be used

	anywhere in the config file, not just as a top-level option.

	<tag><label id="dsc-log">log "<m/filename/"|syslog [name <m/name/]|stderr all|{ <m/list of classes/ }</tag>

	Set logging of messages having the given class (either <cf/all/ or

	<cf><m/P/.last</cf> returns the last ASN (the source ASN) in path <m/P/.

	<cf><m/P/.last_nonaggregated</cf> returns the last ASN in the non-aggregated part of the path <m/P/.

	Both <cf/first/ and <cf/last/ return zero if there is no appropriate

	ASN, for example if the path contains an AS set element as the first (or

	the last) part.

	the last) part. If the path ends with an AS set, <cf/last_nonaggregated/

	may be used to get last ASN before any AS set.

	<cf><m/P/.len</cf> returns the length of path <m/P/.

	in neighbor's implementation of 4B AS extension. Even when disabled

	(off), BIRD behaves internally as AS4-aware BGP router. Default: on.

	<tag>enable extended messages <m/switch/</tag>

	The BGP protocol uses maximum message length of 4096 bytes. This option

	provides an extension to allow extended messages with length up

	to 65535 bytes. Default: off.

	<tag>capabilities <m/switch/</tag>

	Use capability advertisement to advertise optional capabilities. This is

	standard behavior for newer BGP implementations, but there might be some

	updates. Default value is 5.

	<tag>priority <M>num</M></tag>

	On every multiple access network (e.g., the Ethernet) Designed Router

	and Backup Designed router are elected. These routers have some special

	On every multiple access network (e.g., the Ethernet) Designated Router

	and Backup Designated router are elected. These routers have some special

	functions in the flooding process. Higher priority increases preferences

	in this election. Routers with priority 0 are not eligible. Default

	value is 1.

	LEN,

	DEFINED,

	ADD, DELETE, CONTAINS, RESET,

	PREPEND, FIRST, LAST, MATCH,

	PREPEND, FIRST, LAST, LAST_NONAGGREGATED, MATCH,

	EMPTY,

	FILTER, WHERE, EVAL)

 | term '.' MASK '(' term ')' { $$ = f_new_inst(); $$->code = P('i','M'); $$->a1.p = $1; $$->a2.p = $5; }

 | term '.' FIRST { $$ = f_new_inst(); $$->code = P('a','f'); $$->a1.p = $1; }

 | term '.' LAST  { $$ = f_new_inst(); $$->code = P('a','l'); $$->a1.p = $1; }

 | term '.' LAST_NONAGGREGATED  { $$ = f_new_inst(); $$->code = P('a','L'); $$->a1.p = $1; }

/* Communities */

/* This causes one shift/reduce conflict

    res.type = T_INT;

    res.val.i = as;

    break;

  case P('a','L'):	/* Get last ASN from non-aggregated part of AS PATH */

    ONEARG;

    if (v1.type != T_PATH)

      runtime( "AS path expected" );

    res.type = T_INT;

    res.val.i = as_path_get_last_nonaggregated(v1.val.ad);

    break;

  case 'r':

    ONEARG;

    res = v1;

{

  node *z = l->tail;

  n->next = (node *) &l->null;

  n->next = &l->tail_node;

  n->prev = z;

  z->next = n;

  l->tail = n;

  node *z = l->head;

  n->next = z;

  n->prev = (node *) &l->head;

  n->prev = &l->head_node;

  z->prev = n;

  l->head = n;

}

 * rem_node - remove a node from a list

 * @n: node to be removed

 *

 * Removes a node @n from the list it's linked in.

 * Removes a node @n from the list it's linked in. Afterwards, node @n is cleared.

 */

LIST_INLINE void

rem_node(node *n)

  node *z = n->prev;

  node *x = n->next;

  z->next = x;

  x->prev = z;

}

/**

 * rem2_node - remove a node from a list, with cleanup

 * @n: node to be removed

 *

 * Removes a node @n from the list it's linked in and resets its pointers to NULL.

 * Useful if you want to distinguish between linked and unlinked nodes.

 */

LIST_INLINE void

rem2_node(node *n)

{

  node *z = n->prev;

  node *x = n->next;

  z->next = x;

  x->prev = z;

  n->next = NULL;

LIST_INLINE void

init_list(list *l)

{

  l->head = (node *) &l->null;

  l->head = &l->tail_node;

  l->null = NULL;

  l->tail = (node *) &l->head;

  l->tail = &l->head_node;

}

/**

  p->next = q;

  q->prev = p;

  q = l->tail;

  q->next = (node *) &to->null;

  q->next = &to->tail_node;

  to->tail = q;

}

  struct node *next, *prev;

} node;

typedef struct list {			/* In fact two overlayed nodes */

  struct node *head, *null, *tail;

typedef union list {			/* In fact two overlayed nodes */

  struct {				/* Head node */

    struct node head_node;

    void *head_padding;

  };

  struct {				/* Tail node */

    void *tail_padding;

    struct node tail_node;

  };

  struct {				/* Split to separate pointers */

    struct node *head;

    struct node *null;

    struct node *tail;

  };

} list;

#define NODE (node *)

#define HEAD(list) ((void *)((list).head))

#define TAIL(list) ((void *)((list).tail))

void add_tail(list *, node *);

void add_head(list *, node *);

void rem_node(node *);

void rem2_node(node *);

void add_tail_list(list *, list *);

void init_list(list *);

void insert_node(node *, node *);