ospf_transmit_update.c

vxworks下ospf协议栈

        if elapsed time bigger than retransmission interval configured for the interface,
            then update timestamp and accept sending LSA,
            else deny retransmission of this LSA */

    /* Pseudocode: compute elapsed time (take care of wrap around) */

    /* compute elapsed time since last transmission */
    if (current_time >= last_tx_time)
        {
        elapsed_time = current_time - last_tx_time;
        }
    else
        {
        /* current_time in seconds has wrapped since last LSA transmission */
        elapsed_time = 0xFFFFFFFFL + current_time - last_tx_time;
        }

    /*  Pseudocode:
        if (elapsed time >= sptr_interface->retransmit_interval)
            record new timestamp of transmission to this neighbor
            return TRUE (accept transmitting LSA)
        else
            return FALSE (prevent transmitting LSA)
    */
    if (elapsed_time >= sptr_interface->retransmit_interval)
        {
        OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF,"\n          Elapsed time %ld, Interface RxmtInterval %ld ",
               elapsed_time, sptr_interface->retransmit_interval);

        /* should retransmit this LSA: elapsed time since last
        transmission to this neighbor is bigger than
        retransmit interval configured for the interface,
        according to this DB node */
        /* accept transmitting LSA
            and record timestamp of this transmission */
        if (sptr_lsdb_entry != NULL)
            {
            ospf_update_lsa_transmit_timestamp(sptr_lsdb_entry,
                                               sptr_lsa_timestamp,
                                               current_time,
                                               destination_router_id,
                                               sptr_neighbor,
                                               sptr_interface->ifnet_index);

            OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF, "\n        LSA transmit accepted");

            }
        return TRUE;
        }
    else /* Too early: elapsed_time < sptr_interface->retransmit_interval */
        {
        /* must NOT retransmit this LSA: elapsed time since last
        transmission to this neighbor is bigger than
        retransmit interval configured for the interface */

        OSPF_PRINTF_DEBUG (OSPF_DEBUG_PRINTF,"\n        LSA transmit filtered: LSA for %08lx elapsed time %ld, crt time %ld, interface retx interval %ld for %08lx ",
               sptr_database_node->sptr_ls_database_entry->advertisement.sptr_router->ls_header.id,
               elapsed_time, current_time, last_tx_time, destination_router);

        return FALSE;
        }
    }

/****************************************************************************************/

/* Function ospf_free_timestamps_for_lsdb_entry
    frees all timestamps of LSA transmissions for the given LSDB entry
   To be called before deleting any database entry

   Pseudocode:
    if LSDB entry is NULL
        return
    else
        for every timestamp node in the list (of LSA timestamps of the LSDB entry)
        dequeue the timestamp node from list
        free timestamp node
*/

void ospf_free_timestamps_for_lsdb_entry(OSPF_LS_DATABASE_ENTRY *sptr_database_entry)
{
    OSPF_LSA_TIMESTAMP_PER_INTERFACE_LIST *sptr_retx_timestamp_node = NULL;
    OSPF_LSA_TIMESTAMP_PER_INTERFACE_LIST *sptr_next_retx_timestamp_node = NULL;
    if (sptr_database_entry == NULL)
    {   /* param error, recover */
        return;
    }
    /* before database entry is deleted, deallocate its timestamps if any */
    if (sptr_database_entry->sptr_lsa_retransmit_timestamps_per_neighbor != NULL)
    {
        for (   sptr_retx_timestamp_node = sptr_database_entry->sptr_lsa_retransmit_timestamps_per_neighbor;
                sptr_retx_timestamp_node != NULL;
                sptr_retx_timestamp_node = sptr_next_retx_timestamp_node)
        {
            sptr_next_retx_timestamp_node = sptr_retx_timestamp_node->sptr_forward_link;
            ospf_remove_node_from_list ((OSPF_GENERIC_NODE **) &(sptr_database_entry->sptr_lsa_retransmit_timestamps_per_neighbor),
                (OSPF_GENERIC_NODE *) sptr_retx_timestamp_node);
            table_free(sptr_retx_timestamp_node);
        }
        sptr_database_entry->sptr_lsa_retransmit_timestamps_per_neighbor = NULL;
    }

} /* ospf_free_timestamps_for_lsdb_entry */

/* SPR 88619 end */


/**********************************************************************************************************************************/
static enum BOOLEAN ospf_check_if_packet_is_full
    (
    OSPF_LS_DATABASE_NODE *sptr_database_node,
    OSPF_INTERFACE *sptr_interface,
    ULONG packet_length
    )
    {
    OSPF_ROUTER_LINK_ADVERTISEMENT_HEADER *sptr_router_link_advertisement_header;
    ULONG interface_mtu;
    ULONG authentication_size;
    USHORT length_of_advertisement;

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

    interface_mtu = ospf_get_interface_mtu (sptr_interface);

    authentication_size = ospf_get_authentication_size (sptr_interface);

    sptr_router_link_advertisement_header = sptr_database_node->sptr_ls_database_entry->advertisement.sptr_router;

    length_of_advertisement = sptr_router_link_advertisement_header->ls_header.length;
    length_of_advertisement = net_to_host_short (length_of_advertisement);

    /* SPR 85906 -- Eegin */
    if ((packet_length + length_of_advertisement + authentication_size + OSPF_MAXIMUM_IP_HEADER_SIZE) >= interface_mtu)
    /* SPR 85906 -- End */
        {
        return (TRUE);
        }
    else
        {
        return (FALSE);
        }
    }


/**********************************************************************************************************************************/
static UNION_OSPF_ADVERTISEMENT_HEADER *ospf_add_advertisement_to_ls_update_packet
    (
    OSPF_LS_DATABASE_NODE *sptr_database_node,
    UNION_OSPF_ADVERTISEMENT_HEADER *sptr_advertisement_header,
    OSPF_HEADER *sptr_packet,
    ULONG *sptr_packet_length,
    enum BOOLEAN advertisement_installed
    )
    {
    OSPF_ROUTER_LINK_ADVERTISEMENT_HEADER *sptr_router_link_advertisement_header;
    USHORT advertisement_age;
    USHORT length_of_advertisement;
#if defined (__OPAQUE_LSA__)
    OSPF_TYPE_9_LINK_ADVERTISEMENT_HEADER *sptr_type_9_advertisement_header = NULL;
    OSPF_TYPE_10_LINK_ADVERTISEMENT_HEADER *sptr_type_10_advertisement_header = NULL;
    OSPF_TYPE_11_LINK_ADVERTISEMENT_HEADER *sptr_type_11_advertisement_header = NULL;
    OSPF_LS_OPAQUE_HEADER *opaque_lsa = NULL;
    USHORT opaque_lsa_size = 0x0000;
    USHORT opaque_ls_header_size = 0x0000;
    USHORT data_size = 0x0000;
#endif /* __OPAQUE_LSA__ */

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

    sptr_router_link_advertisement_header = sptr_database_node->sptr_ls_database_entry->advertisement.sptr_router;

    length_of_advertisement = net_to_host_short (sptr_router_link_advertisement_header->ls_header.length);

#if defined (__OPAQUE_LSA__)
    if ((sptr_router_link_advertisement_header->ls_header.type == OSPF_LS_TYPE_9) && (advertisement_installed == TRUE))
        {
        opaque_ls_header_size = sizeof(OSPF_LS_OPAQUE_HEADER);
        sptr_type_9_advertisement_header = sptr_database_node->sptr_ls_database_entry->advertisement.sptr_type_9;

        data_size = sptr_type_9_advertisement_header->ls_header.length;
        data_size = net_to_host_short(data_size);
        data_size = (USHORT)(data_size - OSPF_LS_HEADER_SIZE);

        opaque_lsa_size = (USHORT)(data_size + opaque_ls_header_size);
        opaque_lsa = (OSPF_LS_OPAQUE_HEADER *) table_malloc(1, opaque_lsa_size);
        if (opaque_lsa != NULL)
            {
            memset(opaque_lsa, 0x00, opaque_lsa_size);
            memcpy(opaque_lsa, &(sptr_type_9_advertisement_header->ls_header), opaque_ls_header_size);
            if ((sptr_type_9_advertisement_header->data != NULL) && (data_size > 0))
                {
                memcpy(((BYTE *)(opaque_lsa)+opaque_ls_header_size), sptr_type_9_advertisement_header->data, data_size);
                }
            memcpy ((void *) &(sptr_advertisement_header->router), (const void *)opaque_lsa, opaque_lsa_size);
            table_free(opaque_lsa);
            opaque_lsa = NULL;
            sptr_advertisement_header->router.ls_header.checksum = 0x0000;
            sptr_advertisement_header->router.ls_header.checksum = ospf_generate_LS_checksum ((void *) &(sptr_advertisement_header->router), (USHORT)opaque_lsa_size,
                (BYTE *) &sptr_advertisement_header->router.ls_header.checksum);
            }
        }
    else if ((sptr_router_link_advertisement_header->ls_header.type == OSPF_LS_TYPE_10) && (advertisement_installed == TRUE))
        {
        opaque_ls_header_size = sizeof(OSPF_LS_OPAQUE_HEADER);
        sptr_type_10_advertisement_header = sptr_database_node->sptr_ls_database_entry->advertisement.sptr_type_10;

        data_size = sptr_type_10_advertisement_header->ls_header.length;
        data_size = net_to_host_short(data_size);
        data_size = (USHORT)(data_size - OSPF_LS_HEADER_SIZE);

        opaque_lsa_size = (USHORT)(data_size + opaque_ls_header_size);
        opaque_lsa = (OSPF_LS_OPAQUE_HEADER *) table_malloc(1, opaque_lsa_size);
        if (opaque_lsa != NULL)
            {
            memset(opaque_lsa, 0x00, opaque_lsa_size);
            memcpy(opaque_lsa, &(sptr_type_10_advertisement_header->ls_header), opaque_ls_header_size);
            if ((sptr_type_10_advertisement_header->data != NULL) && (data_size > 0))
                {
                memcpy(((BYTE *)(opaque_lsa)+opaque_ls_header_size), sptr_type_10_advertisement_header->data, data_size);
                }
            memcpy ((void *) &(sptr_advertisement_header->router), (const void *)opaque_lsa, opaque_lsa_size);
            table_free(opaque_lsa);
            opaque_lsa = NULL;
            sptr_advertisement_header->router.ls_header.checksum = 0x0000;
            sptr_advertisement_header->router.ls_header.checksum = ospf_generate_LS_checksum ((void *) &(sptr_advertisement_header->router), (USHORT)opaque_lsa_size,
                (BYTE *) &sptr_advertisement_header->router.ls_header.checksum);
            }
        }
    else if ((sptr_router_link_advertisement_header->ls_header.type == OSPF_LS_TYPE_11) && (advertisement_installed == TRUE))
        {
        opaque_ls_header_size = sizeof(OSPF_LS_OPAQUE_HEADER);
        sptr_type_11_advertisement_header = sptr_database_node->sptr_ls_database_entry->advertisement.sptr_type_11;

        data_size = sptr_type_11_advertisement_header->ls_header.length;
        data_size = net_to_host_short(data_size);
        data_size = (USHORT)(data_size - OSPF_LS_HEADER_SIZE);

        opaque_lsa_size = (USHORT)(data_size + opaque_ls_header_size);
        opaque_lsa = (OSPF_LS_OPAQUE_HEADER *) table_malloc(1, opaque_lsa_size);
        if (opaque_lsa != NULL)
            {
            memset(opaque_lsa, 0x00, opaque_lsa_size);
            memcpy(opaque_lsa, &(sptr_type_11_advertisement_header->ls_header), opaque_ls_header_size);
            if (data_size > 0)
                {
                memcpy(((BYTE *)(opaque_lsa)+opaque_ls_header_size), sptr_type_11_advertisement_header->data, data_size);
                }
            memcpy ((void *) &(sptr_advertisement_header->router), (const void *)opaque_lsa, opaque_lsa_size);
            table_free(opaque_lsa);
            opaque_lsa = NULL;
            sptr_advertisement_header->router.ls_header.checksum = 0x0000;
            sptr_advertisement_header->router.ls_header.checksum = ospf_generate_LS_checksum ((void *) &(sptr_advertisement_header->router), (USHORT)opaque_lsa_size,
                (BYTE *) &sptr_advertisement_header->router.ls_header.checksum);

            }
        }
    else
        {
        memcpy ((void *) &(sptr_advertisement_header->router), (const void *) sptr_router_link_advertisement_header,
            (size_t) length_of_advertisement);
        }

#else /* __OPAQUE_LSA__ */
    memcpy ((void *) &(sptr_advertisement_header->router), (const void *) sptr_router_link_advertisement_header,
        (size_t) length_of_advertisement);
#endif /* __OPAQUE_LSA__ */

    advertisement_age = net_to_host_short (sptr_router_link_advertisement_header->ls_header.age);
    advertisement_age = (USHORT) (advertisement_age + OSPF_DEFAULT_TRANSMIT_DELAY   /* sptr_interface->transmit_delay */ );

    sptr_advertisement_header->router.ls_header.age = (USHORT) ospf_min (advertisement_age, OSPF_MAXIMUM_AGE);
    sptr_advertisement_header->router.ls_header.age = host_to_net_short (sptr_advertisement_header->router.ls_header.age);

    sptr_advertisement_header = (UNION_OSPF_ADVERTISEMENT_HEADER *) ((ULONG) sptr_advertisement_header + length_of_advertisement);

    *sptr_packet_length += length_of_advertisement;

    ++sptr_packet->rest_of_packet.ls_update.number_of_advertisements;


    return (sptr_advertisement_header);
    }