ospf_print_utilities.c

vxworks下ospf协议栈

	advertising_router = sptr_ls_header->advertising_router;
	advertising_router = net_to_host_long (advertising_router);

	OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_DEBUG (print_buffer_1, advertising_router);

	sequence_number = sptr_ls_header->sequence_number;
	sequence_number = net_to_host_long (sequence_number);

	length = sptr_ls_header->length;
	length = net_to_host_short (length);

	/* Check for valid index for array string */
	if (type > OSPF_LS_MAX)
		{
		OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "LSA TYPE = %x\n", type);
		type = OSPF_LS_MAX;
		}

	OSPF_PRINTF_PACKET (OSPF_PACKET_PRINTF, "      --- LS Header ---\r\n");
	OSPF_PRINTF_PACKET (OSPF_PACKET_PRINTF,
		"         age = %d, type = %s, id = %s, advertising router = %s, sequence number = %u, checksum = %x, length = %d\r\n",
		age, cptr_ls_type_string[type], print_buffer, print_buffer_1, sequence_number, sptr_ls_header->checksum, length);

	return;
}
/********************************************************************************************************************************/
void ospf_print_memory_error_message_and_free_buffer_if_necessary (void *vptr_buffer,const char *cptr_string)
{
	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_print_memory_error_message_and_free_buffer_if_necessary\r\n");

	OSPF_PRINTF_MEMORY (OSPF_MEMORY_PRINTF, "OSPF: Unable to allocate memory for %s\r\n", cptr_string);

	if (vptr_buffer != NULL)
		{
		table_free ((void*) vptr_buffer);

		vptr_buffer = NULL;
		}

	return;
}
/******************************************************************************************************************************/
void ospf_printf (enum OSPF_PRINTF_GROUPS printf_group,const char *cptr_format, ...)
{
	enum BOOLEAN print_string;

	va_list argptr;

	va_start (argptr,cptr_format);

	if (ospf.printing_enabled == FALSE)
		{
		va_end (argptr);

		return;
		}

	print_string = FALSE;

	switch (printf_group)
		{
		case OSPF_MEMORY_PRINTF:
			print_string = ospf.memory_printing_enabled;
			break;
		case OSPF_ALARM_PRINTF:
			print_string = ospf.alarm_printing_enabled;
			break;
		case OSPF_SNMP_PRINTF:
			print_string = ospf.snmp_printing_enabled;
			break;
		case OSPF_PACKET_PRINTF:
			print_string = ospf.packet_printing_enabled;
			break;
		case OSPF_ROUTING_TABLE_PRINTF:
			print_string = ospf.routing_table_printing_enabled;
			break;
		case OSPF_NEIGHBOR_PRINTF:
			print_string = ospf.neighbor_printing_enabled;
			break;
		case OSPF_INTERFACE_PRINTF:
			print_string = ospf.interface_printing_enabled;
			break;
		case OSPF_DEBUG_PRINTF:
			print_string = ospf.debug_printing_enabled;
			break;
		case OSPF_RTM_PRINTF:
			print_string = ospf.rtm_printing_enabled;
			break;
		case OSPF_PATRICIA_DEBUG_PRINTF:
			print_string = ospf.routing_table_printing_enabled;
			break;
		case OSPF_DB_OVERFLOW_PRINTF:
			print_string = ospf.db_overflow_printing_enabled;
			break;
		case OSPF_SEARCH_PRINTF:
			print_string = ospf.search_printing_enabled;
			break;
		case OSPF_PROLOGUE_PRINTF:
			print_string = ospf.prologue_printing_enabled;
			break;
		default:
			break;
		}

	if (print_string == TRUE)
		vprintf (cptr_format,argptr);

	va_end (argptr);

	return;
}

void ospf_printf_stub(enum OSPF_PRINTF_GROUPS printf_group,const char *cptr_format, ...) /*added for the case when the debug option is turned off*/
{
	PARAMETER_NOT_USED (printf_group);
	PARAMETER_NOT_USED (cptr_format);

	return;
}

/**********************************************************************************************************************************/
void ospf_display_routing_table (void)
{
	ULONG index;
	enum OSPF_ROUTE_TABLE_TYPE table_type;
	enum BOOLEAN empty = TRUE;

	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_display_routing_table\r\n");

	OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "-----------------------------------------------------------------------\r\n");
	OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "                 OSPF: Printing New OSPF routing table:\r\n");
	OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "-----------------------------------------------------------------------\r\n");

	/* SPR#76812 -- Begin */
    for(table_type = OSPF_ROUTE_TABLE_NETWORK; table_type < OSPF_ROUTE_TABLE_MAX; table_type++)
    {
		for(index = 0x00000000L; index < OSPF_RT_HASH_TABLE_SIZE; index++)
		{
			if(ospf.sptr_routing_table_head[table_type][index] != NULL)
			{
				empty = FALSE;
			}
		}
	}

	if(empty == TRUE)
	{
		OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF: --- ROUTING TABLE IS EMPTY ---------------------------\r\n");
	}
	else
	{
		ospf_display_routing_table_node ();
	}
	/* SPR#76812 -- End */

	OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "                 End of OSPF routing table\r\n");
	OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "------------------------------------------------------------------------\r\n");

	return;
}
/**********************************************************************************************************************************/
void ospf_display_routing_table_node (void)
{
	char print_buffer[PRINT_BUFFER_SIZE];
	char print_buffer_1[PRINT_BUFFER_SIZE];
	enum OSPF_ROUTE_DESTINATION_TYPE destination_type;
	enum OSPF_ROUTE_PATH_TYPE path_type;
	ULONG index;
	enum OSPF_ROUTE_TABLE_TYPE table_type;
	OSPF_ROUTING_TABLE_NODE *sptr_routing_table_node = NULL;

	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_display_routing_table_node\r\n");

	/* SPR#76812 -- Begin */
	for(table_type = OSPF_ROUTE_TABLE_NETWORK; table_type < OSPF_ROUTE_TABLE_MAX; table_type++)
	{
		for(index = 0x00000000L; index < OSPF_RT_HASH_TABLE_SIZE; index++)
		{
			for(sptr_routing_table_node = ospf.sptr_routing_table_head[table_type][index];
			    sptr_routing_table_node != NULL;
		 		sptr_routing_table_node = sptr_routing_table_node->sptr_forward_link)
		 	{
				if (sptr_routing_table_node->active_areas_discarded_entry == TRUE )
				{
					OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:----->Routing table entry discarded OR Marked for Delete<-----");
				}

				OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_ROUTING_TABLE (print_buffer, sptr_routing_table_node->sptr_routing_table_entry->destination_id);
				OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_ROUTING_TABLE (print_buffer_1, sptr_routing_table_node->sptr_routing_table_entry->address_mask);

				destination_type = sptr_routing_table_node->sptr_routing_table_entry->destination_type;

				if (destination_type > OSPF_DESTINATION_TYPE_ASE + 1)
				{
					destination_type = (enum	OSPF_ROUTE_DESTINATION_TYPE) (OSPF_DESTINATION_TYPE_ASE + 1);					/* unknown */
				}

				/* Check for valid index in array */
				if ((sptr_routing_table_node->route_node_status != OSPF_ROUTE_IS_NOT_NEW) &&
					(sptr_routing_table_node->route_node_status != OSPF_ROUTE_IS_NEW) &&
					(sptr_routing_table_node->route_node_status != OSPF_ROUTE_IS_NOT_AVAILABLE_NOW) &&
					(sptr_routing_table_node->route_node_status != OSPF_ROUTE_STATUS_DONT_CARE))
				{
					OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "ROUTE STATUS = %x\n", sptr_routing_table_node->route_node_status);
					sptr_routing_table_node->route_node_status = OSPF_ROUTE_STATUS_DONT_CARE + 1;
				}

				/* Check for valid index in array */
				if ((destination_type != OSPF_DESTINATION_TYPE_NETWORK) &&
					(destination_type != OSPF_DESTINATION_TYPE_ASBR) &&
					(destination_type != OSPF_DESTINATION_TYPE_ABR) &&
					(destination_type != OSPF_DESTINATION_TYPE_VIRTUAL) &&
					(destination_type != OSPF_DESTINATION_TYPE_ASE) &&
					(destination_type != OSPF_DESTINATION_TYPE_WILDCARD))
				{
					OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "DESTINATION TYPE = %x\n", destination_type);
					destination_type = OSPF_DESTINATION_TYPE_ASE + 1;
				}

				OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:              destination: id = %s, mask = %s, type = %s  Route_Node_Status: %s\r\n",
				print_buffer, print_buffer_1, cptr_destination_type_string[destination_type],
				cptr_route_node_or_next_hop_status[sptr_routing_table_node->route_node_status]);

				if (sptr_routing_table_node->sptr_routing_table_entry->sptr_area != NULL)
				{
					OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_ROUTING_TABLE (print_buffer, sptr_routing_table_node->sptr_routing_table_entry->sptr_area->area_id);
				}
				else
				{
					sprintf (print_buffer, "----");
				}

				OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:              area = %s\r\n", print_buffer);

				path_type = sptr_routing_table_node->sptr_routing_table_entry->path_type;

				if ((path_type != OSPF_ROUTE_PATH_TYPE_INTRA) &&
					(path_type != OSPF_ROUTE_PATH_TYPE_INTER) &&
					(path_type != OSPF_ROUTE_PATH_TYPE_1_EXTERNAL) &&
					(path_type != OSPF_ROUTE_PATH_TYPE_2_EXTERNAL) &&
					(path_type != OSPF_ROUTE_PATH_TYPE_WILDCARD))
				{
					OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "PATH TYPE = %x\n", path_type);
					path_type = OSPF_ROUTE_PATH_TYPE_2_EXTERNAL + 1;
				}

				OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:              path: cost = %d, type = %s\r\n",
				sptr_routing_table_node->sptr_routing_table_entry->path_cost, cptr_path_type_string[path_type]);

				ospf_print_next_hops (sptr_routing_table_node->sptr_routing_table_entry->sptr_next_hop);

				OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_ROUTING_TABLE (print_buffer, sptr_routing_table_node->sptr_routing_table_entry->advertising_router);

				OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:              advertising router = %s\r\n", print_buffer);

				/* Check for valid index for array string */
				if (sptr_routing_table_node->sptr_routing_table_entry->link_type > OSPF_LS_MAX)
				{
					OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "LSA TYPE = %x\n", sptr_routing_table_node->sptr_routing_table_entry->link_type);
					sptr_routing_table_node->sptr_routing_table_entry->link_type = OSPF_LS_MAX;
				}

				OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:              Miscellaneous INFO - link state_id(in HEX): %lx cashecd ip address(in HEX): %lx OSPF Link Type: %s \r\n",
				sptr_routing_table_node->sptr_routing_table_entry->link_state_id,
				sptr_routing_table_node->sptr_routing_table_entry->cached_ip_address,
				cptr_link_type[sptr_routing_table_node->sptr_routing_table_entry->link_type]);

				OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF: \r\n");
			}
		}
	}
	/* SPR#76812 -- End */
}
/**********************************************************************************************************************************/
void ospf_print_next_hops (OSPF_NEXT_HOP_BLOCK* sptr_next_hop)
{
	char print_buffer[PRINT_BUFFER_SIZE];
	char print_buffer_1[PRINT_BUFFER_SIZE];

	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_print_next_hops\r\n");

	for (; sptr_next_hop != NULL; sptr_next_hop = sptr_next_hop->sptr_forward_link)
		{
		memset (print_buffer, 0x00, PRINT_BUFFER_SIZE);

		memset (print_buffer_1, 0x00, PRINT_BUFFER_SIZE);

		OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_ROUTING_TABLE (print_buffer, sptr_next_hop->next_hop_router);

		OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_ROUTING_TABLE (print_buffer_1, sptr_next_hop->outgoing_router_interface);

		/* Check for valid index in array */
		if ((sptr_next_hop->route_status != OSPF_ROUTE_IS_NOT_NEW) &&
			(sptr_next_hop->route_status != OSPF_ROUTE_IS_NEW) &&
			(sptr_next_hop->route_status != OSPF_ROUTE_IS_NOT_AVAILABLE_NOW) &&
			(sptr_next_hop->route_status != OSPF_ROUTE_STATUS_DONT_CARE))
			{
			OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "ROUTE STATUS = %x\n", sptr_next_hop->route_status);
			sptr_next_hop->route_status = OSPF_ROUTE_STATUS_DONT_CARE + 1;
			}

		OSPF_PRINTF_ROUTING_TABLE (OSPF_ROUTING_TABLE_PRINTF, "OSPF:              next hop: router = %s, outgoing interface = %s  Next_Hop_Status: %s\r\n",
			print_buffer, print_buffer_1, cptr_route_node_or_next_hop_status[sptr_next_hop->route_status]);
		}

	return;
}