[mirror_frr.git] / zebra / debug.c

/*
 * Zebra debug related function
 * Copyright (C) 1999 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 "command.h"
#include "debug.h"

/* For debug statement. */
unsigned long zebra_debug_event;
unsigned long zebra_debug_packet;
unsigned long zebra_debug_kernel;
unsigned long zebra_debug_rib;
unsigned long zebra_debug_fpm;
unsigned long zebra_debug_nht;
unsigned long zebra_debug_mpls;

DEFUN (show_debugging_zebra,
       show_debugging_zebra_cmd,
       "show debugging zebra",
       SHOW_STR
       "Debugging information\n"
       "Zebra configuration\n")
{
  vty_out (vty, "Zebra debugging status:%s", VTY_NEWLINE);

  if (IS_ZEBRA_DEBUG_EVENT)
    vty_out (vty, "  Zebra event debugging is on%s", VTY_NEWLINE);

  if (IS_ZEBRA_DEBUG_PACKET)
    {
      if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV)
	{
	  vty_out (vty, "  Zebra packet%s debugging is on%s",
		   IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
		   VTY_NEWLINE);
	}
      else
	{
	  if (IS_ZEBRA_DEBUG_SEND)
	    vty_out (vty, "  Zebra packet send%s debugging is on%s",
		     IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
		     VTY_NEWLINE);
	  else
	    vty_out (vty, "  Zebra packet receive%s debugging is on%s",
		     IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
		     VTY_NEWLINE);
	}
    }

  if (IS_ZEBRA_DEBUG_KERNEL)
    vty_out (vty, "  Zebra kernel debugging is on%s", VTY_NEWLINE);
  if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
    vty_out (vty, "  Zebra kernel netlink message dumps (send) are on%s", VTY_NEWLINE);
  if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
    vty_out (vty, "  Zebra kernel netlink message dumps (recv) are on%s", VTY_NEWLINE);

  /* Check here using flags as the 'macro' does an OR */
  if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB))
    vty_out (vty, "  Zebra RIB debugging is on%s", VTY_NEWLINE);
  if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
    vty_out (vty, "  Zebra RIB detailed debugging is on%s", VTY_NEWLINE);

  if (IS_ZEBRA_DEBUG_FPM)
    vty_out (vty, "  Zebra FPM debugging is on%s", VTY_NEWLINE);
  if (IS_ZEBRA_DEBUG_NHT)
    vty_out (vty, "  Zebra next-hop tracking debugging is on%s", VTY_NEWLINE);
  if (IS_ZEBRA_DEBUG_MPLS)
    vty_out (vty, "  Zebra MPLS debugging is on%s", VTY_NEWLINE);

  return CMD_SUCCESS;
}

DEFUN (debug_zebra_events,
       debug_zebra_events_cmd,
       "debug zebra events",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra events\n")
{
  zebra_debug_event = ZEBRA_DEBUG_EVENT;
  return CMD_WARNING;
}

DEFUN (debug_zebra_nht,
       debug_zebra_nht_cmd,
       "debug zebra nht",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra next hop tracking\n")
{
  zebra_debug_nht = ZEBRA_DEBUG_NHT;
  return CMD_WARNING;
}

DEFUN (debug_zebra_mpls,
       debug_zebra_mpls_cmd,
       "debug zebra mpls",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra MPLS LSPs\n")
{
  zebra_debug_mpls = ZEBRA_DEBUG_MPLS;
  return CMD_WARNING;
}

DEFUN (debug_zebra_packet,
       debug_zebra_packet_cmd,
       "debug zebra packet [<recv|send>] [detail]",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra packet\n"
       "Debug option set for receive packet\n"
       "Debug option set for send packet\n"
       "Debug option set for detailed info\n")
{
  int idx = 0;
  zebra_debug_packet = ZEBRA_DEBUG_PACKET;

  if (argv_find (argv, argc, "send", &idx))
    SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
  idx = 0;
  if (argv_find (argv, argc, "recv", &idx))
    SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
  idx = 0;
  if (argv_find (argv, argc, "detail", &idx))
    SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_DETAIL);

  if (!(zebra_debug_packet & ZEBRA_DEBUG_SEND & ZEBRA_DEBUG_RECV))
  {
    SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
    SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
  }
  return CMD_SUCCESS;
}

DEFUN (debug_zebra_kernel,
       debug_zebra_kernel_cmd,
       "debug zebra kernel",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n")
{
  SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);
  return CMD_SUCCESS;
}

DEFUN (debug_zebra_kernel_msgdump,
       debug_zebra_kernel_msgdump_cmd,
       "debug zebra kernel msgdump [<recv|send>]",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n"
       "Dump raw netlink messages, sent and received\n"
       "Dump raw netlink messages received\n"
       "Dump raw netlink messages sent\n")
{
  int idx_recv_send = 4;
  if (argv[idx_recv_send]->arg && strncmp(argv[idx_recv_send]->arg, "recv", strlen(argv[idx_recv_send]->arg)) == 0)
    SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
  if (!argv[idx_recv_send]->arg || strncmp(argv[idx_recv_send]->arg, "send", strlen(argv[idx_recv_send]->arg)) == 0)
    SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
  return CMD_SUCCESS;
}

DEFUN (debug_zebra_rib,
       debug_zebra_rib_cmd,
       "debug zebra rib",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug RIB events\n")
{
  SET_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB);
  return CMD_SUCCESS;
}

DEFUN (debug_zebra_rib_detailed,
       debug_zebra_rib_detailed_cmd,
       "debug zebra rib detailed",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug RIB events\n"
       "Detailed debugs\n")
{
  SET_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);
  return CMD_SUCCESS;
}

DEFUN (debug_zebra_fpm,
       debug_zebra_fpm_cmd,
       "debug zebra fpm",
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra FPM events\n")
{
  SET_FLAG (zebra_debug_fpm, ZEBRA_DEBUG_FPM);
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_events,
       no_debug_zebra_events_cmd,
       "no debug zebra events",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra events\n")
{
  zebra_debug_event = 0;
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_nht,
       no_debug_zebra_nht_cmd,
       "no debug zebra nht",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra next hop tracking\n")
{
  zebra_debug_nht = 0;
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_mpls,
       no_debug_zebra_mpls_cmd,
       "no debug zebra mpls",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra MPLS LSPs\n")
{
  zebra_debug_mpls = 0;
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_packet,
       no_debug_zebra_packet_cmd,
       "no debug zebra packet [<recv|send>]",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra packet\n"
       "Debug option set for receive packet\n"
       "Debug option set for send packet\n")
{
  int idx = 0;
  if (argc == 4 || argv_find (argv, argc, "send", &idx))
    UNSET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
  if (argc == 4 || argv_find (argv, argc, "recv", &idx))
    UNSET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_kernel,
       no_debug_zebra_kernel_cmd,
       "no debug zebra kernel",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n")
{
  UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_kernel_msgdump,
       no_debug_zebra_kernel_msgdump_cmd,
       "no debug zebra kernel msgdump [<recv|send>]",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug option set for zebra between kernel interface\n"
       "Dump raw netlink messages, sent and received\n"
       "Dump raw netlink messages received\n"
       "Dump raw netlink messages sent\n")
{
  int idx = 0;
  if (argc == 5 || argv_find (argv, argc, "recv", &idx))
    UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
  if (argc == 5 || argv_find (argv, argc, "send", &idx))
    UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);

  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_rib,
       no_debug_zebra_rib_cmd,
       "no debug zebra rib",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra RIB\n")
{
  zebra_debug_rib = 0;
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_rib_detailed,
       no_debug_zebra_rib_detailed_cmd,
       "no debug zebra rib detailed",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra RIB\n"
       "Detailed debugs\n")
{
  UNSET_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);
  return CMD_SUCCESS;
}

DEFUN (no_debug_zebra_fpm,
       no_debug_zebra_fpm_cmd,
       "no debug zebra fpm",
       NO_STR
       DEBUG_STR
       "Zebra configuration\n"
       "Debug zebra FPM events\n")
{
  zebra_debug_fpm = 0;
  return CMD_SUCCESS;
}

/* Debug node. */
struct cmd_node debug_node =
{
  DEBUG_NODE,
  "",				/* Debug node has no interface. */
  1
};

static int
config_write_debug (struct vty *vty)
{
  int write = 0;

  if (IS_ZEBRA_DEBUG_EVENT)
    {
      vty_out (vty, "debug zebra events%s", VTY_NEWLINE);
      write++;
    }
  if (IS_ZEBRA_DEBUG_PACKET)
    {
      if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV)
	{
	  vty_out (vty, "debug zebra packet%s%s",
		   IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
		   VTY_NEWLINE);
	  write++;
	}
      else
	{
	  if (IS_ZEBRA_DEBUG_SEND)
	    vty_out (vty, "debug zebra packet send%s%s",
		     IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
		     VTY_NEWLINE);
	  else
	    vty_out (vty, "debug zebra packet recv%s%s",
		     IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
		     VTY_NEWLINE);
	  write++;
	}
    }
  if (IS_ZEBRA_DEBUG_KERNEL)
    {
      vty_out (vty, "debug zebra kernel%s", VTY_NEWLINE);
      write++;
    }
  /* Check here using flags as the 'macro' does an OR */
  if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB))
    {
      vty_out (vty, "debug zebra rib%s", VTY_NEWLINE);
      write++;
    }
  if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
    {
      vty_out (vty, "debug zebra rib detailed%s", VTY_NEWLINE);
      write++;
    }
  if (IS_ZEBRA_DEBUG_FPM)
    {
      vty_out (vty, "debug zebra fpm%s", VTY_NEWLINE);
      write++;
    }
  if (IS_ZEBRA_DEBUG_MPLS)
    {
      vty_out (vty, "debug zebra mpls%s", VTY_NEWLINE);
      write++;
    }
  return write;
}

void
zebra_debug_init (void)
{
  zebra_debug_event = 0;
  zebra_debug_packet = 0;
  zebra_debug_kernel = 0;
  zebra_debug_rib = 0;
  zebra_debug_fpm = 0;
  zebra_debug_mpls = 0;

  install_node (&debug_node, config_write_debug);

  install_element (VIEW_NODE, &show_debugging_zebra_cmd);

  install_element (ENABLE_NODE, &debug_zebra_events_cmd);
  install_element (ENABLE_NODE, &debug_zebra_nht_cmd);
  install_element (ENABLE_NODE, &debug_zebra_mpls_cmd);
  install_element (ENABLE_NODE, &debug_zebra_packet_cmd);
  install_element (ENABLE_NODE, &debug_zebra_kernel_cmd);
  install_element (ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
  install_element (ENABLE_NODE, &debug_zebra_rib_cmd);
  install_element (ENABLE_NODE, &debug_zebra_rib_detailed_cmd);
  install_element (ENABLE_NODE, &debug_zebra_fpm_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_events_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_nht_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_mpls_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_packet_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_kernel_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_rib_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_rib_detailed_cmd);
  install_element (ENABLE_NODE, &no_debug_zebra_fpm_cmd);

  install_element (CONFIG_NODE, &debug_zebra_events_cmd);
  install_element (CONFIG_NODE, &debug_zebra_nht_cmd);
  install_element (CONFIG_NODE, &debug_zebra_mpls_cmd);
  install_element (CONFIG_NODE, &debug_zebra_packet_cmd);
  install_element (CONFIG_NODE, &debug_zebra_kernel_cmd);
  install_element (CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
  install_element (CONFIG_NODE, &debug_zebra_rib_cmd);
  install_element (CONFIG_NODE, &debug_zebra_rib_detailed_cmd);
  install_element (CONFIG_NODE, &debug_zebra_fpm_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_events_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_nht_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_mpls_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_packet_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_kernel_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_rib_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_rib_detailed_cmd);
  install_element (CONFIG_NODE, &no_debug_zebra_fpm_cmd);
}
Commit	Line	Data
718e3744	1	/*
	2	* Zebra debug related function
	3	* Copyright (C) 1999 Kunihiro Ishiguro
	4	*
	5	* This file is part of GNU Zebra.
	6	*
	7	* GNU Zebra is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the
	9	* Free Software Foundation; either version 2, or (at your option) any
	10	* later version.
	11	*
	12	* GNU Zebra is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with GNU Zebra; see the file COPYING. If not, write to the
	19	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	20	* Boston, MA 02111-1307, USA.
	21	*/
	22
	23	#include <zebra.h>
	24	#include "command.h"
	25	#include "debug.h"
	26
	27	/* For debug statement. */
	28	unsigned long zebra_debug_event;
	29	unsigned long zebra_debug_packet;
	30	unsigned long zebra_debug_kernel;
b0498dc6	31	unsigned long zebra_debug_rib;
5adc2528	32	unsigned long zebra_debug_fpm;
fb018d25	33	unsigned long zebra_debug_nht;
7758e3f3	34	unsigned long zebra_debug_mpls;
718e3744	35
	36	DEFUN (show_debugging_zebra,
	37	show_debugging_zebra_cmd,
	38	"show debugging zebra",
	39	SHOW_STR
2b00515a CF	40	"Debugging information\n"
2b00515a CF	41	"Zebra configuration\n")
718e3744	42	{
	43	vty_out (vty, "Zebra debugging status:%s", VTY_NEWLINE);
	44
	45	if (IS_ZEBRA_DEBUG_EVENT)
	46	vty_out (vty, " Zebra event debugging is on%s", VTY_NEWLINE);
	47
	48	if (IS_ZEBRA_DEBUG_PACKET)
	49	{
	50	if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV)
	51	{
	52	vty_out (vty, " Zebra packet%s debugging is on%s",
	53	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
	54	VTY_NEWLINE);
	55	}
	56	else
	57	{
	58	if (IS_ZEBRA_DEBUG_SEND)
	59	vty_out (vty, " Zebra packet send%s debugging is on%s",
	60	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
	61	VTY_NEWLINE);
	62	else
	63	vty_out (vty, " Zebra packet receive%s debugging is on%s",
	64	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
	65	VTY_NEWLINE);
	66	}
	67	}
	68
	69	if (IS_ZEBRA_DEBUG_KERNEL)
	70	vty_out (vty, " Zebra kernel debugging is on%s", VTY_NEWLINE);
556b904e QY	71	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
	72	vty_out (vty, " Zebra kernel netlink message dumps (send) are on%s", VTY_NEWLINE);
	73	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
	74	vty_out (vty, " Zebra kernel netlink message dumps (recv) are on%s", VTY_NEWLINE);
718e3744	75
41ec9222	76	/* Check here using flags as the 'macro' does an OR */
41ec9222	77	if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB))
b0498dc6	78	vty_out (vty, " Zebra RIB debugging is on%s", VTY_NEWLINE);
41ec9222	79	if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
41ec9222	80	vty_out (vty, " Zebra RIB detailed debugging is on%s", VTY_NEWLINE);
b0498dc6	81
5adc2528 AS	82	if (IS_ZEBRA_DEBUG_FPM)
5adc2528 AS	83	vty_out (vty, " Zebra FPM debugging is on%s", VTY_NEWLINE);
fb018d25 DS	84	if (IS_ZEBRA_DEBUG_NHT)
fb018d25 DS	85	vty_out (vty, " Zebra next-hop tracking debugging is on%s", VTY_NEWLINE);
7758e3f3	86	if (IS_ZEBRA_DEBUG_MPLS)
7758e3f3	87	vty_out (vty, " Zebra MPLS debugging is on%s", VTY_NEWLINE);
5adc2528	88
718e3744	89	return CMD_SUCCESS;
	90	}
	91
	92	DEFUN (debug_zebra_events,
	93	debug_zebra_events_cmd,
	94	"debug zebra events",
	95	DEBUG_STR
	96	"Zebra configuration\n"
	97	"Debug option set for zebra events\n")
	98	{
	99	zebra_debug_event = ZEBRA_DEBUG_EVENT;
	100	return CMD_WARNING;
	101	}
	102
fb018d25 DS	103	DEFUN (debug_zebra_nht,
	104	debug_zebra_nht_cmd,
	105	"debug zebra nht",
	106	DEBUG_STR
	107	"Zebra configuration\n"
	108	"Debug option set for zebra next hop tracking\n")
	109	{
	110	zebra_debug_nht = ZEBRA_DEBUG_NHT;
	111	return CMD_WARNING;
	112	}
	113
7758e3f3	114	DEFUN (debug_zebra_mpls,
	115	debug_zebra_mpls_cmd,
	116	"debug zebra mpls",
	117	DEBUG_STR
	118	"Zebra configuration\n"
	119	"Debug option set for zebra MPLS LSPs\n")
	120	{
	121	zebra_debug_mpls = ZEBRA_DEBUG_MPLS;
	122	return CMD_WARNING;
	123	}
	124
718e3744	125	DEFUN (debug_zebra_packet,
718e3744	126	debug_zebra_packet_cmd,
16cedbb0	127	"debug zebra packet [<recv\|send>] [detail]",
718e3744	128	DEBUG_STR
	129	"Zebra configuration\n"
	130	"Debug option set for zebra packet\n"
	131	"Debug option set for receive packet\n"
16cedbb0 QY	132	"Debug option set for send packet\n"
16cedbb0 QY	133	"Debug option set for detailed info\n")
718e3744	134	{
16cedbb0	135	int idx = 0;
718e3744	136	zebra_debug_packet = ZEBRA_DEBUG_PACKET;
16cedbb0 QY	137
16cedbb0 QY	138	if (argv_find (argv, argc, "send", &idx))
0d72b344	139	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
16cedbb0 QY	140	idx = 0;
16cedbb0 QY	141	if (argv_find (argv, argc, "recv", &idx))
0d72b344	142	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
16cedbb0 QY	143	idx = 0;
16cedbb0 QY	144	if (argv_find (argv, argc, "detail", &idx))
0d72b344	145	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_DETAIL);
718e3744	146
16cedbb0 QY	147	if (!(zebra_debug_packet & ZEBRA_DEBUG_SEND & ZEBRA_DEBUG_RECV))
16cedbb0 QY	148	{
0d72b344	149	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
0d72b344	150	SET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
16cedbb0	151	}
718e3744	152	return CMD_SUCCESS;
	153	}
	154
	155	DEFUN (debug_zebra_kernel,
	156	debug_zebra_kernel_cmd,
	157	"debug zebra kernel",
	158	DEBUG_STR
	159	"Zebra configuration\n"
	160	"Debug option set for zebra between kernel interface\n")
	161	{
556b904e QY	162	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);
	163	return CMD_SUCCESS;
	164	}
	165
	166	DEFUN (debug_zebra_kernel_msgdump,
	167	debug_zebra_kernel_msgdump_cmd,
6de69f83	168	"debug zebra kernel msgdump [<recv\|send>]",
556b904e QY	169	DEBUG_STR
	170	"Zebra configuration\n"
	171	"Debug option set for zebra between kernel interface\n"
	172	"Dump raw netlink messages, sent and received\n"
	173	"Dump raw netlink messages received\n"
	174	"Dump raw netlink messages sent\n")
	175	{
7c022376 DW	176	int idx_recv_send = 4;
7c022376 DW	177	if (argv[idx_recv_send]->arg && strncmp(argv[idx_recv_send]->arg, "recv", strlen(argv[idx_recv_send]->arg)) == 0)
556b904e	178	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
7c022376	179	if (!argv[idx_recv_send]->arg \|\| strncmp(argv[idx_recv_send]->arg, "send", strlen(argv[idx_recv_send]->arg)) == 0)
556b904e	180	SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
718e3744	181	return CMD_SUCCESS;
	182	}
	183
b0498dc6 PJ	184	DEFUN (debug_zebra_rib,
	185	debug_zebra_rib_cmd,
	186	"debug zebra rib",
	187	DEBUG_STR
	188	"Zebra configuration\n"
	189	"Debug RIB events\n")
	190	{
	191	SET_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB);
	192	return CMD_SUCCESS;
	193	}
	194
41ec9222	195	DEFUN (debug_zebra_rib_detailed,
	196	debug_zebra_rib_detailed_cmd,
	197	"debug zebra rib detailed",
b0498dc6 PJ	198	DEBUG_STR
	199	"Zebra configuration\n"
	200	"Debug RIB events\n"
41ec9222	201	"Detailed debugs\n")
b0498dc6	202	{
41ec9222	203	SET_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);
b0498dc6 PJ	204	return CMD_SUCCESS;
	205	}
	206
5adc2528 AS	207	DEFUN (debug_zebra_fpm,
	208	debug_zebra_fpm_cmd,
	209	"debug zebra fpm",
	210	DEBUG_STR
	211	"Zebra configuration\n"
	212	"Debug zebra FPM events\n")
	213	{
	214	SET_FLAG (zebra_debug_fpm, ZEBRA_DEBUG_FPM);
	215	return CMD_SUCCESS;
	216	}
	217
718e3744	218	DEFUN (no_debug_zebra_events,
	219	no_debug_zebra_events_cmd,
	220	"no debug zebra events",
	221	NO_STR
	222	DEBUG_STR
	223	"Zebra configuration\n"
	224	"Debug option set for zebra events\n")
	225	{
	226	zebra_debug_event = 0;
	227	return CMD_SUCCESS;
	228	}
	229
fb018d25 DS	230	DEFUN (no_debug_zebra_nht,
	231	no_debug_zebra_nht_cmd,
	232	"no debug zebra nht",
	233	NO_STR
	234	DEBUG_STR
	235	"Zebra configuration\n"
	236	"Debug option set for zebra next hop tracking\n")
	237	{
	238	zebra_debug_nht = 0;
	239	return CMD_SUCCESS;
	240	}
	241
7758e3f3	242	DEFUN (no_debug_zebra_mpls,
	243	no_debug_zebra_mpls_cmd,
	244	"no debug zebra mpls",
	245	NO_STR
	246	DEBUG_STR
	247	"Zebra configuration\n"
	248	"Debug option set for zebra MPLS LSPs\n")
	249	{
	250	zebra_debug_mpls = 0;
	251	return CMD_SUCCESS;
	252	}
	253
718e3744	254	DEFUN (no_debug_zebra_packet,
718e3744	255	no_debug_zebra_packet_cmd,
16cedbb0	256	"no debug zebra packet [<recv\|send>]",
718e3744	257	NO_STR
	258	DEBUG_STR
	259	"Zebra configuration\n"
	260	"Debug option set for zebra packet\n"
	261	"Debug option set for receive packet\n"
	262	"Debug option set for send packet\n")
	263	{
16cedbb0 QY	264	int idx = 0;
16cedbb0 QY	265	if (argc == 4 \|\| argv_find (argv, argc, "send", &idx))
0d72b344	266	UNSET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_SEND);
16cedbb0	267	if (argc == 4 \|\| argv_find (argv, argc, "recv", &idx))
0d72b344	268	UNSET_FLAG(zebra_debug_packet, ZEBRA_DEBUG_RECV);
718e3744	269	return CMD_SUCCESS;
	270	}
	271
	272	DEFUN (no_debug_zebra_kernel,
	273	no_debug_zebra_kernel_cmd,
	274	"no debug zebra kernel",
	275	NO_STR
	276	DEBUG_STR
	277	"Zebra configuration\n"
	278	"Debug option set for zebra between kernel interface\n")
	279	{
556b904e QY	280	UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL);
	281	return CMD_SUCCESS;
	282	}
	283
	284	DEFUN (no_debug_zebra_kernel_msgdump,
	285	no_debug_zebra_kernel_msgdump_cmd,
6de69f83	286	"no debug zebra kernel msgdump [<recv\|send>]",
16cedbb0	287	NO_STR
556b904e QY	288	DEBUG_STR
	289	"Zebra configuration\n"
	290	"Debug option set for zebra between kernel interface\n"
	291	"Dump raw netlink messages, sent and received\n"
	292	"Dump raw netlink messages received\n"
	293	"Dump raw netlink messages sent\n")
	294	{
16cedbb0 QY	295	int idx = 0;
16cedbb0 QY	296	if (argc == 5 \|\| argv_find (argv, argc, "recv", &idx))
556b904e	297	UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
16cedbb0	298	if (argc == 5 \|\| argv_find (argv, argc, "send", &idx))
556b904e	299	UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
16cedbb0	300
718e3744	301	return CMD_SUCCESS;
	302	}
	303
b0498dc6 PJ	304	DEFUN (no_debug_zebra_rib,
	305	no_debug_zebra_rib_cmd,
	306	"no debug zebra rib",
	307	NO_STR
	308	DEBUG_STR
	309	"Zebra configuration\n"
	310	"Debug zebra RIB\n")
	311	{
	312	zebra_debug_rib = 0;
	313	return CMD_SUCCESS;
	314	}
	315
41ec9222	316	DEFUN (no_debug_zebra_rib_detailed,
	317	no_debug_zebra_rib_detailed_cmd,
	318	"no debug zebra rib detailed",
b0498dc6 PJ	319	NO_STR
	320	DEBUG_STR
	321	"Zebra configuration\n"
	322	"Debug zebra RIB\n"
41ec9222	323	"Detailed debugs\n")
b0498dc6	324	{
41ec9222	325	UNSET_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED);
b0498dc6 PJ	326	return CMD_SUCCESS;
	327	}
	328
5adc2528 AS	329	DEFUN (no_debug_zebra_fpm,
	330	no_debug_zebra_fpm_cmd,
	331	"no debug zebra fpm",
	332	NO_STR
	333	DEBUG_STR
	334	"Zebra configuration\n"
	335	"Debug zebra FPM events\n")
	336	{
	337	zebra_debug_fpm = 0;
	338	return CMD_SUCCESS;
	339	}
	340
718e3744	341	/* Debug node. */
	342	struct cmd_node debug_node =
	343	{
	344	DEBUG_NODE,
	345	"", /* Debug node has no interface. */
	346	1
	347	};
	348
a1ac18c4	349	static int
718e3744	350	config_write_debug (struct vty *vty)
	351	{
	352	int write = 0;
	353
	354	if (IS_ZEBRA_DEBUG_EVENT)
	355	{
	356	vty_out (vty, "debug zebra events%s", VTY_NEWLINE);
	357	write++;
	358	}
	359	if (IS_ZEBRA_DEBUG_PACKET)
	360	{
	361	if (IS_ZEBRA_DEBUG_SEND && IS_ZEBRA_DEBUG_RECV)
	362	{
	363	vty_out (vty, "debug zebra packet%s%s",
	364	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
	365	VTY_NEWLINE);
	366	write++;
	367	}
	368	else
	369	{
	370	if (IS_ZEBRA_DEBUG_SEND)
	371	vty_out (vty, "debug zebra packet send%s%s",
	372	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
	373	VTY_NEWLINE);
	374	else
	375	vty_out (vty, "debug zebra packet recv%s%s",
	376	IS_ZEBRA_DEBUG_DETAIL ? " detail" : "",
	377	VTY_NEWLINE);
	378	write++;
	379	}
	380	}
	381	if (IS_ZEBRA_DEBUG_KERNEL)
	382	{
	383	vty_out (vty, "debug zebra kernel%s", VTY_NEWLINE);
	384	write++;
	385	}
41ec9222	386	/* Check here using flags as the 'macro' does an OR */
41ec9222	387	if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB))
b0498dc6 PJ	388	{
	389	vty_out (vty, "debug zebra rib%s", VTY_NEWLINE);
	390	write++;
	391	}
41ec9222	392	if (CHECK_FLAG (zebra_debug_rib, ZEBRA_DEBUG_RIB_DETAILED))
b0498dc6	393	{
41ec9222	394	vty_out (vty, "debug zebra rib detailed%s", VTY_NEWLINE);
b0498dc6 PJ	395	write++;
b0498dc6 PJ	396	}
5adc2528 AS	397	if (IS_ZEBRA_DEBUG_FPM)
	398	{
	399	vty_out (vty, "debug zebra fpm%s", VTY_NEWLINE);
	400	write++;
	401	}
7758e3f3	402	if (IS_ZEBRA_DEBUG_MPLS)
	403	{
	404	vty_out (vty, "debug zebra mpls%s", VTY_NEWLINE);
	405	write++;
	406	}
718e3744	407	return write;
	408	}
	409
	410	void
a1ac18c4	411	zebra_debug_init (void)
718e3744	412	{
	413	zebra_debug_event = 0;
	414	zebra_debug_packet = 0;
b0498dc6 PJ	415	zebra_debug_kernel = 0;
b0498dc6 PJ	416	zebra_debug_rib = 0;
5adc2528	417	zebra_debug_fpm = 0;
7758e3f3	418	zebra_debug_mpls = 0;
718e3744	419
	420	install_node (&debug_node, config_write_debug);
	421
	422	install_element (VIEW_NODE, &show_debugging_zebra_cmd);
	423
718e3744	424	install_element (ENABLE_NODE, &debug_zebra_events_cmd);
fb018d25	425	install_element (ENABLE_NODE, &debug_zebra_nht_cmd);
7758e3f3	426	install_element (ENABLE_NODE, &debug_zebra_mpls_cmd);
718e3744	427	install_element (ENABLE_NODE, &debug_zebra_packet_cmd);
718e3744	428	install_element (ENABLE_NODE, &debug_zebra_kernel_cmd);
556b904e	429	install_element (ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
b0498dc6	430	install_element (ENABLE_NODE, &debug_zebra_rib_cmd);
41ec9222	431	install_element (ENABLE_NODE, &debug_zebra_rib_detailed_cmd);
5adc2528	432	install_element (ENABLE_NODE, &debug_zebra_fpm_cmd);
718e3744	433	install_element (ENABLE_NODE, &no_debug_zebra_events_cmd);
fb018d25	434	install_element (ENABLE_NODE, &no_debug_zebra_nht_cmd);
7758e3f3	435	install_element (ENABLE_NODE, &no_debug_zebra_mpls_cmd);
718e3744	436	install_element (ENABLE_NODE, &no_debug_zebra_packet_cmd);
718e3744	437	install_element (ENABLE_NODE, &no_debug_zebra_kernel_cmd);
556b904e	438	install_element (ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
b0498dc6	439	install_element (ENABLE_NODE, &no_debug_zebra_rib_cmd);
41ec9222	440	install_element (ENABLE_NODE, &no_debug_zebra_rib_detailed_cmd);
5adc2528	441	install_element (ENABLE_NODE, &no_debug_zebra_fpm_cmd);
718e3744	442
718e3744	443	install_element (CONFIG_NODE, &debug_zebra_events_cmd);
fb018d25	444	install_element (CONFIG_NODE, &debug_zebra_nht_cmd);
7758e3f3	445	install_element (CONFIG_NODE, &debug_zebra_mpls_cmd);
718e3744	446	install_element (CONFIG_NODE, &debug_zebra_packet_cmd);
718e3744	447	install_element (CONFIG_NODE, &debug_zebra_kernel_cmd);
556b904e	448	install_element (CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
b0498dc6	449	install_element (CONFIG_NODE, &debug_zebra_rib_cmd);
41ec9222	450	install_element (CONFIG_NODE, &debug_zebra_rib_detailed_cmd);
5adc2528	451	install_element (CONFIG_NODE, &debug_zebra_fpm_cmd);
718e3744	452	install_element (CONFIG_NODE, &no_debug_zebra_events_cmd);
fb018d25	453	install_element (CONFIG_NODE, &no_debug_zebra_nht_cmd);
7758e3f3	454	install_element (CONFIG_NODE, &no_debug_zebra_mpls_cmd);
718e3744	455	install_element (CONFIG_NODE, &no_debug_zebra_packet_cmd);
718e3744	456	install_element (CONFIG_NODE, &no_debug_zebra_kernel_cmd);
556b904e	457	install_element (CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
b0498dc6	458	install_element (CONFIG_NODE, &no_debug_zebra_rib_cmd);
41ec9222	459	install_element (CONFIG_NODE, &no_debug_zebra_rib_detailed_cmd);
5adc2528	460	install_element (CONFIG_NODE, &no_debug_zebra_fpm_cmd);
718e3744	461	}