proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-05-28 16:06:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
0b2aa3a0a8
mirror_frr/bgpd/bgp_debug.c
Paul Jakma 0b2aa3a0a8 [bgpd] Merge AS4 support 
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
2007-10-14 22:32:21 +00:00

933 lines
25 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* BGP-4, BGP-4+ packet debug routine
Copyright (C) 1996, 97, 99 Kunihiro Ishiguro
This file is part of GNU Zebra.
GNU Zebra is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
GNU Zebra is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Zebra; see the file COPYING. If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#include <zebra.h>
#include <lib/version.h>
#include "prefix.h"
#include "linklist.h"
#include "stream.h"
#include "command.h"
#include "str.h"
#include "log.h"
#include "sockunion.h"
#include "bgpd/bgpd.h"
#include "bgpd/bgp_aspath.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_attr.h"
#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;
unsigned long conf_bgp_debug_filter;
unsigned long conf_bgp_debug_keepalive;
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;
unsigned long term_bgp_debug_filter;
unsigned long term_bgp_debug_keepalive;
unsigned long term_bgp_debug_update;
unsigned long term_bgp_debug_normal;
unsigned long term_bgp_debug_zebra;
/* messages for BGP-4 status */
struct message bgp_status_msg[] =
{
{ 0, "null" },
{ Idle, "Idle" },
{ Connect, "Connect" },
{ Active, "Active" },
{ OpenSent, "OpenSent" },
{ OpenConfirm, "OpenConfirm" },
{ Established, "Established" },
{ Clearing, "Clearing" },
{ Deleted, "Deleted" },
};
int bgp_status_msg_max = BGP_STATUS_MAX;
/* BGP message type string. */
const char *bgp_type_str[] =
{
NULL,
"OPEN",
"UPDATE",
"NOTIFICATION",
"KEEPALIVE",
"ROUTE-REFRESH",
"CAPABILITY"
};
/* message for BGP-4 Notify */
struct message bgp_notify_msg[] =
{
{ 0, "" },
{ BGP_NOTIFY_HEADER_ERR, "Message Header Error"},
{ BGP_NOTIFY_OPEN_ERR, "OPEN Message Error"},
{ BGP_NOTIFY_UPDATE_ERR, "UPDATE Message Error"},
{ BGP_NOTIFY_HOLD_ERR, "Hold Timer Expired"},
{ BGP_NOTIFY_FSM_ERR, "Finite State Machine Error"},
{ BGP_NOTIFY_CEASE, "Cease"},
{ BGP_NOTIFY_CAPABILITY_ERR, "CAPABILITY Message Error"},
};
int bgp_notify_msg_max = BGP_NOTIFY_MAX;
struct message bgp_notify_head_msg[] =
{
{ 0, "null"},
{ BGP_NOTIFY_HEADER_NOT_SYNC, "/Connection Not Synchronized"},
{ BGP_NOTIFY_HEADER_BAD_MESLEN, "/Bad Message Length"},
{ BGP_NOTIFY_HEADER_BAD_MESTYPE, "/Bad Message Type"}
};
int bgp_notify_head_msg_max = BGP_NOTIFY_HEADER_MAX;
struct message bgp_notify_open_msg[] =
{
{ 0, "null" },
{ BGP_NOTIFY_OPEN_UNSUP_VERSION, "/Unsupported Version Number" },
{ BGP_NOTIFY_OPEN_BAD_PEER_AS, "/Bad Peer AS"},
{ BGP_NOTIFY_OPEN_BAD_BGP_IDENT, "/Bad BGP Identifier"},
{ BGP_NOTIFY_OPEN_UNSUP_PARAM, "/Unsupported Optional Parameter"},
{ BGP_NOTIFY_OPEN_AUTH_FAILURE, "/Authentication Failure"},
{ BGP_NOTIFY_OPEN_UNACEP_HOLDTIME, "/Unacceptable Hold Time"},
{ BGP_NOTIFY_OPEN_UNSUP_CAPBL, "/Unsupported Capability"},
};
int bgp_notify_open_msg_max = BGP_NOTIFY_OPEN_MAX;
struct message bgp_notify_update_msg[] =
{
{ 0, "null"},
{ BGP_NOTIFY_UPDATE_MAL_ATTR, "/Malformed Attribute List"},
{ BGP_NOTIFY_UPDATE_UNREC_ATTR, "/Unrecognized Well-known Attribute"},
{ BGP_NOTIFY_UPDATE_MISS_ATTR, "/Missing Well-known Attribute"},
{ BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR, "/Attribute Flags Error"},
{ BGP_NOTIFY_UPDATE_ATTR_LENG_ERR, "/Attribute Length Error"},
{ BGP_NOTIFY_UPDATE_INVAL_ORIGIN, "/Invalid ORIGIN Attribute"},
{ BGP_NOTIFY_UPDATE_AS_ROUTE_LOOP, "/AS Routing Loop"},
{ BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP, "/Invalid NEXT_HOP Attribute"},
{ BGP_NOTIFY_UPDATE_OPT_ATTR_ERR, "/Optional Attribute Error"},
{ BGP_NOTIFY_UPDATE_INVAL_NETWORK, "/Invalid Network Field"},
{ BGP_NOTIFY_UPDATE_MAL_AS_PATH, "/Malformed AS_PATH"},
};
int bgp_notify_update_msg_max = BGP_NOTIFY_UPDATE_MAX;
struct message bgp_notify_cease_msg[] =
{
{ 0, ""},
{ BGP_NOTIFY_CEASE_MAX_PREFIX, "/Maximum Number of Prefixes Reached"},
{ BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN, "/Administratively Shutdown"},
{ BGP_NOTIFY_CEASE_PEER_UNCONFIG, "/Peer Unconfigured"},
{ BGP_NOTIFY_CEASE_ADMIN_RESET, "/Administratively Reset"},
{ BGP_NOTIFY_CEASE_CONNECT_REJECT, "/Connection Rejected"},
{ BGP_NOTIFY_CEASE_CONFIG_CHANGE, "/Other Configuration Change"},
{ BGP_NOTIFY_CEASE_COLLISION_RESOLUTION, "/Connection collision resolution"},
{ BGP_NOTIFY_CEASE_OUT_OF_RESOURCE, "/Out of Resource"},
};
int bgp_notify_cease_msg_max = BGP_NOTIFY_CEASE_MAX;
struct message bgp_notify_capability_msg[] =
{
{ 0, "null" },
{ BGP_NOTIFY_CAPABILITY_INVALID_ACTION, "/Invalid Action Value" },
{ BGP_NOTIFY_CAPABILITY_INVALID_LENGTH, "/Invalid Capability Length"},
{ BGP_NOTIFY_CAPABILITY_MALFORMED_CODE, "/Malformed Capability Value"},
};
int bgp_notify_capability_msg_max = BGP_NOTIFY_CAPABILITY_MAX;
/* Origin strings. */
const char *bgp_origin_str[] = {"i","e","?"};
const char *bgp_origin_long_str[] = {"IGP","EGP","incomplete"};
/* Dump attribute. */
int
bgp_dump_attr (struct peer *peer, struct attr *attr, char *buf, size_t size)
{
if (! attr)
return 0;
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP)))
snprintf (buf, size, "nexthop %s", inet_ntoa (attr->nexthop));
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGIN)))
snprintf (buf + strlen (buf), size - strlen (buf), ", origin %s",
bgp_origin_str[attr->origin]);
#ifdef HAVE_IPV6
if (attr->extra)
{
char addrbuf[BUFSIZ];
/* Add MP case. */
if (attr->extra->mp_nexthop_len == 16
|| attr->extra->mp_nexthop_len == 32)
snprintf (buf + strlen (buf), size - strlen (buf), ", mp_nexthop %s",
inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global,
addrbuf, BUFSIZ));
if (attr->extra->mp_nexthop_len == 32)
snprintf (buf + strlen (buf), size - strlen (buf), "(%s)",
inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local,
addrbuf, BUFSIZ));
}
#endif /* HAVE_IPV6 */
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF)))
snprintf (buf + strlen (buf), size - strlen (buf), ", localpref %d",
attr->local_pref);
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC)))
snprintf (buf + strlen (buf), size - strlen (buf), ", metric %d",
attr->med);
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES)))
snprintf (buf + strlen (buf), size - strlen (buf), ", community %s",
community_str (attr->community));
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE)))
snprintf (buf + strlen (buf), size - strlen (buf), ", atomic-aggregate");
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR)))
snprintf (buf + strlen (buf), size - strlen (buf), ", aggregated by %d %s",
attr->extra->aggregator_as,
inet_ntoa (attr->extra->aggregator_addr));
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID)))
snprintf (buf + strlen (buf), size - strlen (buf), ", originator %s",
inet_ntoa (attr->extra->originator_id));
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST)))
{
int i;
snprintf (buf + strlen (buf), size - strlen (buf), ", clusterlist");
for (i = 0; i < attr->extra->cluster->length / 4; i++)
snprintf (buf + strlen (buf), size - strlen (buf), " %s",
inet_ntoa (attr->extra->cluster->list[i]));
}
if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH)))
snprintf (buf + strlen (buf), size - strlen (buf), ", path %s",
aspath_print (attr->aspath));
if (strlen (buf) > 1)
return 1;
else
return 0;
}
/* dump notify packet */
void
bgp_notify_print(struct peer *peer, struct bgp_notify *bgp_notify,
const char *direct)
{
const char *subcode_str;
subcode_str = "";
switch (bgp_notify->code)
{
case BGP_NOTIFY_HEADER_ERR:
subcode_str = LOOKUP (bgp_notify_head_msg, bgp_notify->subcode);
break;
case BGP_NOTIFY_OPEN_ERR:
subcode_str = LOOKUP (bgp_notify_open_msg, bgp_notify->subcode);
break;
case BGP_NOTIFY_UPDATE_ERR:
subcode_str = LOOKUP (bgp_notify_update_msg, bgp_notify->subcode);
break;
case BGP_NOTIFY_HOLD_ERR:
subcode_str = "";
break;
case BGP_NOTIFY_FSM_ERR:
subcode_str = "";
break;
case BGP_NOTIFY_CEASE:
subcode_str = LOOKUP (bgp_notify_cease_msg, bgp_notify->subcode);
break;
case BGP_NOTIFY_CAPABILITY_ERR:
subcode_str = LOOKUP (bgp_notify_capability_msg, bgp_notify->subcode);
break;
}
if (bgp_flag_check (peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
zlog_info ("%%NOTIFICATION: %s neighbor %s %d/%d (%s%s) %d bytes %s",
strcmp (direct, "received") == 0 ? "received from" : "sent to",
peer->host, bgp_notify->code, bgp_notify->subcode,
LOOKUP (bgp_notify_msg, bgp_notify->code),
subcode_str, bgp_notify->length,
bgp_notify->data ? bgp_notify->data : "");
else if (BGP_DEBUG (normal, NORMAL))
plog_debug (peer->log, "%s %s NOTIFICATION %d/%d (%s%s) %d bytes %s",
peer ? peer->host : "",
direct, bgp_notify->code, bgp_notify->subcode,
LOOKUP (bgp_notify_msg, bgp_notify->code),
subcode_str, bgp_notify->length,
bgp_notify->data ? bgp_notify->data : "");
}
/* Debug option setting interface. */
unsigned long bgp_debug_option = 0;
int
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",
DEBUG_STR
BGP_STR
"BGP Finite State Machine\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (fsm, FSM);
else
{
TERM_DEBUG_ON (fsm, FSM);
vty_out (vty, "BGP fsm debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_fsm,
no_debug_bgp_fsm_cmd,
"no debug bgp fsm",
NO_STR
DEBUG_STR
BGP_STR
"Finite State Machine\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (fsm, FSM);
else
{
TERM_DEBUG_OFF (fsm, FSM);
vty_out (vty, "BGP fsm debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_fsm,
undebug_bgp_fsm_cmd,
"undebug bgp fsm",
UNDEBUG_STR
DEBUG_STR
BGP_STR
"Finite State Machine\n")
DEFUN (debug_bgp_events,
debug_bgp_events_cmd,
"debug bgp events",
DEBUG_STR
BGP_STR
"BGP events\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (events, EVENTS);
else
{
TERM_DEBUG_ON (events, EVENTS);
vty_out (vty, "BGP events debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_events,
no_debug_bgp_events_cmd,
"no debug bgp events",
NO_STR
DEBUG_STR
BGP_STR
"BGP events\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (events, EVENTS);
else
{
TERM_DEBUG_OFF (events, EVENTS);
vty_out (vty, "BGP events debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_events,
undebug_bgp_events_cmd,
"undebug bgp events",
UNDEBUG_STR
BGP_STR
"BGP events\n")
DEFUN (debug_bgp_filter,
debug_bgp_filter_cmd,
"debug bgp filters",
DEBUG_STR
BGP_STR
"BGP filters\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (filter, FILTER);
else
{
TERM_DEBUG_ON (filter, FILTER);
vty_out (vty, "BGP filters debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_filter,
no_debug_bgp_filter_cmd,
"no debug bgp filters",
NO_STR
DEBUG_STR
BGP_STR
"BGP filters\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (filter, FILTER);
else
{
TERM_DEBUG_OFF (filter, FILTER);
vty_out (vty, "BGP filters debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_filter,
undebug_bgp_filter_cmd,
"undebug bgp filters",
UNDEBUG_STR
BGP_STR
"BGP filters\n")
DEFUN (debug_bgp_keepalive,
debug_bgp_keepalive_cmd,
"debug bgp keepalives",
DEBUG_STR
BGP_STR
"BGP keepalives\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (keepalive, KEEPALIVE);
else
{
TERM_DEBUG_ON (keepalive, KEEPALIVE);
vty_out (vty, "BGP keepalives debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_keepalive,
no_debug_bgp_keepalive_cmd,
"no debug bgp keepalives",
NO_STR
DEBUG_STR
BGP_STR
"BGP keepalives\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (keepalive, KEEPALIVE);
else
{
TERM_DEBUG_OFF (keepalive, KEEPALIVE);
vty_out (vty, "BGP keepalives debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_keepalive,
undebug_bgp_keepalive_cmd,
"undebug bgp keepalives",
UNDEBUG_STR
BGP_STR
"BGP keepalives\n")
DEFUN (debug_bgp_update,
debug_bgp_update_cmd,
"debug bgp updates",
DEBUG_STR
BGP_STR
"BGP updates\n")
{
if (vty->node == CONFIG_NODE)
{
DEBUG_ON (update, UPDATE_IN);
DEBUG_ON (update, UPDATE_OUT);
}
else
{
TERM_DEBUG_ON (update, UPDATE_IN);
TERM_DEBUG_ON (update, UPDATE_OUT);
vty_out (vty, "BGP updates debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (debug_bgp_update_direct,
debug_bgp_update_direct_cmd,
"debug bgp updates (in|out)",
DEBUG_STR
BGP_STR
"BGP updates\n"
"Inbound updates\n"
"Outbound updates\n")
{
if (vty->node == CONFIG_NODE)
{
if (strncmp ("i", argv[0], 1) == 0)
{
DEBUG_OFF (update, UPDATE_OUT);
DEBUG_ON (update, UPDATE_IN);
}
else
{
DEBUG_OFF (update, UPDATE_IN);
DEBUG_ON (update, UPDATE_OUT);
}
}
else
{
if (strncmp ("i", argv[0], 1) == 0)
{
TERM_DEBUG_OFF (update, UPDATE_OUT);
TERM_DEBUG_ON (update, UPDATE_IN);
vty_out (vty, "BGP updates debugging is on (inbound)%s", VTY_NEWLINE);
}
else
{
TERM_DEBUG_OFF (update, UPDATE_IN);
TERM_DEBUG_ON (update, UPDATE_OUT);
vty_out (vty, "BGP updates debugging is on (outbound)%s", VTY_NEWLINE);
}
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_update,
no_debug_bgp_update_cmd,
"no debug bgp updates",
NO_STR
DEBUG_STR
BGP_STR
"BGP updates\n")
{
if (vty->node == CONFIG_NODE)
{
DEBUG_OFF (update, UPDATE_IN);
DEBUG_OFF (update, UPDATE_OUT);
}
else
{
TERM_DEBUG_OFF (update, UPDATE_IN);
TERM_DEBUG_OFF (update, UPDATE_OUT);
vty_out (vty, "BGP updates debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_update,
undebug_bgp_update_cmd,
"undebug bgp updates",
UNDEBUG_STR
BGP_STR
"BGP updates\n")
DEFUN (debug_bgp_normal,
debug_bgp_normal_cmd,
"debug bgp",
DEBUG_STR
BGP_STR)
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (normal, NORMAL);
else
{
TERM_DEBUG_ON (normal, NORMAL);
vty_out (vty, "BGP debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_normal,
no_debug_bgp_normal_cmd,
"no debug bgp",
NO_STR
DEBUG_STR
BGP_STR)
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (normal, NORMAL);
else
{
TERM_DEBUG_OFF (normal, NORMAL);
vty_out (vty, "BGP debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_normal,
undebug_bgp_normal_cmd,
"undebug bgp",
UNDEBUG_STR
BGP_STR)
DEFUN (debug_bgp_zebra,
debug_bgp_zebra_cmd,
"debug bgp zebra",
DEBUG_STR
BGP_STR
"BGP Zebra messages\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_ON (zebra, ZEBRA);
else
{
TERM_DEBUG_ON (zebra, ZEBRA);
vty_out (vty, "BGP zebra debugging is on%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
DEFUN (no_debug_bgp_zebra,
no_debug_bgp_zebra_cmd,
"no debug bgp zebra",
NO_STR
DEBUG_STR
BGP_STR
"BGP Zebra messages\n")
{
if (vty->node == CONFIG_NODE)
DEBUG_OFF (zebra, ZEBRA);
else
{
TERM_DEBUG_OFF (zebra, ZEBRA);
vty_out (vty, "BGP zebra debugging is off%s", VTY_NEWLINE);
}
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_zebra,
undebug_bgp_zebra_cmd,
"undebug bgp zebra",
UNDEBUG_STR
DEBUG_STR
BGP_STR
"BGP Zebra messages\n")
DEFUN (no_debug_bgp_all,
no_debug_bgp_all_cmd,
"no debug all bgp",
NO_STR
DEBUG_STR
"Enable all debugging\n"
BGP_STR)
{
TERM_DEBUG_OFF (normal, NORMAL);
TERM_DEBUG_OFF (events, EVENTS);
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);
vty_out (vty, "All possible debugging has been turned off%s", VTY_NEWLINE);
return CMD_SUCCESS;
}
ALIAS (no_debug_bgp_all,
undebug_bgp_all_cmd,
"undebug all bgp",
UNDEBUG_STR
"Enable all debugging\n"
BGP_STR)
DEFUN (show_debugging_bgp,
show_debugging_bgp_cmd,
"show debugging bgp",
SHOW_STR
DEBUG_STR
BGP_STR)
{
vty_out (vty, "BGP debugging status:%s", VTY_NEWLINE);
if (BGP_DEBUG (normal, NORMAL))
vty_out (vty, " BGP debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (events, EVENTS))
vty_out (vty, " BGP events debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (keepalive, KEEPALIVE))
vty_out (vty, " BGP keepalives debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (update, UPDATE_IN) && BGP_DEBUG (update, UPDATE_OUT))
vty_out (vty, " BGP updates debugging is on%s", VTY_NEWLINE);
else if (BGP_DEBUG (update, UPDATE_IN))
vty_out (vty, " BGP updates debugging is on (inbound)%s", VTY_NEWLINE);
else if (BGP_DEBUG (update, UPDATE_OUT))
vty_out (vty, " BGP updates debugging is on (outbound)%s", VTY_NEWLINE);
if (BGP_DEBUG (fsm, FSM))
vty_out (vty, " BGP fsm debugging is on%s", VTY_NEWLINE);
if (BGP_DEBUG (filter, FILTER))
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;
}
static int
bgp_config_write_debug (struct vty *vty)
{
int write = 0;
if (CONF_BGP_DEBUG (normal, NORMAL))
{
vty_out (vty, "debug bgp%s", VTY_NEWLINE);
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);
write++;
}
if (CONF_BGP_DEBUG (keepalive, KEEPALIVE))
{
vty_out (vty, "debug bgp keepalives%s", VTY_NEWLINE);
write++;
}
if (CONF_BGP_DEBUG (update, UPDATE_IN) && CONF_BGP_DEBUG (update, UPDATE_OUT))
{
vty_out (vty, "debug bgp updates%s", VTY_NEWLINE);
write++;
}
else if (CONF_BGP_DEBUG (update, UPDATE_IN))
{
vty_out (vty, "debug bgp updates in%s", VTY_NEWLINE);
write++;
}
else if (CONF_BGP_DEBUG (update, UPDATE_OUT))
{
vty_out (vty, "debug bgp updates out%s", VTY_NEWLINE);
write++;
}
if (CONF_BGP_DEBUG (fsm, FSM))
{
vty_out (vty, "debug bgp fsm%s", VTY_NEWLINE);
write++;
}
if (CONF_BGP_DEBUG (filter, FILTER))
{
vty_out (vty, "debug bgp filters%s", VTY_NEWLINE);
write++;
}
if (CONF_BGP_DEBUG (zebra, ZEBRA))
{
vty_out (vty, "debug bgp zebra%s", VTY_NEWLINE);
write++;
}
return write;
}
struct cmd_node debug_node =
{
DEBUG_NODE,
"",
1
};
void
bgp_debug_init (void)
{
install_node (&debug_node, bgp_config_write_debug);
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);
install_element (CONFIG_NODE, &debug_bgp_events_cmd);
install_element (ENABLE_NODE, &debug_bgp_filter_cmd);
install_element (CONFIG_NODE, &debug_bgp_filter_cmd);
install_element (ENABLE_NODE, &debug_bgp_keepalive_cmd);
install_element (CONFIG_NODE, &debug_bgp_keepalive_cmd);
install_element (ENABLE_NODE, &debug_bgp_update_cmd);
install_element (CONFIG_NODE, &debug_bgp_update_cmd);
install_element (ENABLE_NODE, &debug_bgp_update_direct_cmd);
install_element (CONFIG_NODE, &debug_bgp_update_direct_cmd);
install_element (ENABLE_NODE, &debug_bgp_normal_cmd);
install_element (CONFIG_NODE, &debug_bgp_normal_cmd);
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);
install_element (ENABLE_NODE, &no_debug_bgp_events_cmd);
install_element (ENABLE_NODE, &undebug_bgp_events_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_events_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_filter_cmd);
install_element (ENABLE_NODE, &undebug_bgp_filter_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_filter_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_keepalive_cmd);
install_element (ENABLE_NODE, &undebug_bgp_keepalive_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_keepalive_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_update_cmd);
install_element (ENABLE_NODE, &undebug_bgp_update_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_update_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_normal_cmd);
install_element (ENABLE_NODE, &undebug_bgp_normal_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_normal_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_zebra_cmd);
install_element (ENABLE_NODE, &undebug_bgp_zebra_cmd);
install_element (CONFIG_NODE, &no_debug_bgp_zebra_cmd);
install_element (ENABLE_NODE, &no_debug_bgp_all_cmd);
install_element (ENABLE_NODE, &undebug_bgp_all_cmd);
}
Reference in New Issue View Git Blame Copy Permalink