ospf_neighbor_events.c

vxworks下ospf协议栈

    ++sptr_neighbor->events;

    if (sptr_neighbor->address == sptr_interface->designated_router.address)
        {
        sptr_interface->designated_router.address = 0x00000000L;

        sptr_interface->sptr_neighbor->designated_router = 0x00000000L;
        }

    if (sptr_neighbor->address == sptr_interface->backup_designated_router.address)
        {
        sptr_interface->backup_designated_router.address = 0x00000000L;

        sptr_interface->sptr_neighbor->backup_designated_router = 0x00000000L;
        }


    sptr_neighbor = ospf_remove_neighbor_from_interface_neighbor_list (sptr_interface, sptr_neighbor);

#if defined (__OSPF_VIRTUAL_LINK__)

if (sptr_interface->type == OSPF_VIRTUAL_LINK)
    {
    if (ospf.sptr_backbone_area != NULL)
        {
        if (ospf.sptr_backbone_area->lock_time == 0x00000000L)
            {
			/* SPR 84312 -- Begin */
            ospf.sptr_backbone_area->lock_time = ospf_get_system_elapsed_time_second ();
            /* SPR 84312 -- End */
            }
        }
    if(sptr_interface->sptr_transit_area != NULL)
        {

        if (sptr_interface->sptr_transit_area->lock_time == 0x00000000L)
            {
			/* SPR 84312 -- Begin */
            sptr_interface->sptr_transit_area->lock_time = ospf_get_system_elapsed_time_second ();
            /* SPR 84312 -- End */
            }
        }

     }
#endif /* __OSPF_VIRTUAL_LINK__ */



    ospf_schedule_routing_table_build ();       /* the entire routing table must be recalculated */

    return;
}

/*******************************************************************************************************************************/
void ospf_clear_advertisements_from_lists (OSPF_INTERFACE *sptr_interface,OSPF_NEIGHBOR *sptr_neighbor)
{
    ospf_remove_all_database_pointers_from_neighbor_retransmit_list (sptr_neighbor);
    ospf_free_neighbor_database_summary_list (sptr_neighbor);
    ospf_free_neighbor_ls_request_list (sptr_neighbor);

    ospf_free_interface_acknowledgement_list (sptr_interface, TRUE);

    return;
}

/*******************************************************************************************************************************/
static void ospf_establish_adjacency (OSPF_INTERFACE *sptr_interface,OSPF_NEIGHBOR *sptr_neighbor)
{
    enum OSPF_NEIGHBOR_STATE old_state;

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

    old_state = sptr_neighbor->state;

    sptr_neighbor->state = OSPF_NEIGHBOR_EXCHANGE_START;

    ospf_update_designated_router_state_if_necessary (old_state, sptr_interface, sptr_neighbor);

    if (sptr_neighbor->database_description_sequence_number == 0x00000000L)
        {
		/* SPR 84312 -- Begin */
        sptr_neighbor->database_description_sequence_number = ospf_get_system_elapsed_time_second ();  /* first attempt at adjacency, so initialize to time of day clock (p. 82) */
        /* SPR 84312 -- End */
        }
    else
        {
        ++sptr_neighbor->database_description_sequence_number;
        }

    sptr_neighbor->flags._byte = 0x00;
    sptr_neighbor->flags._bit.master = TRUE;
    sptr_neighbor->flags._bit.initialize = TRUE;
    sptr_neighbor->flags._bit.more = TRUE;

    ospf_send_an_empty_database_description_packet (sptr_interface, sptr_neighbor);

    return;
}

/*******************************************************************************************************************************/
static OSPF_NEIGHBOR *ospf_remove_neighbor_from_interface_neighbor_list (OSPF_INTERFACE *sptr_interface,OSPF_NEIGHBOR *sptr_neighbor_to_remove)
{
    OSPF_NEIGHBOR *sptr_neighbor = NULL;
    OSPF_NEIGHBOR *sptr_next_neighbor = NULL;


    /*
     * This is the per interface neighborlist
     */

    OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_remove_neighbor_from_interface_neighbor_list\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;
        if (sptr_neighbor == sptr_neighbor_to_remove)
            {

		    /* SPR#76812 */
		    semTake (ospf_config_mutex, WAIT_FOREVER);

            ospf_remove_node_from_list ((OSPF_GENERIC_NODE **) &(sptr_interface->sptr_neighbor), (OSPF_GENERIC_NODE *) sptr_neighbor_to_remove);

            --ospf.number_of_neighbors;

            semGive (ospf_config_mutex);


#if defined(__OSPF_MIB__)
            if ( sptr_neighbor->sptr_interface->type == OSPF_VIRTUAL_LINK )
            {
                /* tell MIB API to remove this virtual neighbor */
                ospf2Mapi_request( (void *)sptr_neighbor, ospfVirtNbrDeleteReqType );
            }
            else
            {
                /* tell MIB API to remove this neighbor */
                ospf2Mapi_request( (void *)sptr_neighbor, ospfNbrDeleteReqType );
            }
#endif /* __OSPF_MIB__ */

            return (sptr_neighbor_to_remove);
            }
        }

    return (sptr_neighbor_to_remove);
}
/*******************************************************************************************************************************/
static void ospf_update_flags_due_to_adjacency_tear_down (OSPF_INTERFACE *sptr_interface)
{
    OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_update_flags_due_to_adjacency_tear_down\r\n");

    if (((sptr_interface->type == OSPF_BROADCAST) || (sptr_interface->type == OSPF_NBMA)) && (sptr_interface->state >= OSPF_INTERFACE_DESIGNATED_ROUTER))
        {
        sptr_interface->flags._bit.neighbor_change = TRUE;
        }
    else if ((sptr_interface->type == OSPF_POINT_TO_POINT) || (sptr_interface->type == OSPF_POINT_TO_MULTIPOINT) ||
        (sptr_interface->type == OSPF_VIRTUAL_LINK))
        {
        sptr_interface->sptr_area->build_router = TRUE;     /* update route information since the adjacency is now gone */
        }

    return;
}
/*******************************************************************************************************************************/
static void ospf_decrement_appropriate_neighbor_state_counters (OSPF_INTERFACE *sptr_interface,enum OSPF_NEIGHBOR_STATE old_state,
    enum OSPF_NEIGHBOR_STATE new_state)
{
    OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_decrement_appropriate_neighbor_state_counters\r\n");

    if ((old_state >= OSPF_NEIGHBOR_INITIALIZING) && (new_state < OSPF_NEIGHBOR_INITIALIZING))
        {
        ospf_update_neighbor_state_counters (sptr_interface, OSPF_NEIGHBOR_INITIALIZING, OSPF_DECREMENT_COUNTERS);
        }

    if ((old_state >= OSPF_NEIGHBOR_EXCHANGE) && (new_state < OSPF_NEIGHBOR_EXCHANGE))
        {
        ospf_update_neighbor_state_counters (sptr_interface, OSPF_NEIGHBOR_EXCHANGE, OSPF_DECREMENT_COUNTERS);
        }

    if ((old_state == OSPF_NEIGHBOR_FULL) && (new_state < OSPF_NEIGHBOR_FULL))
        {
        ospf_update_neighbor_state_counters (sptr_interface, OSPF_NEIGHBOR_FULL, OSPF_DECREMENT_COUNTERS);
        }

    return;
}
/*******************************************************************************************************************************/
static void ospf_update_designated_router_state_if_necessary (enum OSPF_NEIGHBOR_STATE old_state,OSPF_INTERFACE *sptr_interface,
    OSPF_NEIGHBOR *sptr_neighbor)
{
    OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_update_designated_router_state_if_necessary\r\n");

    if ((old_state >= OSPF_NEIGHBOR_2_WAY) &&
        (sptr_interface->designated_router.address != 0x00000000L) &&
        (sptr_interface->designated_router.id == sptr_neighbor->id) &&
        (sptr_interface->designated_router.address == sptr_neighbor->address))
        {
        sptr_interface->designated_router.state = sptr_neighbor->state;
        }

    return;
}
/*******************************************************************************************************************************/
static void ospf_update_neighbor_state_counters (OSPF_INTERFACE *sptr_interface,enum OSPF_NEIGHBOR_STATE state,
    enum OSPF_COUNTER_ACTION_TYPE action)
{
    OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "OSPF: Entering ospf_update_neighbor_state_counters\r\n");

    switch (state)
        {
        case OSPF_NEIGHBOR_INITIALIZING:
            {
            if (action == OSPF_INCREMENT_COUNTERS)
                {
                ++sptr_interface->number_of_neighbors_in_init_state;
                ++sptr_interface->sptr_area->number_of_neighbors_in_init_state;
                ++ospf.number_of_neighbors_in_init_state;
                }
            else
                {
                --sptr_interface->number_of_neighbors_in_init_state;
                --sptr_interface->sptr_area->number_of_neighbors_in_init_state;
                --ospf.number_of_neighbors_in_init_state;
                }

            break;
            }

        case OSPF_NEIGHBOR_FULL:
            {
            if (action == OSPF_INCREMENT_COUNTERS)
                {
                ++sptr_interface->number_of_neighbors_in_full_state;
                ++sptr_interface->sptr_area->number_of_neighbors_in_full_state;
                ++ospf.number_of_neighbors_in_full_state;
                }
            else
                {
                --sptr_interface->number_of_neighbors_in_full_state;
                --sptr_interface->sptr_area->number_of_neighbors_in_full_state;
                --ospf.number_of_neighbors_in_full_state;
                }

            break;
            }

        case OSPF_NEIGHBOR_EXCHANGE:
            {
            if (action == OSPF_INCREMENT_COUNTERS)
                {
                ++sptr_interface->number_of_neighbors_in_exchange_state;
                ++sptr_interface->sptr_area->number_of_neighbors_in_exchange_state;
                ++ospf.number_of_neighbors_in_exchange_state;
                }
            else
                {
                --sptr_interface->number_of_neighbors_in_exchange_state;
                --sptr_interface->sptr_area->number_of_neighbors_in_exchange_state;
                --ospf.number_of_neighbors_in_exchange_state;
                }

            break;
            }

        default:
            {
            break;
            }
        }

    return;
}
/*******************************************************************************************************************************/
static void ospf_neighbor_state_transition_printf (OSPF_NEIGHBOR *sptr_neighbor,enum OSPF_NEIGHBOR_EVENT event,
    enum OSPF_NEIGHBOR_STATE old_state)
{
    char print_buffer[PRINT_BUFFER_SIZE];

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

    OSPF_CONVERT_IP_ADDRESS_TO_DOT_FORMAT_FOR_DEBUG (print_buffer, sptr_neighbor->address);

    OSPF_PRINTF_NEIGHBOR (OSPF_NEIGHBOR_PRINTF, "OSPF: Neighbor %s has transitioned from state %s to state %s because of event %s\r\n",
        print_buffer, ospf_neighbor_states[old_state], ospf_neighbor_states[sptr_neighbor->state], ospf_neighbor_events[event]);

    return;
}
/***********************************************************************************************************************************/