ospf_flood.c

vxworks下ospf协议栈

    OSPF_ROUTER_LINK_ADVERTISEMENT_HEADER *sptr_advertisement,
    OSPF_NEIGHBOR *sptr_neighbor_advertisement_received_from,
    enum BOOLEAN advertisement_installed
    )
    {
    OSPF_NEIGHBOR *sptr_neighbor = NULL;
    OSPF_NEIGHBOR *sptr_next_neighbor = NULL;
    enum BOOLEAN advertisement_was_added_to_a_retransmission_list = FALSE;
    enum BOOLEAN done_processing_this_neighbor;
    enum BOOLEAN found_lsa = TRUE;

    OSPF_PRINTF_PROLOGUE (
        OSPF_PROLOGUE_PRINTF,
        "OSPF: Entering ospf_examine_each_neighbor_and_add_advertisement_to_the_retransmission_list_if_necessary\r\n");


    for (sptr_neighbor = sptr_interface->sptr_neighbor;
         sptr_neighbor != NULL;
         sptr_neighbor = sptr_next_neighbor)
        {
        sptr_next_neighbor = sptr_neighbor->sptr_forward_link;
        /* section 13.3, item (1a) - (page 139) */

        if (sptr_neighbor->state < OSPF_NEIGHBOR_EXCHANGE)
            {
            continue;
            }

        /* section 13.3, item (1b) - (page 139) */

        if ((sptr_neighbor->state == OSPF_NEIGHBOR_EXCHANGE) ||
            (sptr_neighbor->state == OSPF_NEIGHBOR_LOADING))
            {
            done_processing_this_neighbor = ospf_update_ls_request_list_for_this_adjacency (sptr_advertisement, sptr_neighbor);

            if (done_processing_this_neighbor == TRUE)
                {
                continue;
                }
            }

        /*
         * If the advertisement was learned from the this neighbor skip
         * to next neighbor on the interface list
         */
        if (sptr_neighbor_advertisement_received_from != NULL)
            {

        if (sptr_neighbor->address == sptr_neighbor_advertisement_received_from->address)
            {
            continue;
            }
            }


       /*opaque lsa examine each neighbor retransmission list jkw*/
        /*RFC 2370 Section 3.1 item 4*/
#if defined (__OPAQUE_LSA__)
        if ((sptr_advertisement->ls_header.type == OSPF_LS_TYPE_9) ||
            (sptr_advertisement->ls_header.type == OSPF_LS_TYPE_10) ||
            (sptr_advertisement->ls_header.type == OSPF_LS_TYPE_11))
            {
            if (sptr_neighbor->opaque_capability == FALSE)
                {
                continue;
                }
            }
#endif (__OPAQUE_LSA__)


        /* section 13.3, item (1d) - (page 139) */

        *ptr_to_sptr_database_list = ospf_add_advertisement_to_the_link_state_retransmission_list_for_the_adjacency (sptr_advertisement,
            sptr_neighbor, *ptr_to_sptr_database_list, advertisement_was_added_to_a_retransmission_list, &found_lsa, advertisement_installed);

        /* Added change as per TMS PR #1590
               Return FALSE if failed to add advertisement to retransmission list*/

        if (( *ptr_to_sptr_database_list == NULL ) && (found_lsa == TRUE))
            {
            advertisement_was_added_to_a_retransmission_list = FALSE;
            }
        else
            {
            advertisement_was_added_to_a_retransmission_list = TRUE;
            }
        }

    return (advertisement_was_added_to_a_retransmission_list);
    }


/*************************************************************************
*
* ospf_update_ls_request_list_for_this_adjacency - update link state request list for adjacency
*
* This routine will update the link state request list
* for the adjacency for a particular neighbor.
*
* <sptr_advertisement> Advertisement to be added to retransmit list
*
* <sptr_neighbor> OSPF neighbor
*
* RETURNS: TRUE or FALSE
*
* ERRNO: N/A
*
* NOMANUAL
*/
/*************************************************************************************//* section 13.3, item (1b) - (page 139) */
static enum BOOLEAN ospf_update_ls_request_list_for_this_adjacency (OSPF_ROUTER_LINK_ADVERTISEMENT_HEADER *sptr_advertisement,
    OSPF_NEIGHBOR *sptr_neighbor)
{
    OSPF_LS_DATABASE_ENTRY database_entry;
    OSPF_LS_REQUEST *sptr_ls_request =NULL;
    OSPF_LS_HEADER ls_header;
    enum TEST return_test_type;
    enum BOOLEAN done_processing_this_neighbor;

    OSPF_PRINTF_PROLOGUE (OSPF_PROLOGUE_PRINTF, "OSPF: Entering ospf_update_ls_request_list_for_this_adjacency\r\n");

    done_processing_this_neighbor = FALSE;

    database_entry.advertisement.sptr_router = sptr_advertisement;

    sptr_ls_request = ospf_find_advertisement_on_neighbors_ls_request_list (sptr_neighbor, &database_entry);

    if (sptr_ls_request != NULL)
        {
        /*
         * ospf_check_if_more_recent () requires two variables of type OSPF_LS_HEADER as input.  So transfer the necessary fields from
         * the OSPF_LS_REQUEST structure to a temporary OSPF_LS_HEADER structure so we can call the routine properly.
         */

        ospf_transfer_fields_from_ls_request_structure_to_ls_header_structure (sptr_ls_request, &ls_header);

        /* section 13.3, item (1b), bullet #1 - (page 139) */

        return_test_type = ospf_check_if_more_recent (&ls_header, &(sptr_advertisement->ls_header), 0x00000000L);

        if (return_test_type == PASS)
            {
            OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Advertisement is less recent\r\n");

            done_processing_this_neighbor = TRUE;
            }
        else
            {
            /* section 13.3, item (1b), bullet #2 and #3 - (page 139) */

            OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Deleting advertisement from Link state request list\r\n");

            ospf_remove_node_from_list ((OSPF_GENERIC_NODE **) &(sptr_neighbor->sptr_ls_request[sptr_advertisement->ls_header.type]),
                (OSPF_GENERIC_NODE *) sptr_ls_request);

            table_free ((void *) sptr_ls_request);

            sptr_ls_request = NULL;

            --sptr_neighbor->ls_request_queue_count;

            if ((sptr_neighbor->ls_request_queue_count == 0x0000) && (sptr_neighbor->state == OSPF_NEIGHBOR_LOADING))
                {
                ospf_execute_neighbor_state_machine (OSPF_LOADING_DONE, sptr_neighbor->state, sptr_neighbor->sptr_interface, sptr_neighbor);
                }

            sptr_neighbor->ls_request_list_has_changed = TRUE;

            /* section 13.3, item (1b), bullet #2 - (page 139) */

            return_test_type = ospf_check_if_same_instance (&ls_header, &(sptr_advertisement->ls_header), 0x00000000L);

            if (return_test_type == PASS)
                {
                OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Advertisement is the same instance\r\n");

                done_processing_this_neighbor = TRUE;
                }
            }
        }

    return (done_processing_this_neighbor);
}

/*************************************************************************
*
* ospf_add_advertisement_to_the_link_state_retransmission_list_for_the_adjacency - add advertisement to retransmission list
*
* This routine will update the retransmission list
* for the adjacency for a particular neighbor.
*
* <sptr_advertisement> Advertisement to be added to retransmit list
*
* <sptr_neighbor> OSPF neighbor
*
* <sptr_database_list> Database list
*
* <advertisement_was_added_to_a_retransmission_list> Boolean if advertisement was added to retransmission list
*
* <advertisement_installed> Boolean to check if advertisement is installed
*
* RETURNS: OSPF_LS_DATABASE_NODE * or NULL
*
* ERRNO: N/A
*
* NOMANUAL
*/
static OSPF_LS_DATABASE_NODE *ospf_add_advertisement_to_the_link_state_retransmission_list_for_the_adjacency (
    OSPF_ROUTER_LINK_ADVERTISEMENT_HEADER *sptr_advertisement,OSPF_NEIGHBOR *sptr_neighbor,OSPF_LS_DATABASE_NODE *sptr_database_list,
    enum BOOLEAN advertisement_was_added_to_a_retransmission_list, enum BOOLEAN *found_lsa, enum BOOLEAN advertisement_installed)
{
    OSPF_LS_DATABASE_ENTRY *sptr_database_entry =NULL;
    OSPF_LS_DATABASE_ENTRY *sptr_database_entry_fill_retrans_info =NULL;
    OSPF_LS_DATABASE_NODE *sptr_database_node =NULL;
    OSPF_LS_DATABASE_NODE *sptr_lsdb_node =NULL;
    OSPF_NEIGHBOR_LIST *sptr_neighbor_retrans_info =NULL;

    ULONG link_state_id =0;
    ULONG advertising_router =0;
    USHORT age = 0x0000;

    OSPF_PRINTF_PROLOGUE (OSPF_PROLOGUE_PRINTF, "OSPF: Entering ospf_add_advertisement_to_the_link_state_retransmission_list_for_the_adjacency\r\n");

    sptr_database_node = NULL;
    sptr_lsdb_node = NULL;
    sptr_neighbor_retrans_info = NULL;

    PARAMETER_NOT_USED (sptr_database_node);
    PARAMETER_NOT_USED (sptr_lsdb_node);
    PARAMETER_NOT_USED (sptr_neighbor_retrans_info);

    link_state_id = sptr_advertisement->ls_header.id;
    link_state_id = net_to_host_long (link_state_id);

    advertising_router = sptr_advertisement->ls_header.advertising_router;
    advertising_router = net_to_host_long (advertising_router);

    if (advertisement_installed == TRUE)
    {
        /* SPR#76812 */
        sptr_database_entry_fill_retrans_info = ospf_find_LSA(sptr_neighbor->sptr_interface->sptr_area,
                                                              link_state_id, advertising_router,
                                                              sptr_advertisement->ls_header.type);
    }

    if (sptr_database_entry_fill_retrans_info == NULL)
        {
        *found_lsa = FALSE;
        }

    sptr_database_entry = (OSPF_LS_DATABASE_ENTRY *) table_malloc (1, sizeof (OSPF_LS_DATABASE_ENTRY));

    if (sptr_database_entry == NULL)
        {
        ospf_print_memory_error_message_and_free_buffer_if_necessary ((void *) NULL, "OSPF_LS_DATABASE_ENTRY");
        *found_lsa = TRUE;
        return (NULL);
        }

    memset (sptr_database_entry, 0x00, sizeof (OSPF_LS_DATABASE_ENTRY));

    if (sptr_database_entry_fill_retrans_info == NULL)
        {
        sptr_database_entry->advertisement.sptr_router = sptr_advertisement;
        }
    else
        {
        sptr_database_entry->advertisement.sptr_router = sptr_database_entry_fill_retrans_info->advertisement.sptr_router;
        }


    age = sptr_advertisement->ls_header.age;
    age = net_to_host_short(age);
    if (age == OSPF_MAXIMUM_AGE)
        {
        sptr_database_entry->advertisement.sptr_router->ls_header.age = sptr_advertisement->ls_header.age;
        }

    if (sptr_database_entry_fill_retrans_info != NULL)
        {
        ospf_add_database_entry_to_neighbor_retransmit_list (sptr_neighbor, sptr_database_entry );
        ospf_add_neighbor_to_database_retransmit_list (sptr_database_entry_fill_retrans_info, sptr_neighbor);
        }

    if (advertisement_was_added_to_a_retransmission_list == FALSE)      /* first time, so initialize database list */
        {
        sptr_database_list = (OSPF_LS_DATABASE_NODE *) table_malloc (1, sizeof (OSPF_LS_DATABASE_NODE));

        if (sptr_database_list == NULL)
            {
            ospf_print_memory_error_message_and_free_buffer_if_necessary ((void *) sptr_database_entry, "OSPF_LS_DATABASE_NODE");
            *found_lsa = TRUE;
            return (NULL);
            }

        memset (sptr_database_list, 0x00, sizeof (OSPF_LS_DATABASE_NODE));

        sptr_database_list->sptr_forward_link = NULL;
        sptr_database_list->sptr_backward_link = NULL;
        sptr_database_list->sptr_ls_database_entry = sptr_database_entry;
        sptr_database_list->flood = TRUE;
        sptr_database_list->periodic_retransmit_time_counter = 0x00000000L;
        }

    *found_lsa = TRUE;
    return (sptr_database_list);
}