📄 rip2.c
字号:
#if (INCLUDE_UDP == NU_TRUE)
/* Delete UDP cached route for the corresponding socket */
for(y = 0; y < UDP_MAX_PORTS; y++)
{
if(UDP_Ports[y])
{
uprt = UDP_Ports[y];
if( uprt->up_route.rt_route == delete_nodes[i])
{
uprt->up_route.rt_route = NU_NULL;
}
}
}
#endif /* INCLUDE_UDP == NU_TRUE */
#if (INCLUDE_TCP == NU_TRUE)
/* Delete TCP cached route for the corresponding socket */
for(y = 0; y < TCP_MAX_PORTS; y++)
{
if(TCP_Ports[y])
{
tprt = TCP_Ports[y];
if( tprt->tp_route.rt_route == delete_nodes[i])
{
tprt->tp_route.rt_route = NU_NULL;
}
}
}
#endif /* INCLUDE_TCP == NU_TRUE */
#if (INCLUDE_IP_RAW == NU_TRUE)
/* Delete IP Raw cached route for the corresponding socket */
for(y=0; y < IPR_MAX_PORTS; y++)
{
if(IPR_Ports[y])
{
ipprt = IPR_Ports[y];
if( ipprt->ip_route.rt_route == delete_nodes[i])
{
ipprt->ip_route.rt_route = NU_NULL;
}
}
}
#endif /* INCLUDE_IP_RAW == NU_TRUE */
RTAB_Delete_Node(delete_nodes[i]);
delete_nodes[i] = 0;
}
delete_num = 0;
status = NU_Release_Semaphore(&RIP2_Semaphore);
if( status != NU_SUCCESS )
{
NERRS_Log_Error( NERR_RECOVERABLE, __FILE__, __LINE__);
}
return(i);
} /* RIP2_Delete_Old */
/*************************************************************************
*
* FUNCTION
*
* RIP2_Gather_Old
*
* DESCRIPTION
*
* Gather up old route entries and place them into array.
*
* INPUTS
*
* *rn
* curtime
* flag
*
* OUTPUTS
*
* None - this is a void function
*
*************************************************************************/
VOID RIP2_Gather_Old(ROUTE_NODE *rn, UINT32 curtime, INT16 flag)
{
if( flag )
delete_num = 0;
if( rn != NULL_ROUTE_NODE )
{
if( rn->rt_child[MORE] )
RIP2_Gather_Old(rn->rt_child[MORE], curtime, 0);
if( (curtime - rn->rt_clock) >= RT_LIFE_TIME ||
rn->rt_rip2->metric >= RT_INFINITY )
{
if( delete_num < MAX_DELETES )
{
if( rn->rt_refcnt < 1 )
{
if((rn->rt_flags & RT_STATIC) == 0)
{
delete_nodes[delete_num] = rn;
delete_num++;
}
}
else
{
if((rn->rt_flags & RT_STATIC) == 0)
{
rn->rt_flags &= ~RT_UP;
}
}
}
}
if( rn->rt_child[LESS] )
RIP2_Gather_Old(rn->rt_child[LESS], curtime, 0);
}
} /* RIP2_Gather_Old */
/*************************************************************************
*
* FUNCTION
*
* RIP2_Gather_Updated
*
* DESCRIPTION
*
* Finds all updated route entries and places them into array.
*
* INPUTS
*
* *rn
* *dv
* *num
*
* OUTPUTS
*
* None
*
*************************************************************************/
VOID RIP2_Gather_Updated(ROUTE_NODE *rn, DV_DEVICE_ENTRY *dv, INT *num)
{
if( rn != NULL_ROUTE_NODE )
{
if( rn->rt_child[MORE] )
RIP2_Gather_Updated(rn->rt_child[MORE], dv, num);
if( memcmp(&rn->rt_device->dev_addr.dev_ip_addr,
&dv->dev_addr.dev_ip_addr, 4) != 0 &&
rn->rt_rip2->metric < RT_INFINITY )
{
if( (rn->rt_clock > 0) && (rn->rt_lastsent != rn->rt_clock)
&& (!(rn->rt_flags & RT_SILENT)) )
{
if( *num < MAX_PER_PACKET )
{
updated_nodes[*num] = rn;
*num = *num + 1;
}
}
}
if( rn->rt_child[LESS] )
RIP2_Gather_Updated(rn->rt_child[LESS], dv, num);
}
} /* RIP2_Gather_Updated */
/*************************************************************************
*
* FUNCTION
*
* RIP2_Gather_All
*
* DESCRIPTION
*
* Gather all route entries in route table.
*
* INPUTS
*
* *rn
* *dv
* n
* *num
*
* OUTPUTS
*
* None
*
*************************************************************************/
VOID RIP2_Gather_All(ROUTE_NODE *rn, DV_DEVICE_ENTRY *dv, UINT32 n, INT *num)
{
if( rn != NULL_ROUTE_NODE )
{
if( rn->rt_child[MORE] )
RIP2_Gather_All(rn->rt_child[MORE], dv, n, num);
if( memcmp(&rn->rt_device->dev_addr.dev_ip_addr,
&dv->dev_addr.dev_ip_addr, 4) != 0 &&
rn->rt_rip2->metric < RT_INFINITY)
{
if( (rn->rt_sendcnt < n) && (!(rn->rt_flags & RT_SILENT)) )
{
if( *num < MAX_PER_PACKET )
{
updated_nodes[*num] = rn;
*num = *num + 1;
}
}
}
if( rn->rt_child[LESS] )
RIP2_Gather_All(rn->rt_child[LESS], dv, n, num);
}
} /* RIP2_Gather_All */
/*************************************************************************
*
* FUNCTION
*
* RIP2_Send_Updates
*
* DESCRIPTION
*
* Send all updated route table entries since last send.
*
* INPUTS
*
* *rpkt
* *node
* entries
* *faddr
*
* OUTPUTS
*
* None
*
*************************************************************************/
VOID RIP2_Send_Updates(RIP2_PACKET *rpkt, RIP2_LIST_NODE *node, INT entries,
struct addr_struct *faddr)
{
SIGNED ret;
UINT16 i;
UINT16 len;
INT16 count = 0;
RIP2_ENTRY *pkt;
RIP2_HEADER *rh;
ROUTE_NODE *rn;
struct addr_struct baddr;
STATUS status;
#if (NU_DEBUG_RIP2 == NU_TRUE)
/* sprintf(debug_string, "in RIP2_Send_Updates\n\r"); */
strcpy(debug_string, "in RIP2_Send_Updates\n\r");
ATI_DEBUG_PRINT(debug_string);
#endif
if( RIP2_Socket < 0 )
return;
rh = (RIP2_HEADER *)rpkt;
/* ignore RIP-2 packets if RIP1_ONLY is on */
if( node->r2_recvmode == RECV_RIP1 && rh->version == 2 )
{
/* see RFC 1058, section 3.4 and RFC 1723 3.6 and 4.1 */
return; /* do not do version 2 routes */
}
if( node->r2_recvmode == RECV_RIP2 && rh->version == 1 )
{
/* see RFC 1058, section 3.4 and RFC 1723 3.6 and 4.1 */
return; /* do not do version 2 routes */
}
/* Neither RIP-1 or 2 version packet */
if( rh->version != 1 && rh->version != 2 )
return; /* only understand version 1 and 2. */
/* Wait for n seconds for the semaphore to become avaible. */
status = NU_Obtain_Semaphore(&RIP2_Semaphore, SEMA_WAIT_TIME);
if( status != NU_SUCCESS )
{
NERRS_Log_Error( NERR_RECOVERABLE, __FILE__, __LINE__);
return;
}
baddr.family = NU_FAMILY_IP;
baddr.port = RIP_PORT;
baddr.id.is_ip_addrs[0] = faddr->id.is_ip_addrs[0];
baddr.id.is_ip_addrs[1] = faddr->id.is_ip_addrs[1];
baddr.id.is_ip_addrs[2] = faddr->id.is_ip_addrs[2];
baddr.id.is_ip_addrs[3] = faddr->id.is_ip_addrs[3];
baddr.name = "RIPRESP";
/* for each rip struct in RIP2_PACKET, see if route exists and */
/* update metric in packet o⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -