rip2.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

*   OUTPUTS                                                               
*                                                                         
*       Returns:                                                          
*           0 for Unknown Class Network Address                           
*           1 for Class A Address                                         
*           2 for Class B Address                                         
*           3 for Class C Address                                         
*                                                                         
*************************************************************************/
INT16 RIP2_IsNetworkClass_ABC(UINT8 *ip_addr)
{
    INT16 ret = 0;
    
    if( (ip_addr[0] >> 6) <= 1 )
        ret = 1;
    else
        if( (ip_addr[0] >> 6) == 2 )
            ret = 2;
        else
            if( (ip_addr[0] >> 6) == 3 )
                ret = 3;
            
            return(ret);
}   /* RIP2_IsNetworkClass_ABC */

/*************************************************************************
*                                                                         
*   FUNCTION                                                              
*                                                                         
*       RIP2_IsBroadcast_Address                                          
*                                                                         
*   DESCRIPTION                                                           
*                                                                         
*       If IP address is a broadcast address return true.                 
*                                                                         
*   INPUTS                                                                
*                                                                         
*       *ip_addr                                                      
*       c                                                             
*                                                                         
*   OUTPUTS                                                               
*                                                                         
*       Returns:                                                          
*           0 for Unknown Class Network Address                           
*           1 for Class A and Broadcast Address                           
*           2 for Class B and Broadcast Address                           
*           3 for Class C and Broadcast Address                           
*                                                                         
*************************************************************************/
INT16 RIP2_IsBroadcast_Address( UINT8 *ip_addr, INT16 c )
{
    INT16 ret = 0;
    UINT32 addr;
    UINT32 netmask;
    
    addr = *(UINT32 *)ip_addr;
    
    switch( c )
    {
    case 1:                 /* is a class A network address */
        netmask = 0x00ffffffUL;
        if( (addr & 0x7f000000UL) != LOOPBACK_ADDR ||
            (addr & netmask) == CLASSA_BROADCAST)
            ret = 1;
        break;
        
    case 2:                 /* is a class B network address */
        netmask = 0x0000ffff;
        if( (addr & netmask) == CLASSB_BROADCAST )
            ret = 2;
        break;
        
    case 3:                 /* is a class C network address */
        netmask = 0x000000ff;
        if( (addr & netmask) == CLASSC_BROADCAST )
            ret = 3;
        break;
        
    default:
        break;
    }
    
    return( ret );
}   /* RIP2_IsBroadcast_Address */

/*************************************************************************
*                                                                         
*   FUNCTION                                                              
*                                                                         
*       RIP2_IsFromMe                                                     
*                                                                         
*   DESCRIPTION                                                           
*                                                                         
*       If the address is from one of my interfaces, return true.         
*                                                                         
*   INPUTS                                                                
*                                                                         
*       *dv                                                 
*       *addr                                            
*                                                                         
*   OUTPUTS                                                               
*                                                                         
*       1 if the address is from one of my interfaces                     
*       0 if the address is not from one of my interfaces                 
*                                                                         
*************************************************************************/
INT16 RIP2_IsFromMe(DV_DEVICE_ENTRY *dv, struct addr_struct *addr)
{
    if( dv->dev_addr.dev_ip_addr == (IP_ADDR (addr->id.is_ip_addrs)))
        return(1);
    
    return(0);
}   /* RIP2_IsFromMe */

/*************************************************************************
*                                                                         
*   FUNCTION                                                              
*                                                                         
*       RIP2_Find_Route                                                   
*                                                                         
*   DESCRIPTION                                                           
*                                                                         
*       Finds a route to a destination IP address.                        
*                                                                         
*   INPUTS                                                                
*                                                                         
*       RIP2_ENTRY *re                                                    
*                                                                         
*   OUTPUTS                                                               
*                                                                         
*       Returns either NULL_ROUTE_NODE or n, depending on the outcome:    
*           NULL_ROUTE_NODE         The root node has no children.        
*           n                       A pointer to the node requested.      
*                                                                         
*************************************************************************/
ROUTE_NODE *RIP2_Find_Route( RIP2_ENTRY *re )
{
    INT dir = -1;
    ROUTE_NODE *n, c;
    ROUTE_NODE *Top_Node;
    
    Top_Node = RTAB_Root_Node();
    if( Top_Node == NULL_ROUTE_NODE )
        return( NULL_ROUTE_NODE );
    
    c.rt_rip2 = re;
    c.rt_auth = 0;
    
    n = Top_Node;
    while( n )
    {
        dir = RTAB_Compare_Addresses( n, &c );
        if ( dir == MIDDLE )
            break;
        else
            n = n->rt_child[dir];
    }
    
    if( dir == MIDDLE )
        return(n);
    else
        return(NULL_ROUTE_NODE);
}   /* RIP2_Find_Route */


/*************************************************************************
*                                                                         
*   FUNCTION                                                              
*                                                                         
*       RIP2_Find_Entry                                                   
*                                                                         
*   DESCRIPTION                                                           
*                                                                         
*       Finds device by IP address.                                       
*                                                                         
*   INPUTS                                                                
*                                                                         
*       *addr                                                         
*                                                                         
*   OUTPUTS                                                               
*                                                                         
*       node            The requested entry.                              
*                                                                         
*************************************************************************/
RIP2_LIST_NODE *RIP2_Find_Entry(UINT8 *addr)
{
    UINT32              addr1, addr2;
    RIP2_LIST_NODE      *node;
    
    for (node = RIP2_List.r2_head; node; node = node->r2_next)
    {
        addr1 = *(UINT32 *)addr;
        addr2 = node->r2_device->dev_addr.dev_netmask;
        addr1 = (addr1 & addr2);
        if( (addr1 & node->r2_device->dev_addr.dev_ip_addr) == addr1 )
        {
            break;
        }
    }
    
    return (node);
    
}   /* RIP2_Find_Entry */

/*************************************************************************
*                                                                         
*   FUNCTION                                                              
*                                                                         
*       RIP2_Find_Index                                                   
*                                                                         
*   DESCRIPTION                                                           
*                                                                         
*       Find array index number for a device.                             
*                                                                         
*   INPUTS                                                                
*                                                                         
*       *dv                                                        
*       dvnum                                                        
*       *addr                                                         
*                                                                         
*   OUTPUTS                                                               
*                                                                         
*       The index                                                   
*                                                                         
*************************************************************************/

#if 0
INT16 RIP2_Find_Index(DEV_DEVICE *dv, UINT16 dvnum, UINT8 *addr)
{
    INT16 i;
    INT16 idx = -1;
    UINT32 addr1, addr2;
    DV_DEVICE_ENTRY *dvp;
    
    if( dvnum <= 0 )
        return( idx );          /* id not found return -1 */
    
    for( i = 0; i < dvnum; i++)
    {
        dvp = DEV_Get_Dev_By_Name(dv->dv_name);
        addr1 = *(UINT32 *)addr;
        addr2 = dvp->dev_addr.dev_netmask;
        addr1 = (addr1 & addr2);
        if( (addr1 & *(UINT32 *)dvp->dev_addr.dev_ip_addr) == addr1 )
        {
            idx = i;
            break;
        }
    }
    
    return( idx );
}   /* RIP2_Find_Index */
#endif 

/*************************************************************************
*                                                                         
*   FUNCTION                                                              
*                                                                         
*       RIP2_Delete_Old                                                   
*                                                                         
*   DESCRIPTION                                                           
*                                                                         
*       Deletes old or unreachable routes from routing table.             
*                                                                         
*   INPUTS                                                                
*                                                                         
*       None                                                              
*                                                                         
*   OUTPUTS                                                               
*                                                                         
*       0 if there are no nodes to delete                                 
*       Negative number if there was an error                             
*       i if all went well - index to the next node                       
*                                                                         
*************************************************************************/
INT RIP2_Delete_Old(VOID)
{
    INT                 i;
    INT                 y;
    STATUS              status;
    
#if (INCLUDE_UDP == NU_TRUE)
    UDP_PORT            *uprt;
#endif
    
#if (INCLUDE_TCP == NU_TRUE)
    struct _TCP_Port    *tprt;
#endif
    
#if (INCLUDE_IP_RAW == NU_TRUE)
    struct iport        *ipprt;
#endif
    
    if( delete_num <= 0 )
    {
        delete_num = 0;
        return(0);
    }
    
    /* Wait for one second for the semaphore to become available. */
    status = NU_Obtain_Semaphore(&RIP2_Semaphore, SEMA_WAIT_TIME);
    if( status != NU_SUCCESS )
    {
        NERRS_Log_Error( NERR_RECOVERABLE, __FILE__, __LINE__);
        return(-1);
    }
    
    /* Delete in reverse order */
    for( i = (delete_num - 1); i >= 0; i-- )
    {