boolean RTCS_cmd_service
(
RTCSPCB_PTR pcb,
void (_CODE_PTR_ command)(pointer)
)
{ /* Body */
RTCS_DATA_PTR RTCS_data_ptr;
TCPIP_MESSAGE_PTR message;
RTCS_data_ptr = RTCS_get_data();
message = RTCS_msg_alloc(RTCS_data_ptr->TCPIP_msg_pool);
if (message == NULL) {
return FALSE;
} /* Endif */
message->HEAD.TARGET_QID = RTCS_data_ptr->TCPIP_qid;
message->HEAD.SOURCE_QID = 0;
message->HEAD.SIZE = sizeof(*message);
message->COMMAND = command;
message->DATA = pcb;
return RTCS_msgq_send(message, RTCS_data_ptr->TCPIP_msg_pool);
} /* Endbody */
void RTCSLOG_disable
(
uint32_t logtype
/* [IN] the type of log entry to disable */
)
{ /* Body */
RTCS_DATA_PTR rtcs = RTCS_get_data();
uint32_t i;
if (rtcs) {
rtcs->RTCS_LOG_CONTROL &= ~logtype;
if (logtype & RTCS_LOGCTRL_PCB) {
for (i=0; i<RTCSLOG_PROT_MAX; i++) {
rtcs->RTCS_LOG_PCB[i] = 0;
} /* Endfor */
} /* Endif */
if (logtype & RTCS_LOGCTRL_TIMER) {
for (i=0; i<RTCSLOG_PROT_MAX; i++) {
rtcs->RTCS_LOG_TIMER[i] = 0;
} /* Endfor */
} /* Endif */
}
} /* Endbody */
uint_32 RTCS_cmd_issue
(
TCPIP_PARM_PTR parm_ptr,
void (_CODE_PTR_ command)(pointer)
)
{ /* Body */
RTCS_DATA_PTR RTCS_data_ptr;
TCPIP_MESSAGE_PTR message;
RTCS_data_ptr = RTCS_get_data();
message = RTCS_msg_alloc(RTCS_data_ptr->TCPIP_msg_pool);
if (message == NULL) {
parm_ptr->ERROR = RTCSERR_OUT_OF_BUFFERS;
} else {
parm_ptr->ERROR = RTCS_OK;
parm_ptr->SYNC = _task_get_td(0);
message->HEAD.TARGET_QID = RTCS_data_ptr->TCPIP_qid;
message->HEAD.SOURCE_QID = 0;
message->HEAD.SIZE = sizeof(*message);
message->COMMAND = command;
message->DATA = parm_ptr;
if (!RTCS_msgq_send_blocked(message, RTCS_data_ptr->TCPIP_msg_pool)) {
parm_ptr->ERROR = RTCSERR_SEND_FAILED;
} /* Endif */
} /* Endif */
return parm_ptr->ERROR;
} /* Endbody */
void RTCSLOG_enable_prot
(
uint32_t logtype,
/* [IN] the type of log entry to enable */
uint32_t protocol
/* [IN] the protocol to enable */
)
{ /* Body */
RTCS_DATA_PTR rtcs = RTCS_get_data();
uint32_t i, j;
rtcs->RTCS_LOG_CONTROL |= logtype;
if (logtype & RTCS_LOGCTRL_PCB) {
j = RTCSLOG_PROT_MAX;
for (i = RTCSLOG_PROT_MAX; i > 0; ) {
i--;
if (rtcs->RTCS_LOG_PCB[i] == protocol) {
j = i;
break;
} else if (rtcs->RTCS_LOG_PCB[i] == 0) {
j = i;
} /* Endif */
} /* Endfor */
if (j < RTCSLOG_PROT_MAX) {
rtcs->RTCS_LOG_PCB[j] = protocol;
} /* Endif */
} /* Endif */
if (logtype & RTCS_LOGCTRL_TIMER) {
j = RTCSLOG_PROT_MAX;
for (i = RTCSLOG_PROT_MAX; i > 0; ) {
i--;
if (rtcs->RTCS_LOG_TIMER[i] == protocol) {
j = i;
break;
} else if (rtcs->RTCS_LOG_TIMER[i] == 0) {
j = i;
} /* Endif */
} /* Endfor */
if (j < RTCSLOG_PROT_MAX) {
rtcs->RTCS_LOG_TIMER[j] = protocol;
} /* Endif */
} /* Endif */
} /* Endbody */
uint_32 RTCS_cmd_smartissue
(
TCPIP_PARM_PTR parm_ptr,
void (_CODE_PTR_ command)(pointer)
)
{ /* Body */
RTCS_DATA_PTR RTCS_data_ptr;
RTCS_data_ptr = RTCS_get_data();
if (RTCS_task_getid() == RTCS_data_ptr->TCPIP_TASKID) {
return RTCS_cmd_internal(parm_ptr, command);
} else {
return RTCS_cmd_issue(parm_ptr, command);
} /* Endif */
} /* Endbody */
uint32_t RTCSPCB_init
(
void
)
{
RTCS_DATA_PTR RTCS_data_ptr;
RTCS_data_ptr = RTCS_get_data();
RTCS_data_ptr->RTCS_PCB_partition =
RTCS_part_create(sizeof(RTCSPCB),_RTCSPCB_init, _RTCSPCB_grow, _RTCSPCB_max,
RTCSPCB_construct, RTCSPCB_destroy);
if (RTCS_data_ptr->RTCS_PCB_partition == 0) {
return RTCSERR_PCB_ALLOC;
} /* Endif */
return RTCS_OK;
}
void RTCSLOG_disable_prot
(
uint32_t logtype,
/* [IN] the type of log entry to disable */
uint32_t protocol
/* [IN] the protocol to disable */
)
{ /* Body */
RTCS_DATA_PTR rtcs = RTCS_get_data();
uint32_t i, j;
rtcs->RTCS_LOG_CONTROL &= ~logtype | (RTCS_LOGCTRL_PCB | RTCS_LOGCTRL_TIMER);
if (logtype & RTCS_LOGCTRL_PCB) {
j = RTCSLOG_PROT_MAX;
for (i = 0; i < RTCSLOG_PROT_MAX; i++) {
if (rtcs->RTCS_LOG_PCB[i] == protocol) {
rtcs->RTCS_LOG_PCB[i] = 0;
} else if (rtcs->RTCS_LOG_PCB[i] != 0) {
j = i;
} /* Endif */
} /* Endfor */
if (j < RTCSLOG_PROT_MAX) {
rtcs->RTCS_LOG_CONTROL &= ~RTCS_LOGCTRL_PCB;
} /* Endif */
} /* Endif */
if (logtype & RTCS_LOGCTRL_TIMER) {
j = RTCSLOG_PROT_MAX;
for (i = 0; i < RTCSLOG_PROT_MAX; i++) {
if (rtcs->RTCS_LOG_TIMER[i] == protocol) {
rtcs->RTCS_LOG_TIMER[i] = 0;
} else if (rtcs->RTCS_LOG_TIMER[i] != 0) {
j = i;
} /* Endif */
} /* Endfor */
if (j < RTCSLOG_PROT_MAX) {
rtcs->RTCS_LOG_CONTROL &= ~RTCS_LOGCTRL_TIMER;
} /* Endif */
} /* Endif */
} /* 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;
}
void RTCSLOG_enable
(
uint32_t logtype
/* [IN] the type of log entry to enable */
)
{ /* Body */
RTCS_DATA_PTR rtcs = RTCS_get_data();
if (rtcs) {
rtcs->RTCS_LOG_CONTROL |= logtype;
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_IFTYPE (IPIFTYPE_ETHERNET) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_IFTYPE (IPIFTYPE_PPP) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_IFTYPE (IPIFTYPE_LOOPBACK) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_ARP (IPIFTYPE_ETHERNET) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PROTO (IPPROTO_ICMP) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PROTO (IPPROTO_IGMP) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PROTO (IPPROTO_IP) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PROTO (IPPROTO_TCP) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PROTO (IPPROTO_UDP) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PROTO (IPPROTO_OSPF) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PORT (IPPORT_BOOTPC) );
RTCSLOG_enable_prot(logtype, RTCS_LOGCTRL_PORT (IPPORT_RIP) );
}
} /* 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 */
uint_32 RTCS_create
(
void
)
{ /* Body */
RTCS_DATA_PTR RTCS_data_ptr;
SOCKET_CONFIG_STRUCT_PTR socket_cfg_ptr;
uint_32 error;
/*
** Check and see if this is the first time we have initialized,
*/
if (RTCS_get_data() != NULL) {
return RTCSERR_INITIALIZED;
}
//
RTCS_data_ptr = RTCS_mem_alloc_system_zero(sizeof(RTCS_DATA));
if (RTCS_data_ptr == NULL) {
error = RTCSERR_OUT_OF_MEMORY;
} else {
_mem_set_type(RTCS_data_ptr, MEM_TYPE_RTCS_DATA);
RTCS_set_data(RTCS_data_ptr);
/*
** Initialize socket state
*/
socket_cfg_ptr = RTCS_mem_alloc_system_zero(sizeof(SOCKET_CONFIG_STRUCT));
if (socket_cfg_ptr == NULL) {
error = RTCSERR_OUT_OF_MEMORY;
} else {
_mem_set_type(socket_cfg_ptr, MEM_TYPE_SOCKET_CONFIG_STRUCT);
socket_cfg_ptr->INITIALIZED = TRUE;
socket_cfg_ptr->SOCKET_HEAD = NULL;
socket_cfg_ptr->SOCKET_TAIL = NULL;
RTCS_mutex_init(&socket_cfg_ptr->SOCK_MUTEX);
RTCS_setcfg(SOCKET, socket_cfg_ptr);
/*
** Initialize global data
*/
_IP_forward = FALSE;
_TCP_bypass_rx = FALSE;
_TCP_bypass_tx = FALSE;
RTCS_data_ptr->VERSION = RTCS_VERSION;
#if RTCSCFG_LOG_SOCKET_API||RTCSCFG_LOG_PCB
RTCS_data_ptr->RTCS_LOG_PROTCOUNT = RTCSLOG_PROT_MAX;
RTCSLOG_disable(RTCS_LOGCTRL_ALL);
#endif
RTCS_data_ptr->TCPIP_qid = RTCS_msgq_get_id(0,TCPIP_QUEUE);
/*
** Create a pool of buffers for use in communicating to the TCP/IP task.
*/
RTCS_data_ptr->TCPIP_msg_pool = RTCS_msgpool_create(sizeof(TCPIP_MESSAGE),
_RTCS_msgpool_init, _RTCS_msgpool_grow, _RTCS_msgpool_max);
if (RTCS_data_ptr->TCPIP_msg_pool == MSGPOOL_NULL_POOL_ID) {
RTCS_log_error( ERROR_TCPIP, RTCSERR_CREATE_POOL_FAILED, 0, 0, 0);
error = RTCSERR_CREATE_POOL_FAILED;
} else {
/*
** Create the socket partition
*/
RTCS_data_ptr->RTCS_socket_partition = RTCS_part_create(sizeof(SOCKET_STRUCT),
_RTCS_socket_part_init, _RTCS_socket_part_grow, _RTCS_socket_part_max, NULL, NULL);
if (RTCS_data_ptr->RTCS_socket_partition == 0) {
RTCS_log_error(ERROR_RTCS, RTCSERR_CREATE_PARTITION_FAILED, 0, 0, 0);
error = RTCSERR_CREATE_PARTITION_FAILED;
} else {
/*
** Create TCPIP task
*/
error = RTCS_task_create("TCP/IP", _RTCSTASK_priority, _RTCSTASK_stacksize, TCPIP_task, NULL);
if (error) {
RTCS_part_destroy(RTCS_data_ptr->RTCS_socket_partition);
}
}
if (error) {
RTCS_msgpool_destroy( RTCS_data_ptr->TCPIP_msg_pool );
}
}
if (error) {
RTCS_setcfg(SOCKET, NULL);
_mem_free(socket_cfg_ptr);
}
}
if (error) {
RTCS_set_data(NULL);
_mem_free(RTCS_data_ptr);
}
}
return error;
} /* Endbody */
SOCKET_STRUCT_PTR SOCK_Get_sock_struct
(
RTCS_SOCKET_CALL_STRUCT_PTR type,
_rtcs_taskid owner
)
{ /* Body */
RTCS_DATA_PTR RTCS_data_ptr;
SOCKET_CONFIG_STRUCT_PTR socket_cfg_ptr;
SOCKET_STRUCT_PTR socket_ptr;
RTCS_data_ptr = RTCS_get_data();
socket_cfg_ptr = RTCS_data_ptr->SOCKET_CFG;
socket_ptr = RTCS_part_alloc_zero(RTCS_data_ptr->RTCS_socket_partition);
if ( socket_ptr != NULL ) {
RTCS_mutex_lock(&socket_cfg_ptr->SOCK_MUTEX);
socket_cfg_ptr->CURRENT_SOCKETS++;
#if RTCSCFG_SOCKET_OWNERSHIP
SOCK_Add_owner(socket_ptr, owner);
#endif
/*
** link in this socket into the linked list of active sockets
*/
if ( socket_cfg_ptr->SOCKET_HEAD != NULL ) {
((SOCKET_STRUCT_PTR)socket_cfg_ptr->SOCKET_TAIL)->NEXT =
(void *)socket_ptr;
socket_ptr->PREV = (SOCKET_STRUCT_PTR)socket_cfg_ptr->SOCKET_TAIL;
} else {
socket_cfg_ptr->SOCKET_HEAD = (void *)socket_ptr;
socket_ptr->PREV = NULL;
} /* Endif */
socket_ptr->NEXT = NULL;
socket_cfg_ptr->SOCKET_TAIL = (void *)socket_ptr;
RTCS_mutex_unlock(&socket_cfg_ptr->SOCK_MUTEX);
socket_ptr->VALID = SOCKET_VALID;
/*
** set the default socket options
*/
socket_ptr->CONNECT_TIMEOUT = DEFAULT_CONNECT_TIMEOUT;
socket_ptr->RETRANSMISSION_TIMEOUT = DEFAULT_RETRANSMISSION_TIMEOUT;
socket_ptr->SEND_TIMEOUT = DEFAULT_SEND_TIMEOUT;
socket_ptr->RECEIVE_TIMEOUT = DEFAULT_RECEIVE_TIMEOUT;
socket_ptr->RECEIVE_PUSH = DEFAULT_PUSH;
socket_ptr->SEND_NOWAIT = DEFAULT_SEND_NOWAIT;
socket_ptr->SEND_WAIT = DEFAULT_SEND_WAIT;
socket_ptr->SEND_PUSH = DEFAULT_PUSH;
socket_ptr->RECEIVE_NOWAIT = DEFAULT_RECEIVE_NOWAIT;
socket_ptr->CHECKSUM_BYPASS = DEFAULT_CHECKSUM_BYPASS;
socket_ptr->ACTIVE = DEFAULT_ACTIVE;
socket_ptr->TBSIZE = DEFAULT_TBSIZE;
socket_ptr->RBSIZE = DEFAULT_RBSIZE;
socket_ptr->MAXRTO = DEFAULT_MAXRTO;
socket_ptr->MAXRCV_WND = DEFAULT_MAXRCV_WND;
socket_ptr->KEEPALIVE = DEFAULT_KEEPALIVE;
socket_ptr->NOWAIT = DEFAULT_NOWAIT;
socket_ptr->NO_NAGLE_ALGORITHM = DEFAULT_NO_NAGLE_ALGORITHM;
socket_ptr->NOSWRBUF = DEFAULT_NOSWRBUF;
socket_ptr->CALL_BACK = DEFAULT_CALL_BACK;
socket_ptr->TYPE_MIRROR = (uint32_t)type;
socket_ptr->APPLICATION_CALLBACK = DEFAULT_CALLBACK;
socket_ptr->TIMEWAIT_TIMEOUT = DEFAULT_TIMEWAIT_TIMEOUT;
socket_ptr->DELAY_ACK = DEFAULT_DELAY_ACK;
#if RTCSCFG_ENABLE_IP6
socket_ptr->LINK_OPTIONS.TX.HOP_LIMIT_MULTICAST = DEFAULT_IP6_MULTICAST_HOPS;
#endif
socket_ptr->PROTOCOL = type;
} /* Endif */
return(socket_ptr);
} /* Endbody */
