IPREASM_BLK_PTR IPREASM_blk_get
(
IP_DGRAM_PTR dgram, /* [IN] the IP datagram */
uint32_t offset /* [IN] the offset into the datagram */
)
{ /* Body */
IPREASM_BLK_PTR blk;
uint32_t nb;
uint32_t ni;
nb = IPREASM_BLK_NUM(offset);
if (IPREASM_IS_DIRECT(nb)) {
blk = dgram->DIRECT[nb];
if (!blk) {
blk = RTCS_part_alloc(IPREASM_part);
if (blk) {
blk->BUSYINT = 0;
dgram->DIRECT[nb] = blk;
} /* Endif */
} /* Endif */
return blk;
} /* Endif */
/* If we get here, it's an indirect block */
ni = IPREASM_IND_NUM(nb);
if (ni >= IPREASM_NB_IND) {
return NULL;
} /* Endif */
if (!dgram->INDIR[ni]) {
dgram->INDIR[ni] = RTCS_part_alloc_zero(IPREASM_part);
if (!dgram->INDIR[ni]) {
return NULL;
} /* Endif */
} /* Endif */
nb = IPREASM_IND_OFS(nb);
blk = dgram->INDIR[ni]->DIRECT[nb];
if (!blk) {
blk = RTCS_part_alloc(IPREASM_part);
if (blk) {
blk->BUSYINT = 0;
dgram->INDIR[ni]->DIRECT[nb] = blk;
} /* Endif */
} /* Endif */
return blk;
} /* Endbody */
static void RIP_create_rt(
RTCSPCB_PTR pcb, /* [IN] incoming packet */
RIP_ENTRY_PTR rte,
uint8_t rip_vers
)
{ /* Body */
uint32_t nmetric= RIP_cpu_metric(pcb,mqx_ntohl(rte->METRIC));
RIP_CFG_STRUCT_PTR ripcfg = RTCS_getcfg(RIP);
IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
IP_ROUTE_INDIRECT_PTR gate;
_ip_address network, netmask;
gate = RTCS_part_alloc(IP_cfg_ptr->GATE_PARTID);
if (!gate) return;
_mem_zero(gate, sizeof(*gate));
/* init the route */
RIP_adopt_rt(pcb, gate, rte, nmetric, &network, &netmask);
/* insert it in the table */
ROUTE_insert(gate, network, netmask);
/* flag it as changed */
ripcfg->RT_CHANGED_F = TRUE;
} /* Endbody */
static PCB_PTR _iopcb_hdlc_read
(
_iopcb_handle handle,
/* [IN] - the structure handle */
uint_32 flags
/* [IN] - flags */
)
{ /* Body */
RTCS_HDLC_MESSAGE_STRUCT_PTR msg_ptr;
HDLCIO_STRUCT_PTR hdlcio_ptr = (HDLCIO_STRUCT_PTR)((void _PTR_)handle);
PCB_FRAGMENT _PTR_ pcb_frag_ptr;
uint_32 data_length;
PCB_PTR pcb;
while (TRUE) {
PPP_mutex_lock(hdlcio_ptr->MUTEX_PTR);
msg_ptr = RTCS_msgq_receive(hdlcio_ptr->QID, 0, hdlcio_ptr->POOL_ID);
hdlcio_ptr->STATS.COMMON.ST_RX_TOTAL++;
if ( msg_ptr == NULL ) {
hdlcio_ptr->STATS.COMMON.ST_RX_ERRORS++;
RTCS_time_delay(1);
} else {
data_length = msg_ptr->HDLC_HEADER.PACKET_SIZE;
if (data_length > RTCS_HDLC_MESSAGE_SIZE ) {
hdlcio_ptr->STATS.ST_RX_GIANT++;
RTCS_msg_free(msg_ptr);
continue;
} else if (data_length < 2) {
hdlcio_ptr->STATS.ST_RX_RUNT++;
RTCS_msg_free(msg_ptr);
continue;
} else {
pcb = RTCS_part_alloc(hdlcio_ptr->PART_ID);
if (!pcb) {
hdlcio_ptr->STATS.COMMON.ST_RX_MISSED++;
RTCS_msg_free(msg_ptr);
continue;
}/* Endif */
break;
} /* Endif */
} /* Endif */
} /* Endwhile */
pcb->FREE = (void (_CODE_PTR_)(PCB_PTR))RTCS_part_free;
pcb->PRIVATE = pcb;
pcb_frag_ptr = pcb->FRAG;
pcb_frag_ptr->FRAGMENT = (uchar_ptr)pcb + sizeof(PCB) + sizeof(PCB_FRAGMENT);
pcb_frag_ptr->LENGTH = data_length - 2;
pcb_frag_ptr++;
pcb_frag_ptr->LENGTH = 0;
pcb_frag_ptr->FRAGMENT = NULL;
RTCS_memcopy(msg_ptr->DATA+2, pcb->FRAG[0].FRAGMENT, data_length - 2);
RTCS_msg_free(msg_ptr);
return pcb;
} /* Endbody */
uint_32 IP_route_add_virtual
(
_ip_address address, /* Destination address */
_ip_address netmask, /* Mask for the address parameter */
_ip_address source, /* Source address for interface */
_ip_address source_net, /* Allowed source network */
_ip_address source_mask, /* Allowes source network mask */
IP_IF_PTR destif, /* Interface for outgoing packets */
pointer data /* Route information */
)
{ /* Body */
#if RTCSCFG_ENABLE_VIRTUAL_ROUTES
IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
IP_ROUTE_VIRTUAL_PTR route;
struct ip_route_insert insdata;
IP_ROUTE_FN_PTR fn;
route = RTCS_part_alloc(IP_cfg_ptr->VIRTUAL_PARTID);
if (!route) {
return RTCSERR_IP_VIRTUAL_ALLOC;
} /* Endif */
route->ADDRESS = source;
route->IS_DIRECT = NULL;
route->DESTIF = destif;
route->FLAGS = RTF_STATIC | RTF_UP;
route->SOURCE_NET = source_net;
route->SOURCE_MASK = source_mask;
route->DATA = data;
insdata.error = RTCSERR_IP_VIRTUAL_ALLOC;
insdata.route = route;
insdata.index = 2;
insdata.sort = NULL;
IPRADIX_insert(&IP_cfg_ptr->ROUTE_ROOT.NODE, address & netmask, netmask,
IP_cfg_ptr->RADIX_PARTID, IP_route_insert, &insdata);
if (insdata.error) {
RTCS_part_free(route);
} else if (!~netmask) {
fn = IP_cfg_ptr->ROUTE_FN;
while (fn) {
fn->INIT_RT((IP_ROUTE_INDIRECT_PTR)route, 0);
fn = fn->NEXT;
} /* Endwhile */
} /* Endif */
return insdata.error;
#else
return RTCSERR_IP_VIRTUAL_ALLOC;
#endif
} /* Endbody */
uint_32 IP_route_add_direct
(
_ip_address address, /* Address or network address of destif */
_ip_address netmask, /* Mask for the address parameter */
IP_IF_PTR netif, /* Interface for incomming packets */
IP_IF_PTR destif /* Interface for outgoing packets */
)
{ /* Body */
IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
IP_ROUTE_DIRECT_PTR route;
IP_ROUTE_FN_PTR fn;
struct ip_route_insert insertdata;
route = RTCS_part_alloc(IP_cfg_ptr->ROUTE_PARTID);
if (!route) {
return RTCSERR_IP_ROUTE_ALLOC;
} /* Endif */
route->ADDRESS = address;
route->NETIF = netif;
route->DESTIF = destif;
route->FLAGS = RTF_STATIC | RTF_UP;
insertdata.error = RTCSERR_IP_ROUTE_ALLOC;
insertdata.route = route;
insertdata.index = 0;
insertdata.sort = NULL;
IPRADIX_insert(&IP_cfg_ptr->ROUTE_ROOT.NODE, address & netmask, netmask,
IP_cfg_ptr->RADIX_PARTID,
IP_route_insert, &insertdata);
if (insertdata.error) {
RTCS_part_free(route);
} else if (!~netmask) {
ROUTE_new_bindif(route); /* If the route is a leaf (has a full IP) */
} else if (route->DESTIF != IP_cfg_ptr->IF_LOCALHOST) {
fn = IP_cfg_ptr->ROUTE_FN; /* If the route is a network connection */
while (fn) {
fn->INIT_RT((IP_ROUTE_INDIRECT_PTR)((void _PTR_)route), 0);
fn = fn->NEXT;
} /* Endwhile */
} /* Endif */
return insertdata.error;
} /* Endbody */
uint_32 IP_route_add_indirect
(
_ip_address address, /* Gateway address */
_ip_address netmask, /* Network mask */
_ip_address network, /* Network address */
uint_32 flag, /* [IN] RTF_* */
uint_16 metric /* [IN] the route metric [0,65535] */
)
{ /* Body */
IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
IP_ROUTE_INDIRECT_PTR route;
struct ip_route_insert insertdata;
IP_ROUTE_FN_PTR fn;
route = RTCS_part_alloc(IP_cfg_ptr->GATE_PARTID);
if (!route) {
return RTCSERR_IP_GATE_ALLOC;
} /* Endif */
route->GATEWAY = address;
route->FLAGS = flag | RTF_UP;
route->IS_DIRECT = NULL;
route->METRIC = metric;
insertdata.error = RTCSERR_IP_GATE_ALLOC;
insertdata.route = route;
insertdata.index = 1;
insertdata.sort = IP_route_add_indirect_sort;
IPRADIX_insert(&IP_cfg_ptr->ROUTE_ROOT.NODE, network & netmask, netmask,
IP_cfg_ptr->RADIX_PARTID,
IP_route_insert, &insertdata);
if (insertdata.error) {
RTCS_part_free(route);
} else {
fn = IP_cfg_ptr->ROUTE_FN;
while (fn) {
fn->INIT_RT(route, metric);
fn = fn->NEXT;
} /* Endwhile */
} /* Endif */
return insertdata.error;
} /* Endbody */
RTCSPCB_PTR RTCSPCB_alloc( void )
{
RTCS_DATA_PTR RTCS_data_ptr;
RTCSPCB_PTR rtcs_pcb;
RTCS_data_ptr = RTCS_get_data();
rtcs_pcb = RTCS_part_alloc(RTCS_data_ptr->RTCS_PCB_partition);
if (rtcs_pcb != NULL)
{
/* Set default values.*/
rtcs_pcb->IP_SUM_PTR = NULL;
_mem_zero(&rtcs_pcb->LINK_OPTIONS, sizeof(rtcs_pcb->LINK_OPTIONS));
RTCSPCB_SET_TRANS_PROTL(rtcs_pcb, 0);
}
RTCSLOG_PCB_ALLOC(rtcs_pcb);
return rtcs_pcb;
}
RTCSPCB_PTR RTCSPCB_alloc
(
void
)
{
RTCS_DATA_PTR RTCS_data_ptr;
RTCSPCB_PTR rtcs_pcb;
RTCS_data_ptr = RTCS_get_data();
rtcs_pcb = RTCS_part_alloc(RTCS_data_ptr->RTCS_PCB_partition);
if (rtcs_pcb != NULL) {
rtcs_pcb->IP_SUM_PTR = NULL;
_mem_zero(&rtcs_pcb->LINK_OPTIONS, sizeof(rtcs_pcb->LINK_OPTIONS));
} /* Endif */
RTCSLOG_PCB_ALLOC(rtcs_pcb);
return rtcs_pcb;
}
