]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - bgpd/bgp_debug.c
Import Upstream version 1.2.2
[quagga-debian.git] / bgpd / bgp_debug.c
1 /* BGP-4, BGP-4+ packet debug routine
2    Copyright (C) 1996, 97, 99 Kunihiro Ishiguro
3
4 This file is part of GNU Zebra.
5
6 GNU Zebra is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
9 later version.
10
11 GNU Zebra is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Zebra; see the file COPYING.  If not, write to the Free
18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, USA.  */
20
21 #include <zebra.h>
22
23 #include <lib/version.h>
24 #include "prefix.h"
25 #include "linklist.h"
26 #include "stream.h"
27 #include "command.h"
28 #include "str.h"
29 #include "log.h"
30 #include "sockunion.h"
31 #include "filter.h"
32
33 #include "bgpd/bgpd.h"
34 #include "bgpd/bgp_aspath.h"
35 #include "bgpd/bgp_route.h"
36 #include "bgpd/bgp_attr.h"
37 #include "bgpd/bgp_debug.h"
38 #include "bgpd/bgp_community.h"
39
40 unsigned long conf_bgp_debug_as4;
41 unsigned long conf_bgp_debug_fsm;
42 unsigned long conf_bgp_debug_events;
43 unsigned long conf_bgp_debug_packet;
44 unsigned long conf_bgp_debug_filter;
45 unsigned long conf_bgp_debug_keepalive;
46 unsigned long conf_bgp_debug_update;
47 unsigned long conf_bgp_debug_normal;
48 unsigned long conf_bgp_debug_zebra;
49 unsigned long conf_bgp_debug_allow_martians;
50 unsigned long conf_bgp_debug_nht;
51
52 unsigned long term_bgp_debug_as4;
53 unsigned long term_bgp_debug_fsm;
54 unsigned long term_bgp_debug_events;
55 unsigned long term_bgp_debug_packet;
56 unsigned long term_bgp_debug_filter;
57 unsigned long term_bgp_debug_keepalive;
58 unsigned long term_bgp_debug_update;
59 unsigned long term_bgp_debug_normal;
60 unsigned long term_bgp_debug_zebra;
61 unsigned long term_bgp_debug_allow_martians;
62 unsigned long term_bgp_debug_nht;
63
64 /* messages for BGP-4 status */
65 const struct message bgp_status_msg[] = 
66 {
67   { Idle, "Idle" },
68   { Connect, "Connect" },
69   { Active, "Active" },
70   { OpenSent, "OpenSent" },
71   { OpenConfirm, "OpenConfirm" },
72   { Established, "Established" },
73   { Clearing,    "Clearing"    },
74   { Deleted,     "Deleted"     },
75 };
76 const int bgp_status_msg_max = BGP_STATUS_MAX;
77
78 /* BGP message type string. */
79 const char *bgp_type_str[] =
80 {
81   NULL,
82   "OPEN",
83   "UPDATE",
84   "NOTIFICATION",
85   "KEEPALIVE",
86   "ROUTE-REFRESH",
87   "CAPABILITY"
88 };
89
90 /* message for BGP-4 Notify */
91 static const struct message bgp_notify_msg[] = 
92 {
93   { BGP_NOTIFY_HEADER_ERR, "Message Header Error"},
94   { BGP_NOTIFY_OPEN_ERR, "OPEN Message Error"},
95   { BGP_NOTIFY_UPDATE_ERR, "UPDATE Message Error"},
96   { BGP_NOTIFY_HOLD_ERR, "Hold Timer Expired"},
97   { BGP_NOTIFY_FSM_ERR, "Finite State Machine Error"},
98   { BGP_NOTIFY_CEASE, "Cease"},
99   { BGP_NOTIFY_CAPABILITY_ERR, "CAPABILITY Message Error"},
100 };
101 static const int bgp_notify_msg_max = BGP_NOTIFY_MAX;
102
103 static const struct message bgp_notify_head_msg[] = 
104 {
105   { BGP_NOTIFY_HEADER_NOT_SYNC, "/Connection Not Synchronized"},
106   { BGP_NOTIFY_HEADER_BAD_MESLEN, "/Bad Message Length"},
107   { BGP_NOTIFY_HEADER_BAD_MESTYPE, "/Bad Message Type"}
108 };
109 static const int bgp_notify_head_msg_max = BGP_NOTIFY_HEADER_MAX;
110
111 static const struct message bgp_notify_open_msg[] = 
112 {
113   { BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
114   { BGP_NOTIFY_OPEN_UNSUP_VERSION, "/Unsupported Version Number" },
115   { BGP_NOTIFY_OPEN_BAD_PEER_AS, "/Bad Peer AS"},
116   { BGP_NOTIFY_OPEN_BAD_BGP_IDENT, "/Bad BGP Identifier"},
117   { BGP_NOTIFY_OPEN_UNSUP_PARAM, "/Unsupported Optional Parameter"},
118   { BGP_NOTIFY_OPEN_AUTH_FAILURE, "/Authentication Failure"},
119   { BGP_NOTIFY_OPEN_UNACEP_HOLDTIME, "/Unacceptable Hold Time"}, 
120   { BGP_NOTIFY_OPEN_UNSUP_CAPBL, "/Unsupported Capability"},
121 };
122 static const int bgp_notify_open_msg_max = BGP_NOTIFY_OPEN_MAX;
123
124 static const struct message bgp_notify_update_msg[] = 
125 {
126   { BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
127   { BGP_NOTIFY_UPDATE_MAL_ATTR, "/Malformed Attribute List"},
128   { BGP_NOTIFY_UPDATE_UNREC_ATTR, "/Unrecognized Well-known Attribute"},
129   { BGP_NOTIFY_UPDATE_MISS_ATTR, "/Missing Well-known Attribute"},
130   { BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR, "/Attribute Flags Error"},
131   { BGP_NOTIFY_UPDATE_ATTR_LENG_ERR, "/Attribute Length Error"},
132   { BGP_NOTIFY_UPDATE_INVAL_ORIGIN, "/Invalid ORIGIN Attribute"},
133   { BGP_NOTIFY_UPDATE_AS_ROUTE_LOOP, "/AS Routing Loop"},
134   { BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP, "/Invalid NEXT_HOP Attribute"},
135   { BGP_NOTIFY_UPDATE_OPT_ATTR_ERR, "/Optional Attribute Error"},
136   { BGP_NOTIFY_UPDATE_INVAL_NETWORK, "/Invalid Network Field"},
137   { BGP_NOTIFY_UPDATE_MAL_AS_PATH, "/Malformed AS_PATH"},
138 };
139 static const int bgp_notify_update_msg_max = BGP_NOTIFY_UPDATE_MAX;
140
141 static const struct message bgp_notify_cease_msg[] =
142 {
143   { BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
144   { BGP_NOTIFY_CEASE_MAX_PREFIX, "/Maximum Number of Prefixes Reached"},
145   { BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN, "/Administratively Shutdown"},
146   { BGP_NOTIFY_CEASE_PEER_UNCONFIG, "/Peer Unconfigured"},
147   { BGP_NOTIFY_CEASE_ADMIN_RESET, "/Administratively Reset"},
148   { BGP_NOTIFY_CEASE_CONNECT_REJECT, "/Connection Rejected"},
149   { BGP_NOTIFY_CEASE_CONFIG_CHANGE, "/Other Configuration Change"},
150   { BGP_NOTIFY_CEASE_COLLISION_RESOLUTION, "/Connection collision resolution"},
151   { BGP_NOTIFY_CEASE_OUT_OF_RESOURCE, "/Out of Resource"},
152 };
153 static const int bgp_notify_cease_msg_max = BGP_NOTIFY_CEASE_MAX;
154
155 static const struct message bgp_notify_capability_msg[] = 
156 {
157   { BGP_NOTIFY_SUBCODE_UNSPECIFIC, "/Unspecific"},
158   { BGP_NOTIFY_CAPABILITY_INVALID_ACTION, "/Invalid Action Value" },
159   { BGP_NOTIFY_CAPABILITY_INVALID_LENGTH, "/Invalid Capability Length"},
160   { BGP_NOTIFY_CAPABILITY_MALFORMED_CODE, "/Malformed Capability Value"},
161 };
162 static const int bgp_notify_capability_msg_max = BGP_NOTIFY_CAPABILITY_MAX;
163
164 /* Origin strings. */
165 const char *bgp_origin_str[] = {"i","e","?"};
166 const char *bgp_origin_long_str[] = {"IGP","EGP","incomplete"};
167
168 /* Dump attribute. */
169 int
170 bgp_dump_attr (struct peer *peer, struct attr *attr, char *buf, size_t size)
171 {
172   if (! attr)
173     return 0;
174
175   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP)))
176     snprintf (buf, size, "nexthop %s", inet_ntoa (attr->nexthop));
177
178   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGIN)))
179     snprintf (buf + strlen (buf), size - strlen (buf), ", origin %s",
180               bgp_origin_str[attr->origin]);
181
182   if (attr->extra)
183     {
184       char addrbuf[BUFSIZ];
185
186       /* Add MP case. */
187       if (attr->extra->mp_nexthop_len == 16 
188           || attr->extra->mp_nexthop_len == 32)
189         snprintf (buf + strlen (buf), size - strlen (buf), ", mp_nexthop %s",
190                   inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, 
191                              addrbuf, BUFSIZ));
192
193       if (attr->extra->mp_nexthop_len == 32)
194         snprintf (buf + strlen (buf), size - strlen (buf), "(%s)",
195                   inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local, 
196                              addrbuf, BUFSIZ));
197     }
198
199   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF)))
200     snprintf (buf + strlen (buf), size - strlen (buf), ", localpref %u",
201               attr->local_pref);
202
203   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))) 
204     snprintf (buf + strlen (buf), size - strlen (buf), ", metric %u",
205               attr->med);
206
207   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES))) 
208     snprintf (buf + strlen (buf), size - strlen (buf), ", community %s",
209               community_str (attr->community));
210
211   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE)))
212     snprintf (buf + strlen (buf), size - strlen (buf), ", atomic-aggregate");
213
214   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR)))
215     snprintf (buf + strlen (buf), size - strlen (buf), ", aggregated by %u %s",
216               attr->extra->aggregator_as,
217               inet_ntoa (attr->extra->aggregator_addr));
218
219   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID)))
220     snprintf (buf + strlen (buf), size - strlen (buf), ", originator %s",
221               inet_ntoa (attr->extra->originator_id));
222
223   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST)))
224     {
225       int i;
226
227       snprintf (buf + strlen (buf), size - strlen (buf), ", clusterlist");
228       for (i = 0; i < attr->extra->cluster->length / 4; i++)
229         snprintf (buf + strlen (buf), size - strlen (buf), " %s",
230                   inet_ntoa (attr->extra->cluster->list[i]));
231     }
232
233   if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH))) 
234     snprintf (buf + strlen (buf), size - strlen (buf), ", path %s",
235               aspath_print (attr->aspath));
236
237   if (strlen (buf) > 1)
238     return 1;
239   else
240     return 0;
241 }
242
243 /* dump notify packet */
244 void
245 bgp_notify_print(struct peer *peer, struct bgp_notify *bgp_notify, 
246                  const char *direct)
247 {
248   const char *subcode_str;
249   const char *code_str;
250
251   subcode_str = "";
252   code_str = LOOKUP_DEF (bgp_notify_msg, bgp_notify->code,
253                          "Unrecognized Error Code");
254
255   switch (bgp_notify->code)
256     {
257     case BGP_NOTIFY_HEADER_ERR:
258       subcode_str = LOOKUP_DEF (bgp_notify_head_msg, bgp_notify->subcode,
259                                 "Unrecognized Error Subcode");
260       break;
261     case BGP_NOTIFY_OPEN_ERR:
262       subcode_str = LOOKUP_DEF (bgp_notify_open_msg, bgp_notify->subcode,
263                                 "Unrecognized Error Subcode");
264       break;
265     case BGP_NOTIFY_UPDATE_ERR:
266       subcode_str = LOOKUP_DEF (bgp_notify_update_msg, bgp_notify->subcode,
267                                 "Unrecognized Error Subcode");
268       break;
269     case BGP_NOTIFY_HOLD_ERR:
270       break;
271     case BGP_NOTIFY_FSM_ERR:
272       break;
273     case BGP_NOTIFY_CEASE:
274       subcode_str = LOOKUP_DEF (bgp_notify_cease_msg, bgp_notify->subcode,
275                                 "Unrecognized Error Subcode");
276       break;
277     case BGP_NOTIFY_CAPABILITY_ERR:
278       subcode_str = LOOKUP_DEF (bgp_notify_capability_msg, bgp_notify->subcode,
279                                 "Unrecognized Error Subcode");
280       break;
281     }
282
283   if (bgp_flag_check (peer->bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES))
284     zlog_info ("%%NOTIFICATION: %s neighbor %s %d/%d (%s%s) %d bytes %s",
285               strcmp (direct, "received") == 0 ? "received from" : "sent to",
286               peer->host, bgp_notify->code, bgp_notify->subcode,
287               code_str, subcode_str, bgp_notify->length,
288               bgp_notify->data ? bgp_notify->data : "");
289   else if (BGP_DEBUG (normal, NORMAL))
290     plog_debug (peer->log, "%s %s NOTIFICATION %d/%d (%s%s) %d bytes %s",
291                peer ? peer->host : "",
292                direct, bgp_notify->code, bgp_notify->subcode,
293                code_str, subcode_str, bgp_notify->length,
294                bgp_notify->data ? bgp_notify->data : "");
295 }
296
297 /* Debug option setting interface. */
298 unsigned long bgp_debug_option = 0;
299
300 int  
301 debug (unsigned int option)
302 {
303   return bgp_debug_option & option; 
304 }
305
306 DEFUN (debug_bgp_as4,
307        debug_bgp_as4_cmd,
308        "debug bgp as4",
309        DEBUG_STR
310        BGP_STR
311        "BGP AS4 actions\n")
312 {
313   if (vty->node == CONFIG_NODE)
314     DEBUG_ON (as4, AS4);
315   else
316     {
317       TERM_DEBUG_ON (as4, AS4);
318       vty_out (vty, "BGP as4 debugging is on%s", VTY_NEWLINE);
319     }
320   return CMD_SUCCESS;
321 }
322
323 DEFUN (no_debug_bgp_as4,
324        no_debug_bgp_as4_cmd,
325        "no debug bgp as4",
326        NO_STR
327        DEBUG_STR
328        BGP_STR
329        "BGP AS4 actions\n")
330 {
331   if (vty->node == CONFIG_NODE)
332     DEBUG_OFF (as4, AS4);
333   else
334     {
335       TERM_DEBUG_OFF (as4, AS4);
336       vty_out (vty, "BGP as4 debugging is off%s", VTY_NEWLINE);
337     }
338   return CMD_SUCCESS;
339 }
340
341 ALIAS (no_debug_bgp_as4,
342        undebug_bgp_as4_cmd,
343        "undebug bgp as4",
344        UNDEBUG_STR
345        BGP_STR
346        "BGP AS4 actions\n")
347
348 DEFUN (debug_bgp_as4_segment,
349        debug_bgp_as4_segment_cmd,
350        "debug bgp as4 segment",
351        DEBUG_STR
352        BGP_STR
353        "BGP AS4 actions\n"
354        "BGP AS4 aspath segment handling\n")
355 {
356   if (vty->node == CONFIG_NODE)
357     DEBUG_ON (as4, AS4_SEGMENT);
358   else
359     {
360       TERM_DEBUG_ON (as4, AS4_SEGMENT);
361       vty_out (vty, "BGP as4 segment debugging is on%s", VTY_NEWLINE);
362     }
363   return CMD_SUCCESS;
364 }
365
366 DEFUN (no_debug_bgp_as4_segment,
367        no_debug_bgp_as4_segment_cmd,
368        "no debug bgp as4 segment",
369        NO_STR
370        DEBUG_STR
371        BGP_STR
372        "BGP AS4 actions\n"
373        "BGP AS4 aspath segment handling\n")
374 {
375   if (vty->node == CONFIG_NODE)
376     DEBUG_OFF (as4, AS4_SEGMENT);
377   else
378     {
379       TERM_DEBUG_OFF (as4, AS4_SEGMENT);
380       vty_out (vty, "BGP as4 segment debugging is off%s", VTY_NEWLINE);
381     }
382   return CMD_SUCCESS;
383 }
384
385 ALIAS (no_debug_bgp_as4_segment,
386        undebug_bgp_as4_segment_cmd,
387        "undebug bgp as4 segment",
388        UNDEBUG_STR
389        BGP_STR
390        "BGP AS4 actions\n"
391        "BGP AS4 aspath segment handling\n")
392
393 DEFUN (debug_bgp_fsm,
394        debug_bgp_fsm_cmd,
395        "debug bgp fsm",
396        DEBUG_STR
397        BGP_STR
398        "BGP Finite State Machine\n")
399 {
400   if (vty->node == CONFIG_NODE)
401     DEBUG_ON (fsm, FSM);
402   else
403     {
404       TERM_DEBUG_ON (fsm, FSM);
405       vty_out (vty, "BGP fsm debugging is on%s", VTY_NEWLINE);
406     }
407   return CMD_SUCCESS;
408 }
409
410 DEFUN (no_debug_bgp_fsm,
411        no_debug_bgp_fsm_cmd,
412        "no debug bgp fsm",
413        NO_STR
414        DEBUG_STR
415        BGP_STR
416        "Finite State Machine\n")
417 {
418   if (vty->node == CONFIG_NODE)
419     DEBUG_OFF (fsm, FSM);
420   else
421     {
422       TERM_DEBUG_OFF (fsm, FSM);
423       vty_out (vty, "BGP fsm debugging is off%s", VTY_NEWLINE);
424     }
425   return CMD_SUCCESS;
426 }
427
428 ALIAS (no_debug_bgp_fsm,
429        undebug_bgp_fsm_cmd,
430        "undebug bgp fsm",
431        UNDEBUG_STR
432        BGP_STR
433        "Finite State Machine\n")
434
435 DEFUN (debug_bgp_events,
436        debug_bgp_events_cmd,
437        "debug bgp events",
438        DEBUG_STR
439        BGP_STR
440        "BGP events\n")
441 {
442   if (vty->node == CONFIG_NODE)
443     DEBUG_ON (events, EVENTS);
444   else
445     {
446       TERM_DEBUG_ON (events, EVENTS);
447       vty_out (vty, "BGP events debugging is on%s", VTY_NEWLINE);
448     }
449   return CMD_SUCCESS;
450 }
451
452 DEFUN (no_debug_bgp_events,
453        no_debug_bgp_events_cmd,
454        "no debug bgp events",
455        NO_STR
456        DEBUG_STR
457        BGP_STR
458        "BGP events\n")
459 {
460   if (vty->node == CONFIG_NODE)
461     DEBUG_OFF (events, EVENTS);
462   else
463     {
464       TERM_DEBUG_OFF (events, EVENTS);
465       vty_out (vty, "BGP events debugging is off%s", VTY_NEWLINE);
466     }
467   return CMD_SUCCESS;
468 }
469
470 ALIAS (no_debug_bgp_events,
471        undebug_bgp_events_cmd,
472        "undebug bgp events",
473        UNDEBUG_STR
474        BGP_STR
475        "BGP events\n")
476
477 DEFUN (debug_bgp_nht,
478        debug_bgp_nht_cmd,
479        "debug bgp nht",
480        DEBUG_STR
481        BGP_STR
482        "BGP nexthop tracking events\n")
483 {
484   if (vty->node == CONFIG_NODE)
485     DEBUG_ON (nht, NHT);
486   else
487     {
488       TERM_DEBUG_ON (nht, NHT);
489       vty_out (vty, "BGP nexthop tracking debugging is on%s", VTY_NEWLINE);
490     }
491   return CMD_SUCCESS;
492 }
493
494 DEFUN (no_debug_bgp_nht,
495        no_debug_bgp_nht_cmd,
496        "no debug bgp nht",
497        NO_STR
498        DEBUG_STR
499        BGP_STR
500        "BGP nexthop tracking events\n")
501 {
502   if (vty->node == CONFIG_NODE)
503     DEBUG_OFF (nht, NHT);
504   else
505     {
506       TERM_DEBUG_OFF (nht, NHT);
507       vty_out (vty, "BGP nexthop tracking debugging is off%s", VTY_NEWLINE);
508     }
509   return CMD_SUCCESS;
510 }
511
512 ALIAS (no_debug_bgp_nht,
513        undebug_bgp_nht_cmd,
514        "undebug bgp nht",
515        UNDEBUG_STR
516        BGP_STR
517        "BGP next-hop tracking updates\n")
518
519 DEFUN (debug_bgp_filter,
520        debug_bgp_filter_cmd,
521        "debug bgp filters",
522        DEBUG_STR
523        BGP_STR
524        "BGP filters\n")
525 {
526   if (vty->node == CONFIG_NODE)
527     DEBUG_ON (filter, FILTER);
528   else
529     {
530       TERM_DEBUG_ON (filter, FILTER);
531       vty_out (vty, "BGP filters debugging is on%s", VTY_NEWLINE);
532     }
533   return CMD_SUCCESS;
534 }
535
536 DEFUN (no_debug_bgp_filter,
537        no_debug_bgp_filter_cmd,
538        "no debug bgp filters",
539        NO_STR
540        DEBUG_STR
541        BGP_STR
542        "BGP filters\n")
543 {
544   if (vty->node == CONFIG_NODE)
545     DEBUG_OFF (filter, FILTER);
546   else
547     {
548       TERM_DEBUG_OFF (filter, FILTER);
549       vty_out (vty, "BGP filters debugging is off%s", VTY_NEWLINE);
550     }
551   return CMD_SUCCESS;
552 }
553
554 ALIAS (no_debug_bgp_filter,
555        undebug_bgp_filter_cmd,
556        "undebug bgp filters",
557        UNDEBUG_STR
558        BGP_STR
559        "BGP filters\n")
560
561 DEFUN (debug_bgp_keepalive,
562        debug_bgp_keepalive_cmd,
563        "debug bgp keepalives",
564        DEBUG_STR
565        BGP_STR
566        "BGP keepalives\n")
567 {
568   if (vty->node == CONFIG_NODE)
569     DEBUG_ON (keepalive, KEEPALIVE);
570   else
571     {
572       TERM_DEBUG_ON (keepalive, KEEPALIVE);
573       vty_out (vty, "BGP keepalives debugging is on%s", VTY_NEWLINE);
574     }
575   return CMD_SUCCESS;
576 }
577
578 DEFUN (no_debug_bgp_keepalive,
579        no_debug_bgp_keepalive_cmd,
580        "no debug bgp keepalives",
581        NO_STR
582        DEBUG_STR
583        BGP_STR
584        "BGP keepalives\n")
585 {
586   if (vty->node == CONFIG_NODE)
587     DEBUG_OFF (keepalive, KEEPALIVE);
588   else
589     {
590       TERM_DEBUG_OFF (keepalive, KEEPALIVE);
591       vty_out (vty, "BGP keepalives debugging is off%s", VTY_NEWLINE);
592     }
593   return CMD_SUCCESS;
594 }
595
596 ALIAS (no_debug_bgp_keepalive,
597        undebug_bgp_keepalive_cmd,
598        "undebug bgp keepalives",
599        UNDEBUG_STR
600        BGP_STR
601        "BGP keepalives\n")
602
603 DEFUN (debug_bgp_update,
604        debug_bgp_update_cmd,
605        "debug bgp updates",
606        DEBUG_STR
607        BGP_STR
608        "BGP updates\n")
609 {
610   if (vty->node == CONFIG_NODE)
611     {
612       DEBUG_ON (update, UPDATE_IN);
613       DEBUG_ON (update, UPDATE_OUT);
614     }
615   else
616     {
617       TERM_DEBUG_ON (update, UPDATE_IN);
618       TERM_DEBUG_ON (update, UPDATE_OUT);
619       vty_out (vty, "BGP updates debugging is on%s", VTY_NEWLINE);
620     }
621   return CMD_SUCCESS;
622 }
623
624 DEFUN (debug_bgp_update_direct,
625        debug_bgp_update_direct_cmd,
626        "debug bgp updates (in|out)",
627        DEBUG_STR
628        BGP_STR
629        "BGP updates\n"
630        "Inbound updates\n"
631        "Outbound updates\n")
632 {
633   if (vty->node == CONFIG_NODE)
634     {
635       if (strncmp ("i", argv[0], 1) == 0)
636         {
637           DEBUG_OFF (update, UPDATE_OUT);
638           DEBUG_ON (update, UPDATE_IN);
639         }
640       else
641         {       
642           DEBUG_OFF (update, UPDATE_IN);
643           DEBUG_ON (update, UPDATE_OUT);
644         }
645     }
646   else
647     {
648       if (strncmp ("i", argv[0], 1) == 0)
649         {
650           TERM_DEBUG_OFF (update, UPDATE_OUT);
651           TERM_DEBUG_ON (update, UPDATE_IN);
652           vty_out (vty, "BGP updates debugging is on (inbound)%s", VTY_NEWLINE);
653         }
654       else
655         {
656           TERM_DEBUG_OFF (update, UPDATE_IN);
657           TERM_DEBUG_ON (update, UPDATE_OUT);
658           vty_out (vty, "BGP updates debugging is on (outbound)%s", VTY_NEWLINE);
659         }
660     }
661   return CMD_SUCCESS;
662 }
663
664 DEFUN (no_debug_bgp_update,
665        no_debug_bgp_update_cmd,
666        "no debug bgp updates",
667        NO_STR
668        DEBUG_STR
669        BGP_STR
670        "BGP updates\n")
671 {
672   if (vty->node == CONFIG_NODE)
673     {
674       DEBUG_OFF (update, UPDATE_IN);
675       DEBUG_OFF (update, UPDATE_OUT);
676     }
677   else
678     {
679       TERM_DEBUG_OFF (update, UPDATE_IN);
680       TERM_DEBUG_OFF (update, UPDATE_OUT);
681       vty_out (vty, "BGP updates debugging is off%s", VTY_NEWLINE);
682     }
683   return CMD_SUCCESS;
684 }
685
686 ALIAS (no_debug_bgp_update,
687        undebug_bgp_update_cmd,
688        "undebug bgp updates",
689        UNDEBUG_STR
690        BGP_STR
691        "BGP updates\n")
692
693 DEFUN (debug_bgp_normal,
694        debug_bgp_normal_cmd,
695        "debug bgp",
696        DEBUG_STR
697        BGP_STR)
698 {
699   if (vty->node == CONFIG_NODE)
700     DEBUG_ON (normal, NORMAL);
701   else
702     {
703       TERM_DEBUG_ON (normal, NORMAL);
704       vty_out (vty, "BGP debugging is on%s", VTY_NEWLINE);
705     }
706   return CMD_SUCCESS;
707 }
708
709 DEFUN (no_debug_bgp_normal,
710        no_debug_bgp_normal_cmd,
711        "no debug bgp",
712        NO_STR
713        DEBUG_STR
714        BGP_STR)
715 {
716   if (vty->node == CONFIG_NODE)
717     DEBUG_OFF (normal, NORMAL);
718   else
719     {
720       TERM_DEBUG_OFF (normal, NORMAL);
721       vty_out (vty, "BGP debugging is off%s", VTY_NEWLINE);
722     }
723   return CMD_SUCCESS;
724 }
725
726 ALIAS (no_debug_bgp_normal,
727        undebug_bgp_normal_cmd,
728        "undebug bgp",
729        UNDEBUG_STR
730        BGP_STR)
731
732 DEFUN (debug_bgp_zebra,
733        debug_bgp_zebra_cmd,
734        "debug bgp zebra",
735        DEBUG_STR
736        BGP_STR
737        "BGP Zebra messages\n")
738 {
739   if (vty->node == CONFIG_NODE)
740     DEBUG_ON (zebra, ZEBRA);
741   else
742     {
743       TERM_DEBUG_ON (zebra, ZEBRA);
744       vty_out (vty, "BGP zebra debugging is on%s", VTY_NEWLINE);
745     }
746   return CMD_SUCCESS;
747 }
748
749 DEFUN (no_debug_bgp_zebra,
750        no_debug_bgp_zebra_cmd,
751        "no debug bgp zebra",
752        NO_STR
753        DEBUG_STR
754        BGP_STR
755        "BGP Zebra messages\n")
756 {
757   if (vty->node == CONFIG_NODE)
758     DEBUG_OFF (zebra, ZEBRA);
759   else
760     {
761       TERM_DEBUG_OFF (zebra, ZEBRA);
762       vty_out (vty, "BGP zebra debugging is off%s", VTY_NEWLINE);
763     }
764   return CMD_SUCCESS;
765 }
766
767 ALIAS (no_debug_bgp_zebra,
768        undebug_bgp_zebra_cmd,
769        "undebug bgp zebra",
770        UNDEBUG_STR
771        BGP_STR
772        "BGP Zebra messages\n")
773
774 DEFUN (debug_bgp_allow_martians,
775        debug_bgp_allow_martians_cmd,
776        "debug bgp allow-martians",
777        DEBUG_STR
778        BGP_STR
779        "BGP allow martian next hops\n")
780 {
781   if (vty->node == CONFIG_NODE)
782     DEBUG_ON (allow_martians, ALLOW_MARTIANS);
783   else
784     {
785       TERM_DEBUG_ON (allow_martians, ALLOW_MARTIANS);
786       vty_out (vty, "BGP allow_martian next hop debugging is on%s", VTY_NEWLINE);
787     }
788   return CMD_SUCCESS;
789 }
790
791 DEFUN (no_debug_bgp_allow_martians,
792        no_debug_bgp_allow_martians_cmd,
793        "no debug bgp allow-martians",
794        NO_STR
795        DEBUG_STR
796        BGP_STR
797        "BGP allow martian next hops\n")
798 {
799   if (vty->node == CONFIG_NODE)
800     DEBUG_OFF (allow_martians, ALLOW_MARTIANS);
801   else
802     {
803       TERM_DEBUG_OFF (allow_martians, ALLOW_MARTIANS);
804       vty_out (vty, "BGP allow martian next hop debugging is off%s", VTY_NEWLINE);
805     }
806   return CMD_SUCCESS;
807 }
808
809 ALIAS (no_debug_bgp_allow_martians,
810        undebug_bgp_allow_martians_cmd,
811        "undebug bgp allow-martians",
812        UNDEBUG_STR
813        BGP_STR
814        "BGP allow martian next hops\n")
815
816 DEFUN (no_debug_bgp_all,
817        no_debug_bgp_all_cmd,
818        "no debug all bgp",
819        NO_STR
820        DEBUG_STR
821        "Enable all debugging\n"
822        BGP_STR)
823 {
824   TERM_DEBUG_OFF (normal, NORMAL);
825   TERM_DEBUG_OFF (events, EVENTS);
826   TERM_DEBUG_OFF (keepalive, KEEPALIVE);
827   TERM_DEBUG_OFF (update, UPDATE_IN);
828   TERM_DEBUG_OFF (update, UPDATE_OUT);
829   TERM_DEBUG_OFF (as4, AS4);
830   TERM_DEBUG_OFF (as4, AS4_SEGMENT);
831   TERM_DEBUG_OFF (fsm, FSM);
832   TERM_DEBUG_OFF (filter, FILTER);
833   TERM_DEBUG_OFF (zebra, ZEBRA);
834   TERM_DEBUG_OFF (allow_martians, ALLOW_MARTIANS);
835   vty_out (vty, "All possible debugging has been turned off%s", VTY_NEWLINE);
836       
837   return CMD_SUCCESS;
838 }
839
840 ALIAS (no_debug_bgp_all,
841        undebug_bgp_all_cmd,
842        "undebug all bgp",
843        UNDEBUG_STR
844        "Enable all debugging\n"
845        BGP_STR)
846
847 DEFUN (show_debugging_bgp,
848        show_debugging_bgp_cmd,
849        "show debugging bgp",
850        SHOW_STR
851        DEBUG_STR
852        BGP_STR)
853 {
854   vty_out (vty, "BGP debugging status:%s", VTY_NEWLINE);
855
856   if (BGP_DEBUG (normal, NORMAL))
857     vty_out (vty, "  BGP debugging is on%s", VTY_NEWLINE);
858   if (BGP_DEBUG (events, EVENTS))
859     vty_out (vty, "  BGP events debugging is on%s", VTY_NEWLINE);
860   if (BGP_DEBUG (keepalive, KEEPALIVE))
861     vty_out (vty, "  BGP keepalives debugging is on%s", VTY_NEWLINE);
862   if (BGP_DEBUG (update, UPDATE_IN) && BGP_DEBUG (update, UPDATE_OUT))
863     vty_out (vty, "  BGP updates debugging is on%s", VTY_NEWLINE);
864   else if (BGP_DEBUG (update, UPDATE_IN))
865     vty_out (vty, "  BGP updates debugging is on (inbound)%s", VTY_NEWLINE);
866   else if (BGP_DEBUG (update, UPDATE_OUT))
867     vty_out (vty, "  BGP updates debugging is on (outbound)%s", VTY_NEWLINE);
868   if (BGP_DEBUG (fsm, FSM))
869     vty_out (vty, "  BGP fsm debugging is on%s", VTY_NEWLINE);
870   if (BGP_DEBUG (filter, FILTER))
871     vty_out (vty, "  BGP filter debugging is on%s", VTY_NEWLINE);
872   if (BGP_DEBUG (zebra, ZEBRA))
873     vty_out (vty, "  BGP zebra debugging is on%s", VTY_NEWLINE);
874   if (BGP_DEBUG (as4, AS4))
875     vty_out (vty, "  BGP as4 debugging is on%s", VTY_NEWLINE);
876   if (BGP_DEBUG (as4, AS4_SEGMENT))
877     vty_out (vty, "  BGP as4 aspath segment debugging is on%s", VTY_NEWLINE);
878   if (BGP_DEBUG (allow_martians, ALLOW_MARTIANS))
879     vty_out (vty, "  BGP allow martian next hop debugging is on%s", VTY_NEWLINE);
880   if (BGP_DEBUG (nht, NHT))
881     vty_out (vty, "  BGP next-hop tracking debugging is on%s", VTY_NEWLINE);
882   vty_out (vty, "%s", VTY_NEWLINE);
883   return CMD_SUCCESS;
884 }
885
886 static int
887 bgp_config_write_debug (struct vty *vty)
888 {
889   int write = 0;
890
891   if (CONF_BGP_DEBUG (normal, NORMAL))
892     {
893       vty_out (vty, "debug bgp%s", VTY_NEWLINE);
894       write++;
895     }
896
897   if (CONF_BGP_DEBUG (as4, AS4))
898     {
899       vty_out (vty, "debug bgp as4%s", VTY_NEWLINE);
900       write++;
901     }
902
903   if (CONF_BGP_DEBUG (as4, AS4_SEGMENT))
904     {
905       vty_out (vty, "debug bgp as4 segment%s", VTY_NEWLINE);
906       write++;
907     }
908
909   if (CONF_BGP_DEBUG (events, EVENTS))
910     {
911       vty_out (vty, "debug bgp events%s", VTY_NEWLINE);
912       write++;
913     }
914
915   if (CONF_BGP_DEBUG (keepalive, KEEPALIVE))
916     {
917       vty_out (vty, "debug bgp keepalives%s", VTY_NEWLINE);
918       write++;
919     }
920
921   if (CONF_BGP_DEBUG (update, UPDATE_IN) && CONF_BGP_DEBUG (update, UPDATE_OUT))
922     {
923       vty_out (vty, "debug bgp updates%s", VTY_NEWLINE);
924       write++;
925     }
926   else if (CONF_BGP_DEBUG (update, UPDATE_IN))
927     {
928       vty_out (vty, "debug bgp updates in%s", VTY_NEWLINE);
929       write++;
930     }
931   else if (CONF_BGP_DEBUG (update, UPDATE_OUT))
932     {
933       vty_out (vty, "debug bgp updates out%s", VTY_NEWLINE);
934       write++;
935     }
936
937   if (CONF_BGP_DEBUG (fsm, FSM))
938     {
939       vty_out (vty, "debug bgp fsm%s", VTY_NEWLINE);
940       write++;
941     }
942
943   if (CONF_BGP_DEBUG (filter, FILTER))
944     {
945       vty_out (vty, "debug bgp filters%s", VTY_NEWLINE);
946       write++;
947     }
948
949   if (CONF_BGP_DEBUG (zebra, ZEBRA))
950     {
951       vty_out (vty, "debug bgp zebra%s", VTY_NEWLINE);
952       write++;
953     }
954
955   if (CONF_BGP_DEBUG (allow_martians, ALLOW_MARTIANS))
956     {
957       vty_out (vty, "debug bgp allow-martians%s", VTY_NEWLINE);
958       write++;
959     }
960   
961   if (CONF_BGP_DEBUG (nht, NHT))
962     {
963       vty_out (vty, "debug bgp nht%s", VTY_NEWLINE);
964       write++;
965     }
966
967   return write;
968 }
969
970 static struct cmd_node debug_node =
971 {
972   DEBUG_NODE,
973   "",
974   1
975 };
976
977 void
978 bgp_debug_init (void)
979 {
980   install_node (&debug_node, bgp_config_write_debug);
981
982   install_element (ENABLE_NODE, &show_debugging_bgp_cmd);
983
984   install_element (ENABLE_NODE, &debug_bgp_as4_cmd);
985   install_element (CONFIG_NODE, &debug_bgp_as4_cmd);
986   install_element (ENABLE_NODE, &debug_bgp_as4_segment_cmd);
987   install_element (CONFIG_NODE, &debug_bgp_as4_segment_cmd);
988
989   install_element (ENABLE_NODE, &debug_bgp_fsm_cmd);
990   install_element (CONFIG_NODE, &debug_bgp_fsm_cmd);
991   install_element (ENABLE_NODE, &debug_bgp_events_cmd);
992   install_element (CONFIG_NODE, &debug_bgp_events_cmd);
993   install_element (ENABLE_NODE, &debug_bgp_nht_cmd);
994   install_element (CONFIG_NODE, &debug_bgp_nht_cmd);
995   install_element (ENABLE_NODE, &debug_bgp_filter_cmd);
996   install_element (CONFIG_NODE, &debug_bgp_filter_cmd);
997   install_element (ENABLE_NODE, &debug_bgp_keepalive_cmd);
998   install_element (CONFIG_NODE, &debug_bgp_keepalive_cmd);
999   install_element (ENABLE_NODE, &debug_bgp_update_cmd);
1000   install_element (CONFIG_NODE, &debug_bgp_update_cmd);
1001   install_element (ENABLE_NODE, &debug_bgp_update_direct_cmd);
1002   install_element (CONFIG_NODE, &debug_bgp_update_direct_cmd);
1003   install_element (ENABLE_NODE, &debug_bgp_normal_cmd);
1004   install_element (CONFIG_NODE, &debug_bgp_normal_cmd);
1005   install_element (ENABLE_NODE, &debug_bgp_zebra_cmd);
1006   install_element (CONFIG_NODE, &debug_bgp_zebra_cmd);
1007   install_element (ENABLE_NODE, &debug_bgp_allow_martians_cmd);
1008   install_element (CONFIG_NODE, &debug_bgp_allow_martians_cmd);
1009
1010   install_element (ENABLE_NODE, &no_debug_bgp_as4_cmd);
1011   install_element (ENABLE_NODE, &undebug_bgp_as4_cmd);
1012   install_element (CONFIG_NODE, &no_debug_bgp_as4_cmd);
1013   install_element (ENABLE_NODE, &no_debug_bgp_as4_segment_cmd);
1014   install_element (ENABLE_NODE, &undebug_bgp_as4_segment_cmd);
1015   install_element (CONFIG_NODE, &no_debug_bgp_as4_segment_cmd);
1016
1017   install_element (ENABLE_NODE, &no_debug_bgp_fsm_cmd);
1018   install_element (ENABLE_NODE, &undebug_bgp_fsm_cmd);
1019   install_element (CONFIG_NODE, &no_debug_bgp_fsm_cmd);
1020   install_element (ENABLE_NODE, &no_debug_bgp_events_cmd);
1021   install_element (ENABLE_NODE, &undebug_bgp_events_cmd);
1022   install_element (CONFIG_NODE, &no_debug_bgp_events_cmd);
1023   install_element (ENABLE_NODE, &no_debug_bgp_nht_cmd);
1024   install_element (ENABLE_NODE, &undebug_bgp_nht_cmd);
1025   install_element (CONFIG_NODE, &no_debug_bgp_nht_cmd);
1026   install_element (ENABLE_NODE, &no_debug_bgp_filter_cmd);
1027   install_element (ENABLE_NODE, &undebug_bgp_filter_cmd);
1028   install_element (CONFIG_NODE, &no_debug_bgp_filter_cmd);
1029   install_element (ENABLE_NODE, &no_debug_bgp_keepalive_cmd);
1030   install_element (ENABLE_NODE, &undebug_bgp_keepalive_cmd);
1031   install_element (CONFIG_NODE, &no_debug_bgp_keepalive_cmd);
1032   install_element (ENABLE_NODE, &no_debug_bgp_update_cmd);
1033   install_element (ENABLE_NODE, &undebug_bgp_update_cmd);
1034   install_element (CONFIG_NODE, &no_debug_bgp_update_cmd);
1035   install_element (ENABLE_NODE, &no_debug_bgp_normal_cmd);
1036   install_element (ENABLE_NODE, &undebug_bgp_normal_cmd);
1037   install_element (CONFIG_NODE, &no_debug_bgp_normal_cmd);
1038   install_element (ENABLE_NODE, &no_debug_bgp_zebra_cmd);
1039   install_element (ENABLE_NODE, &undebug_bgp_zebra_cmd);
1040   install_element (CONFIG_NODE, &no_debug_bgp_zebra_cmd);
1041   install_element (ENABLE_NODE, &no_debug_bgp_allow_martians_cmd);
1042   install_element (ENABLE_NODE, &undebug_bgp_allow_martians_cmd);
1043   install_element (CONFIG_NODE, &no_debug_bgp_allow_martians_cmd);
1044   install_element (ENABLE_NODE, &no_debug_bgp_all_cmd);
1045   install_element (ENABLE_NODE, &undebug_bgp_all_cmd);
1046 }