ospf_utilities.c

vxworks下ospf协议栈

			return (PASS);
			}
		else
			{
			new_age = sptr_new_ls_header->age;
			new_age = net_to_host_short (new_age);

			current_age = sptr_current_ls_header->age;
			current_age = net_to_host_short (current_age);

			if (current_age == new_age)
				{
				return (FAIL);
				}
			else if (new_age == OSPF_MAXIMUM_AGE) /*#$-NOTE:note-$#*/
				{
				return (PASS);
				}

			if (new_age == OSPF_MAXIMUM_AGE)
				{
				if ((current_age + elapsed_time) < OSPF_MAXIMUM_AGE)
					{
					return (PASS);
					}
				}
			else
				{
				if (((current_age + elapsed_time) < OSPF_MAXIMUM_AGE) &&
					((current_age + elapsed_time) > new_age))
					{
					if (((current_age + elapsed_time) - new_age) > OSPF_MAXIMUM_AGE_DIFFERENCE)
						{
						return (PASS);
						}
					}
				}
			}
		}

	return (FAIL);
}


/******************************************************************************/
enum TEST ospf_check_if_same_instance (OSPF_LS_HEADER *sptr_new_ls_header,OSPF_LS_HEADER *sptr_current_ls_header,ULONG elapsed_time)
{
	USHORT new_age;
	USHORT current_age;
	ULONG difference;
	seq_t new_sequence_number;
	seq_t current_sequence_number;

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

	PARAMETER_NOT_USED(elapsed_time);

	new_sequence_number = sptr_new_ls_header->sequence_number;
	new_sequence_number = net_to_host_long (new_sequence_number);

	current_sequence_number = sptr_current_ls_header->sequence_number;
	current_sequence_number = net_to_host_long (current_sequence_number);

	if ((new_sequence_number == current_sequence_number) &&
		(sptr_new_ls_header->checksum == sptr_current_ls_header->checksum))
		{
		new_age = sptr_new_ls_header->age;
		new_age = net_to_host_short (new_age);

		current_age = sptr_current_ls_header->age;
		current_age = net_to_host_short (current_age);

		if (current_age == new_age)
			{
			return (PASS);
			}

		current_age = (USHORT) (current_age);

		if ((new_age == OSPF_MAXIMUM_AGE) && (current_age >= OSPF_MAXIMUM_AGE))
			{
			return (PASS);
			}
		else if ((new_age != OSPF_MAXIMUM_AGE) && (current_age < OSPF_MAXIMUM_AGE))
			{
			if (new_age > current_age)
				{
				difference = new_age - current_age;
				}
			else
				{
				difference = current_age - new_age;
				}

			if (difference <= OSPF_MAXIMUM_AGE_DIFFERENCE)
				{
				return (PASS);
				}
			}
		}

	return (FAIL);
}


/******************************************************************************/
/*
 * Description: This routine should only be called ONCE for each new
 * LSA that is to be originated.
 * Inputs: not used
 * Returns: The next sequence number in Network byte order
 */
seq_t ospf_increment_sequence_number (seq_t sequence_number_in_net_order)
{
	seq_t new_sequence_number;
	seq_t sequence_number_in_host_order;

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

	sequence_number_in_host_order = sequence_number_in_net_order;
	sequence_number_in_host_order = net_to_host_long(sequence_number_in_host_order);
	sequence_number_in_host_order++;

	new_sequence_number = sequence_number_in_host_order;

	if (new_sequence_number == OSPFINVALDLSSEQ)
		{
		new_sequence_number = OSPFINITLSSEQ;
		}

	OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: new_seq # = %x\n", new_sequence_number);

	new_sequence_number = host_to_net_long (new_sequence_number);

	return (new_sequence_number);

}


/******************************************************************************/
void ospf_add_entry_to_interfaces_delayed_acknowledgement_list (OSPF_INTERFACE *sptr_interface,OSPF_LS_DATABASE_ENTRY *sptr_database_entry)
{
	OSPF_LS_HEADER_QUEUE *sptr_acknowledgement;
	USHORT acknowledgement_age;

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

	if (sptr_database_entry == NULL)
		{
		return;
		}

	sptr_acknowledgement = (OSPF_LS_HEADER_QUEUE *) table_malloc (1, sizeof (OSPF_LS_HEADER_QUEUE));

	if (sptr_acknowledgement == NULL)
		{
		ospf_print_memory_error_message_and_free_buffer_if_necessary ((void *) NULL, "OSPF_LS_HEADER_QUEUE");

		return;
		}

	memset (sptr_acknowledgement, 0x00, sizeof (OSPF_LS_HEADER_QUEUE));

	sptr_acknowledgement->ls_header = sptr_database_entry->advertisement.sptr_router->ls_header;

	acknowledgement_age = sptr_database_entry->advertisement.sptr_router->ls_header.age;
	acknowledgement_age = net_to_host_short (acknowledgement_age);

	if (acknowledgement_age > OSPF_MAXIMUM_AGE)
		{
		acknowledgement_age = OSPF_MAXIMUM_AGE;
		}

	acknowledgement_age = host_to_net_short(acknowledgement_age);
	sptr_acknowledgement->ls_header.age = acknowledgement_age;
	sptr_acknowledgement->ls_header.options._byte = sptr_database_entry->advertisement.sptr_router->ls_header.options._byte;
	sptr_acknowledgement->ls_header.type = sptr_database_entry->advertisement.sptr_router->ls_header.type;
	sptr_acknowledgement->ls_header.id = sptr_database_entry->advertisement.sptr_router->ls_header.id;
	sptr_acknowledgement->ls_header.advertising_router = sptr_database_entry->advertisement.sptr_router->ls_header.advertising_router;
	sptr_acknowledgement->ls_header.sequence_number = sptr_database_entry->advertisement.sptr_router->ls_header.sequence_number;
	sptr_acknowledgement->ls_header.checksum = sptr_database_entry->advertisement.sptr_router->ls_header.checksum;
	sptr_acknowledgement->ls_header.length = sptr_database_entry->advertisement.sptr_router->ls_header.length;

	if (sptr_interface->sptr_head_of_delayed_acknowledgement_list == NULL)
		{
		sptr_interface->sptr_head_of_delayed_acknowledgement_list = sptr_acknowledgement;
		}
	else
		{
		ospf_add_node_to_end_of_list ((OSPF_GENERIC_NODE *) sptr_acknowledgement,
			(OSPF_GENERIC_NODE *) sptr_interface->sptr_head_of_delayed_acknowledgement_list);
		}

	++(sptr_interface->number_of_acknowledgements_on_delayed_acknowledgement_list);

	if (sptr_interface->delayed_acknowledgement_timer_enabled == FALSE)
		{
		sptr_interface->periodic_delayed_acknowledgement_time_counter = 0x00000000L;
		sptr_interface->delayed_acknowledgement_timer_enabled = TRUE;
		}

	return;
}


/******************************************************************************/
enum TEST ospf_check_for_valid_ls_type (OSPF_INTERFACE *sptr_interface,OSPF_LS_HEADER *sptr_ls_header, enum OSPF_UNION_PACKET_TYPES packet_type)
{
	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_check_for_valid_ls_type\r\n");
	switch (sptr_ls_header->type)
		{
		case OSPF_LS_ROUTER:
		case OSPF_LS_NETWORK:
		case OSPF_LS_SUMMARY_NETWORK:
		case OSPF_LS_SUMMARY_AS_BOUNDARY_ROUTER:
#if defined (__NSSA__)
		case OSPF_LS_TYPE_7:
#endif /*__NSSA__*/
			{
			return (PASS);
			}

        /*opaque lsa check for valid ls type jkw*/
#if defined (__OPAQUE_LSA__)
		case OSPF_LS_TYPE_9:
		case OSPF_LS_TYPE_10:
			if (ospf.opaque_capability == FALSE)
				{
				return FAIL;
				}
			else
				{
				return (PASS);
				}
        /*opaque lsa check for valid ls type jkw*/
		case OSPF_LS_TYPE_11:
			if (ospf.opaque_capability == FALSE)
				{
				return FAIL;
				}
			else
				{
				/* AS external advertisements are not flooded into/throughout stub+nssa areas.*/
				if ((sptr_interface->sptr_area->flags._bit.stub == TRUE) && (sptr_interface->sptr_area->flags._bit.nssa == TRUE))
					{
					if ((packet_type != OSPF_LINK_STATE_ACKNOWLEDGEMENT_PACKET) &&
						(packet_type != OSPF_DATABASE_DESCRIPTION_PACKET))
						{
						return (FAIL);
						}
					}
				else if (sptr_interface->type == OSPF_VIRTUAL_LINK)			/* AS external advertisements are never flooded */
					{																		/* over virtual adjacencies.                    */
					return (PASS);  /*#$-NOTE:note16-$#*/
					}
				else
					{
					return (PASS);
					}

				break;
				}
#endif /* __OPAQUE_LSA__ */

		case OSPF_LS_AS_EXTERNAL:
			{
			/* AS external advertisements are not flooded into/throughout stub+nssa areas.*/
			if ((sptr_interface->sptr_area->flags._bit.stub == TRUE) || (sptr_interface->sptr_area->flags._bit.nssa == TRUE))
				{
				if ((packet_type != OSPF_LINK_STATE_ACKNOWLEDGEMENT_PACKET) &&
					(packet_type != OSPF_DATABASE_DESCRIPTION_PACKET))
					{
					return (FAIL);
					}
				}
			else if (sptr_interface->type == OSPF_VIRTUAL_LINK)			/* AS external advertisements are never flooded */
				{																		/* over virtual adjacencies.                    */
				return (PASS);  /*#$-NOTE:note16-$#*/
				}
			else
				{
				return (PASS);
				}

			break;
			}

		default:
			{
			if ((packet_type != OSPF_LINK_STATE_ACKNOWLEDGEMENT_PACKET) &&
				(packet_type != OSPF_DATABASE_DESCRIPTION_PACKET))
				{
				return (FAIL);
				}

			break;
			}
		}

	OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: BAD LS TYPE\r\n");

	return (FAIL);
}


/******************************************************************************/
OSPF_HEADER *ospf_new_link_state_update (UNION_OSPF_ADVERTISEMENT_HEADER **ptr_to_uptr_acknowledgement_header,OSPF_INTERFACE *sptr_interface)
{
	ULONG			interface_mtu;
	OSPF_HEADER	*sptr_update_packet;

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

	sptr_update_packet = NULL;

	interface_mtu = ospf_get_interface_mtu (sptr_interface);

	sptr_update_packet = ospf_get_an_ospf_send_packet (interface_mtu);

	if (sptr_update_packet == NULL) /*!!!alexs check for null*/
		{

		OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: ospf_new_link_state_update::ospf_get_an_ospf_send_packet() failed!\r\n");

		return (NULL);
		}

	sptr_update_packet->rest_of_packet.ls_update.number_of_advertisements = 0x00000000L;

	*ptr_to_uptr_acknowledgement_header = (UNION_OSPF_ADVERTISEMENT_HEADER *) &(sptr_update_packet->rest_of_packet.ls_update.advertisement_header);

	return (sptr_update_packet);
}


/******************************************************************************/
enum TEST ospf_check_if_ip_destination_falls_into_address_range (ULONG destination_ip_address,ULONG destination_id,ULONG address_mask)
{
	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_check_if_ip_destination_falls_into_address_range\r\n");

	if ((destination_ip_address & address_mask) == (destination_id & address_mask))
		{
		return (PASS);
		}
	else
		{
		return (FAIL);
		}
}


/******************************************************************************/
enum TEST ospf_check_if_out_going_interface_belongs_to_the_passed_area (ULONG out_going_interfaces_address, OSPF_AREA_ENTRY* sptr_area)
{
	OSPF_INTERFACE *sptr_interface = NULL;
	OSPF_INTERFACE *sptr_next_interface = NULL;

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

	for (sptr_interface = sptr_area->sptr_interfaces; sptr_interface != NULL; sptr_interface = sptr_next_interface)
		{
		sptr_next_interface = sptr_interface->sptr_forward_link;
		if (sptr_interface->area_id == sptr_area->area_id)
			{
			if (sptr_interface->address == out_going_interfaces_address)
				{
				return (PASS);
				}
#if defined (__UNNUMBERED_LINK__)
			else if (out_going_interfaces_address == sptr_interface->port_number) /* unumbered */
				{
				return (PASS);
				}
#endif /* __UNNUMBERED_LINK__ */

			}
		}
	return (FAIL);
}


/******************************************************************************/
void ospf_transfer_fields_from_ls_request_structure_to_ls_header_structure (OSPF_LS_REQUEST *sptr_ls_request,OSPF_LS_HEADER *sptr_ls_header)
{
	OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_transfer_fields_from_ls_request_structure_to_ls_header_structure\r\n");

	sptr_ls_header->sequence_number = sptr_ls_request->sequence_number;
	sptr_ls_header->checksum = sptr_ls_request->checksum;
	sptr_ls_header->age = sptr_ls_request->age;

	return;
}


/******************************************************************************/
enum TEST ospf_parse_port_plain_text_or_md5_password (char *cptr_port_password_string)
{
	USHORT port_number;
	USHORT password_length;
	char *cptr_current_token;
	OSPF_AUTHENTICATION_KEY	*sptr_authentication_key;
	BYTE key_ID;

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

	password_length = 0x0000;

	cptr_current_token = strtok (cptr_port_password_string, " \t,;\n");