ospf_vx_ip_adaptation.c

vxworks下ospf协议栈

                    /* Does the interface that matched this? */
                    if (intf_addr == destination_address)
                        {
                        /* There is an interface that matched with this ospf packet, but
                           can't use it yet. just saved it */
                        sptr_saved_interface = sptr_interface;
                    
                        /* continue to scan through the rest of the interface to see if
                           an unnumbered interface also match this packet */
                        for (sptr_interface = sptr_saved_interface; 
                             sptr_interface != NULL;
                             sptr_interface = sptr_interface->sptr_forward_link)
                             {
                             /* if the interface is unnumbered then get the interface */
                             if (sptr_interface->unnumbered_dest_ip == source_address)
                                 {
                                 sptr_saved_interface = sptr_interface;
                                 break;
                                 }
                             }

                        /* at this point the interface is either unnumbered or numbered */
                        sptr_interface = sptr_saved_interface;
                        break;
                        }

                    }       /* for loop */

#else   /* __UNNUMBERED_LINK__ver1.0 */

                /* it is unicast - got destination address in the ip header */
                for (sptr_interface = ospf.sptr_interface_list; 
                     sptr_interface != NULL;
                     sptr_interface = sptr_next_interface)
                    {
                    sptr_next_interface = sptr_interface->sptr_forward_link;
                    destination_address = ip_header->ip_dst.s_addr;
                    destination_address = net_to_host_long (destination_address);

                    intf_addr = sptr_interface->address;
                    
                    if (intf_addr == destination_address)
                        {
                        break;
                        }
                    }
#endif  /* __UNNUMBERED_LINK__ver1.0 */
                }   /* if (IN_MULTICAST (destination_address)) */

            /* if can't find matching interface, ignore the packet */
            if ( sptr_interface == NULL )
                {
                OSPF_PRINTF_DEBUG(OSPF_ALARM_PRINTF,
                        "dropped recvpkt - recvif not found!\n");
                semGive (ospf_global_mutex);
                continue;
                }
            /* call ospf_router_rx_packet() to process the packet */
            ospf_router_rx_packet (
                sptr_interface,
                (OSPF_PACKET *)ospf_receive_message_buffer,
                (USHORT)ip_header->ip_len, ip_header->ip_src.s_addr,
                ip_header->ip_dst.s_addr);

            /* release the mutex */
            semGive (ospf_global_mutex);
            }
        }
    }





/***************************************************************************************
* ospf_vx_ip_output - packet send routine
*
* This is packet send routine. If packet needs to be multicast <flag_multicast is set>,
* it calls setsockopt() to specify the network interface through which the multicast
* packet is sent.
*
* RETURNS: N/A
*/
void ospf_vx_ip_output (OSPF_HEADER *sptr_packet, ULONG source_address, bool flag_multicast, ULONG destination_address, ULONG length /* in host order */, enum BOOLEAN free_packet)
{
    struct  sockaddr_in dest;
    struct  in_addr localIpAddr;
        int     status;
        ULONG   source_ip_address = 0x00000000;
        ULONG   destination_ip_address = 0x00000000;
    /* HME Fix SPR#81451 Begin */
#if defined(ENABLE_IP_HDRINCL)
    struct in_addr src;
    unsigned int bOpt=1;       
    char ospfSignalData [OSPF_MAX_PKT_SIZE];    /* Contents of signal */
    int ipPktLength = IPHL + length;
    struct ip * 	pIph;
    OSPF_HEADER * 	pOspfh;
#endif
    /* HME Fix SPR#81451 End */

    /* asr: set virtual stack context */
    #if defined (VIRTUAL_STACK)
        virtualStackNumTaskIdSet (ospf.ospf_vsid);
    #endif /* VIRTUAL_STACK */
    
    if ( sptr_packet == NULL )
    {
        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF,"OSPF:invalid transmit data\n");
        return;
    }

    /* HME Fix SPR#81451 Begin */
    source_ip_address = source_address;
    source_ip_address = host_to_net_long(source_ip_address);
    /* HME Fix SPR#81451 End */

    if (flag_multicast == true)
    {
        localIpAddr.s_addr = source_ip_address;

        /* call setsockopt to select an outgoing interface for multicasting the packet */
        if (setsockopt (ipSock, IPPROTO_IP, IP_MULTICAST_IF, (char *)&localIpAddr,
                        sizeof(localIpAddr)) != OK)
        {
            OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF:setsockopt failed for tranmit\n");

            if (free_packet)
            {
                buffer_free(sptr_packet);
                                sptr_packet = NULL;
            }
            return;
        }
    }

    /* send the packet using the raw socket */
    destination_ip_address = destination_address;
    destination_ip_address = host_to_net_long(destination_ip_address);
    dest.sin_addr.s_addr = destination_ip_address;
    dest.sin_family = AF_INET;

/* HME Fix SPR#81451 Begin */   
#if defined(ENABLE_IP_HDRINCL)
    /* enable IP_HDRINCL option */
    if (setsockopt(ipSock, IPPROTO_IP, IP_HDRINCL, (char *)&bOpt, sizeof(bOpt)) != OK) {        
        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF:setsockopt IP_HDRINCL failed \n");
        return;
    }

    /* Check whether the size of ospfSignalData is larger than ipPktLength */
    if (ipPktLength > OSPF_MAX_PKT_SIZE) 
    {
        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: Ospf pkt size is too big (ipPktLength > OSPF_MAX_PKT_SIZE) \n");
        return;
    }
    
    /* Create an IP packet and copy the OSPF packet to it*/
    bzero (ospfSignalData, ipPktLength);
    pIph = (struct ip *)ospfSignalData;
    src.s_addr = source_ip_address;
    ipHeaderCreate(IPPROTO_OSPF, &src, &dest.sin_addr, (struct ip *)pIph, htons(ipPktLength)); 

/* HME Fix SPR#69807 & SPR#72167  Begin*/
    pIph->ip_tos = TOS_BYTE_VALUE;
/* HME Fix SPR#69807 & SPR#72167  End*/
    
    /* copy original OSPF data into the IP packet */
    pOspfh = (OSPF_HEADER *) (ospfSignalData + IPHL);
    bcopy( (const char *)sptr_packet, (char *) pOspfh, length);  
 
    /* send the IP packet */
    status = sendto(ipSock, (void *)pIph, ipPktLength, 0, (struct sockaddr *)&dest,
                   sizeof(dest));
#else    
    status = sendto(ipSock, (void *)sptr_packet, length, 0, (struct sockaddr *)&dest,
                    sizeof(dest));
#endif
/* HME Fix SPR#81451 End */

    if (free_packet)
    {
        buffer_free(sptr_packet);
                sptr_packet = NULL;
    }

    return;
}

/************************************************************************/
#if defined (__OSPF_ROUTER_STACK__)
void ospf_ctlinput
    (
    unsigned long intf, 
    unsigned short intf_index, 
    int intf_flags
    )
    {
        bool interface_found;
#if defined (NOT_SUPPORTED_YET)
        ULONG port_number;
#endif /* NOT_SUPPORTED_YET */
        OSPF_INTERFACE *sptr_interface = NULL;
        OSPF_INTERFACE *sptr_next_interface = NULL;
        ULONG ip_address = 0x00000000;

        interface_found = false;

        for (sptr_interface = ospf.sptr_interface_list; 
             sptr_interface != NULL; 
             sptr_interface = sptr_next_interface)
            {
            sptr_next_interface = sptr_interface->sptr_forward_link;
            ip_address = sptr_interface->address;
            ip_address = host_to_net_long(ip_address);


            if(intf_index == sptr_interface->ifnet_index)
                {
                if( intf_flags & IFF_UP )
                    {
                    semTake (ospf_global_mutex, WAIT_FOREVER);
                    ospf_indicate_lower_level_interface_state_change (
                        sptr_interface, 
                        true);
                    semGive (ospf_global_mutex);
                    interface_found = true;
                    break;
                    }
                else
                    {
                    semTake (ospf_global_mutex, WAIT_FOREVER);
                    ospf_indicate_lower_level_interface_state_change (
                        sptr_interface, 
                        false);
                    semGive (ospf_global_mutex);
                    interface_found = true;
                    break;
                    }
                }
            }

    if (interface_found  == false)
        {
        OSPF_PRINTF_ALARM (
            OSPF_ALARM_PRINTF, 
            "OSPF: ospf_ctlinput() called, but interface is not found \r\n");
        }
    }


/*********************************************************************************************************************************************************************/
#else /* __OSPF_ROUTER_STACK__ */
void ospf_ctlinput (int command, struct sockaddr *sa,register struct ip *ip)
{
        ULONG interface_address;
        bool interface_found;

    OSPF_INTERFACE *sptr_interface = NULL;
        OSPF_INTERFACE *sptr_next_interface = NULL;
        struct sockaddr_in *address;

        PARAMETER_NOT_USED (ip);
        interface_found = false;


        if (command == PRC_IFDOWN)
                {
                address = (struct sockaddr_in *) sa;

                interface_address = (ULONG) (address->sin_addr.s_addr);

                interface_address = ntohl (interface_address);

                OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: ospf_ctlinput() called, %lx \r\n", interface_address);

        interface_found = false;
        semTake (ospf_global_mutex, WAIT_FOREVER); 

        for ( sptr_interface = ospf.sptr_interface_list; sptr_interface != NULL;
              sptr_interface = sptr_next_interface)
        {
                        sptr_next_interface = sptr_interface->sptr_forward_link;
            if ( sptr_interface->address == interface_address)
            {
                ospf_indicate_lower_level_interface_state_change (sptr_interface, false);
                interface_found = true;
                break;
            }
        }
        
        semGive (ospf_global_mutex);

                if (interface_found  == false)
                        {
                        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: ospf_ctlinput() called, but interface is not found \r\n");
                        }

                }
#if defined (NOT_SUPPORTED_YET)
        if (command == PRC_IFUP)
                {
                address = (struct sockaddr_in *) sa;

                interface_address = (ULONG) (address->sin_addr.s_addr);

                interface_address = ntohl (interface_address);

                OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: ospf_ctlinput() called, %lx \r\n", interface_address);

        interface_found = false;
        
        semTake (ospf_global_mutex, WAIT_FOREVER);
        
        for (sptr_interface = ospf.sptr_interface_list; sptr_interface != NULL;
              sptr_interface = sptr_next_interface)
        {
                        sptr_next_interface = sptr_interface->sptr_forward_link;
            if (sptr_interface->address == interface_address)
            {
                ospf_indicate_lower_level_interface_state_change (sptr_interface, true);
                interface_found = true;
                break;
            }
        }         

        semGive (ospf_global_mutex);

                if (interface_found  == false)
                        {
                        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: ospf_ctlinput() called, but interface is not found \r\n");
                        }

                }
#endif


        /* More commands - PRC_XXX will be supported in future */
        return;
}
#endif /* __OSPF_ROUTER_STACK__ */

/************************************************************************/
void ospf_indicate_lower_level_interface_state_change (OSPF_INTERFACE* sptr_ospf_interface, bool new_state)
{

        if (sptr_ospf_interface == NULL)
                {
                OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: ospf_indicate_lower_level_interface_state_change() called, but interface is NULL \r\n");

                return;
                }

        if (new_state == false /* down */)
                {
                if (sptr_ospf_interface->state != OSPF_INTERFACE_IS_DOWN)
                        {
                        ospf_execute_interface_state_machine( OSPF_INTERFACE_DOWN,
                                sptr_ospf_interface->state, sptr_ospf_interface );
                        sptr_ospf_interface->sptr_area->build_router = TRUE;
                        ospf_generate_network_and_router_link_state_advertisements (sptr_ospf_interface);
                        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: INTERFACE DOWN with address (HEX) %lx\r\n", sptr_ospf_interface->address);
                        }
                }

        else if (new_state == true /* up */)
                {
                if (sptr_ospf_interface->state == OSPF_INTERFACE_IS_DOWN)
                        {
                        sptr_ospf_interface->state = OSPF_INTERFACE_WAITING;
                        ospf_execute_interface_state_machine (OSPF_INTERFACE_UP, OSPF_INTERFACE_IS_DOWN, sptr_ospf_interface);
                        sptr_ospf_interface->sptr_area->build_router = TRUE;
                        ospf_generate_network_and_router_link_state_advertisements (sptr_ospf_interface);
                        OSPF_PRINTF_ALARM (OSPF_ALARM_PRINTF, "OSPF: INTERFACE UP with address (HEX) %lx\r\n", sptr_ospf_interface->address);
                        }
                }
        return;
}