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 */
void PPP_tx_task
(
void *handle,
/* [IN] - the PPP state structure */
void *creator
/* [IN] - the creation information */
)
{ /* Body */
#if RTCSCFG_ENABLE_IP4
PPP_CFG_PTR ppp_ptr = handle;
uint32_t ctrl;
bool state;
PPP_OPT opt;
PCB_PTR pcb;
uint32_t pcbopt;
PPP_MESSAGE_PTR message, xmithead, * xmitnode;
uint32_t timebefore, timeafter;
bool wait;
int32_t timeout;
uint16_t protocol;
_queue_id queue;
void *param;
/* Obtain a message queue so that PPP_send() can reach us */
queue = RTCS_msgq_open(0, 0);
if (queue == 0) {
RTCS_task_exit(creator, RTCSERR_PPP_OPEN_QUEUE_FAILED);
} /* Endif */
RTCS_task_resume_creator(creator, PPP_OK);
ppp_ptr->MSG_QUEUE = queue;
xmithead = NULL;
timebefore = RTCS_time_get();
#define PPPTX_DISCARD(msg) \
(msg)->PCB->FREE = (msg)->ORIG_FREE; \
PCB_free((msg)->PCB); \
RTCS_msg_free(msg)
for(;;)
{
/**********************************************************
**
** Wait for a packet to send
**
*/
wait = TRUE;
timeout = 0;
/* Check if a packet is waiting for retransmission */
if (xmithead) {
/* Measure elapsed time */
timeafter = RTCS_time_get();
timeout = RTCS_timer_get_interval(timebefore, timeafter);
timebefore = timeafter;
xmithead->DELTA -= timeout;
/* If its timer has expired, send it */
timeout = xmithead->DELTA;
if (timeout <= 0) {
message = NULL;
wait = FALSE;
} /* Endif */
} /* Endif */
/*
** There are three cases at this point:
** 1) Retransmission queue is empty
** (wait == TRUE, timeout == 0, message == ?)
** 2) Retransmission queue is nonempty, positive timeout
** (wait == TRUE, timeout > 0, message == ?)
** 3) Retransmission queue is nonempty, nonpositive timeout,
** i.e., head of retransmission queue timed out
** (wait == FALSE, timeout == 0, message == NULL)
*/
/* If there are no expired messages, block */
if (wait) {
message = RTCS_msgq_receive(queue, timeout, ppp_ptr->MSG_POOL);
} /* Endif */
/*
** There are two cases at this point:
** 1) We got a message from _msgq_receive
** (message != NULL)
** 2) Head of retransmission queue timed out
** (message == NULL)
*/
/* We got a packet to send */
if (message) {
/* Control packets restart or stop retransmission */
ctrl = message->COMMAND;
if (ctrl == PPPCMD_SHUTDOWN) {
param = message->PARAM;
/* Free the message we just got */
RTCS_msg_free(message);
for (xmitnode = &xmithead;;){
if (*xmitnode == NULL) {
break;
} else {
/* unlink */
message = *xmitnode;
*xmitnode = message->NEXT;
/* Free the message from the list */
PPPTX_DISCARD(message);
} /* Endif */
} /* Endfor */
RTCS_msgq_close(queue);
/* Unblock PPP_shutdown() */
RTCS_sem_post(param);
/* Kill self */
return;
} /* Endif */
if (ctrl != PPPCMD_SEND) {
protocol = message->PROTOCOL;
RTCS_msg_free(message);
/*
** Search the retransmission queue for a packet
** matching the protocol field of the control message
*/
for (xmitnode = &xmithead;;
xmitnode = &(*xmitnode)->NEXT) {
if (*xmitnode == NULL) {
break;
} else if ((*xmitnode)->PROTOCOL == protocol) {
message = *xmitnode;
switch (ctrl) {
case PPPCMD_RESTART:
message->TIMEOUT = _PPP_MIN_XMIT_TIMEOUT;
message->RETRY = _PPP_MAX_CONF_RETRIES;
break;
case PPPCMD_STOP:
if (message->NEXT) {
message->NEXT->DELTA += message->DELTA;
} /* Endif */
*xmitnode = message->NEXT;
PPPTX_DISCARD(message);
break;
} /* Endswitch */
break;
} /* Endif */
} /* Endfor */
continue;
} /* Endif */
/* Save the PCB's FREE field */
message->ORIG_FREE = message->PCB->FREE;
if (message->TIMEOUT) {
message->PCB->FREE = PPP_tx_pcbfree;
} /* Endif */
/* Receive timed out -- get the head of the retransmission queue */
} else {
message = xmithead;
xmithead = message->NEXT;
if (xmithead) {
xmithead->DELTA += message->DELTA;
} /* Endif */
/* Generate a TO event */
if (message->CALL) {
message->CALL(message->PARAM, message->PCB, message->RETRY == 1);
} /* Endif */
/* RETRY == 0 means retry forever */
if (message->RETRY) {
/* When the retry count reaches zero, discard the packet */
if (!--message->RETRY) {
PPPTX_DISCARD(message);
continue;
} /* Endif */
} /* Endif */
/* Use exponential backoff when retransmitting */
message->TIMEOUT <<= 1;
if (message->TIMEOUT > _PPP_MAX_XMIT_TIMEOUT) {
message->TIMEOUT = _PPP_MAX_XMIT_TIMEOUT;
} /* Endif */
} /* Endif */
/**********************************************************
**
** We have a packet -- validate it
**
*/
/* Take a snapshot of the current state and send options */
PPP_mutex_lock(&ppp_ptr->MUTEX);
state = ppp_ptr->LINK_STATE;
opt = *ppp_ptr->SEND_OPTIONS;
PPP_mutex_unlock(&ppp_ptr->MUTEX);
/* Send the data packet (unless the link is not open) */
if (!state && message->PROTOCOL != PPP_PROT_LCP) {
PPPTX_DISCARD(message);
ppp_ptr->ST_TX_DISCARDED++;
continue;
} /* Endif */
/**********************************************************
**
** We have a valid packet -- send it
**
*/
/* LCP control packets are always sent with default options */
if (message->PROTOCOL == PPP_PROT_LCP
&& message->PCB->FRAG[0].FRAGMENT[2] >= 1
&& message->PCB->FRAG[0].FRAGMENT[2] <= 7) {
pcbopt = 1;
} else {
pcbopt = 0;
} /* Endif */
pcb = message->PCB;
/* Only data packets are compressed */
/* Start CR 2296 */
//if (((message->PROTOCOL & 0xC000) == 0) && opt.CP) {
/* End CR 2296 */
// pcb = opt.CP->CP_comp(&ppp_ptr->CCP_STATE.SEND_DATA, pcb, ppp_ptr, &opt);
// mqx_htons(pcb->FRAG[0].FRAGMENT, PPP_PROT_CP);
//} /* Endif */
_iopcb_write(ppp_ptr->DEVICE, pcb, pcbopt);
/**********************************************************
**
** Packet is sent -- update retransmission queue
**
*/
/* Free the buffer unless it may need to be retransmitted */
if (message->TIMEOUT) {
/* Measure elapsed time */
timeafter = RTCS_time_get();
timeout = RTCS_timer_get_interval(timebefore, timeafter);
timebefore = timeafter;
if (xmithead) {
xmithead->DELTA -= timeout;
} /* Endif */
/* Insert packet into proper place in retransmission queue */
for (message->DELTA = message->TIMEOUT, xmitnode = &xmithead;;
message->DELTA -= (*xmitnode)->DELTA, xmitnode = &(*xmitnode)->NEXT) {
if (*xmitnode == NULL) {
/* Add packet at tail of queue */
message->NEXT = NULL;
*xmitnode = message;
break;
} else if ((*xmitnode)->DELTA > message->TIMEOUT) {
/* Insert packet in middle (possibly head) of queue */
(*xmitnode)->DELTA -= message->DELTA;
message->NEXT = *xmitnode;
*xmitnode = message;
break;
} /* Endif */
} /* Endfor */
} else {
/* PCB has already been freed by _iopcb_write() */
RTCS_msg_free(message);
} /* Endif */
} /* Endfor */
#endif /* RTCSCFG_ENABLE_IP4 */
} /* Endbody */
void TCPIP_task
(
void *dummy,
void *creator
)
{ /* Body */
TCPIP_CFG_STRUCT TCPIP_cfg;
RTCS_DATA_PTR RTCS_data_ptr;
uint32_t i;
TCPIP_MESSAGE_PTR tcpip_msg;
uint32_t timeout = 1, timebefore, timeafter, timedelta;
uint32_t status; /* Return status */
_queue_id tcpip_qid;
RTCSLOG_FNE2(RTCSLOG_FN_TCPIP_task, creator);
RTCS_data_ptr = RTCS_get_data();
RTCS_setcfg(TCPIP, &TCPIP_cfg);
TCPIP_cfg.status = RTCS_OK;
tcpip_qid = RTCS_msgq_open(TCPIP_QUEUE, 0);
if (tcpip_qid == 0) {
RTCS_task_exit(creator, RTCSERR_OPEN_QUEUE_FAILED);
} /* Endif */
RTCS_data_ptr->TCPIP_TASKID = RTCS_task_getid();
/*
** Initialize the Time Service
*/
TCP_tick = TCPIP_fake_tick;
TCPIP_Event_init();
timebefore = RTCS_time_get();
/*
** Allocate a block of PCBs
*/
status = RTCSPCB_init();
if (status != RTCS_OK) {
RTCS_task_exit(creator, status);
} /* Endif */
IF_FREE = NULL;
/*
** Initialize the protocols
*/
#if RTCSCFG_ENABLE_IP4
/*********************************************
* Initialize IPv4
**********************************************/
status = IP_init();
if (status)
{
RTCS_task_exit(creator, status);
}
#if RTCSCFG_ENABLE_ICMP
status = ICMP_init();
if (status)
{
RTCS_task_exit(creator, status);
}
#endif /* RTCSCFG_ENABLE_ICMP */
ARP_init();
BOOT_init();
#endif /* RTCSCFG_ENABLE_IP4 */
#if RTCSCFG_ENABLE_IP6
/*********************************************
* Initialize IPv6
**********************************************/
status = IP6_init();
if (status)
{
RTCS_task_exit(creator, status);
}
/* Init ICMP6. */
status = ICMP6_init(); //TBD Add it to RTCS6_protocol_table
if (status)
{
RTCS_task_exit(creator, status);
}
#endif /* RTCSCFG_ENABLE_IP6*/
#if (RTCSCFG_ENABLE_IP_REASSEMBLY && RTCSCFG_ENABLE_IP4) || (RTCSCFG_ENABLE_IP6_REASSEMBLY && RTCSCFG_ENABLE_IP6)
/* Initialize the reassembler */
status = IP_reasm_init();
if (status)
{
RTCS_task_exit(creator, status);
}
#endif
/* Add loopback interface.*/
status = IPLOCAL_init ();
if (status)
{
RTCS_task_exit(creator, status);
};
for (i = 0; RTCS_protocol_table[i]; i++) {
status = (*RTCS_protocol_table[i])();
if (status) {
RTCS_task_exit(creator, status);
} /* Endif */
} /* Endfor */
_RTCS_initialized= TRUE;
RTCS_task_resume_creator(creator, RTCS_OK);
while (1)
{
TCPIP_EVENT_PTR queue = TCPIP_Event_head;
tcpip_msg = (TCPIP_MESSAGE_PTR)RTCS_msgq_receive(tcpip_qid, timeout, RTCS_data_ptr->TCPIP_msg_pool);
if (tcpip_msg)
{
if (NULL != tcpip_msg->COMMAND)
{
tcpip_msg->COMMAND(tcpip_msg->DATA);
}
RTCS_msg_free(tcpip_msg);
}
timeout = TCP_tick();
timeafter = RTCS_time_get();
/* If head changed set time delta to zero to prevent immidiate event */
if (queue == TCPIP_Event_head)
{
timedelta = RTCS_timer_get_interval(timebefore, timeafter);
}
else
{
timedelta = 0;
}
timebefore = timeafter;
timedelta = TCPIP_Event_time(timedelta);
if (timedelta != 0)
{
if ((timedelta < timeout) || (timeout == 0))
{
timeout = timedelta;
}
}
}
} /* Endbody */
