proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-13 00:27:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[bgpd] Merge AS4 support

Browse Source 
2007-10-14 Paul Jakma <paul.jakma@sun.com>

	* NEWS: Note that MRT dumps are now version 2
	* (general) Merge in Juergen Kammer's AS4 patch.

2007-09-27 Paul Jakma <paul.jakma@sun.com>

	* bgp_aspath.c: (assegment_normalise) remove duplicates from
	  from sets.
	  (aspath_reconcile_as4) disregard a broken part of the RFC around
	  error handling in path reconciliation.
	* aspath_test.c: Test dupe-weeding from sets.
	  Test that reconciliation merges AS_PATH and AS4_PATH where
	  former is shorter than latter.

2007-09-26 Paul Jakma <paul.jakma@sun.com>

	* aspath_test.c: Test AS4_PATH reconcilation where length
	  of AS_PATH and AS4_PATH is same.

2007-09-25 Paul Jakma <paul.jakma@sun.com>

	* bgp_open.c: (peek_for_as4_capability) Fix to work.
	* bgp_packet.c: (bgp_open_receive) Fix sanity check of as4.
	* tests/bgp_capability_test.c: (general) Extend tests to validate
	  peek_for_as4_capability.
	  Add test of full OPEN Option block, with multiple capabilities,
	  both as a series of Option, and a single option.
	  Add some crap to beginning of stream, to prevent code depending
	  on getp == 0.

2007-09-18 Paul Jakma <paul.jakma@sun.com>

	* bgp_open.c: (bgp_capability_as4) debug printf inline with others.
	  (peek_for_as4_capability) There's no need to signal failure, as
	  failure is better dealt with through full capability parser -
	  just return the AS4, simpler.
	* bgp_packet.c: (bgp_open_receive) Update to match
	  peek_for_as4_capability change.
	  Allow use of BGP_AS_TRANS by 2b speakers.
	  Use NOTIFY_OPEN_ERR rather than CEASE for OPEN parsing errors.
	  (bgp_capability_msg_parse) missing argument to debug print
	  (bgp_capability_receive) missing return values.
	* tests/bgp_capability_test.c: (parse_test) update for changes to
	  peek_for_as4_capability

2007-07-25 Paul Jakma <paul.jakma@sun.com>

	* Remove 2-byte size macros, just make existing macros take
	  argument to indicate which size to use.
	  Adjust all users - typically they want '1'.
	* bgp_aspath.c: (aspath_has_as4) New, return 1 if there are any
	  as4's in a path.
	  (aspath_put) Return the number of bytes actually written, to
	  fix the bug Juergen noted: Splitting of segments will change
	  the number of bytes written from that already written to the
	  AS_PATH header.
	  (aspath_snmp_pathseg) Pass 2-byte flag to aspath_put. SNMP
	  is still defined as 2b.
	  (aspath_aggregate) fix latent bug.
	  (aspath_reconcile_as4) AS_PATH+NEW_AS_PATH reconciliation
	  function.
	  (aspath_key_make) Hash the AS_PATH string, rather than
	  just taking the addition of assegment ASes as the hash value,
	  hopefully sligthly more collision resistant.
	  (bgp_attr_munge_as4_attrs) Collide the NEW_ attributes
	  together with the OLD 2-byte forms, code Juergen
	  had in bgp_attr_parse but re-organised a bit.
	  (bgp_attr_parse) Bunch of code from Juergen moves
	  to previous function.
	  (bgp_packet_attribute) Compact significantly by
	  just /always/ using extended-length attr header.
	  Fix bug Juergen noted, by using aspath_put's
	  (new) returned size value for the attr header rather
	  than the (guesstimate) of aspath_size() - the two could
	  differ when aspath_put had to split large segments, unlikely
	  this bug was ever hit in the 'wild'.
	  (bgp_dump_routes_attr) Always use extended-len and
	  use aspath_put return for header length. Output 4b ASN
	  for AS_PATH and AGGREGATOR.
	* bgp_ecommunity.c: (ecommunity_{hash_make,cmp}) fix
	  hash callback declarations to match prototypes.
	  (ecommunity_gettoken) Updated for ECOMMUNITY_ENCODE_AS4,
	  complete rewrite of Juergen's changes (no asdot support)
	* bgp_open.c: (bgp_capability_as4) New, does what it says
	  on the tin.
	  (peek_for_as4_capability) Rewritten to use streams and
	  bgp_capability_as4.
	* bgp_packet.c: (bgp_open_send) minor edit
	  checked (in the abstract at least) with Juergen.
	  Changes are to be more accepting, e.g, allow AS_TRANS on
	  a 2-byte session.
	* (general) Update all commands to use CMD_AS_RANGE.
	* bgp_vty.c: (bgp_clear) Fix return vals to use CMD_..
	  Remove stuff replicated by VTY_GET_LONG
	  (bgp_clear_vty) Return bgp_clear directly to vty.
	* tests/aspath_test.c: Exercise 32bit parsing. Test reconcile
	  function.
	* tests/ecommunity_test.c: New, test AS4 ecommunity changes,
	  positive test only at this time, error cases not tested yet.

2007-07-25 Juergen Kammer <j.kammer@eurodata.de>

	* (general) AS4 support.
	* bgpd.h: as_t changes to 4-bytes.
	* bgp_aspath.h: Add BGP_AS4_MAX and BGP_AS_TRANS defines.
	* bgp_aspath.c: AS_VALUE_SIZE becomes 4-byte, AS16_VALUE_SIZE
	  added for 2-byte.
	  Add AS16 versions of length calc macros.
	  (aspath_count_numas) New, count number of ASes.
	  (aspath_has_as4) New, return 1 if there are any as4's in a
	  path.
	  (assegments_parse) Interpret assegment as 4 or 2 byte,
	  according to how the caller instructs us, with a new
	  argument.
	  (aspath_parse) Add use32bit argument to pass to
	  assegments_parse. Adjust all its callers to pass 1, unless
	  otherwise noted.
	  (assegment_data_put) Adjust to be able to write 2 or 4 byte
	  AS, according to new use32bit argument.
	  (aspath_put) Adjust to write 2 or 4.
	  (aspath_gettoken) Use a long for passed in asno.
	* bgp_attr.c: (attr_str) Add BGP_ATTR_AS4_PATH and
	  BGP_ATTR_AS4_AGGREGATOR.
	  (bgp_attr_aspath) Call aspath_parse with right 2/4 arg, as
	  determined by received-capability flag.
	  (bgp_attr_aspath_check) New, code previously in attr_aspath
	  but moved to new func so it can be run after NEW_AS_PATH
	  reconciliation.
	  (bgp_attr_as4_path) New, handle NEW_AS_PATH.
	  (bgp_attr_aggregator) Adjust to cope with 2/4 byte ASes.
	  (bgp_attr_as4_aggregator) New, read NEW_AGGREGATOR.
	  (bgp_attr_parse) Add handoffs to previous parsers for the two
	  new AS4 NEW_ attributes.
	  Various checks added for NEW/OLD reconciliation.
	  (bgp_packet_attribute) Support 2/4 for AS_PATH and
	  AGGREGATOR, detect when NEW_ attrs need to be sent.
	* bgp_debug.{c,h}: Add 'debug bgp as4'.
	* bgp_dump.c: MRTv2 support, unconditionally enabled, which
	  supports AS4. Based on patches from Erik (RIPE?).
	* bgp_ecommunity.c: (ecommunity_ecom2str) ECOMMUNITY_ENCODE_AS4
	  support.
	* bgp_open.c: (peek_for_as4_capability) New, peek for AS4
	  capability prior to full capability parsing, so we know which
	  ASN to use for struct peer lookup.
	  (bgp_open_capability) Always send AS4 capability.
	* bgp_packet.c: (bgp_open_send) AS4 handling for AS field
	  (bgp_open_receive) Peek for AS4 capability first, and figure
	  out which AS to believe.
	* bgp_vty.c: (bgp_show_peer) Print AS4 cap
	* tests/aspath_test.c: Support asn32 changes, call aspath_parse
	  with 16 bit.
	* vtysh/extract.pl: AS4 compatibility for router bgp ASNUMBER
	* vtysh/extract.pl.in: AS4 compatibility for router bgp ASNUMBER
	* vtysh/vtysh.c: AS4 compatibility for router bgp ASNUMBER
This commit is contained in:
Paul Jakma 2007-10-14 22:32:21 +00:00
parent 7593fddfa1
commit 0b2aa3a0a8
27 changed files with 1900 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -1,3 +1,7 @@
2007-10-14 Paul Jakma <paul.jakma@sun.com>
* NEWS: Note that MRT dumps are now version 2
2007-09-07 Paul Jakma <paul.jakma@sun.com>
* configure.ac: Bump version to 0.99.9

6
NEWS
View File

@ -1,5 +1,11 @@
* Changes in Quagga 0.99.2
- [bgpd] 4-byte AS support added
- [bgpd] MRT format changes to version 2. Those relying on
bgpd MRT table dumps may need to update their tools.
* Changes in Quagga 0.99.2
- [bgpd] Work queues added to bgpd to split up update processing,
particularly beneficial when a peer session goes down. AS_PATH
parsing rewritten to be clearer, more robust and ready for 4-byte.

128
bgpd/ChangeLog
View File

@ -1,3 +1,131 @@
2007-09-27 Paul Jakma <paul.jakma@sun.com>
* bgp_aspath.c: (assegment_normalise) remove duplicates from
from sets.
(aspath_reconcile_as4) disregard a broken part of the RFC around
error handling in path reconciliation.
2007-09-25 Paul Jakma <paul.jakma@sun.com>
* bgp_open.c: (peek_for_as4_capability) Fix to work.
* bgp_packet.c: (bgp_open_receive) Fix sanity check of as4.
2007-09-18 Paul Jakma <paul.jakma@sun.com>
* bgp_open.c: (bgp_capability_as4) debug printf inline with others.
(peek_for_as4_capability) There's no need to signal failure, as
failure is better dealt with through full capability parser -
just return the AS4, simpler.
* bgp_packet.c: (bgp_open_receive) Update to match
peek_for_as4_capability change.
Allow use of BGP_AS_TRANS by 2b speakers.
Use NOTIFY_OPEN_ERR rather than CEASE for OPEN parsing errors.
(bgp_capability_msg_parse) missing argument to debug print
(bgp_capability_receive) missing return values.
2007-07-25 Paul Jakma <paul.jakma@sun.com>
* Remove 2-byte size macros, just make existing macros take
argument to indicate which size to use.
Adjust all users - typically they want '1'.
* bgp_aspath.c: (aspath_has_as4) New, return 1 if there are any
as4's in a path.
(aspath_put) Return the number of bytes actually written, to
fix the bug Juergen noted: Splitting of segments will change
the number of bytes written from that already written to the
AS_PATH header.
(aspath_snmp_pathseg) Pass 2-byte flag to aspath_put. SNMP
is still defined as 2b.
(aspath_aggregate) fix latent bug.
(aspath_reconcile_as4) AS_PATH+NEW_AS_PATH reconciliation
function.
(aspath_key_make) Hash the AS_PATH string, rather than
just taking the addition of assegment ASes as the hash value,
hopefully sligthly more collision resistant.
(bgp_attr_munge_as4_attrs) Collide the NEW_ attributes
together with the OLD 2-byte forms, code Juergen
had in bgp_attr_parse but re-organised a bit.
(bgp_attr_parse) Bunch of code from Juergen moves
to previous function.
(bgp_packet_attribute) Compact significantly by
just /always/ using extended-length attr header.
Fix bug Juergen noted, by using aspath_put's
(new) returned size value for the attr header rather
than the (guesstimate) of aspath_size() - the two could
differ when aspath_put had to split large segments, unlikely
this bug was ever hit in the 'wild'.
(bgp_dump_routes_attr) Always use extended-len and
use aspath_put return for header length. Output 4b ASN
for AS_PATH and AGGREGATOR.
* bgp_ecommunity.c: (ecommunity_{hash_make,cmp}) fix
hash callback declarations to match prototypes.
(ecommunity_gettoken) Updated for ECOMMUNITY_ENCODE_AS4,
complete rewrite of Juergen's changes (no asdot support)
* bgp_open.c: (bgp_capability_as4) New, does what it says
on the tin.
(peek_for_as4_capability) Rewritten to use streams and
bgp_capability_as4.
* bgp_packet.c: (bgp_open_send) minor edit
checked (in the abstract at least) with Juergen.
Changes are to be more accepting, e.g, allow AS_TRANS on
a 2-byte session.
* (general) Update all commands to use CMD_AS_RANGE.
* bgp_vty.c: (bgp_clear) Fix return vals to use CMD_..
Remove stuff replicated by VTY_GET_LONG
(bgp_clear_vty) Return bgp_clear directly to vty.
2007-07-25 Juergen Kammer <j.kammer@eurodata.de>
* (general) AS4 support.
* bgpd.h: as_t changes to 4-bytes.
* bgp_aspath.h: Add BGP_AS4_MAX and BGP_AS_TRANS defines.
* bgp_aspath.c: AS_VALUE_SIZE becomes 4-byte, AS16_VALUE_SIZE
added for 2-byte.
Add AS16 versions of length calc macros.
(aspath_count_numas) New, count number of ASes.
(aspath_has_as4) New, return 1 if there are any as4's in a
path.
(assegments_parse) Interpret assegment as 4 or 2 byte,
according to how the caller instructs us, with a new
argument.
(aspath_parse) Add use32bit argument to pass to
assegments_parse. Adjust all its callers to pass 1, unless
otherwise noted.
(assegment_data_put) Adjust to be able to write 2 or 4 byte
AS, according to new use32bit argument.
(aspath_put) Adjust to write 2 or 4.
(aspath_gettoken) Use a long for passed in asno.
* bgp_attr.c: (attr_str) Add BGP_ATTR_AS4_PATH and
BGP_ATTR_AS4_AGGREGATOR.
(bgp_attr_aspath) Call aspath_parse with right 2/4 arg, as
determined by received-capability flag.
(bgp_attr_aspath_check) New, code previously in attr_aspath
but moved to new func so it can be run after NEW_AS_PATH
reconciliation.
(bgp_attr_as4_path) New, handle NEW_AS_PATH.
(bgp_attr_aggregator) Adjust to cope with 2/4 byte ASes.
(bgp_attr_as4_aggregator) New, read NEW_AGGREGATOR.
(bgp_attr_parse) Add handoffs to previous parsers for the two
new AS4 NEW_ attributes.
Various checks added for NEW/OLD reconciliation.
(bgp_packet_attribute) Support 2/4 for AS_PATH and
AGGREGATOR, detect when NEW_ attrs need to be sent.
* bgp_debug.{c,h}: Add 'debug bgp as4'.
* bgp_dump.c: MRTv2 support, unconditionally enabled, which
supports AS4. Based on patches from Erik (RIPE?).
* bgp_ecommunity.c: (ecommunity_ecom2str) ECOMMUNITY_ENCODE_AS4
support.
* bgp_open.c: (peek_for_as4_capability) New, peek for AS4
capability prior to full capability parsing, so we know which
ASN to use for struct peer lookup.
(bgp_open_capability) Always send AS4 capability.
* bgp_packet.c: (bgp_open_send) AS4 handling for AS field
(bgp_open_receive) Peek for AS4 capability first, and figure
out which AS to believe.
* bgp_vty.c: (bgp_show_peer) Print AS4 cap
2007-09-17 Paul Jakma <paul.jakma@sun.com>
* bgp_open.c: (bgp_capability_mp) We were setting

357
bgpd/bgp_aspath.c
View File

@ -28,15 +28,20 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#include "str.h"
#include "log.h"
#include "stream.h"
#include "jhash.h"
#include "bgpd/bgpd.h"
#include "bgpd/bgp_aspath.h"
#include "bgpd/bgp_debug.h"
#include "bgpd/bgp_attr.h"
/* Attr. Flags and Attr. Type Code. */
#define AS_HEADER_SIZE 2
/* Two octet is used for AS value. */
/* Now FOUR octets are used for AS value. */
#define AS_VALUE_SIZE sizeof (as_t)
/* This is the old one */
#define AS16_VALUE_SIZE sizeof (as16_t)
/* Maximum protocol segment length value */
#define AS_SEGMENT_MAX 255
@ -46,16 +51,20 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* sizes and lengths. At present (200508) they sort of match, however
* the ONLY functions which should now about the on-wire syntax are
* aspath_put, assegment_put and assegment_parse.
*
* aspath_put returns bytes written, the only definitive record of
* size of wire-format attribute..
*/
/* Calculated size in bytes of ASN segment data to hold N ASN's */
#define ASSEGMENT_DATA_SIZE(N) ((N) * AS_VALUE_SIZE)
#define ASSEGMENT_DATA_SIZE(N,S) \
((N) * ( (S) ? AS_VALUE_SIZE : AS16_VALUE_SIZE) )
/* Calculated size of segment struct to hold N ASN's */
#define ASSEGMENT_SIZE(N) (AS_HEADER_SIZE + ASSEGMENT_DATA_SIZE (N))
#define ASSEGMENT_SIZE(N,S) (AS_HEADER_SIZE + ASSEGMENT_DATA_SIZE (N,S))
/* AS segment octet length. */
#define ASSEGMENT_LEN(X) ASSEGMENT_SIZE((X)->length)
#define ASSEGMENT_LEN(X,S) ASSEGMENT_SIZE((X)->length,S)
/* AS_SEQUENCE segments can be packed together */
/* Can the types of X and Y be considered for packing? */
@ -85,7 +94,7 @@ static struct stream *snmp_stream;
static inline as_t *
assegment_data_new (int num)
{
return (XCALLOC (MTYPE_AS_SEG_DATA, ASSEGMENT_DATA_SIZE (num)));
return (XCALLOC (MTYPE_AS_SEG_DATA, ASSEGMENT_DATA_SIZE (num, 1)));
}
static inline void
@ -150,7 +159,7 @@ assegment_dup (struct assegment *seg)
struct assegment *new;
new = assegment_new (seg->type, seg->length);
memcpy (new->as, seg->as, ASSEGMENT_DATA_SIZE (new->length) );
memcpy (new->as, seg->as, ASSEGMENT_DATA_SIZE (new->length, 1) );
return new;
}
@ -197,7 +206,7 @@ assegment_prepend_asns (struct assegment *seg, as_t asnum, int num)
for (i = 0; i < num; i++)
newas[i] = asnum;
memcpy (newas + num, seg->as, ASSEGMENT_DATA_SIZE (seg->length));
memcpy (newas + num, seg->as, ASSEGMENT_DATA_SIZE (seg->length, 1));
XFREE (MTYPE_AS_SEG_DATA, seg->as);
seg->as = newas;
seg->length += num;
@ -215,12 +224,12 @@ assegment_append_asns (struct assegment *seg, as_t *asnos, int num)
as_t *newas;
newas = XREALLOC (MTYPE_AS_SEG_DATA, seg->as,
ASSEGMENT_DATA_SIZE (seg->length + num));
ASSEGMENT_DATA_SIZE (seg->length + num, 1));
if (newas)
{
seg->as = newas;
memcpy (seg->as + seg->length, asnos, ASSEGMENT_DATA_SIZE(num));
memcpy (seg->as + seg->length, asnos, ASSEGMENT_DATA_SIZE(num, 1));
seg->length += num;
return seg;
}
@ -263,7 +272,26 @@ assegment_normalise (struct assegment *head)
* and because it helps other lesser implementations ;)
*/
if (seg->type == AS_SET || seg->type == AS_CONFED_SET)
qsort (seg->as, seg->length, sizeof(as_t), int_cmp);
{
int tail = 0;
int i;
qsort (seg->as, seg->length, sizeof(as_t), int_cmp);
/* weed out dupes */
for (i=1; i < seg->length; i++)
{
if (seg->as[tail] == seg->as[i])
continue;
tail++;
if (tail < i)
seg->as[tail] = seg->as[i];
}
/* seg->length can be 0.. */
if (seg->length)
seg->length = tail + 1;
}
/* read ahead from the current, pinned segment while the segments
* are packable/mergeable. Append all following packable segments
@ -420,6 +448,12 @@ aspath_count_hops (struct aspath *aspath)
return count;
}
/* Estimate size aspath /might/ take if encoded into an
* ASPATH attribute.
*
* This is a quick estimate, not definitive! aspath_put()
* may return a different number!!
*/
unsigned int
aspath_size (struct aspath *aspath)
{
@ -428,7 +462,7 @@ aspath_size (struct aspath *aspath)
while (seg)
{
size += ASSEGMENT_SIZE(seg->length);
size += ASSEGMENT_SIZE(seg->length, 1);
seg = seg->next;
}
return size;
@ -454,6 +488,39 @@ aspath_highest (struct aspath *aspath)
return highest;
}
/* Return 1 if there are any 4-byte ASes in the path */
unsigned int
aspath_has_as4 (struct aspath *aspath)
{
struct assegment *seg = aspath->segments;
unsigned int i;
while (seg)
{
for (i = 0; i < seg->length; i++)
if (seg->as[i] > BGP_AS_MAX)
return 1;
seg = seg->next;
}
return 0;
}
/* Return number of as numbers in in path */
unsigned int
aspath_count_numas (struct aspath *aspath)
{
struct assegment *seg = aspath->segments;
unsigned int num;
num=0;
while (seg)
{
num += seg->length;
seg = seg->next;
}
return num;
}
/* Convert aspath structure to string expression. */
static char *
aspath_make_str_count (struct aspath *as)
@ -478,6 +545,9 @@ aspath_make_str_count (struct aspath *as)
* 2 chars for segment delimiters, and the final '\0'.
* Hopefully this is large enough to avoid hitting the realloc
* code below for most common sequences.
*
* With 32bit ASNs, this range will increase, but only worth changing
* once there are significant numbers of ASN >= 100000
*/
#define ASN_STR_LEN (5 + 1)
str_size = MAX (assegment_count_asns (seg, 0) * ASN_STR_LEN + 2 + 1,
@ -510,6 +580,9 @@ aspath_make_str_count (struct aspath *as)
* have been wrong. need 5 chars for ASN, a seperator each and
* potentially two segment delimiters, plus a space between each
* segment and trailing zero.
*
* This may need to revised if/when significant numbers of
* ASNs >= 100000 are assigned and in-use on the internet...
*/
#define SEGMENT_STR_LEN(X) (((X)->length * ASN_STR_LEN) + 2 + 1 + 1)
if ( (len + SEGMENT_STR_LEN(seg)) > str_size)
@ -605,7 +678,7 @@ aspath_hash_alloc (void *arg)
{
struct aspath *aspath;
/* New aspath strucutre is needed. */
/* New aspath structure is needed. */
aspath = aspath_dup (arg);
/* Malformed AS path value. */
@ -620,7 +693,7 @@ aspath_hash_alloc (void *arg)
/* parse as-segment byte stream in struct assegment */
static struct assegment *
assegments_parse (struct stream *s, size_t length)
assegments_parse (struct stream *s, size_t length, int use32bit)
{
struct assegment_header segh;
struct assegment *seg, *prev = NULL, *head = NULL;
@ -630,27 +703,37 @@ assegments_parse (struct stream *s, size_t length)
if (length == 0)
return NULL;
if (BGP_DEBUG (as4, AS4_SEGMENT))
zlog_debug ("[AS4SEG] Parse aspath segment: got total byte length %lu",
(unsigned long) length);
/* basic checks */
if ( (STREAM_READABLE(s) < length)
|| (STREAM_READABLE(s) < AS_HEADER_SIZE)
|| (length % AS_VALUE_SIZE))
|| (length % AS16_VALUE_SIZE ))
return NULL;
while ( (STREAM_READABLE(s) > AS_HEADER_SIZE)
&& (bytes < length))
{
int i;
int seg_size;
/* softly softly, get the header first on its own */
segh.type = stream_getc (s);
segh.length = stream_getc (s);
seg_size = ASSEGMENT_SIZE(segh.length, use32bit);
if (BGP_DEBUG (as4, AS4_SEGMENT))
zlog_debug ("[AS4SEG] Parse aspath segment: got type %d, length %d",
segh.type, segh.length);
/* check it.. */
if ( ((bytes + ASSEGMENT_SIZE(segh.length)) > length)
if ( ((bytes + seg_size) > length)
/* 1771bis 4.3b: seg length contains one or more */
|| (segh.length == 0)
/* Paranoia in case someone changes type of segment length */
|| ((sizeof segh.length > 1) && segh.length > AS_SEGMENT_MAX))
|| ((sizeof segh.length > 1) && (segh.length > AS_SEGMENT_MAX)) )
{
if (head)
assegment_free_all (head);
@ -666,9 +749,13 @@ assegments_parse (struct stream *s, size_t length)
head = prev = seg;
for (i = 0; i < segh.length; i++)
seg->as[i] = stream_getw (s);
seg->as[i] = (use32bit) ? stream_getl (s) : stream_getw (s);
bytes += seg_size;
bytes += ASSEGMENT_SIZE(segh.length);
if (BGP_DEBUG (as4, AS4_SEGMENT))
zlog_debug ("[AS4SEG] Parse aspath segment: Bytes now: %lu",
(unsigned long) bytes);
prev = seg;
}
@ -680,16 +767,22 @@ assegments_parse (struct stream *s, size_t length)
is length of byte stream. If there is same AS path in the the AS
path hash then return it else make new AS path structure. */
struct aspath *
aspath_parse (struct stream *s, size_t length)
aspath_parse (struct stream *s, size_t length, int use32bit)
{
struct aspath as;
struct aspath *find;
/* If length is odd it's malformed AS path. */
if (length % AS_VALUE_SIZE)
/* Nit-picking: if (use32bit == 0) it is malformed if odd,
* otherwise its malformed when length is larger than 2 and (length-2)
* is not dividable by 4.
* But... this time we're lazy
*/
if (length % AS16_VALUE_SIZE )
return NULL;
as.segments = assegments_parse (s, length);
memset (&as, 0, sizeof (struct aspath));
as.segments = assegments_parse (s, length, use32bit);
/* If already same aspath exist then return it. */
find = hash_get (ashash, &as, aspath_hash_alloc);
@ -698,6 +791,8 @@ aspath_parse (struct stream *s, size_t length)
* optimised out.
*/
assegment_free_all (as.segments);
if (as.str)
XFREE (MTYPE_AS_STR, as.str);
if (! find)
return NULL;
@ -707,13 +802,21 @@ aspath_parse (struct stream *s, size_t length)
}
static inline void
assegment_data_put (struct stream *s, as_t *as, int num)
assegment_data_put (struct stream *s, as_t *as, int num, int use32bit)
{
int i;
assert (num <= AS_SEGMENT_MAX);
for (i = 0; i < num; i++)
stream_putw (s, as[i]);
if ( use32bit )
stream_putl (s, as[i]);
else
{
if ( as[i] <= BGP_AS_MAX )
stream_putw(s, as[i]);
else
stream_putw(s, BGP_AS_TRANS);
}
}
static inline size_t
@ -728,38 +831,51 @@ assegment_header_put (struct stream *s, u_char type, int length)
}
/* write aspath data to stream */
void
aspath_put (struct stream *s, struct aspath *as)
size_t
aspath_put (struct stream *s, struct aspath *as, int use32bit )
{
struct assegment *seg = as->segments;
size_t bytes = 0;
if (!seg || seg->length == 0)
return;
return 0;
if (seg)
{
while (seg && (ASSEGMENT_LEN (seg) <= STREAM_WRITEABLE(s)))
/*
* Hey, what do we do when we have > STREAM_WRITABLE(s) here?
* At the moment, we would write out a partial aspath, and our peer
* will complain and drop the session :-/
*
* The general assumption here is that many things tested will
* never happen. And, in real live, up to now, they have not.
*/
while (seg && (ASSEGMENT_LEN(seg, use32bit) <= STREAM_WRITEABLE(s)))
{
struct assegment *next = seg->next;
int written = 0;
int asns_packed = 0;
size_t lenp;
/* Overlength segments have to be split up */
while ( (seg->length - written) > AS_SEGMENT_MAX)
{
assegment_header_put (s, seg->type, AS_SEGMENT_MAX);
assegment_data_put (s, seg->as, AS_SEGMENT_MAX);
assegment_data_put (s, seg->as, AS_SEGMENT_MAX, use32bit);
written += AS_SEGMENT_MAX;
bytes += ASSEGMENT_SIZE (written, use32bit);
}
/* write the final segment, probably is also the first */
lenp = assegment_header_put (s, seg->type, seg->length - written);
assegment_data_put (s, (seg->as + written), seg->length - written);
assegment_data_put (s, (seg->as + written), seg->length - written,
use32bit);
/* Sequence-type segments can be 'packed' together
* Case of a segment which was overlength and split up
* will be missed here, but that doesn't matter.
*/
if (seg->next && ASSEGMENTS_PACKABLE (seg, seg->next))
while (next && ASSEGMENTS_PACKABLE (seg, next))
{
/* NB: We should never normally get here given we
* normalise aspath data when parse them. However, better
@ -771,17 +887,21 @@ aspath_put (struct stream *s, struct aspath *as)
*/
/* Next segment's data can fit in this one */
assegment_data_put (s, seg->next->as, seg->next->length);
assegment_data_put (s, next->as, next->length, use32bit);
/* update the length of the segment header */
stream_putc_at (s, lenp,
seg->length - written + seg->next->length);
seg = seg->next->next; /* skip to past next */
stream_putc_at (s, lenp, seg->length - written + next->length);
asns_packed += next->length;
next = next->next;
}
else
seg = seg->next;
bytes += ASSEGMENT_SIZE (seg->length - written + asns_packed,
use32bit);
seg = next;
}
}
return bytes;
}
/* This is for SNMP BGP4PATHATTRASPATHSEGMENT
@ -803,7 +923,7 @@ aspath_snmp_pathseg (struct aspath *as, size_t *varlen)
*varlen = 0;
return NULL;
}
aspath_put (snmp_stream, as);
aspath_put (snmp_stream, as, 0); /* use 16 bit for now here */
*varlen = stream_get_endp (snmp_stream);
return stream_pnt(snmp_stream);
@ -861,8 +981,9 @@ aspath_aggregate (struct aspath *as1, struct aspath *as2)
int from;
struct assegment *seg1 = as1->segments;
struct assegment *seg2 = as2->segments;
struct aspath *aspath;
struct aspath *aspath = NULL;
struct assegment *asset;
struct assegment *prevseg = NULL;
match = 0;
minlen = 0;
@ -871,7 +992,7 @@ aspath_aggregate (struct aspath *as1, struct aspath *as2)
/* First of all check common leading sequence. */
while (seg1 && seg2)
{
{
/* Check segment type. */
if (seg1->type != seg2->type)
break;
@ -885,11 +1006,19 @@ aspath_aggregate (struct aspath *as1, struct aspath *as2)
if (match)
{
struct assegment *seg = assegment_new (seg1->type, 0);
seg = assegment_append_asns (seg, seg1->as, match);
if (! aspath)
aspath = aspath_new ();
aspath->segments = assegment_new (seg1->type, 0);
aspath->segments = assegment_append_asns (aspath->segments,
seg1->as, match);
{
aspath = aspath_new ();
aspath->segments = seg;
}
else
prevseg->next = seg;
prevseg = seg;
}
if (match != minlen || match != seg1->length
@ -1174,6 +1303,108 @@ aspath_cmp_left (struct aspath *aspath1, struct aspath *aspath2)
return 0;
}
/* Truncate an aspath after a number of hops, and put the hops remaining
* at the front of another aspath. Needed for AS4 compat.
*
* Returned aspath is a /new/ aspath, which should either by free'd or
* interned by the caller, as desired.
*/
struct aspath *
aspath_reconcile_as4 ( struct aspath *aspath, struct aspath *as4path)
{
struct assegment *seg, *newseg, *prevseg = NULL;
struct aspath *newpath = NULL, *mergedpath;
int hops, cpasns = 0;
if (!aspath)
return NULL;
seg = aspath->segments;
/* CONFEDs should get reconciled too.. */
hops = (aspath_count_hops (aspath) + aspath_count_confeds (aspath))
- aspath_count_hops (as4path);
if (hops < 0)
{
if (BGP_DEBUG (as4, AS4))
zlog_warn ("[AS4] Fewer hops in AS_PATH than NEW_AS_PATH");
/* Something's gone wrong. The RFC says we should now ignore AS4_PATH,
* which is daft behaviour - it contains vital loop-detection
* information which must have been removed from AS_PATH.
*/
hops = aspath_count_hops (aspath);
}
if (!hops)
return aspath_dup (as4path);
if ( BGP_DEBUG(as4, AS4))
zlog_debug("[AS4] got AS_PATH %s and AS4_PATH %s synthesizing now",
aspath->str, as4path->str);
while (seg && hops > 0)
{
switch (seg->type)
{
case AS_SET:
case AS_CONFED_SET:
hops--;
cpasns = seg->length;
break;
case AS_CONFED_SEQUENCE:
/* Should never split a confed-sequence, if hop-count
* suggests we must then something's gone wrong somewhere.
*
* Most important goal is to preserve AS_PATHs prime function
* as loop-detector, so we fudge the numbers so that the entire
* confed-sequence is merged in.
*/
if (hops < seg->length)
{
if (BGP_DEBUG (as4, AS4))
zlog_debug ("[AS4] AS4PATHmangle: AS_CONFED_SEQUENCE falls"
" across 2/4 ASN boundary somewhere, broken..");
hops = seg->length;
}
case AS_SEQUENCE:
cpasns = MIN(seg->length, hops);
hops -= seg->length;
}
assert (cpasns <= seg->length);
newseg = assegment_new (seg->type, 0);
newseg = assegment_append_asns (newseg, seg->as, cpasns);
if (!newpath)
{
newpath = aspath_new ();
newpath->segments = newseg;
}
else
prevseg->next = newseg;
prevseg = newseg;
seg = seg->next;
}
/* We may be able to join some segments here, and we must
* do this because... we want normalised aspaths in out hash
* and we do not want to stumble in aspath_put.
*/
mergedpath = aspath_merge (newpath, aspath_dup(as4path));
aspath_free (newpath);
mergedpath->segments = assegment_normalise (mergedpath->segments);
aspath_str_update (mergedpath);
if ( BGP_DEBUG(as4, AS4))
zlog_debug ("[AS4] result of synthesizing is %s",
mergedpath->str);
return mergedpath;
}
/* Compare leftmost AS value for MED check. If as1's leftmost AS and
as2's leftmost AS is same return 1. (confederation as-path
only). */
@ -1273,7 +1504,7 @@ aspath_segment_add (struct aspath *as, int type)
struct aspath *
aspath_empty (void)
{
return aspath_parse (NULL, 0);
return aspath_parse (NULL, 0, 1); /* 32Bit ;-) */
}
struct aspath *
@ -1316,7 +1547,7 @@ enum as_token
/* Return next token and point for string parse. */
static const char *
aspath_gettoken (const char *buf, enum as_token *token, u_short *asno)
aspath_gettoken (const char *buf, enum as_token *token, u_long *asno)
{
const char *p = buf;
@ -1360,16 +1591,17 @@ aspath_gettoken (const char *buf, enum as_token *token, u_short *asno)
if (isdigit ((int) *p))
{
u_short asval;
*token = as_token_asval;
asval = (*p - '0');
p++;
while (isdigit ((int) *p))
{
asval *= 10;
asval += (*p - '0');
p++;
}
{
asval *= 10;
asval += (*p - '0');
p++;
}
*asno = asval;
return p;
}
@ -1384,7 +1616,7 @@ aspath_str2aspath (const char *str)
{
enum as_token token = as_token_unknown;
u_short as_type;
u_short asno = 0;
u_long asno = 0;
struct aspath *aspath;
int needtype;
@ -1451,24 +1683,11 @@ aspath_key_make (void *p)
{
struct aspath * aspath = (struct aspath *) p;
unsigned int key = 0;
unsigned int i;
struct assegment *seg = aspath->segments;
struct assegment *prev = NULL;
while (seg)
{
/* segment types should be part of the hash
* otherwise seq(1) and set(1) will hash to same value
*/
if (!(prev && seg->type == AS_SEQUENCE && seg->type == prev->type))
key += seg->type;
for (i = 0; i < seg->length; i++)
key += seg->as[i];
prev = seg;
seg = seg->next;
}
if (!aspath->str)
aspath_str_update (aspath);
key = jhash (aspath->str, strlen(aspath->str), 2334325);
return key;
}

14
bgpd/bgp_aspath.h
View File

@ -31,7 +31,11 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#define BGP_PRIVATE_AS_MIN 64512U
#define BGP_PRIVATE_AS_MAX 65535U
#define BGP_AS_MAX 65535U
/* we leave BGP_AS_MAX as the 16bit AS MAX number. */
#define BGP_AS_MAX 65535U
#define BGP_AS4_MAX 4294967295U
/* Transition 16Bit AS as defined by IANA */
#define BGP_AS_TRANS 23456U
/* AS_PATH segment data in abstracted form, no limit is placed on length */
struct assegment
@ -61,7 +65,7 @@ struct aspath
/* Prototypes. */
extern void aspath_init (void);
extern void aspath_finish (void);
extern struct aspath *aspath_parse (struct stream *, size_t);
extern struct aspath *aspath_parse (struct stream *, size_t, int);
extern struct aspath *aspath_dup (struct aspath *);
extern struct aspath *aspath_aggregate (struct aspath *, struct aspath *);
extern struct aspath *aspath_prepend (struct aspath *, struct aspath *);
@ -88,7 +92,11 @@ extern unsigned int aspath_count_hops (struct aspath *);
extern unsigned int aspath_count_confeds (struct aspath *);
extern unsigned int aspath_size (struct aspath *);
extern as_t aspath_highest (struct aspath *);
extern void aspath_put (struct stream *, struct aspath *);
extern size_t aspath_put (struct stream *, struct aspath *, int);
extern struct aspath *aspath_reconcile_as4 (struct aspath *, struct aspath *);
extern unsigned int aspath_has_as4 (struct aspath *);
extern unsigned int aspath_count_numas (struct aspath *);
/* For SNMP BGP4PATHATTRASPATHSEGMENT, might be useful for debug */
extern u_char *aspath_snmp_pathseg (struct aspath *, size_t *);

409
bgpd/bgp_attr.c
View File

@ -56,8 +56,10 @@ static struct message attr_str [] =
{ BGP_ATTR_RCID_PATH, "RCID_PATH" },
{ BGP_ATTR_MP_REACH_NLRI, "MP_REACH_NLRI" },
{ BGP_ATTR_MP_UNREACH_NLRI, "MP_UNREACH_NLRI" },
{ BGP_ATTR_EXT_COMMUNITIES, "BGP_ATTR_EXT_COMMUNITIES" },
{ BGP_ATTR_AS_PATHLIMIT, "BGP_ATTR_AS_PATHLIMIT" },
{ BGP_ATTR_EXT_COMMUNITIES, "EXT_COMMUNITIES" },
{ BGP_ATTR_AS4_PATH, "AS4_PATH" },
{ BGP_ATTR_AS4_AGGREGATOR, "AS4_AGGREGATOR" },
{ BGP_ATTR_AS_PATHLIMIT, "AS_PATHLIMIT" },
{ 0, NULL }
};
int attr_str_max = sizeof(attr_str)/sizeof(attr_str[0]);
@ -794,8 +796,6 @@ static int
bgp_attr_aspath (struct peer *peer, bgp_size_t length,
struct attr *attr, u_char flag, u_char *startp)
{
struct bgp *bgp;
struct aspath *aspath;
bgp_size_t total;
total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
@ -813,8 +813,14 @@ bgp_attr_aspath (struct peer *peer, bgp_size_t length,
return -1;
}
/*
* peer with AS4 => will get 4Byte ASnums
* otherwise, will get 16 Bit
*/
attr->aspath = aspath_parse (peer->ibuf, length,
CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV));
/* In case of IBGP, length will be zero. */
attr->aspath = aspath_parse (peer->ibuf, length);
if (! attr->aspath)
{
zlog (peer->log, LOG_ERR, "Malformed AS path length is %d", length);
@ -824,6 +830,28 @@ bgp_attr_aspath (struct peer *peer, bgp_size_t length,
return -1;
}
/* Forward pointer. */
/* stream_forward_getp (peer->ibuf, length);*/
/* Set aspath attribute flag. */
attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
return 0;
}
static int bgp_attr_aspath_check( struct peer *peer,
struct attr *attr)
{
/* These checks were part of bgp_attr_aspath, but with
* as4 we should to check aspath things when
* aspath synthesizing with as4_path has already taken place.
* Otherwise we check ASPATH and use the synthesized thing, and that is
* not right.
* So do the checks later, i.e. here
*/
struct bgp *bgp = peer->bgp;
struct aspath *aspath;
bgp = peer->bgp;
/* First AS check for EBGP. */
@ -851,11 +879,20 @@ bgp_attr_aspath (struct peer *peer, bgp_size_t length,
attr->aspath = aspath_intern (aspath);
}
/* Forward pointer. */
/* stream_forward_getp (peer->ibuf, length);*/
return 0;
}
/* Parse AS4 path information. This function is another wrapper of
aspath_parse. */
static int
bgp_attr_as4_path (struct peer *peer, bgp_size_t length,
struct attr *attr, struct aspath **as4_path)
{
*as4_path = aspath_parse (peer->ibuf, length, 1);
/* Set aspath attribute flag. */
attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS4_PATH);
return 0;
}
@ -981,18 +1018,27 @@ static int
bgp_attr_aggregator (struct peer *peer, bgp_size_t length,
struct attr *attr, u_char flag)
{
int wantedlen = 6;
struct attr_extra *attre = bgp_attr_extra_get (attr);
if (length != 6)
/* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
if ( CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV ) )
wantedlen = 8;
if (length != wantedlen)
{
zlog (peer->log, LOG_ERR, "Aggregator length is not 6 [%d]", length);
zlog (peer->log, LOG_ERR, "Aggregator length is not %d [%d]", wantedlen, length);
bgp_notify_send (peer,
BGP_NOTIFY_UPDATE_ERR,
BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
return -1;
}
attre->aggregator_as = stream_getw (peer->ibuf);
if ( CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV ) )
attre->aggregator_as = stream_getl (peer->ibuf);
else
attre->aggregator_as = stream_getw (peer->ibuf);
attre->aggregator_addr.s_addr = stream_get_ipv4 (peer->ibuf);
/* Set atomic aggregate flag. */
@ -1001,6 +1047,145 @@ bgp_attr_aggregator (struct peer *peer, bgp_size_t length,
return 0;
}
/* New Aggregator attribute */
static int
bgp_attr_as4_aggregator (struct peer *peer, bgp_size_t length,
struct attr *attr, as_t *as4_aggregator_as,
struct in_addr *as4_aggregator_addr)
{
if (length != 8)
{
zlog (peer->log, LOG_ERR, "New Aggregator length is not 8 [%d]", length);
bgp_notify_send (peer,
BGP_NOTIFY_UPDATE_ERR,
BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
return -1;
}
*as4_aggregator_as = stream_getl (peer->ibuf);
as4_aggregator_addr->s_addr = stream_get_ipv4 (peer->ibuf);
attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR);
return 0;
}
/* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
*/
static int
bgp_attr_munge_as4_attrs (struct peer *peer, struct attr *attr,
struct aspath *as4_path, as_t as4_aggregator,
struct in_addr *as4_aggregator_addr)
{
int ignore_as4_path = 0;
struct aspath *newpath;
struct attr_extra *attre = attr->extra;
if ( CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) )
{
/* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
* if given.
* It is worth a warning though, because the peer really
* should not send them
*/
if (BGP_DEBUG(as4, AS4))
{
if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH)))
zlog_debug ("[AS4] %s %s AS4_PATH",
peer->host, "AS4 capable peer, yet it sent");
if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR)))
zlog_debug ("[AS4] %s %s AS4_AGGREGATOR",
peer->host, "AS4 capable peer, yet it sent");
}
return 0;
}
if (attr->flag & ( ATTR_FLAG_BIT( BGP_ATTR_AS4_PATH))
&& !(attr->flag & ( ATTR_FLAG_BIT( BGP_ATTR_AS_PATH))))
{
/* Hu? This is not supposed to happen at all!
* got as4_path and no aspath,
* This should already
* have been handled by 'well known attributes missing'
* But... yeah, paranoia
* Take this as a "malformed attribute"
*/
zlog (peer->log, LOG_ERR,
"%s BGP not AS4 capable peer sent AS4_PATH but"
" no AS_PATH, cant do anything here", peer->host);
bgp_notify_send (peer,
BGP_NOTIFY_UPDATE_ERR,
BGP_NOTIFY_UPDATE_MAL_ATTR);
return -1;
}
/* We have a asn16 peer. First, look for AS4_AGGREGATOR
* because that may override AS4_PATH
*/
if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR) ) )
{
assert (attre);
if ( attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR) ) )
{
/* received both.
* if the as_number in aggregator is not AS_TRANS,
* then AS4_AGGREGATOR and AS4_PATH shall be ignored
* and the Aggregator shall be taken as
* info on the aggregating node, and the AS_PATH
* shall be taken as the AS_PATH
* otherwise
* the Aggregator shall be ignored and the
* AS4_AGGREGATOR shall be taken as the
* Aggregating node and the AS_PATH is to be
* constructed "as in all other cases"
*/
if ( attre->aggregator_as != BGP_AS_TRANS )
{
/* ignore */
if ( BGP_DEBUG(as4, AS4))
zlog_debug ("[AS4] %s BGP not AS4 capable peer"
" send AGGREGATOR != AS_TRANS and"
" AS4_AGGREGATOR, so ignore"
" AS4_AGGREGATOR and AS4_PATH", peer->host);
ignore_as4_path = 1;
}
else
{
/* "New_aggregator shall be taken as aggregator" */
attre->aggregator_as = as4_aggregator;
attre->aggregator_addr.s_addr = as4_aggregator_addr->s_addr;
}
}
else
{
/* We received a AS4_AGGREGATOR but no AGGREGATOR.
* That is bogus - but reading the conditions
* we have to handle AS4_AGGREGATOR as if it were
* AGGREGATOR in that case
*/
if ( BGP_DEBUG(as4, AS4))
zlog_debug ("[AS4] %s BGP not AS4 capable peer send"
" AS4_AGGREGATOR but no AGGREGATOR, will take"
" it as if AGGREGATOR with AS_TRANS had been there", peer->host);
attre->aggregator_as = as4_aggregator;
/* sweep it under the carpet and simulate a "good" AGGREGATOR */
attr->flag |= (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR));
}
}
/* need to reconcile NEW_AS_PATH and AS_PATH */
if ( !ignore_as4_path && (attr->flag & ( ATTR_FLAG_BIT( BGP_ATTR_AS4_PATH))) )
{
newpath = aspath_reconcile_as4 (attr->aspath, as4_path);
aspath_unintern (attr->aspath);
attr->aspath = aspath_intern (newpath);
}
return 0;
}
/* Community attribute. */
static int
bgp_attr_community (struct peer *peer, bgp_size_t length,
@ -1318,11 +1503,16 @@ bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
{
int ret;
u_char flag;
u_char type;
u_char type = 0;
bgp_size_t length;
u_char *startp, *endp;
u_char *attr_endp;
u_char seen[BGP_ATTR_BITMAP_SIZE];
/* we need the as4_path only until we have synthesized the as_path with it */
/* same goes for as4_aggregator */
struct aspath *as4_path = NULL;
as_t as4_aggregator = 0;
struct in_addr as4_aggregator_addr = { 0 };
/* Initialize bitmap. */
memset (seen, 0, BGP_ATTR_BITMAP_SIZE);
@ -1339,7 +1529,8 @@ bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
/* XXX warning: long int format, int arg (arg 5) */
zlog (peer->log, LOG_WARNING,
"%s error BGP attribute length %lu is smaller than min len",
peer->host, endp - STREAM_PNT (BGP_INPUT (peer)));
peer->host,
(unsigned long) (endp - STREAM_PNT (BGP_INPUT (peer))));
bgp_notify_send (peer,
BGP_NOTIFY_UPDATE_ERR,
@ -1401,6 +1592,9 @@ bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
case BGP_ATTR_AS_PATH:
ret = bgp_attr_aspath (peer, length, attr, flag, startp);
break;
case BGP_ATTR_AS4_PATH:
ret = bgp_attr_as4_path (peer, length, attr, &as4_path );
break;
case BGP_ATTR_NEXT_HOP:
ret = bgp_attr_nexthop (peer, length, attr, flag, startp);
break;
@ -1416,6 +1610,9 @@ bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
case BGP_ATTR_AGGREGATOR:
ret = bgp_attr_aggregator (peer, length, attr, flag);
break;
case BGP_ATTR_AS4_AGGREGATOR:
ret = bgp_attr_as4_aggregator (peer, length, attr, &as4_aggregator, &as4_aggregator_addr);
break;
case BGP_ATTR_COMMUNITIES:
ret = bgp_attr_community (peer, length, attr, flag);
break;
@ -1480,6 +1677,51 @@ bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
return -1;
}
/*
* At this place we can see whether we got AS4_PATH and/or
* AS4_AGGREGATOR from a 16Bit peer and act accordingly.
* We can not do this before we've read all attributes because
* the as4 handling does not say whether AS4_PATH has to be sent
* after AS_PATH or not - and when AS4_AGGREGATOR will be send
* in relationship to AGGREGATOR.
* So, to be defensive, we are not relying on any order and read
* all attributes first, including these 32bit ones, and now,
* afterwards, we look what and if something is to be done for as4.
*/
if (bgp_attr_munge_as4_attrs (peer, attr, as4_path,
as4_aggregator, &as4_aggregator_addr))
return -1;
/* At this stage, we have done all fiddling with as4, and the
* resulting info is in attr->aggregator resp. attr->aspath
* so we can chuck as4_aggregator and as4_path alltogether in
* order to save memory
*/
if ( as4_path )
{
aspath_unintern( as4_path ); /* unintern - it is in the hash */
as4_path = NULL;
/* The flag that we got this is still there, but that does not
* do any trouble
*/
}
/*
* The "rest" of the code does nothing with as4_aggregator.
* there is no memory attached specifically which is not part
* of the attr.
* so ignoring just means do nothing.
*/
/*
* Finally do the checks on the aspath we did not do yet
* because we waited for a potentially synthesized aspath.
*/
if ( attr->flag & ( ATTR_FLAG_BIT( BGP_ATTR_AS_PATH)))
{
ret = bgp_attr_aspath_check( peer, attr );
if ( ret < 0 )
return ret;
}
/* Finally intern unknown attribute. */
if (attr->extra && attr->extra->transit)
attr->extra->transit = transit_intern (attr->extra->transit);
@ -1530,8 +1772,11 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
struct prefix_rd *prd, u_char *tag)
{
size_t cp;
unsigned int aspath_data_size;
size_t aspath_sizep;
struct aspath *aspath;
int send_as4_path = 0;
int send_as4_aggregator = 0;
int use32bit = (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV)) ? 1 : 0;
if (! bgp)
bgp = bgp_get_default ();
@ -1578,25 +1823,27 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
else
aspath = attr->aspath;
/* AS path attribute extended length bit check. */
aspath_data_size = aspath_size (aspath);
if (aspath_data_size > 255)
{
stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
stream_putc (s, BGP_ATTR_AS_PATH);
stream_putw (s, aspath_data_size);
}
else
{
stream_putc (s, BGP_ATTR_FLAG_TRANS);
stream_putc (s, BGP_ATTR_AS_PATH);
stream_putc (s, aspath_data_size);
}
aspath_put (s, aspath);
if (aspath != attr->aspath)
aspath_free (aspath);
/* If peer is not AS4 capable, then:
* - send the created AS_PATH out as AS4_PATH (optional, transitive),
* but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path segment
* types are in it (i.e. exclude them if they are there)
* AND do this only if there is at least one asnum > 65535 in the path!
* - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and change
* all ASnums > 65535 to BGP_AS_TRANS
*/
stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
stream_putc (s, BGP_ATTR_AS_PATH);
aspath_sizep = stream_get_endp (s);
stream_putw (s, 0);
stream_putw_at (s, aspath_sizep, aspath_put (s, aspath, use32bit));
/* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
* in the path
*/
if (!use32bit && aspath_has_as4 (aspath))
send_as4_path = 1; /* we'll do this later, at the correct place */
/* Nexthop attribute. */
if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP) && afi == AFI_IP)
{
@ -1645,10 +1892,36 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
{
assert (attr->extra);
/* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
stream_putc (s, BGP_ATTR_AGGREGATOR);
stream_putc (s, 6);
stream_putw (s, attr->extra->aggregator_as);
if (use32bit)
{
/* AS4 capable peer */
stream_putc (s, 8);
stream_putl (s, attr->extra->aggregator_as);
}
else
{
/* 2-byte AS peer */
stream_putc (s, 6);
/* Is ASN representable in 2-bytes? Or must AS_TRANS be used? */
if ( attr->extra->aggregator_as > 65535 )
{
stream_putw (s, BGP_AS_TRANS);
/* we have to send AS4_AGGREGATOR, too.
* we'll do that later in order to send attributes in ascending
* order.
*/
send_as4_aggregator = 1;
}
else
stream_putw (s, (u_int16_t) attr->extra->aggregator_as);
}
stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
}
@ -1873,6 +2146,47 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
}
}
}
if ( send_as4_path )
{
/* If the peer is NOT As4 capable, AND */
/* there are ASnums > 65535 in path THEN
* give out AS4_PATH */
/* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
* path segments!
* Hm, I wonder... confederation things *should* only be at
* the beginning of an aspath, right? Then we should use
* aspath_delete_confed_seq for this, because it is already
* there! (JK)
* Folks, talk to me: what is reasonable here!?
*/
aspath = aspath_delete_confed_seq (aspath);
stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_EXTLEN);
stream_putc (s, BGP_ATTR_AS4_PATH);
aspath_sizep = stream_get_endp (s);
stream_putw (s, 0);
stream_putw_at (s, aspath_sizep, aspath_put (s, aspath, 1));
}
if (aspath != attr->aspath)
aspath_free (aspath);
if ( send_as4_aggregator )
{
assert (attr->extra);
/* send AS4_AGGREGATOR, at this place */
/* this section of code moved here in order to ensure the correct
* *ascending* order of attributes
*/
stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
stream_putc (s, BGP_ATTR_AS4_AGGREGATOR);
stream_putc (s, 8);
stream_putl (s, attr->extra->aggregator_as);
stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
}
/* AS-Pathlimit */
if (attr->pathlimit.ttl)
@ -1967,7 +2281,7 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr,
{
unsigned long cp;
unsigned long len;
unsigned int aspathlen;
size_t aspath_lenp;
struct aspath *aspath;
/* Remember current pointer. */
@ -1983,20 +2297,13 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr,
stream_putc (s, attr->origin);
aspath = attr->aspath;
if ( (aspathlen = aspath_size (aspath)) > 255 )
{
stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
stream_putc (s, BGP_ATTR_AS_PATH);
stream_putw (s, aspathlen);
}
else
{
stream_putc (s, BGP_ATTR_FLAG_TRANS);
stream_putc (s, BGP_ATTR_AS_PATH);
stream_putc (s, aspathlen);
}
aspath_put (s, aspath);
stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
stream_putc (s, BGP_ATTR_AS_PATH);
aspath_lenp = stream_get_endp (s);
stream_putw (s, 0);
stream_putw_at (s, aspath_lenp, aspath_put (s, aspath, 1));
/* Nexthop attribute. */
/* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
@ -2044,8 +2351,8 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr,
assert (attr->extra);
stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
stream_putc (s, BGP_ATTR_AGGREGATOR);
stream_putc (s, 6);
stream_putw (s, attr->extra->aggregator_as);
stream_putc (s, 8);
stream_putl (s, attr->extra->aggregator_as);
stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
}

118
bgpd/bgp_debug.c
View File

@ -36,6 +36,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#include "bgpd/bgp_debug.h"
#include "bgpd/bgp_community.h"
unsigned long conf_bgp_debug_as4;
unsigned long conf_bgp_debug_fsm;
unsigned long conf_bgp_debug_events;
unsigned long conf_bgp_debug_packet;
@ -45,6 +46,7 @@ unsigned long conf_bgp_debug_update;
unsigned long conf_bgp_debug_normal;
unsigned long conf_bgp_debug_zebra;
unsigned long term_bgp_debug_as4;
unsigned long term_bgp_debug_fsm;
unsigned long term_bgp_debug_events;
unsigned long term_bgp_debug_packet;
@ -297,6 +299,92 @@ debug (unsigned int option)
return bgp_debug_option & option;
}
DEFUN (debug_bgp_as4,
debug_bgp_as4_cmd,
"debug bgp as4",
DEBUG_STR
BGP_STR
"BGP AS4 actions\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (as4, AS4);
else
{
TERM_DEBUG_ON (as4, AS4);
vty_out (vty, "BGP as4 debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_as4,
no_debug_bgp_as4_cmd,
"no debug bgp as4",
NO_STR
DEBUG_STR
BGP_STR
"BGP AS4 actions\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (as4, AS4);
else
{
TERM_DEBUG_OFF (as4, AS4);
vty_out (vty, "BGP as4 debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_as4,
undebug_bgp_as4_cmd,
"undebug bgp as4",
UNDEBUG_STR
DEBUG_STR
BGP_STR
"BGP AS4 actions\n")
DEFUN (debug_bgp_as4_segment,
debug_bgp_as4_segment_cmd,
"debug bgp as4 segment",
DEBUG_STR
BGP_STR
"BGP AS4 aspath segment handling\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (as4, AS4_SEGMENT);
else
{
TERM_DEBUG_ON (as4, AS4_SEGMENT);
vty_out (vty, "BGP as4 segment debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_as4_segment,
no_debug_bgp_as4_segment_cmd,
"no debug bgp as4 segment",
NO_STR
DEBUG_STR
BGP_STR
"BGP AS4 aspath segment handling\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (as4, AS4_SEGMENT);
else
{
TERM_DEBUG_OFF (as4, AS4_SEGMENT);
vty_out (vty, "BGP as4 segment debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_as4_segment,
undebug_bgp_as4_segment_cmd,
"undebug bgp as4 segment",
UNDEBUG_STR
DEBUG_STR
BGP_STR
"BGP AS4 aspath segment handling\n")
DEFUN (debug_bgp_fsm,
debug_bgp_fsm_cmd,
"debug bgp fsm",
@ -651,6 +739,8 @@ DEFUN (no_debug_bgp_all,
TERM_DEBUG_OFF (keepalive, KEEPALIVE);
TERM_DEBUG_OFF (update, UPDATE_IN);
TERM_DEBUG_OFF (update, UPDATE_OUT);
TERM_DEBUG_OFF (as4, AS4);
TERM_DEBUG_OFF (as4, AS4_SEGMENT);
TERM_DEBUG_OFF (fsm, FSM);
TERM_DEBUG_OFF (filter, FILTER);
TERM_DEBUG_OFF (zebra, ZEBRA);
@ -693,6 +783,10 @@ DEFUN (show_debugging_bgp,
vty_out (vty, " BGP filter debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (zebra, ZEBRA))
vty_out (vty, " BGP zebra debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (as4, AS4))
vty_out (vty, " BGP as4 debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (as4, AS4_SEGMENT))
vty_out (vty, " BGP as4 aspath segment debugging is on%s", VTY_NEWLINE);
vty_out (vty, "%s", VTY_NEWLINE);
return CMD_SUCCESS;
}
@ -708,6 +802,18 @@ bgp_config_write_debug (struct vty *vty)
write++;
}
if (CONF_BGP_DEBUG (as4, AS4))
{
vty_out (vty, "debug bgp as4%s", VTY_NEWLINE);
write++;
}
if (CONF_BGP_DEBUG (as4, AS4_SEGMENT))
{
vty_out (vty, "debug bgp as4 segment%s", VTY_NEWLINE);
write++;
}
if (CONF_BGP_DEBUG (events, EVENTS))
{
vty_out (vty, "debug bgp events%s", VTY_NEWLINE);
@ -771,6 +877,11 @@ bgp_debug_init (void)
install_element (ENABLE_NODE, &show_debugging_bgp_cmd);
install_element (ENABLE_NODE, &debug_bgp_as4_cmd);
install_element (CONFIG_NODE, &debug_bgp_as4_cmd);
install_element (ENABLE_NODE, &debug_bgp_as4_segment_cmd);
install_element (CONFIG_NODE, &debug_bgp_as4_segment_cmd);
install_element (ENABLE_NODE, &debug_bgp_fsm_cmd);
install_element (CONFIG_NODE, &debug_bgp_fsm_cmd);
install_element (ENABLE_NODE, &debug_bgp_events_cmd);
@ -788,6 +899,13 @@ bgp_debug_init (void)
install_element (ENABLE_NODE, &debug_bgp_zebra_cmd);
install_element (CONFIG_NODE, &debug_bgp_zebra_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_as4_cmd);
install_element (ENABLE_NODE, &undebug_bgp_as4_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_as4_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_as4_segment_cmd);
install_element (ENABLE_NODE, &undebug_bgp_as4_segment_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_as4_segment_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_fsm_cmd);
install_element (ENABLE_NODE, &undebug_bgp_fsm_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_fsm_cmd);

7
bgpd/bgp_debug.h
View File

@ -21,6 +21,8 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#ifndef _QUAGGA_BGP_DEBUG_H
#define _QUAGGA_BGP_DEBUG_H
#include "bgp_attr.h"
/* sort of packet direction */
#define DUMP_ON 1
#define DUMP_SEND 2
@ -56,6 +58,7 @@ extern void bgp_packet_dump (struct stream *);
extern int debug (unsigned int option);
extern unsigned long conf_bgp_debug_as4;
extern unsigned long conf_bgp_debug_fsm;
extern unsigned long conf_bgp_debug_events;
extern unsigned long conf_bgp_debug_packet;
@ -65,6 +68,7 @@ extern unsigned long conf_bgp_debug_update;
extern unsigned long conf_bgp_debug_normal;
extern unsigned long conf_bgp_debug_zebra;
extern unsigned long term_bgp_debug_as4;
extern unsigned long term_bgp_debug_fsm;
extern unsigned long term_bgp_debug_events;
extern unsigned long term_bgp_debug_packet;
@ -74,6 +78,9 @@ extern unsigned long term_bgp_debug_update;
extern unsigned long term_bgp_debug_normal;
extern unsigned long term_bgp_debug_zebra;
#define BGP_DEBUG_AS4 0x01
#define BGP_DEBUG_AS4_SEGMENT 0x02
#define BGP_DEBUG_FSM 0x01
#define BGP_DEBUG_EVENTS 0x01
#define BGP_DEBUG_PACKET 0x01

273
bgpd/bgp_dump.c
View File

@ -26,6 +26,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#include "command.h"
#include "prefix.h"
#include "thread.h"
#include "linklist.h"
#include "bgpd/bgp_table.h"
#include "bgpd/bgpd.h"
@ -53,7 +54,8 @@ enum MRT_MSG_TYPES {
MSG_PROTOCOL_BGP4PLUS, /* msg is a BGP4+ packet */
MSG_PROTOCOL_BGP4PLUS_01, /* msg is a BGP4+ (draft 01) packet */
MSG_PROTOCOL_OSPF, /* msg is an OSPF packet */
MSG_TABLE_DUMP /* routing table dump */
MSG_TABLE_DUMP, /* routing table dump */
MSG_TABLE_DUMP_V2 /* routing table dump, version 2 */
};
static int bgp_dump_interval_func (struct thread *);
@ -191,137 +193,189 @@ bgp_dump_set_size (struct stream *s, int type)
}
static void
bgp_dump_routes_entry (struct prefix *p, struct bgp_info *info, int afi,
int type, unsigned int seq)
bgp_dump_routes_index_table(struct bgp *bgp)
{
struct stream *obuf;
struct attr *attr;
struct peer *peer;
int plen;
int safi = 0;
struct listnode *node;
uint16_t peerno = 0;
struct stream *obuf;
/* Make dump stream. */
obuf = bgp_dump_obuf;
stream_reset (obuf);
attr = info->attr;
peer = info->peer;
/* MRT header */
bgp_dump_header (obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_PEER_INDEX_TABLE);
/* We support MRT's old format. */
if (type == MSG_TABLE_DUMP)
/* Collector BGP ID */
stream_put_in_addr (obuf, &bgp->router_id);
/* View name */
if(bgp->name)
{
bgp_dump_header (obuf, MSG_TABLE_DUMP, afi);
stream_putw (obuf, 0); /* View # */
stream_putw (obuf, seq); /* Sequence number. */
stream_putw (obuf, strlen(bgp->name));
stream_put(obuf, bgp->name, strlen(bgp->name));
}
else
{
bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_ENTRY);
stream_putl (obuf, info->uptime); /* Time Last Change */
stream_putw (obuf, afi); /* Address Family */
stream_putc (obuf, safi); /* SAFI */
stream_putw(obuf, 0);
}
if (afi == AFI_IP)
/* Peer count */
stream_putw (obuf, listcount(bgp->peer));
/* Walk down all peers */
for(ALL_LIST_ELEMENTS_RO (bgp->peer, node, peer))
{
if (type == MSG_TABLE_DUMP)
{
/* Prefix */
stream_put_in_addr (obuf, &p->u.prefix4);
stream_putc (obuf, p->prefixlen);
/* Status */
stream_putc (obuf, 1);
/* Originated */
stream_putl (obuf, info->uptime);
/* Peer's IP address */
stream_put_in_addr (obuf, &peer->su.sin.sin_addr);
/* Peer's AS number. */
stream_putw (obuf, peer->as);
/* Dump attribute. */
bgp_dump_routes_attr (obuf, attr, p);
}
else
{
/* Next-Hop-Len */
stream_putc (obuf, IPV4_MAX_BYTELEN);
stream_put_in_addr (obuf, &attr->nexthop);
stream_putc (obuf, p->prefixlen);
plen = PSIZE (p->prefixlen);
stream_put (obuf, &p->u.prefix4, plen);
bgp_dump_routes_attr (obuf, attr, p);
}
}
/* Peer's type */
if (sockunion_family(&peer->su) == AF_INET)
{
stream_putc (obuf, TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4+TABLE_DUMP_V2_PEER_INDEX_TABLE_IP);
}
#ifdef HAVE_IPV6
else if (afi == AFI_IP6)
{
if (type == MSG_TABLE_DUMP)
{
/* Prefix */
stream_write (obuf, (u_char *)&p->u.prefix6, IPV6_MAX_BYTELEN);
stream_putc (obuf, p->prefixlen);
/* Status */
stream_putc (obuf, 1);
/* Originated */
stream_putl (obuf, info->uptime);
/* Peer's IP address */
stream_write (obuf, (u_char *)&peer->su.sin6.sin6_addr,
IPV6_MAX_BYTELEN);
/* Peer's AS number. */
stream_putw (obuf, peer->as);
/* Dump attribute. */
bgp_dump_routes_attr (obuf, attr, p);
}
else
{
;
}
}
else if (sockunion_family(&peer->su) == AF_INET6)
{
stream_putc (obuf, TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4+TABLE_DUMP_V2_PEER_INDEX_TABLE_IP6);
}
#endif /* HAVE_IPV6 */
/* Set length. */
bgp_dump_set_size (obuf, type);
/* Peer's BGP ID */
stream_put_in_addr (obuf, &peer->remote_id);
/* Peer's IP address */
if (sockunion_family(&peer->su) == AF_INET)
{
stream_put_in_addr (obuf, &peer->su.sin.sin_addr);
}
#ifdef HAVE_IPV6
else if (sockunion_family(&peer->su) == AF_INET6)
{
stream_write (obuf, (u_char *)&peer->su.sin6.sin6_addr,
IPV6_MAX_BYTELEN);
}
#endif /* HAVE_IPV6 */
/* Peer's AS number. */
/* Note that, as this is an AS4 compliant quagga, the RIB is always AS4 */
stream_putl (obuf, peer->as);
/* Store the peer number for this peer */
peer->table_dump_index = peerno;
peerno++;
}
bgp_dump_set_size(obuf, MSG_TABLE_DUMP_V2);
fwrite (STREAM_DATA (obuf), stream_get_endp (obuf), 1, bgp_dump_routes.fp);
fflush (bgp_dump_routes.fp);
}
/* Runs under child process. */
static void
bgp_dump_routes_func (int afi)
static unsigned int
bgp_dump_routes_func (int afi, int first_run, unsigned int seq)
{
struct stream *obuf;
struct bgp_node *rn;
struct bgp_info *info;
struct bgp_node *rn;
struct bgp *bgp;
struct bgp_table *table;
unsigned int seq = 0;
obuf = bgp_dump_obuf;
bgp = bgp_get_default ();
if (!bgp)
return;
return seq;
if (bgp_dump_routes.fp == NULL)
return;
return seq;
/* Note that bgp_dump_routes_index_table will do ipv4 and ipv6 peers,
so this should only be done on the first call to bgp_dump_routes_func.
( this function will be called once for ipv4 and once for ipv6 ) */
if(first_run)
bgp_dump_routes_index_table(bgp);
obuf = bgp_dump_obuf;
stream_reset(obuf);
/* Walk down each BGP route. */
table = bgp->rib[afi][SAFI_UNICAST];
for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn))
for (info = rn->info; info; info = info->next)
bgp_dump_routes_entry (&rn->p, info, afi, MSG_TABLE_DUMP, seq++);
{
if(!rn->info)
continue;
stream_reset(obuf);
/* MRT header */
if (afi == AFI_IP)
{
bgp_dump_header (obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_RIB_IPV4_UNICAST);
}
#ifdef HAVE_IPV6
else if (afi == AFI_IP6)
{
bgp_dump_header (obuf, MSG_TABLE_DUMP_V2, TABLE_DUMP_V2_RIB_IPV6_UNICAST);
}
#endif /* HAVE_IPV6 */
/* Sequence number */
stream_putl(obuf, seq);
/* Prefix length */
stream_putc (obuf, rn->p.prefixlen);
/* Prefix */
if (afi == AFI_IP)
{
/* We'll dump only the useful bits (those not 0), but have to align on 8 bits */
stream_write(obuf, (u_char *)&rn->p.u.prefix4, (rn->p.prefixlen+7)/8);
}
#ifdef HAVE_IPV6
else if (afi == AFI_IP6)
{
/* We'll dump only the useful bits (those not 0), but have to align on 8 bits */
stream_write (obuf, (u_char *)&rn->p.u.prefix6, (rn->p.prefixlen+7)/8);
}
#endif /* HAVE_IPV6 */
/* Save where we are now, so we can overwride the entry count later */
int sizep = stream_get_endp(obuf);
/* Entry count */
uint16_t entry_count = 0;
/* Entry count, note that this is overwritten later */
stream_putw(obuf, 0);
for (info = rn->info; info; info = info->next)
{
entry_count++;
/* Peer index */
stream_putw(obuf, info->peer->table_dump_index);
/* Originated */
stream_putl (obuf, info->uptime);
/* Dump attribute. */
/* Skip prefix & AFI/SAFI for MP_NLRI */
bgp_dump_routes_attr (obuf, info->attr, &rn->p);
}
/* Overwrite the entry count, now that we know the right number */
stream_putw_at (obuf, sizep, entry_count);
seq++;
bgp_dump_set_size(obuf, MSG_TABLE_DUMP_V2);
fwrite (STREAM_DATA (obuf), stream_get_endp (obuf), 1, bgp_dump_routes.fp);
}
fflush (bgp_dump_routes.fp);
return seq;
}
static int
@ -337,9 +391,9 @@ bgp_dump_interval_func (struct thread *t)
/* In case of bgp_dump_routes, we need special route dump function. */
if (bgp_dump->type == BGP_DUMP_ROUTES)
{
bgp_dump_routes_func (AFI_IP);
unsigned int seq = bgp_dump_routes_func (AFI_IP, 1, 0);
#ifdef HAVE_IPV6
bgp_dump_routes_func (AFI_IP6);
bgp_dump_routes_func (AFI_IP6, 0, seq);
#endif /* HAVE_IPV6 */
/* Close the file now. For a RIB dump there's no point in leaving
* it open until the next scheduled dump starts. */
@ -356,13 +410,21 @@ bgp_dump_interval_func (struct thread *t)
/* Dump common information. */
static void
bgp_dump_common (struct stream *obuf, struct peer *peer)
bgp_dump_common (struct stream *obuf, struct peer *peer, int forceas4)
{
char empty[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
/* Source AS number and Destination AS number. */
stream_putw (obuf, peer->as);
stream_putw (obuf, peer->local_as);
if (forceas4 || CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) )
{
stream_putl (obuf, peer->as);
stream_putl (obuf, peer->local_as);
}
else
{
stream_putw (obuf, peer->as);
stream_putw (obuf, peer->local_as);
}
if (peer->su.sa.sa_family == AF_INET)
{
@ -408,8 +470,8 @@ bgp_dump_state (struct peer *peer, int status_old, int status_new)
obuf = bgp_dump_obuf;
stream_reset (obuf);
bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_STATE_CHANGE);
bgp_dump_common (obuf, peer);
bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_STATE_CHANGE_AS4);
bgp_dump_common (obuf, peer, 1);/* force this in as4speak*/
stream_putw (obuf, status_old);
stream_putw (obuf, status_new);
@ -437,8 +499,15 @@ bgp_dump_packet_func (struct bgp_dump *bgp_dump, struct peer *peer,
stream_reset (obuf);
/* Dump header and common part. */
bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE);
bgp_dump_common (obuf, peer);
if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) )
{
bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE_AS4);
}
else
{
bgp_dump_header (obuf, MSG_PROTOCOL_BGP4MP, BGP4MP_MESSAGE);
}
bgp_dump_common (obuf, peer, 0);
/* Packet contents. */
stream_put (obuf, STREAM_DATA (packet), stream_get_endp (packet));

22
bgpd/bgp_dump.h
View File

@ -25,14 +25,28 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
/* type value */
#define MSG_PROTOCOL_BGP4MP 16
/* subtype value */
#define BGP4MP_STATE_CHANGE 0
#define BGP4MP_MESSAGE 1
#define BGP4MP_ENTRY 2
#define BGP4MP_SNAPSHOT 3
#define BGP4MP_STATE_CHANGE 0
#define BGP4MP_MESSAGE 1
#define BGP4MP_ENTRY 2
#define BGP4MP_SNAPSHOT 3
#define BGP4MP_MESSAGE_AS4 4
#define BGP4MP_STATE_CHANGE_AS4 5
#define BGP_DUMP_HEADER_SIZE 12
#define BGP_DUMP_MSG_HEADER 40
#define TABLE_DUMP_V2_PEER_INDEX_TABLE 1
#define TABLE_DUMP_V2_RIB_IPV4_UNICAST 2
#define TABLE_DUMP_V2_RIB_IPV4_MULTICAST 3
#define TABLE_DUMP_V2_RIB_IPV6_UNICAST 4
#define TABLE_DUMP_V2_RIB_IPV6_MULTICAST 5
#define TABLE_DUMP_V2_RIB_GENERIC 6
#define TABLE_DUMP_V2_PEER_INDEX_TABLE_IP 0
#define TABLE_DUMP_V2_PEER_INDEX_TABLE_IP6 1
#define TABLE_DUMP_V2_PEER_INDEX_TABLE_AS2 0
#define TABLE_DUMP_V2_PEER_INDEX_TABLE_AS4 2
extern void bgp_dump_init (void);
extern void bgp_dump_state (struct peer *, int, int);
extern void bgp_dump_packet (struct peer *, int, struct stream *);

130
bgpd/bgp_ecommunity.c
View File

@ -27,6 +27,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#include "bgpd/bgpd.h"
#include "bgpd/bgp_ecommunity.h"
#include "bgpd/bgp_aspath.h"
/* Hash of community attribute. */
struct hash *ecomhash;
@ -228,8 +229,9 @@ ecommunity_unintern (struct ecommunity *ecom)
/* Utinity function to make hash key. */
unsigned int
ecommunity_hash_make (struct ecommunity *ecom)
ecommunity_hash_make (void *arg)
{
const struct ecommunity *ecom = arg;
int c;
unsigned int key;
u_int8_t *pnt;
@ -245,9 +247,11 @@ ecommunity_hash_make (struct ecommunity *ecom)
/* Compare two Extended Communities Attribute structure. */
int
ecommunity_cmp (const struct ecommunity *ecom1,
const struct ecommunity *ecom2)
ecommunity_cmp (void *arg1, void *arg2)
{
const struct ecommunity *ecom1 = arg1;
const struct ecommunity *ecom2 = arg2;
if (ecom1->size == ecom2->size
&& memcmp (ecom1->val, ecom2->val, ecom1->size * ECOMMUNITY_SIZE) == 0)
return 1;
@ -256,7 +260,7 @@ ecommunity_cmp (const struct ecommunity *ecom1,
/* Initialize Extended Comminities related hash. */
void
ecommunity_init ()
ecommunity_init (void)
{
ecomhash = hash_create (ecommunity_hash_make, ecommunity_cmp);
}
@ -279,11 +283,12 @@ ecommunity_gettoken (const char *str, struct ecommunity_val *eval,
int dot = 0;
int digit = 0;
int separator = 0;
u_int32_t val_low = 0;
u_int32_t val_high = 0;
const char *p = str;
char *endptr;
struct in_addr ip;
char ipstr[INET_ADDRSTRLEN + 1];
as_t as = 0;
u_int32_t val = 0;
char buf[INET_ADDRSTRLEN + 1];
/* Skip white space. */
while (isspace ((int) *p))
@ -346,32 +351,50 @@ ecommunity_gettoken (const char *str, struct ecommunity_val *eval,
goto error;
}
/* What a mess, there are several possibilities:
*
* a) A.B.C.D:MN
* b) EF:OPQR
* c) GHJK:MN
*
* A.B.C.D: Four Byte IP
* EF: Two byte ASN
* GHJK: Four-byte ASN
* MN: Two byte value
* OPQR: Four byte value
*
*/
while (isdigit ((int) *p) || *p == ':' || *p == '.')
{
if (*p == ':')
if (*p == ':')
{
if (separator)
goto error;
separator = 1;
digit = 0;
if ((p - str) > INET_ADDRSTRLEN)
goto error;
memset (buf, 0, INET_ADDRSTRLEN + 1);
memcpy (buf, str, p - str);
if (dot)
{
if ((p - str) > INET_ADDRSTRLEN)
goto error;
memset (ipstr, 0, INET_ADDRSTRLEN + 1);
memcpy (ipstr, str, p - str);
ret = inet_aton (ipstr, &ip);
/* Parsing A.B.C.D in:
* A.B.C.D:MN
*/
ret = inet_aton (buf, &ip);
if (ret == 0)
goto error;
goto error;
}
else
val_high = val_low;
val_low = 0;
else
{
/* ASN */
as = strtoul (buf, &endptr, 10);
if (*endptr != '\0' || as == BGP_AS4_MAX)
goto error;
}
}
else if (*p == '.')
{
@ -384,35 +407,58 @@ ecommunity_gettoken (const char *str, struct ecommunity_val *eval,
else
{
digit = 1;
val_low *= 10;
val_low += (*p - '0');
/* We're past the IP/ASN part */
if (separator)
{
val *= 10;
val += (*p - '0');
}
}
p++;
}
/* Low digit part must be there. */
if (! digit || ! separator)
if (!digit || !separator)
goto error;
/* Encode result into routing distinguisher. */
if (dot)
{
if (val > UINT16_MAX)
goto error;
eval->val[0] = ECOMMUNITY_ENCODE_IP;
eval->val[1] = 0;
memcpy (&eval->val[2], &ip, sizeof (struct in_addr));
eval->val[6] = (val_low >> 8) & 0xff;
eval->val[7] = val_low & 0xff;
eval->val[6] = (val >> 8) & 0xff;
eval->val[7] = val & 0xff;
}
else if (as > BGP_AS_MAX)
{
if (val > UINT16_MAX)
goto error;
eval->val[0] = ECOMMUNITY_ENCODE_AS4;
eval->val[1] = 0;
eval->val[2] = (as >>24) & 0xff;
eval->val[3] = (as >>16) & 0xff;
eval->val[4] = (as >>8) & 0xff;
eval->val[5] = as & 0xff;
eval->val[6] = (val >> 8) & 0xff;
eval->val[7] = val & 0xff;
}
else
{
eval->val[0] = ECOMMUNITY_ENCODE_AS;
eval->val[1] = 0;
eval->val[2] = (val_high >>8) & 0xff;
eval->val[3] = val_high & 0xff;
eval->val[4] = (val_low >>24) & 0xff;
eval->val[5] = (val_low >>16) & 0xff;
eval->val[6] = (val_low >>8) & 0xff;
eval->val[7] = val_low & 0xff;
eval->val[2] = (as >>8) & 0xff;
eval->val[3] = as & 0xff;
eval->val[4] = (val >>24) & 0xff;
eval->val[5] = (val >>16) & 0xff;
eval->val[6] = (val >>8) & 0xff;
eval->val[7] = val & 0xff;
}
*token = ecommunity_token_val;
return p;
@ -533,7 +579,7 @@ ecommunity_ecom2str (struct ecommunity *ecom, int format)
u_int8_t *pnt;
int encode = 0;
int type = 0;
#define ECOMMUNITY_STR_DEFAULT_LEN 26
#define ECOMMUNITY_STR_DEFAULT_LEN 27
int str_size;
int str_pnt;
char *str_buf;
@ -576,7 +622,8 @@ ecommunity_ecom2str (struct ecommunity *ecom, int format)
/* High-order octet of type. */
encode = *pnt++;
if (encode != ECOMMUNITY_ENCODE_AS && encode != ECOMMUNITY_ENCODE_IP)
if (encode != ECOMMUNITY_ENCODE_AS && encode != ECOMMUNITY_ENCODE_IP
&& encode != ECOMMUNITY_ENCODE_AS4)
{
len = sprintf (str_buf + str_pnt, "?");
str_pnt += len;
@ -618,6 +665,21 @@ ecommunity_ecom2str (struct ecommunity *ecom, int format)
}
/* Put string into buffer. */
if (encode == ECOMMUNITY_ENCODE_AS4)
{
eas.as = (*pnt++ << 24);
eas.as |= (*pnt++ << 16);
eas.as |= (*pnt++ << 8);
eas.as |= (*pnt++);
eas.val = (*pnt++ << 8);
eas.val |= (*pnt++);
len = sprintf( str_buf + str_pnt, "%s%d:%d", prefix,
eas.as, eas.val );
str_pnt += len;
first = 0;
}
if (encode == ECOMMUNITY_ENCODE_AS)
{
eas.as = (*pnt++ << 8);

5
bgpd/bgp_ecommunity.h
View File

@ -24,6 +24,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
/* High-order octet of the Extended Communities type field. */
#define ECOMMUNITY_ENCODE_AS 0x00
#define ECOMMUNITY_ENCODE_IP 0x01
#define ECOMMUNITY_ENCODE_AS4 0x02
/* Low-order octet of the Extended Communityes type field. */
#define ECOMMUNITY_ROUTE_TARGET 0x02
@ -71,9 +72,9 @@ extern struct ecommunity *ecommunity_parse (u_int8_t *, u_short);
extern struct ecommunity *ecommunity_dup (struct ecommunity *);
extern struct ecommunity *ecommunity_merge (struct ecommunity *, struct ecommunity *);
extern struct ecommunity *ecommunity_intern (struct ecommunity *);
extern int ecommunity_cmp (const struct ecommunity *, const struct ecommunity *);
extern int ecommunity_cmp (void *, void *);
extern void ecommunity_unintern (struct ecommunity *);
extern unsigned int ecommunity_hash_make (struct ecommunity *);
extern unsigned int ecommunity_hash_make (void *);
extern struct ecommunity *ecommunity_str2com (const char *, int, int);
extern char *ecommunity_ecom2str (struct ecommunity *, int);
extern int ecommunity_match (const struct ecommunity *, const struct ecommunity *);

116
bgpd/bgp_open.c
View File

@ -34,6 +34,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#include "bgpd/bgp_fsm.h"
#include "bgpd/bgp_packet.h"
#include "bgpd/bgp_open.h"
#include "bgpd/bgp_aspath.h"
#include "bgpd/bgp_vty.h"
/* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
@ -427,6 +428,19 @@ bgp_capability_restart (struct peer *peer, struct capability_header *caphdr)
return 0;
}
static as_t
bgp_capability_as4 (struct peer *peer, struct capability_header *hdr)
{
as_t as4 = stream_getl (BGP_INPUT(peer));
if (BGP_DEBUG (as4, AS4))
zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
peer->host, as4);
SET_FLAG (peer->cap, PEER_CAP_AS4_RCV);
return as4;
}
static struct message capcode_str[] =
{
{ 0, ""},
@ -507,6 +521,7 @@ bgp_capability_parse (struct peer *peer, size_t length, u_char **error)
case CAPABILITY_CODE_ORF:
case CAPABILITY_CODE_ORF_OLD:
case CAPABILITY_CODE_RESTART:
case CAPABILITY_CODE_AS4:
case CAPABILITY_CODE_DYNAMIC:
/* Check length. */
if (caphdr.length < cap_minsizes[caphdr.code])
@ -566,6 +581,14 @@ bgp_capability_parse (struct peer *peer, size_t length, u_char **error)
case CAPABILITY_CODE_DYNAMIC:
SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV);
break;
case CAPABILITY_CODE_AS4:
/* Already handled as a special-case parsing of the capabilities
* at the beginning of OPEN processing. So we care not a jot
* for the value really, only error case.
*/
if (!bgp_capability_as4 (peer, &caphdr))
return -1;
break;
default:
if (caphdr.code > 128)
{
@ -615,6 +638,86 @@ strict_capability_same (struct peer *peer)
return 1;
}
/* peek into option, stores ASN to *as4 if the AS4 capability was found.
* Returns 0 if no as4 found, as4cap value otherwise.
*/
as_t
peek_for_as4_capability (struct peer *peer, u_char length)
{
struct stream *s = BGP_INPUT (peer);
size_t orig_getp = stream_get_getp (s);
size_t end = orig_getp + length;
as_t as4 = 0;
/* The full capability parser will better flag the error.. */
if (STREAM_READABLE(s) < length)
return 0;
if (BGP_DEBUG (as4, AS4))
zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
" peeking for as4",
peer->host, length);
/* the error cases we DONT handle, we ONLY try to read as4 out of
* correctly formatted options.
*/
while (stream_get_getp(s) < end)
{
u_char opt_type;
u_char opt_length;
/* Check the length. */
if (stream_get_getp (s) + 2 > end)
goto end;
/* Fetch option type and length. */
opt_type = stream_getc (s);
opt_length = stream_getc (s);
/* Option length check. */
if (stream_get_getp (s) + opt_length > end)
goto end;
if (opt_type == BGP_OPEN_OPT_CAP)
{
unsigned long capd_start = stream_get_getp (s);
unsigned long capd_end = capd_start + opt_length;
assert (capd_end <= end);
while (stream_get_getp (s) < capd_end)
{
struct capability_header hdr;
if (stream_get_getp (s) + 2 > capd_end)
goto end;
hdr.code = stream_getc (s);
hdr.length = stream_getc (s);
if ((stream_get_getp(s) + hdr.length) > capd_end)
goto end;
if (hdr.code == CAPABILITY_CODE_AS4)
{
if (hdr.length != CAPABILITY_CODE_AS4_LEN)
goto end;
if (BGP_DEBUG (as4, AS4))
zlog_info ("[AS4] found AS4 capability, about to parse");
as4 = bgp_capability_as4 (peer, &hdr);
goto end;
}
stream_forward_getp (s, hdr.length);
}
}
}
end:
stream_set_getp (s, orig_getp);
return as4;
}
/* Parse open option */
int
bgp_open_option_parse (struct peer *peer, u_char length, int *capability)
@ -815,6 +918,7 @@ bgp_open_capability (struct stream *s, struct peer *peer)
unsigned long cp;
afi_t afi;
safi_t safi;
as_t local_as;
/* Remember current pointer for Opt Parm Len. */
cp = stream_get_endp (s);
@ -901,6 +1005,18 @@ bgp_open_capability (struct stream *s, struct peer *peer)
stream_putc (s, CAPABILITY_CODE_REFRESH);
stream_putc (s, CAPABILITY_CODE_REFRESH_LEN);
/* AS4 */
SET_FLAG (peer->cap, PEER_CAP_AS4_ADV);
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_AS4_LEN + 2);
stream_putc (s, CAPABILITY_CODE_AS4);
stream_putc (s, CAPABILITY_CODE_AS4_LEN);
if ( peer->change_local_as )
local_as = peer->change_local_as;
else
local_as = peer->local_as;
stream_putl (s, local_as );
/* ORF capability. */
for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)

6
bgpd/bgp_open.h
View File

@ -48,6 +48,11 @@ struct capability_orf_entry
} __attribute__ ((packed));
#pragma pack()
struct capability_as4
{
uint32_t as4;
};
struct graceful_restart_af
{
u_int16_t afi;
@ -100,6 +105,7 @@ struct capability_gr
extern int bgp_open_option_parse (struct peer *, u_char, int *);
extern void bgp_open_capability (struct stream *, struct peer *);
extern void bgp_capability_vty_out (struct vty *, struct peer *);
extern as_t peek_for_as4_capability (struct peer *, u_char);
extern int bgp_afi_safi_valid_indices (afi_t, safi_t *);
#endif /* _QUAGGA_BGP_OPEN_H */

88
bgpd/bgp_packet.c
View File

@ -804,7 +804,8 @@ bgp_open_send (struct peer *peer)
/* Set open packet values. */
stream_putc (s, BGP_VERSION_4); /* BGP version */
stream_putw (s, local_as); /* My Autonomous System*/
stream_putw (s, (local_as <= BGP_AS_MAX) ? (u_int16_t) local_as
: BGP_AS_TRANS);
stream_putw (s, send_holdtime); /* Hold Time */
stream_put_in_addr (s, &peer->local_id); /* BGP Identifier */
@ -1168,6 +1169,7 @@ bgp_open_receive (struct peer *peer, bgp_size_t size)
u_int16_t holdtime;
u_int16_t send_holdtime;
as_t remote_as;
as_t as4 = 0;
struct peer *realpeer;
struct in_addr remote_id;
int capability;
@ -1186,10 +1188,75 @@ bgp_open_receive (struct peer *peer, bgp_size_t size)
/* Receive OPEN message log */
if (BGP_DEBUG (normal, NORMAL))
zlog_debug ("%s rcv OPEN, version %d, remote-as %d, holdtime %d, id %s",
peer->host, version, remote_as, holdtime,
inet_ntoa (remote_id));
zlog_debug ("%s rcv OPEN, version %d, remote-as (in open) %d,"
" holdtime %d, id %s",
peer->host, version, remote_as, holdtime,
inet_ntoa (remote_id));
/* BEGIN to read the capability here, but dont do it yet */
capability = 0;
optlen = stream_getc (peer->ibuf);
if (optlen != 0)
{
/* We need the as4 capability value *right now* because
* if it is there, we have not got the remote_as yet, and without
* that we do not know which peer is connecting to us now.
*/
as4 = peek_for_as4_capability (peer, optlen);
}
/* Just in case we have a silly peer who sends AS4 capability set to 0 */
if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV) && !as4)
{
zlog_err ("%s bad OPEN, got AS4 capability, but AS4 set to 0",
peer->host);
bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
BGP_NOTIFY_OPEN_BAD_PEER_AS);
return -1;
}
if (remote_as == BGP_AS_TRANS)
{
/* Take the AS4 from the capability. We must have received the
* capability now! Otherwise we have a asn16 peer who uses
* BGP_AS_TRANS, for some unknown reason.
*/
if (as4 == BGP_AS_TRANS)
{
zlog_err ("%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
peer->host);
bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
BGP_NOTIFY_OPEN_BAD_PEER_AS);
return -1;
}
if (!as4 && BGP_DEBUG (as4, AS4))
zlog_debug ("%s [AS4] OPEN remote_as is AS_TRANS, but no AS4."
" Odd, but proceeding.", peer->host);
else if (as4 < BGP_AS_MAX && BGP_DEBUG (as4, AS4))
zlog_debug ("%s [AS4] OPEN remote_as is AS_TRANS, but AS4 fits "
"in 2-bytes, very odd peer.", peer->host, as4);
if (as4)
remote_as = as4;
}
else
{
/* We may have a partner with AS4 who has an asno < BGP_AS_MAX */
/* If we have got the capability, peer->as4cap must match remote_as */
if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV)
&& as4 != remote_as)
{
/* raise error, log this, close session */
zlog_err ("%s bad OPEN, got AS4 capability, but remote_as %u"
" mismatch with 16bit 'myasn' %u in open",
peer->host, as4, remote_as);
bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
BGP_NOTIFY_OPEN_BAD_PEER_AS);
return -1;
}
}
/* Lookup peer from Open packet. */
if (CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
{
@ -1364,8 +1431,6 @@ bgp_open_receive (struct peer *peer, bgp_size_t size)
peer->v_keepalive = peer->v_holdtime / 3;
/* Open option part parse. */
capability = 0;
optlen = stream_getc (peer->ibuf);
if (optlen != 0)
{
ret = bgp_open_option_parse (peer, optlen, &capability);
@ -2049,8 +2114,8 @@ bgp_capability_msg_parse (struct peer *peer, u_char *pnt, bgp_size_t length)
if (!bgp_afi_safi_valid_indices (afi, &safi))
{
if (BGP_DEBUG (normal, NORMAL))
zlog_debug ("%s Dynamic Capability MP_EXT afi/safi invalid",
peer->host, afi, safi);
zlog_debug ("%s Dynamic Capability MP_EXT afi/safi invalid "
"(%u/%u)", peer->host, afi, safi);
continue;
}
@ -2097,7 +2162,6 @@ int
bgp_capability_receive (struct peer *peer, bgp_size_t size)
{
u_char *pnt;
int ret;
/* Fetch pointer. */
pnt = stream_pnt (peer->ibuf);
@ -2113,7 +2177,7 @@ bgp_capability_receive (struct peer *peer, bgp_size_t size)
bgp_notify_send (peer,
BGP_NOTIFY_HEADER_ERR,
BGP_NOTIFY_HEADER_BAD_MESTYPE);
return;
return -1;
}
/* Status must be Established. */
@ -2122,7 +2186,7 @@ bgp_capability_receive (struct peer *peer, bgp_size_t size)
plog_err (peer->log,
"%s [Error] Dynamic capability packet received under status %s", peer->host, LOOKUP (bgp_status_msg, peer->status));
bgp_notify_send (peer, BGP_NOTIFY_FSM_ERR, 0);
return;
return -1;
}
/* Parse packet. */

8
bgpd/bgp_routemap.c
View File

@ -3337,7 +3337,7 @@ DEFUN (no_set_atomic_aggregate,
DEFUN (set_aggregator_as,
set_aggregator_as_cmd,
"set aggregator as <1-65535> A.B.C.D",
"set aggregator as CMD_AS_RANGE A.B.C.D",
SET_STR
"BGP aggregator attribute\n"
"AS number of aggregator\n"
@ -3349,7 +3349,7 @@ DEFUN (set_aggregator_as,
struct in_addr address;
char *argstr;
VTY_GET_INTEGER_RANGE ("AS Path", as, argv[0], 1, BGP_AS_MAX);
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, BGP_AS4_MAX);
ret = inet_aton (argv[1], &address);
if (ret == 0)
@ -3386,7 +3386,7 @@ DEFUN (no_set_aggregator_as,
if (argv == 0)
return bgp_route_set_delete (vty, vty->index, "aggregator as", NULL);
VTY_GET_INTEGER_RANGE ("AS Path", as, argv[0], 1, BGP_AS_MAX);
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, BGP_AS4_MAX);
ret = inet_aton (argv[1], &address);
if (ret == 0)
@ -3409,7 +3409,7 @@ DEFUN (no_set_aggregator_as,
ALIAS (no_set_aggregator_as,
no_set_aggregator_as_val_cmd,
"no set aggregator as <1-65535> A.B.C.D",
"no set aggregator as CMD_AS_RANGE A.B.C.D",
NO_STR
SET_STR
"BGP aggregator attribute\n"

175
bgpd/bgp_vty.c
View File

@ -308,7 +308,7 @@ DEFUN_DEPRECATED (neighbor_version,
/* "router bgp" commands. */
DEFUN (router_bgp,
router_bgp_cmd,
"router bgp <1-65535>",
"router bgp CMD_AS_RANGE",
ROUTER_STR
BGP_STR
AS_STR)
@ -318,7 +318,7 @@ DEFUN (router_bgp,
struct bgp *bgp;
const char *name = NULL;
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, 65535);
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, BGP_AS4_MAX);
if (argc == 2)
name = argv[1];
@ -348,7 +348,7 @@ DEFUN (router_bgp,
ALIAS (router_bgp,
router_bgp_view_cmd,
"router bgp <1-65535> view WORD",
"router bgp CMD_AS_RANGE view WORD",
ROUTER_STR
BGP_STR
AS_STR
@ -358,7 +358,7 @@ ALIAS (router_bgp,
/* "no router bgp" commands. */
DEFUN (no_router_bgp,
no_router_bgp_cmd,
"no router bgp <1-65535>",
"no router bgp CMD_AS_RANGE",
NO_STR
ROUTER_STR
BGP_STR
@ -368,7 +368,7 @@ DEFUN (no_router_bgp,
struct bgp *bgp;
const char *name = NULL;
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, 65535);
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, BGP_AS4_MAX);
if (argc == 2)
name = argv[1];
@ -388,7 +388,7 @@ DEFUN (no_router_bgp,
ALIAS (no_router_bgp,
no_router_bgp_view_cmd,
"no router bgp <1-65535> view WORD",
"no router bgp CMD_AS_RANGE view WORD",
NO_STR
ROUTER_STR
BGP_STR
@ -539,7 +539,7 @@ ALIAS (no_bgp_cluster_id,
DEFUN (bgp_confederation_identifier,
bgp_confederation_identifier_cmd,
"bgp confederation identifier <1-65535>",
"bgp confederation identifier CMD_AS_RANGE",
"BGP specific commands\n"
"AS confederation parameters\n"
"AS number\n"
@ -550,7 +550,7 @@ DEFUN (bgp_confederation_identifier,
bgp = vty->index;
VTY_GET_INTEGER ("AS", as, argv[0]);
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, BGP_AS4_MAX);
bgp_confederation_id_set (bgp, as);
@ -571,7 +571,7 @@ DEFUN (no_bgp_confederation_identifier,
bgp = vty->index;
if (argc == 1)
VTY_GET_INTEGER ("AS", as, argv[0]);
VTY_GET_INTEGER_RANGE ("AS", as, argv[0], 1, BGP_AS4_MAX);
bgp_confederation_id_unset (bgp);
@ -580,7 +580,7 @@ DEFUN (no_bgp_confederation_identifier,
ALIAS (no_bgp_confederation_identifier,
no_bgp_confederation_identifier_arg_cmd,
"no bgp confederation identifier <1-65535>",
"no bgp confederation identifier CMD_AS_RANGE",
NO_STR
"BGP specific commands\n"
"AS confederation parameters\n"
@ -589,7 +589,7 @@ ALIAS (no_bgp_confederation_identifier,
DEFUN (bgp_confederation_peers,
bgp_confederation_peers_cmd,
"bgp confederation peers .<1-65535>",
"bgp confederation peers .CMD_AS_RANGE",
"BGP specific commands\n"
"AS confederation parameters\n"
"Peer ASs in BGP confederation\n"
@ -603,7 +603,7 @@ DEFUN (bgp_confederation_peers,
for (i = 0; i < argc; i++)
{
VTY_GET_INTEGER_RANGE ("AS", as, argv[i], 1, 65535);
VTY_GET_INTEGER_RANGE ("AS", as, argv[i], 1, BGP_AS4_MAX);
if (bgp->as == as)
{
@ -619,7 +619,7 @@ DEFUN (bgp_confederation_peers,
DEFUN (no_bgp_confederation_peers,
no_bgp_confederation_peers_cmd,
"no bgp confederation peers .<1-65535>",
"no bgp confederation peers .CMD_AS_RANGE",
NO_STR
"BGP specific commands\n"
"AS confederation parameters\n"
@ -634,8 +634,8 @@ DEFUN (no_bgp_confederation_peers,
for (i = 0; i < argc; i++)
{
VTY_GET_INTEGER_RANGE ("AS", as, argv[i], 1, 65535);
VTY_GET_INTEGER_RANGE ("AS", as, argv[i], 1, BGP_AS4_MAX);
bgp_confederation_peers_remove (bgp, as);
}
return CMD_SUCCESS;
@ -1249,7 +1249,7 @@ peer_remote_as_vty (struct vty *vty, const char *peer_str,
bgp = vty->index;
/* Get AS number. */
VTY_GET_INTEGER_RANGE ("AS", as, as_str, 1, 65535);
VTY_GET_INTEGER_RANGE ("AS", as, as_str, 1, BGP_AS4_MAX);
/* If peer is peer group, call proper function. */
ret = str2sockunion (peer_str, &su);
@ -1288,7 +1288,7 @@ peer_remote_as_vty (struct vty *vty, const char *peer_str,
DEFUN (neighbor_remote_as,
neighbor_remote_as_cmd,
NEIGHBOR_CMD2 "remote-as <1-65535>",
NEIGHBOR_CMD2 "remote-as CMD_AS_RANGE",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
"Specify a BGP neighbor\n"
@ -1352,7 +1352,7 @@ DEFUN (no_neighbor,
ALIAS (no_neighbor,
no_neighbor_remote_as_cmd,
NO_NEIGHBOR_CMD "remote-as <1-65535>",
NO_NEIGHBOR_CMD "remote-as CMD_AS_RANGE",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR
@ -1382,7 +1382,7 @@ DEFUN (no_neighbor_peer_group,
DEFUN (no_neighbor_peer_group_remote_as,
no_neighbor_peer_group_remote_as_cmd,
"no neighbor WORD remote-as <1-65535>",
"no neighbor WORD remote-as CMD_AS_RANGE",
NO_STR
NEIGHBOR_STR
"Neighbor tag\n"
@ -1404,7 +1404,7 @@ DEFUN (no_neighbor_peer_group_remote_as,
DEFUN (neighbor_local_as,
neighbor_local_as_cmd,
NEIGHBOR_CMD2 "local-as <1-65535>",
NEIGHBOR_CMD2 "local-as CMD_AS_RANGE",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
"Specify a local-as number\n"
@ -1423,7 +1423,7 @@ DEFUN (neighbor_local_as,
DEFUN (neighbor_local_as_no_prepend,
neighbor_local_as_no_prepend_cmd,
NEIGHBOR_CMD2 "local-as <1-65535> no-prepend",
NEIGHBOR_CMD2 "local-as CMD_AS_RANGE no-prepend",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
"Specify a local-as number\n"
@ -1462,7 +1462,7 @@ DEFUN (no_neighbor_local_as,
ALIAS (no_neighbor_local_as,
no_neighbor_local_as_val_cmd,
NO_NEIGHBOR_CMD2 "local-as <1-65535>",
NO_NEIGHBOR_CMD2 "local-as CMD_AS_RANGE",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
@ -1471,7 +1471,7 @@ ALIAS (no_neighbor_local_as,
ALIAS (no_neighbor_local_as,
no_neighbor_local_as_val2_cmd,
NO_NEIGHBOR_CMD2 "local-as <1-65535> no-prepend",
NO_NEIGHBOR_CMD2 "local-as CMD_AS_RANGE no-prepend",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
@ -4037,7 +4037,7 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (ret < 0)
bgp_clear_vty_error (vty, peer, afi, safi, ret);
}
return 0;
return CMD_SUCCESS;
}
/* Clear specified neighbors. */
@ -4051,13 +4051,13 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (ret < 0)
{
vty_out (vty, "Malformed address: %s%s", arg, VTY_NEWLINE);
return -1;
return CMD_WARNING;
}
peer = peer_lookup (bgp, &su);
if (! peer)
{
vty_out (vty, "%%BGP: Unknown neighbor - \"%s\"%s", arg, VTY_NEWLINE);
return -1;
return CMD_WARNING;
}
if (stype == BGP_CLEAR_SOFT_NONE)
@ -4068,7 +4068,7 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (ret < 0)
bgp_clear_vty_error (vty, peer, afi, safi, ret);
return 0;
return CMD_SUCCESS;
}
/* Clear all peer-group members. */
@ -4080,7 +4080,7 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (! group)
{
vty_out (vty, "%%BGP: No such peer-group %s%s", arg, VTY_NEWLINE);
return -1;
return CMD_WARNING;
}
for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
@ -4099,7 +4099,7 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (ret < 0)
bgp_clear_vty_error (vty, peer, afi, safi, ret);
}
return 0;
return CMD_SUCCESS;
}
if (sort == clear_external)
@ -4117,22 +4117,21 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (ret < 0)
bgp_clear_vty_error (vty, peer, afi, safi, ret);
}
return 0;
return CMD_SUCCESS;
}
if (sort == clear_as)
{
as_t as;
unsigned long as_ul;
char *endptr = NULL;
int find = 0;
as_ul = strtoul(arg, &endptr, 10);
if ((as_ul == ULONG_MAX) || (*endptr != '\0') || (as_ul > USHRT_MAX))
VTY_GET_LONG ("AS", as_ul, arg);
if (!as_ul)
{
vty_out (vty, "Invalid AS number%s", VTY_NEWLINE);
return -1;
return CMD_WARNING;
}
as = (as_t) as_ul;
@ -4153,10 +4152,10 @@ bgp_clear (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (! find)
vty_out (vty, "%%BGP: No peer is configured with AS %s%s", arg,
VTY_NEWLINE);
return 0;
return CMD_SUCCESS;
}
return 0;
return CMD_SUCCESS;
}
static int
@ -4164,7 +4163,6 @@ bgp_clear_vty (struct vty *vty, const char *name, afi_t afi, safi_t safi,
enum clear_sort sort, enum bgp_clear_type stype,
const char *arg)
{
int ret;
struct bgp *bgp;
/* BGP structure lookup. */
@ -4187,11 +4185,7 @@ bgp_clear_vty (struct vty *vty, const char *name, afi_t afi, safi_t safi,
}
}
ret = bgp_clear (vty, bgp, afi, safi, sort, stype, arg);
if (ret < 0)
return CMD_WARNING;
return CMD_SUCCESS;
return bgp_clear (vty, bgp, afi, safi, sort, stype, arg);
}
DEFUN (clear_ip_bgp_all,
@ -4328,7 +4322,7 @@ ALIAS (clear_ip_bgp_external,
DEFUN (clear_ip_bgp_as,
clear_ip_bgp_as_cmd,
"clear ip bgp <1-65535>",
"clear ip bgp CMD_AS_RANGE",
CLEAR_STR
IP_STR
BGP_STR
@ -4339,14 +4333,14 @@ DEFUN (clear_ip_bgp_as,
ALIAS (clear_ip_bgp_as,
clear_bgp_as_cmd,
"clear bgp <1-65535>",
"clear bgp CMD_AS_RANGE",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n")
ALIAS (clear_ip_bgp_as,
clear_bgp_ipv6_as_cmd,
"clear bgp ipv6 <1-65535>",
"clear bgp ipv6 CMD_AS_RANGE",
CLEAR_STR
BGP_STR
"Address family\n"
@ -4858,7 +4852,7 @@ ALIAS (clear_bgp_external_soft_out,
DEFUN (clear_ip_bgp_as_soft_out,
clear_ip_bgp_as_soft_out_cmd,
"clear ip bgp <1-65535> soft out",
"clear ip bgp CMD_AS_RANGE soft out",
CLEAR_STR
IP_STR
BGP_STR
@ -4872,7 +4866,7 @@ DEFUN (clear_ip_bgp_as_soft_out,
ALIAS (clear_ip_bgp_as_soft_out,
clear_ip_bgp_as_out_cmd,
"clear ip bgp <1-65535> out",
"clear ip bgp CMD_AS_RANGE out",
CLEAR_STR
IP_STR
BGP_STR
@ -4881,7 +4875,7 @@ ALIAS (clear_ip_bgp_as_soft_out,
DEFUN (clear_ip_bgp_as_ipv4_soft_out,
clear_ip_bgp_as_ipv4_soft_out_cmd,
"clear ip bgp <1-65535> ipv4 (unicast|multicast) soft out",
"clear ip bgp CMD_AS_RANGE ipv4 (unicast|multicast) soft out",
CLEAR_STR
IP_STR
BGP_STR
@ -4902,7 +4896,7 @@ DEFUN (clear_ip_bgp_as_ipv4_soft_out,
ALIAS (clear_ip_bgp_as_ipv4_soft_out,
clear_ip_bgp_as_ipv4_out_cmd,
"clear ip bgp <1-65535> ipv4 (unicast|multicast) out",
"clear ip bgp CMD_AS_RANGE ipv4 (unicast|multicast) out",
CLEAR_STR
IP_STR
BGP_STR
@ -4914,7 +4908,7 @@ ALIAS (clear_ip_bgp_as_ipv4_soft_out,
DEFUN (clear_ip_bgp_as_vpnv4_soft_out,
clear_ip_bgp_as_vpnv4_soft_out_cmd,
"clear ip bgp <1-65535> vpnv4 unicast soft out",
"clear ip bgp CMD_AS_RANGE vpnv4 unicast soft out",
CLEAR_STR
IP_STR
BGP_STR
@ -4930,7 +4924,7 @@ DEFUN (clear_ip_bgp_as_vpnv4_soft_out,
ALIAS (clear_ip_bgp_as_vpnv4_soft_out,
clear_ip_bgp_as_vpnv4_out_cmd,
"clear ip bgp <1-65535> vpnv4 unicast out",
"clear ip bgp CMD_AS_RANGE vpnv4 unicast out",
CLEAR_STR
IP_STR
BGP_STR
@ -4941,7 +4935,7 @@ ALIAS (clear_ip_bgp_as_vpnv4_soft_out,
DEFUN (clear_bgp_as_soft_out,
clear_bgp_as_soft_out_cmd,
"clear bgp <1-65535> soft out",
"clear bgp CMD_AS_RANGE soft out",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n"
@ -4954,7 +4948,7 @@ DEFUN (clear_bgp_as_soft_out,
ALIAS (clear_bgp_as_soft_out,
clear_bgp_ipv6_as_soft_out_cmd,
"clear bgp ipv6 <1-65535> soft out",
"clear bgp ipv6 CMD_AS_RANGE soft out",
CLEAR_STR
BGP_STR
"Address family\n"
@ -4964,7 +4958,7 @@ ALIAS (clear_bgp_as_soft_out,
ALIAS (clear_bgp_as_soft_out,
clear_bgp_as_out_cmd,
"clear bgp <1-65535> out",
"clear bgp CMD_AS_RANGE out",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n"
@ -4972,7 +4966,7 @@ ALIAS (clear_bgp_as_soft_out,
ALIAS (clear_bgp_as_soft_out,
clear_bgp_ipv6_as_out_cmd,
"clear bgp ipv6 <1-65535> out",
"clear bgp ipv6 CMD_AS_RANGE out",
CLEAR_STR
BGP_STR
"Address family\n"
@ -5762,7 +5756,7 @@ ALIAS (clear_bgp_external_in_prefix_filter,
DEFUN (clear_ip_bgp_as_soft_in,
clear_ip_bgp_as_soft_in_cmd,
"clear ip bgp <1-65535> soft in",
"clear ip bgp CMD_AS_RANGE soft in",
CLEAR_STR
IP_STR
BGP_STR
@ -5776,7 +5770,7 @@ DEFUN (clear_ip_bgp_as_soft_in,
ALIAS (clear_ip_bgp_as_soft_in,
clear_ip_bgp_as_in_cmd,
"clear ip bgp <1-65535> in",
"clear ip bgp CMD_AS_RANGE in",
CLEAR_STR
IP_STR
BGP_STR
@ -5785,7 +5779,7 @@ ALIAS (clear_ip_bgp_as_soft_in,
DEFUN (clear_ip_bgp_as_in_prefix_filter,
clear_ip_bgp_as_in_prefix_filter_cmd,
"clear ip bgp <1-65535> in prefix-filter",
"clear ip bgp CMD_AS_RANGE in prefix-filter",
CLEAR_STR
IP_STR
BGP_STR
@ -5799,7 +5793,7 @@ DEFUN (clear_ip_bgp_as_in_prefix_filter,
DEFUN (clear_ip_bgp_as_ipv4_soft_in,
clear_ip_bgp_as_ipv4_soft_in_cmd,
"clear ip bgp <1-65535> ipv4 (unicast|multicast) soft in",
"clear ip bgp CMD_AS_RANGE ipv4 (unicast|multicast) soft in",
CLEAR_STR
IP_STR
BGP_STR
@ -5820,7 +5814,7 @@ DEFUN (clear_ip_bgp_as_ipv4_soft_in,
ALIAS (clear_ip_bgp_as_ipv4_soft_in,
clear_ip_bgp_as_ipv4_in_cmd,
"clear ip bgp <1-65535> ipv4 (unicast|multicast) in",
"clear ip bgp CMD_AS_RANGE ipv4 (unicast|multicast) in",
CLEAR_STR
IP_STR
BGP_STR
@ -5832,7 +5826,7 @@ ALIAS (clear_ip_bgp_as_ipv4_soft_in,
DEFUN (clear_ip_bgp_as_ipv4_in_prefix_filter,
clear_ip_bgp_as_ipv4_in_prefix_filter_cmd,
"clear ip bgp <1-65535> ipv4 (unicast|multicast) in prefix-filter",
"clear ip bgp CMD_AS_RANGE ipv4 (unicast|multicast) in prefix-filter",
CLEAR_STR
IP_STR
BGP_STR
@ -5853,7 +5847,7 @@ DEFUN (clear_ip_bgp_as_ipv4_in_prefix_filter,
DEFUN (clear_ip_bgp_as_vpnv4_soft_in,
clear_ip_bgp_as_vpnv4_soft_in_cmd,
"clear ip bgp <1-65535> vpnv4 unicast soft in",
"clear ip bgp CMD_AS_RANGE vpnv4 unicast soft in",
CLEAR_STR
IP_STR
BGP_STR
@ -5869,7 +5863,7 @@ DEFUN (clear_ip_bgp_as_vpnv4_soft_in,
ALIAS (clear_ip_bgp_as_vpnv4_soft_in,
clear_ip_bgp_as_vpnv4_in_cmd,
"clear ip bgp <1-65535> vpnv4 unicast in",
"clear ip bgp CMD_AS_RANGE vpnv4 unicast in",
CLEAR_STR
IP_STR
BGP_STR
@ -5880,7 +5874,7 @@ ALIAS (clear_ip_bgp_as_vpnv4_soft_in,
DEFUN (clear_bgp_as_soft_in,
clear_bgp_as_soft_in_cmd,
"clear bgp <1-65535> soft in",
"clear bgp CMD_AS_RANGE soft in",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n"
@ -5893,7 +5887,7 @@ DEFUN (clear_bgp_as_soft_in,
ALIAS (clear_bgp_as_soft_in,
clear_bgp_ipv6_as_soft_in_cmd,
"clear bgp ipv6 <1-65535> soft in",
"clear bgp ipv6 CMD_AS_RANGE soft in",
CLEAR_STR
BGP_STR
"Address family\n"
@ -5903,7 +5897,7 @@ ALIAS (clear_bgp_as_soft_in,
ALIAS (clear_bgp_as_soft_in,
clear_bgp_as_in_cmd,
"clear bgp <1-65535> in",
"clear bgp CMD_AS_RANGE in",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n"
@ -5911,7 +5905,7 @@ ALIAS (clear_bgp_as_soft_in,
ALIAS (clear_bgp_as_soft_in,
clear_bgp_ipv6_as_in_cmd,
"clear bgp ipv6 <1-65535> in",
"clear bgp ipv6 CMD_AS_RANGE in",
CLEAR_STR
BGP_STR
"Address family\n"
@ -5920,7 +5914,7 @@ ALIAS (clear_bgp_as_soft_in,
DEFUN (clear_bgp_as_in_prefix_filter,
clear_bgp_as_in_prefix_filter_cmd,
"clear bgp <1-65535> in prefix-filter",
"clear bgp CMD_AS_RANGE in prefix-filter",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n"
@ -5933,7 +5927,7 @@ DEFUN (clear_bgp_as_in_prefix_filter,
ALIAS (clear_bgp_as_in_prefix_filter,
clear_bgp_ipv6_as_in_prefix_filter_cmd,
"clear bgp ipv6 <1-65535> in prefix-filter",
"clear bgp ipv6 CMD_AS_RANGE in prefix-filter",
CLEAR_STR
BGP_STR
"Address family\n"
@ -6248,7 +6242,7 @@ ALIAS (clear_bgp_external_soft,
DEFUN (clear_ip_bgp_as_soft,
clear_ip_bgp_as_soft_cmd,
"clear ip bgp <1-65535> soft",
"clear ip bgp CMD_AS_RANGE soft",
CLEAR_STR
IP_STR
BGP_STR
@ -6261,7 +6255,7 @@ DEFUN (clear_ip_bgp_as_soft,
DEFUN (clear_ip_bgp_as_ipv4_soft,
clear_ip_bgp_as_ipv4_soft_cmd,
"clear ip bgp <1-65535> ipv4 (unicast|multicast) soft",
"clear ip bgp CMD_AS_RANGE ipv4 (unicast|multicast) soft",
CLEAR_STR
IP_STR
BGP_STR
@ -6281,7 +6275,7 @@ DEFUN (clear_ip_bgp_as_ipv4_soft,
DEFUN (clear_ip_bgp_as_vpnv4_soft,
clear_ip_bgp_as_vpnv4_soft_cmd,
"clear ip bgp <1-65535> vpnv4 unicast soft",
"clear ip bgp CMD_AS_RANGE vpnv4 unicast soft",
CLEAR_STR
IP_STR
BGP_STR
@ -6296,7 +6290,7 @@ DEFUN (clear_ip_bgp_as_vpnv4_soft,
DEFUN (clear_bgp_as_soft,
clear_bgp_as_soft_cmd,
"clear bgp <1-65535> soft",
"clear bgp CMD_AS_RANGE soft",
CLEAR_STR
BGP_STR
"Clear peers with the AS number\n"
@ -6308,7 +6302,7 @@ DEFUN (clear_bgp_as_soft,
ALIAS (clear_bgp_as_soft,
clear_bgp_ipv6_as_soft_cmd,
"clear bgp ipv6 <1-65535> soft",
"clear bgp ipv6 CMD_AS_RANGE soft",
CLEAR_STR
BGP_STR
"Address family\n"
@ -6688,7 +6682,7 @@ bgp_show_summary (struct vty *vty, struct bgp *bgp, int afi, int safi)
peer->open_out + peer->update_out + peer->keepalive_out
+ peer->notify_out + peer->refresh_out
+ peer->dynamic_cap_out,
0, 0, (unsigned long)peer->obuf->count);
0, 0, (unsigned long) peer->obuf->count);
vty_out (vty, "%8s",
peer_uptime (peer->uptime, timebuf, BGP_UPTIME_LEN));
@ -7271,6 +7265,18 @@ bgp_show_peer (struct vty *vty, struct peer *p)
{
vty_out (vty, " Neighbor capabilities:%s", VTY_NEWLINE);
/* AS4 */
if (CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV)
|| CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV))
{
vty_out (vty, " 4 Byte AS:");
if (CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV))
vty_out (vty, " advertised");
if (CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV))
vty_out (vty, " %sreceived",
CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV) ? "and " : "");
vty_out (vty, "%s", VTY_NEWLINE);
}
/* Dynamic */
if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_RCV)
|| CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV))
@ -7389,21 +7395,18 @@ bgp_show_peer (struct vty *vty, struct peer *p)
}
if (p->t_gr_restart)
{
vty_out (vty, " The remaining time of restart timer is %ld%s",
thread_timer_remain_second (p->t_gr_restart), VTY_NEWLINE);
}
vty_out (vty, " The remaining time of restart timer is %ld%s",
thread_timer_remain_second (p->t_gr_restart), VTY_NEWLINE);
if (p->t_gr_stale)
{
vty_out (vty, " The remaining time of stalepath timer is %ld%s",
thread_timer_remain_second (p->t_gr_stale), VTY_NEWLINE);
}
vty_out (vty, " The remaining time of stalepath timer is %ld%s",
thread_timer_remain_second (p->t_gr_stale), VTY_NEWLINE);
}
/* Packet counts. */
vty_out (vty, " Message statistics:%s", VTY_NEWLINE);
vty_out (vty, " Inq depth is 0%s", VTY_NEWLINE);
vty_out (vty, " Outq depth is %lu%s", (unsigned long)p->obuf->count, VTY_NEWLINE);
vty_out (vty, " Outq depth is %lu%s", (unsigned long) p->obuf->count, VTY_NEWLINE);
vty_out (vty, " Sent Rcvd%s", VTY_NEWLINE);
vty_out (vty, " Opens: %10d %10d%s", p->open_out, p->open_in, VTY_NEWLINE);
vty_out (vty, " Notifications: %10d %10d%s", p->notify_out, p->notify_in, VTY_NEWLINE);
@ -7907,7 +7910,7 @@ bgp_write_rsclient_summary (struct vty *vty, struct peer *rsclient,
vty_out (vty, "4 ");
vty_out (vty, "%5d ", rsclient->as);
vty_out (vty, "%11d ", rsclient->as);
rmname = ROUTE_MAP_EXPORT_NAME(&rsclient->filter[afi][safi]);
if ( rmname && strlen (rmname) > 13 )

2
bgpd/bgp_vty.h
View File

@ -21,6 +21,8 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#ifndef _QUAGGA_BGP_VTY_H
#define _QUAGGA_BGP_VTY_H
#define CMD_AS_RANGE "<1-4294967295>"
extern void bgp_vty_init (void);
extern const char *afi_safi_print (afi_t, safi_t);

12
bgpd/bgpd.h
View File

@ -25,7 +25,8 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#include "sockunion.h"
/* Typedef BGP specific types. */
typedef u_int16_t as_t;
typedef u_int32_t as_t;
typedef u_int16_t as16_t; /* we may still encounter 16 Bit asnums */
typedef u_int16_t bgp_size_t;
/* BGP master for system wide configurations and variables. */
@ -287,6 +288,9 @@ struct peer
int status;
int ostatus;
/* Peer index, used for dumping TABLE_DUMP_V2 format */
uint16_t table_dump_index;
/* Peer information */
int fd; /* File descriptor */
int ttl; /* TTL of TCP connection to the peer. */
@ -316,7 +320,7 @@ struct peer
u_char afc_recv[AFI_MAX][SAFI_MAX];
/* Capability flags (reset in bgp_stop) */
u_char cap;
u_int16_t cap;
#define PEER_CAP_REFRESH_ADV (1 << 0) /* refresh advertised */
#define PEER_CAP_REFRESH_OLD_RCV (1 << 1) /* refresh old received */
#define PEER_CAP_REFRESH_NEW_RCV (1 << 2) /* refresh rfc received */
@ -324,6 +328,8 @@ struct peer
#define PEER_CAP_DYNAMIC_RCV (1 << 4) /* dynamic received */
#define PEER_CAP_RESTART_ADV (1 << 5) /* restart advertised */
#define PEER_CAP_RESTART_RCV (1 << 6) /* restart received */
#define PEER_CAP_AS4_ADV (1 << 7) /* as4 advertised */
#define PEER_CAP_AS4_RCV (1 << 8) /* as4 received */
/* Capability flags (reset in bgp_stop) */
u_int16_t af_cap[AFI_MAX][SAFI_MAX];
@ -591,6 +597,8 @@ struct bgp_nlri
#define BGP_ATTR_MP_REACH_NLRI 14
#define BGP_ATTR_MP_UNREACH_NLRI 15
#define BGP_ATTR_EXT_COMMUNITIES 16
#define BGP_ATTR_AS4_PATH 17
#define BGP_ATTR_AS4_AGGREGATOR 18
#define BGP_ATTR_AS_PATHLIMIT 21
/* BGP update origin. */

2
doc/BGP-TypeCode
View File

@ -19,6 +19,8 @@
14 MP_REACH_NLRI [RFC 2283]
15 MP_UNREACH_NLRI [RFC 2283]
16 EXT_COMMUNITIES [draft-ramachandra-bgp-ext-communities-09.txt]
17 AS4_PATH [RFC 4893]
18 AS4_AGGREGATOR [RFC 4893]
254 RCID_PATH [RFC 1863]
255 ADVERTISER [RFC 1863]
=========================================================================

36
tests/ChangeLog
View File

@ -1,3 +1,28 @@
2007-09-27 Paul Jakma <paul.jakma@sun.com>
* aspath_test.c: Test dupe-weeding from sets.
Test that reconciliation merges AS_PATH and AS4_PATH where
former is shorter than latter.
2007-09-26 Paul Jakma <paul.jakma@sun.com>
* aspath_test.c: Test AS4_PATH reconcilation where length
of AS_PATH and AS4_PATH is same.
2007-09-25 Paul Jakma <paul.jakma@sun.com>
* bgp_capability_test.c: (general) Extend tests to validate
peek_for_as4_capability.
Add test of full OPEN Option block, with multiple capabilities,
both as a series of Option, and a single option.
Add some crap to beginning of stream, to prevent code depending
on getp == 0.
2007-09-18 Paul Jakma <paul.jakma@sun.com>
* bgp_capability_test.c: (parse_test) update for changes to
peek_for_as4_capability
2007-09-17 Paul Jakma <paul.jakma@sun.com>
* bgp_capability_test.c: Test that peer's adv_recv and adv_nego get
@ -9,6 +34,17 @@
* bgp_capability_test.c: new, capability parser unit tests.
* Makefile.am: add previous.
2007-07-25 Paul Jakma <paul.jakma@sun.com>
* aspath_test.c: Exercise 32bit parsing. Test reconcile
function.
* ecommunity_test.c: New, test AS4 ecommunity changes, positive
test only at this time, error cases not tested yet.
2006-12-01 Juergen Kammer <j.kammer@eurodata.de>
* aspath_test.c: Support asn32 changes, call aspath_parse with 16 bit.
2006-08-26 Paul Jakma <paul.jakma@sun.com>
* heavy-wq.c: (slow_func_del,slow_func) update to match workqueue

4
tests/Makefile.am
View File

@ -2,7 +2,7 @@ INCLUDES = @INCLUDES@ -I.. -I$(top_srcdir) -I$(top_srcdir)/lib
DEFS = @DEFS@ $(LOCAL_OPTS) -DSYSCONFDIR=\"$(sysconfdir)/\"
noinst_PROGRAMS = testsig testbuffer testmemory heavy heavywq heavythread \
aspathtest testprivs teststream testbgpcap
aspathtest testprivs teststream testbgpcap ecommtest
testsig_SOURCES = test-sig.c
testbuffer_SOURCES = test-buffer.c
testmemory_SOURCES = test-memory.c
@ -13,6 +13,7 @@ heavywq_SOURCES = heavy-wq.c main.c
heavythread_SOURCES = heavy-thread.c main.c
aspathtest_SOURCES = aspath_test.c
testbgpcap_SOURCES = bgp_capability_test.c
ecommtest_SOURCES = ecommunity_test.c
testsig_LDADD = ../lib/libzebra.la @LIBCAP@
testbuffer_LDADD = ../lib/libzebra.la @LIBCAP@
@ -24,3 +25,4 @@ heavywq_LDADD = ../lib/libzebra.la @LIBCAP@ -lm
heavythread_LDADD = ../lib/libzebra.la @LIBCAP@ -lm
aspathtest_LDADD = ../lib/libzebra.la @LIBCAP@ -lm ../bgpd/libbgp.a
testbgpcap_LDADD = ../lib/libzebra.la @LIBCAP@ -lm ../bgpd/libbgp.a
ecommtest_LDADD = ../lib/libzebra.la @LIBCAP@ -lm ../bgpd/libbgp.a

245
tests/aspath_test.c
View File

@ -7,6 +7,13 @@
#include "bgpd/bgpd.h"
#include "bgpd/bgp_aspath.h"
#define VT100_RESET "\x1b[0m"
#define VT100_RED "\x1b[31m"
#define VT100_GREEN "\x1b[32m"
#define VT100_YELLOW "\x1b[33m"
#define OK VT100_GREEN "OK" VT100_RESET
#define FAILED VT100_RED "failed" VT100_RESET
/* need these to link in libbgp */
struct zebra_privs_t *bgpd_privs = NULL;
struct thread_master *master = NULL;
@ -312,8 +319,87 @@ static struct test_segment {
/* We shouldn't ever /generate/ such paths. However, we should
* cope with them fine.
*/
"8466 3 52737 4096 3456 {7099,8153,8153,8153}",
"8466 3 52737 4096 3456 {7099,8153,8153,8153}",
"8466 3 52737 4096 3456 {7099,8153}",
"8466 3 52737 4096 3456 {7099,8153}",
6, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
},
{ /* 18 */
"reconcile_lead_asp",
"seq(6435,59408,21665) set(23456,23456,23456), seq(23456,23456,23456)",
{ 0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1,
0x1,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0 },
24,
{ "6435 59408 21665 {23456} 23456 23456 23456",
"6435 59408 21665 {23456} 23456 23456 23456",
7, 0, NOT_ALL_PRIVATE, 23456, 1, 6435 },
},
{ /* 19 */
"reconcile_new_asp",
"set(2457,61697,4369), seq(1842,41591,51793)",
{
0x1,0x3, 0x09,0x99, 0xf1,0x01, 0x11,0x11,
0x2,0x3, 0x07,0x32, 0xa2,0x77, 0xca,0x51 },
16,
{ "{2457,4369,61697} 1842 41591 51793",
"{2457,4369,61697} 1842 41591 51793",
4, 0, NOT_ALL_PRIVATE, 51793, 1, 2457 },
},
{ /* 20 */
"reconcile_confed",
"confseq(123,456,789) confset(456,124,788) seq(6435,59408,21665)"
" set(23456,23456,23456), seq(23456,23456,23456)",
{ 0x3,0x3, 0x00,0x7b, 0x01,0xc8, 0x03,0x15,
0x4,0x3, 0x01,0xc8, 0x00,0x7c, 0x03,0x14,
0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1,
0x1,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0 },
40,
{ "(123 456 789) [124,456,788] 6435 59408 21665"
" {23456} 23456 23456 23456",
"6435 59408 21665 {23456} 23456 23456 23456",
7, 4, NOT_ALL_PRIVATE, 23456, 1, 6435 },
},
{ /* 21 */
"reconcile_start_trans",
"seq(23456,23456,23456) seq(6435,59408,21665)",
{ 0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1, },
16,
{ "23456 23456 23456 6435 59408 21665",
"23456 23456 23456 6435 59408 21665",
6, 0, NOT_ALL_PRIVATE, 21665, 1, 23456 },
},
{ /* 22 */
"reconcile_start_trans4",
"seq(1842,41591,51793) seq(6435,59408,21665)",
{ 0x2,0x3, 0x07,0x32, 0xa2,0x77, 0xca,0x51,
0x2,0x3, 0x19,0x23, 0xe8,0x10, 0x54,0xa1, },
16,
{ "1842 41591 51793 6435 59408 21665",
"1842 41591 51793 6435 59408 21665",
6, 0, NOT_ALL_PRIVATE, 41591, 1, 1842 },
},
{ /* 23 */
"reconcile_start_trans_error",
"seq(23456,23456,23456) seq(6435,59408)",
{ 0x2,0x3, 0x5b,0xa0, 0x5b,0xa0, 0x5b,0xa0,
0x2,0x2, 0x19,0x23, 0xe8,0x10, },
14,
{ "23456 23456 23456 6435 59408",
"23456 23456 23456 6435 59408",
5, 0, NOT_ALL_PRIVATE, 59408, 1, 23456 },
},
{ /* 24 */
"redundantset2",
"seq(8466,3,52737,4096,3456) set(7099,8153,8153,8153,7099)",
{ 0x2,0x5, 0x21,0x12, 0x00,0x03, 0xce,0x01, 0x10,0x00, 0x0d,0x80,
0x1,0x5, 0x1b,0xbb, 0x1f,0xd9, 0x1f,0xd9, 0x1f,0xd9, 0x1b,0xbb,},
24,
{
/* We should weed out duplicate set members. */
"8466 3 52737 4096 3456 {7099,8153}",
"8466 3 52737 4096 3456 {7099,8153}",
6, 0, NOT_ALL_PRIVATE, 4096, 4, 8466 },
},
{ NULL, NULL, {0}, 0, { NULL, 0, 0 } }
@ -432,13 +518,43 @@ static struct tests {
{ NULL, NULL, { NULL, 0, 0, 0, 0, 0, 0, } },
};
struct tests reconcile_tests[] =
{
{ &test_segments[18], &test_segments[19],
{ "6435 59408 21665 {2457,4369,61697} 1842 41591 51793",
"6435 59408 21665 {2457,4369,61697} 1842 41591 51793",
7, 0, NOT_ALL_PRIVATE, 51793, 1, 6435 },
},
{ &test_segments[19], &test_segments[18],
/* AS_PATH (19) has more hops than NEW_AS_PATH,
* so just AS_PATH should be used (though, this practice
* is bad imho).
*/
{ "{2457,4369,61697} 1842 41591 51793 6435 59408 21665 {23456} 23456 23456 23456",
"{2457,4369,61697} 1842 41591 51793 6435 59408 21665 {23456} 23456 23456 23456",
11, 0, NOT_ALL_PRIVATE, 51793, 1, 6435 },
},
{ &test_segments[20], &test_segments[19],
{ "(123 456 789) [124,456,788] 6435 59408 21665"
" {2457,4369,61697} 1842 41591 51793",
"6435 59408 21665 {2457,4369,61697} 1842 41591 51793",
7, 4, NOT_ALL_PRIVATE, 51793, 1, 6435 },
},
{ &test_segments[21], &test_segments[22],
{ "1842 41591 51793 6435 59408 21665",
"1842 41591 51793 6435 59408 21665",
6, 0, NOT_ALL_PRIVATE, 51793, 1, 1842 },
},
{ &test_segments[23], &test_segments[22],
{ "23456 23456 23456 6435 59408 1842 41591 51793 6435 59408 21665",
"23456 23456 23456 6435 59408 1842 41591 51793 6435 59408 21665",
11, 0, NOT_ALL_PRIVATE, 51793, 1, 1842 },
},
{ NULL, NULL, { NULL, 0, 0, 0, 0, 0, 0, } },
};
struct tests aggregate_tests[] =
{
{ &test_segments[0], &test_segments[1],
{ "{3,4,4096,8466,8722,52737}",
"{3,4,4096,8466,8722,52737}",
1, 0, NOT_ALL_PRIVATE, 52737, 1, NULL_ASN },
},
{ &test_segments[0], &test_segments[2],
{ "8466 3 52737 4096 {4,8722}",
"8466 3 52737 4096 {4,8722}",
@ -459,6 +575,13 @@ struct tests aggregate_tests[] =
"8466 {2,3,4,4096,8722,52737}",
2, 0, NOT_ALL_PRIVATE, 2, 20000, 8466 },
},
{ &test_segments[5], &test_segments[18],
{ "6435 59408 21665 {1842,2457,4369,23456,41590,51793,61697}",
"6435 59408 21665 {1842,2457,4369,23456,41590,51793,61697}",
4, 0, NOT_ALL_PRIVATE, 41590, 1, 6435 },
},
{ NULL, NULL, { NULL, 0, 0} },
};
@ -498,7 +621,7 @@ struct compare_tests
/* make an aspath from a data stream */
static struct aspath *
make_aspath (const u_char *data, size_t len)
make_aspath (const u_char *data, size_t len, int use32bit)
{
struct stream *s = NULL;
struct aspath *as;
@ -508,7 +631,7 @@ make_aspath (const u_char *data, size_t len)
s = stream_new (len);
stream_put (s, data, len);
}
as = aspath_parse (s, len);
as = aspath_parse (s, len, use32bit);
if (s)
stream_free (s);
@ -535,18 +658,27 @@ printbytes (const u_char *bytes, int len)
static int
validate (struct aspath *as, const struct test_spec *sp)
{
size_t bytes;
size_t bytes, bytes4;
int fails = 0;
const u_char *out;
struct aspath *asinout, *asconfeddel, *asstr;
static struct stream *s;
struct aspath *asinout, *asconfeddel, *asstr, *as4;
out = aspath_snmp_pathseg (as, &bytes);
asinout = make_aspath (out, bytes);
asinout = make_aspath (out, bytes, 0);
/* Excercise AS4 parsing a bit, with a dogfood test */
if (!s)
s = stream_new (4096);
bytes4 = aspath_put (s, as, 1);
as4 = make_aspath (STREAM_DATA(s), bytes4, 1);
asstr = aspath_str2aspath (sp->shouldbe);
asconfeddel = aspath_delete_confed_seq (aspath_dup (asinout));
printf ("got: %s\n", aspath_print(as));
/* the parsed path should match the specified 'shouldbe' string.
* We should pass the "eat our own dog food" test, be able to output
* this path and then input it again. Ie the path resulting from:
@ -562,6 +694,10 @@ validate (struct aspath *as, const struct test_spec *sp)
*
* aspath_str2aspath() and shouldbe should match
*
* We do the same for:
*
* aspath_parse(aspath_put(as,USE32BIT))
*
* Confederation related tests:
* - aspath_delete_confed_seq(aspath) should match shouldbe_confed
* - aspath_delete_confed_seq should be idempotent.
@ -571,6 +707,8 @@ validate (struct aspath *as, const struct test_spec *sp)
|| (aspath_key_make (as) != aspath_key_make (asinout))
/* by string */
|| strcmp(aspath_print (asinout), sp->shouldbe)
/* By 4-byte parsing */
|| strcmp(aspath_print (as4), sp->shouldbe)
/* by various path counts */
|| (aspath_count_hops (as) != sp->hops)
|| (aspath_count_confeds (as) != sp->confeds)
@ -580,7 +718,7 @@ validate (struct aspath *as, const struct test_spec *sp)
failed++;
fails++;
printf ("shouldbe:\n%s\n", sp->shouldbe);
printf ("got:\n%s\n", aspath_print(as));
printf ("as4:\n%s\n", aspath_print (as4));
printf ("hash keys: in: %d out->in: %d\n",
aspath_key_make (as), aspath_key_make (asinout));
printf ("hops: %d, counted %d %d\n", sp->hops,
@ -635,11 +773,13 @@ validate (struct aspath *as, const struct test_spec *sp)
aspath_private_as_check (as));
}
aspath_unintern (asinout);
aspath_unintern (as4);
aspath_free (asconfeddel);
aspath_free (asstr);
stream_reset (s);
return fails;
}
static void
@ -650,9 +790,9 @@ empty_get_test ()
printf ("empty_get_test, as: %s\n",aspath_print (as));
if (!validate (as, &sp))
printf ("OK\n");
printf ("%s\n", OK);
else
printf ("failed!\n");
printf ("%s!\n", FAILED);
printf ("\n");
@ -667,14 +807,14 @@ parse_test (struct test_segment *t)
printf ("%s: %s\n", t->name, t->desc);
asp = make_aspath (t->asdata, t->len);
asp = make_aspath (t->asdata, t->len, 0);
printf ("aspath: %s\nvalidating...:\n", aspath_print (asp));
if (!validate (asp, &t->sp))
printf ("OK\n");
printf (OK "\n");
else
printf ("failed\n");
printf (FAILED "\n");
printf ("\n");
aspath_unintern (asp);
@ -689,8 +829,8 @@ prepend_test (struct tests *t)
printf ("prepend %s: %s\n", t->test1->name, t->test1->desc);
printf ("to %s: %s\n", t->test2->name, t->test2->desc);
asp1 = make_aspath (t->test1->asdata, t->test1->len);
asp2 = make_aspath (t->test2->asdata, t->test2->len);
asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
ascratch = aspath_dup (asp2);
aspath_unintern (asp2);
@ -700,9 +840,9 @@ prepend_test (struct tests *t)
printf ("aspath: %s\n", aspath_print (asp2));
if (!validate (asp2, &t->sp))
printf ("OK\n");
printf ("%s\n", OK);
else
printf ("failed!\n");
printf ("%s!\n", FAILED);
printf ("\n");
aspath_unintern (asp1);
@ -717,7 +857,7 @@ empty_prepend_test (struct test_segment *t)
printf ("empty prepend %s: %s\n", t->name, t->desc);
asp1 = make_aspath (t->asdata, t->len);
asp1 = make_aspath (t->asdata, t->len, 0);
asp2 = aspath_empty ();
ascratch = aspath_dup (asp2);
@ -728,15 +868,41 @@ empty_prepend_test (struct test_segment *t)
printf ("aspath: %s\n", aspath_print (asp2));
if (!validate (asp2, &t->sp))
printf ("OK\n");
printf (OK "\n");
else
printf ("failed!\n");
printf (FAILED "!\n");
printf ("\n");
aspath_unintern (asp1);
aspath_free (asp2);
}
/* as2+as4 reconciliation testing */
static void
as4_reconcile_test (struct tests *t)
{
struct aspath *asp1, *asp2, *ascratch;
printf ("reconciling %s:\n %s\n", t->test1->name, t->test1->desc);
printf ("with %s:\n %s\n", t->test2->name, t->test2->desc);
asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
ascratch = aspath_reconcile_as4 (asp1, asp2);
if (!validate (ascratch, &t->sp))
printf (OK "\n");
else
printf (FAILED "!\n");
printf ("\n");
aspath_unintern (asp1);
aspath_unintern (asp2);
aspath_free (ascratch);
}
/* aggregation testing */
static void
aggregate_test (struct tests *t)
@ -746,17 +912,15 @@ aggregate_test (struct tests *t)
printf ("aggregate %s: %s\n", t->test1->name, t->test1->desc);
printf ("with %s: %s\n", t->test2->name, t->test2->desc);
asp1 = make_aspath (t->test1->asdata, t->test1->len);
asp2 = make_aspath (t->test2->asdata, t->test2->len);
asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
ascratch = aspath_aggregate (asp1, asp2);
printf ("aspath: %s\n", aspath_print (ascratch));
if (!validate (ascratch, &t->sp))
printf ("OK\n");
printf (OK "\n");
else
printf ("failed!\n");
printf (FAILED "!\n");
printf ("\n");
aspath_unintern (asp1);
@ -782,8 +946,8 @@ cmp_test ()
printf ("left cmp %s: %s\n", t1->name, t1->desc);
printf ("and %s: %s\n", t2->name, t2->desc);
asp1 = make_aspath (t1->asdata, t1->len);
asp2 = make_aspath (t2->asdata, t2->len);
asp1 = make_aspath (t1->asdata, t1->len, 0);
asp2 = make_aspath (t2->asdata, t2->len, 0);
if (aspath_cmp_left (asp1, asp2) != left_compare[i].shouldbe_cmp
|| aspath_cmp_left (asp2, asp1) != left_compare[i].shouldbe_cmp
@ -792,7 +956,8 @@ cmp_test ()
|| aspath_cmp_left_confed (asp2, asp1)
!= left_compare[i].shouldbe_confed)
{
printf ("failed\n");
failed++;
printf (FAILED "\n");
printf ("result should be: cmp: %d, confed: %d\n",
left_compare[i].shouldbe_cmp,
left_compare[i].shouldbe_confed);
@ -801,10 +966,9 @@ cmp_test ()
aspath_cmp_left_confed (asp1, asp2));
printf("path1: %s\npath2: %s\n", aspath_print (asp1),
aspath_print (asp2));
failed++;
}
else
printf ("OK\n");
printf (OK "\n");
printf ("\n");
aspath_unintern (asp1);
@ -831,6 +995,13 @@ main (void)
while (aggregate_tests[i].test1)
aggregate_test (&aggregate_tests[i++]);
i = 0;
while (reconcile_tests[i].test1)
as4_reconcile_test (&reconcile_tests[i++]);
i = 0;
cmp_test();
i = 0;

157
tests/bgp_capability_test.c
View File

@ -15,8 +15,9 @@
#define VT100_YELLOW "\x1b[33m"
#define OPEN 0
#define DYNCAP 1
#define CAPABILITY 0
#define DYNCAP 1
#define OPT_PARAM 2
/* need these to link in libbgp */
struct zebra_privs_t *bgpd_privs = NULL;
@ -34,7 +35,8 @@ static struct test_segment {
#define SHOULD_PARSE 0
#define SHOULD_ERR -1
int parses; /* whether it should parse or not */
int peek_for; /* what peek_for_as4_capability should say */
/* AFI/SAFI validation */
int validate_afi;
afi_t afi;
@ -76,54 +78,55 @@ static struct test_segment mp_segments[] =
{ "MP4",
"MP IP/Uni",
{ 0x1, 0x4, 0x0, 0x1, 0x0, 0x1 },
6, SHOULD_PARSE, AFI_IP, SAFI_UNICAST,
6, SHOULD_PARSE, 0,
1, AFI_IP, SAFI_UNICAST, VALID_AFI,
},
{ "MPv6",
"MP IPv6/Uni",
{ 0x1, 0x4, 0x0, 0x2, 0x0, 0x1 },
6, SHOULD_PARSE,
6, SHOULD_PARSE, 0,
1, AFI_IP6, SAFI_UNICAST, VALID_AFI,
},
/* 5 */
{ "MP2",
"MP IP/Multicast",
{ CAPABILITY_CODE_MP, 0x4, 0x0, 0x1, 0x0, 0x2 },
6, SHOULD_PARSE,
6, SHOULD_PARSE, 0,
1, AFI_IP, SAFI_MULTICAST, VALID_AFI,
},
/* 6 */
{ "MP3",
"MP IP6/VPNv4",
{ CAPABILITY_CODE_MP, 0x4, 0x0, 0x2, 0x0, 0x80 },
6, SHOULD_PARSE, /* parses, but invalid afi,safi */
6, SHOULD_PARSE, 0, /* parses, but invalid afi,safi */
1, AFI_IP6, BGP_SAFI_VPNV4, INVALID_AFI,
},
/* 7 */
{ "MP5",
"MP IP6/MPLS-VPN",
{ CAPABILITY_CODE_MP, 0x4, 0x0, 0x2, 0x0, 0x4 },
6, SHOULD_PARSE,
6, SHOULD_PARSE, 0,
1, AFI_IP6, SAFI_MPLS_VPN, VALID_AFI,
},
/* 8 */
{ "MP6",
"MP IP4/VPNv4",
{ CAPABILITY_CODE_MP, 0x4, 0x0, 0x1, 0x0, 0x80 },
6, SHOULD_PARSE,
6, SHOULD_PARSE, 0,
1, AFI_IP, BGP_SAFI_VPNV4, VALID_AFI,
},
/* 9 */
{ "MP7",
"MP IP4/VPNv6",
{ CAPABILITY_CODE_MP, 0x4, 0x0, 0x1, 0x0, 0x81 },
6, SHOULD_PARSE, /* parses, but invalid afi,safi tuple */
6, SHOULD_PARSE, 0, /* parses, but invalid afi,safi tuple */
1, AFI_IP, BGP_SAFI_VPNV6, INVALID_AFI,
},
/* 10 */
{ "MP8",
"MP unknown AFI",
{ CAPABILITY_CODE_MP, 0x4, 0x0, 0xa, 0x0, 0x81 },
6, SHOULD_PARSE,
6, SHOULD_PARSE, 0,
1, 0xa, 0x81, INVALID_AFI, /* parses, but unknown */
},
/* 11 */
@ -136,7 +139,7 @@ static struct test_segment mp_segments[] =
{ "MP-overflow",
"MP IP4/Unicast, length too long",
{ CAPABILITY_CODE_MP, 0x6, 0x0, 0x1, 0x0, 0x1 },
6, SHOULD_ERR,
6, SHOULD_ERR, 0,
1, AFI_IP, SAFI_UNICAST, VALID_AFI,
},
{ NULL, NULL, {0}, 0, 0}
@ -290,8 +293,8 @@ static struct test_segment misc_segments[] =
/* 19 */
{ "AS4",
"AS4 capability",
{ 0x41, 0x4, 0xab, 0xcd, 0xef, 0x12 },
6, SHOULD_PARSE,
{ 0x41, 0x4, 0xab, 0xcd, 0xef, 0x12 }, /* AS: 2882400018 */
6, SHOULD_PARSE, 2882400018,
},
/* 20 */
{ "GR",
@ -367,7 +370,7 @@ static struct test_segment misc_segments[] =
{ NULL, NULL, {0}, 0, 0}
};
/* DYNAMIC message */
struct test_segment dynamic_cap_msgs[] =
{
{ "DynCap",
@ -397,18 +400,97 @@ struct test_segment dynamic_cap_msgs[] =
},
{ NULL, NULL, {0}, 0, 0}
};
/* Entire Optional-Parameters block */
struct test_segment opt_params[] =
{
{ "Cap-singlets",
"One capability per Optional-Param",
{ 0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
0x02, 0x02, 0x80, 0x00, /* RR (old) */
0x02, 0x02, 0x02, 0x00, /* RR */
},
24, SHOULD_PARSE,
},
{ "Cap-series",
"Series of capability, one Optional-Param",
{ 0x02, 0x10,
0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
0x80, 0x00, /* RR (old) */
0x02, 0x00, /* RR */
},
18, SHOULD_PARSE,
},
{ "AS4more",
"AS4 capability after other caps (singlets)",
{ 0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
0x02, 0x02, 0x80, 0x00, /* RR (old) */
0x02, 0x02, 0x02, 0x00, /* RR */
0x02, 0x06, 0x41, 0x04, 0x00, 0x03, 0x00, 0x06 /* AS4: 1996614 */
},
32, SHOULD_PARSE, 196614,
},
{ "AS4series",
"AS4 capability, in series of capabilities",
{ 0x02, 0x16,
0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
0x80, 0x00, /* RR (old) */
0x02, 0x00, /* RR */
0x41, 0x04, 0x00, 0x03, 0x00, 0x06 /* AS4: 1996614 */
},
24, SHOULD_PARSE, 196614,
},
{ "AS4real",
"AS4 capability, in series of capabilities",
{
0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/uni */
0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/uni */
0x02, 0x02, 0x80, 0x00, /* RR old */
0x02, 0x02, 0x02, 0x00, /* RR */
0x02, 0x06, 0x41, 0x04, 0x00, 0x03, 0x00, 0x06, /* AS4 */
},
32, SHOULD_PARSE, 196614,
},
{ "AS4real2",
"AS4 capability, in series of capabilities",
{
0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01,
0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01,
0x02, 0x02, 0x80, 0x00,
0x02, 0x02, 0x02, 0x00,
0x02, 0x06, 0x41, 0x04, 0x00, 0x00, 0xfc, 0x03,
0x02, 0x09, 0x82, 0x07, 0x00, 0x01, 0x00, 0x01, 0x01, 0x80, 0x03,
0x02, 0x09, 0x03, 0x07, 0x00, 0x01, 0x00, 0x01, 0x01, 0x40, 0x03,
0x02, 0x02, 0x42, 0x00,
},
58, SHOULD_PARSE, 64515,
},
{ NULL, NULL, {0}, 0, 0}
};
/* basic parsing test */
static void
parse_test (struct peer *peer, struct test_segment *t, int type)
{
int ret;
int capability = 0;
as_t as4 = 0;
int oldfailed = failed;
int len = t->len;
#define RANDOM_FUZZ 35
stream_reset (peer->ibuf);
stream_put (peer->ibuf, NULL, RANDOM_FUZZ);
stream_set_getp (peer->ibuf, RANDOM_FUZZ);
switch (type)
{
case OPEN:
case CAPABILITY:
stream_putc (peer->ibuf, BGP_OPEN_OPT_CAP);
stream_putc (peer->ibuf, t->len);
break;
@ -422,11 +504,20 @@ parse_test (struct peer *peer, struct test_segment *t, int type)
stream_write (peer->ibuf, t->data, t->len);
printf ("%s: %s\n", t->name, t->desc);
switch (type)
{
case OPEN:
ret = bgp_open_option_parse (peer, t->len + 2, &capability);
case CAPABILITY:
len += 2; /* to cover the OPT-Param header */
case OPT_PARAM:
printf ("len: %u\n", len);
/* peek_for_as4 wants getp at capibility*/
as4 = peek_for_as4_capability (peer, len);
printf ("peek_for_as4: as4 is %u\n", as4);
/* and it should leave getp as it found it */
assert (stream_get_getp (peer->ibuf) == RANDOM_FUZZ);
ret = bgp_open_option_parse (peer, len, &capability);
break;
case DYNCAP:
ret = bgp_capability_receive (peer, t->len);
@ -458,18 +549,27 @@ parse_test (struct peer *peer, struct test_segment *t, int type)
}
}
if (as4 != t->peek_for)
{
printf ("as4 %u != %u\n", as4, t->peek_for);
failed++;
}
printf ("parsed?: %s\n", ret ? "no" : "yes");
if (ret != t->parses)
failed++;
if (tty)
printf ("%s\n", (failed > oldfailed) ? VT100_RED "failed!" VT100_RESET
printf ("%s", (failed > oldfailed) ? VT100_RED "failed!" VT100_RESET
: VT100_GREEN "OK" VT100_RESET);
else
printf ("%s\n", (failed > oldfailed) ? "failed!" : "OK" );
printf ("%s", (failed > oldfailed) ? "failed!" : "OK" );
printf ("\n");
if (failed)
printf (" (%u)", failed);
printf ("\n\n");
}
static struct bgp *bgp;
@ -485,10 +585,12 @@ main (void)
conf_bgp_debug_events = -1UL;
conf_bgp_debug_packet = -1UL;
conf_bgp_debug_normal = -1UL;
conf_bgp_debug_as4 = -1UL;
term_bgp_debug_fsm = -1UL;
term_bgp_debug_events = -1UL;
term_bgp_debug_packet = -1UL;
term_bgp_debug_normal = -1UL;
term_bgp_debug_as4 = -1UL;
master = thread_master_create ();
bgp_master_init ();
@ -500,6 +602,7 @@ main (void)
return -1;
peer = peer_create_accept (bgp);
peer->host = "foo";
for (i = AFI_IP; i < AFI_MAX; i++)
for (j = SAFI_UNICAST; j < SAFI_MAX; j++)
@ -510,18 +613,22 @@ main (void)
i = 0;
while (mp_segments[i].name)
parse_test (peer, &mp_segments[i++], OPEN);
parse_test (peer, &mp_segments[i++], CAPABILITY);
/* These tests assume mp_segments tests set at least
* one of the afc_nego's
*/
i = 0;
while (test_segments[i].name)
parse_test (peer, &test_segments[i++], OPEN);
parse_test (peer, &test_segments[i++], CAPABILITY);
i = 0;
while (misc_segments[i].name)
parse_test (peer, &misc_segments[i++], OPEN);
parse_test (peer, &misc_segments[i++], CAPABILITY);
i = 0;
while (opt_params[i].name)
parse_test (peer, &opt_params[i++], OPT_PARAM);
SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV);
peer->status = Established;

5
vtysh/ChangeLog
View File

@ -18,6 +18,11 @@
precision commands: send to all daemons.
(vtysh_init_vty) Install new log timestamp precision commands.
2007-02-12 Juergen Kammer <j.kammer@eurodata.de>
* extract.pl: AS4 compatibility for router bgp ASNUMBER
* extract.pl.in: AS4 compatibility for router bgp ASNUMBER
* vtysh.c: AS4 compatibility for router bgp ASNUMBER
2006-07-27 Andrew J. Schorr <ajschorr@alumni.princeton.edu>
* vtysh_main.c: (usage) Add new -d and -E options. And note that

4
vtysh/extract.pl.in
View File

@ -37,8 +37,8 @@ $ignore{'"router ripng"'} = "ignore";
$ignore{'"router ospf"'} = "ignore";
$ignore{'"router ospf <0-65535>"'} = "ignore";
$ignore{'"router ospf6"'} = "ignore";
$ignore{'"router bgp <1-65535>"'} = "ignore";
$ignore{'"router bgp <1-65535> view WORD"'} = "ignore";
$ignore{'"router bgp CMD_AS_RANGE"'} = "ignore";
$ignore{'"router bgp CMD_AS_RANGE view WORD"'} = "ignore";
$ignore{'"router isis WORD"'} = "ignore";
$ignore{'"router zebra"'} = "ignore";
$ignore{'"address-family ipv4"'} = "ignore";

2
vtysh/vtysh.c
View File

@ -838,7 +838,7 @@ DEFUNSH (VTYSH_ALL,
DEFUNSH (VTYSH_BGPD,
router_bgp,
router_bgp_cmd,
"router bgp <1-65535>",
"router bgp CMD_AS_RANGE",
ROUTER_STR
BGP_STR
AS_STR)