uint32_t DNS_init
(
void
)
{ /* Body */
DNS_CONTROL_STRUCT *control_ptr = RTCS_getcfg(DNS);
uint32_t temp_socket = 0;
int32_t error;
if (control_ptr != NULL) {
return RTCS_OK;
}
/*
** Please note, if this is modified to use a value other than
** DNS_MAX_UDP_MESSAGE_SIZE, the recvfrom() in the DNS_Resolver_task
** will need to be modified as well, as they rely on this constant.
*/
control_ptr = RTCS_mem_alloc_system_zero(sizeof(DNS_CONTROL_STRUCT)+DNS_MAX_UDP_MESSAGE_SIZE);
if (control_ptr == NULL) {
return RTCSERR_DNS_UNABLE_TO_ALLOCATE_MEMORY;
} /* Endif */
_mem_set_type(control_ptr, MEM_TYPE_DNS_CONTROL_STRUCT);
RTCS_setcfg(DNS, control_ptr);
temp_socket = socket(PF_INET, SOCK_DGRAM, 0);
if (temp_socket == RTCS_HANDLE_ERROR) {
DNS_init_unwind(control_ptr, temp_socket);
return RTCSERR_DNS_UNABLE_TO_OPEN_SOCKET;
} /* Endif */
error = RTCS_detachsock(temp_socket);
if (error != RTCS_OK) {
DNS_init_unwind(control_ptr, temp_socket);
return error;
} /* Endif */
control_ptr->INT_QUERY_PARTID = RTCS_part_create(
sizeof(DNS_INTERNAL_QUERY_STRUCT), DNSALLOC_SIZE, DNSALLOC_SIZE, 0,
NULL, NULL);
if (control_ptr->INT_QUERY_PARTID == 0) {
DNS_init_unwind(control_ptr, temp_socket);
return RTCSERR_DNS_UNABLE_TO_CREATE_PARTITION;
} /* Endif */
control_ptr->ADDR_RR_PARTID = RTCS_part_create(
sizeof(DNS_ADDR_RECORD_STRUCT), DNSALLOC_SIZE, DNSALLOC_SIZE, 0,
NULL, NULL);
if (control_ptr->ADDR_RR_PARTID == 0) {
DNS_init_unwind(control_ptr, temp_socket);
return RTCSERR_DNS_UNABLE_TO_CREATE_PARTITION;
} /* Endif */
control_ptr->NAME_RR_PARTID = RTCS_part_create(
sizeof(DNS_NAME_RECORD_STRUCT), DNSALLOC_SIZE, DNSALLOC_SIZE, 0,
NULL, NULL);
if (control_ptr->NAME_RR_PARTID == 0) {
DNS_init_unwind(control_ptr, temp_socket);
return RTCSERR_DNS_UNABLE_TO_CREATE_PARTITION;
} /* Endif */
control_ptr->RR_LIST_PARTID = RTCS_part_create(
sizeof(DNS_RR_LIST_STRUCT), DNSALLOC_SIZE, DNSALLOC_SIZE, 0,
NULL, NULL);
if (control_ptr->RR_LIST_PARTID == 0) {
DNS_init_unwind(control_ptr, temp_socket);
return RTCSERR_DNS_UNABLE_TO_CREATE_PARTITION;
} /* Endif */
control_ptr->CNAME_PARTID = RTCS_part_create(
sizeof(DNS_CNAME_STRUCT), DNSALLOC_SIZE, DNSALLOC_SIZE, 0,
NULL, NULL);
if (control_ptr->CNAME_PARTID == 0) {
DNS_init_unwind(control_ptr, temp_socket);
return RTCSERR_DNS_UNABLE_TO_CREATE_PARTITION;
} /* Endif */
control_ptr->ROOT_SLIST_PTR = DNS_A_Root_server;
control_ptr->LOCAL_SLIST_PTR = DNS_First_Local_server;
control_ptr->NS_BUFFER = NULL;
control_ptr->RES_BUFFER = (unsigned char *)(control_ptr + 1);
control_ptr->RES_SOCKET = temp_socket;
control_ptr->UPDATING = FALSE;
error = RTCS_mutex_init(&control_ptr->CACHE_MUTEX);
if (error != RTCS_OK) {
DNS_init_unwind(control_ptr, temp_socket);
return error;
} /* Endif */
error = RTCS_mutex_init(&control_ptr->SLIST_MUTEX);
if (error != RTCS_OK) {
DNS_init_unwind(control_ptr, temp_socket);
return error;
} /* Endif */
error = RTCS_task_create("DNS Resolver", _RTCSTASK_priority,
_RTCSTASK_stacksize + 500 * sizeof(uint32_t),
DNS_Resolver_task, control_ptr);
if (error) {
DNS_init_unwind(control_ptr, temp_socket);
return error;
} /* Endif */
return RTCS_OK;
} /* Endbody */
void DHCPSRV_task
(
pointer dummy,
pointer creator
)
{ /* Body */
DHCPSRV_STATE_STRUCT state;
sockaddr_in addr;
uint_32 timeout;
uchar_ptr msgptr;
uint_32 msglen;
uchar msgtype;
int_32 error;
state.IP_AVAIL = NULL;
state.IP_OFFERED = NULL;
state.IP_LEASED = NULL;
/* Start CR 1547 */
state.IP_TAKEN = NULL;
state.FLAGS = DHCPSVR_FLAG_DO_PROBE;
/* End CR 1547 */
RTCS_mutex_init(&state.IPLIST_SEM);
state.SOCKET = socket(PF_INET, SOCK_DGRAM, 0);
if (state.SOCKET == RTCS_SOCKET_ERROR) {
RTCS_task_exit(creator, RTCSERR_OUT_OF_SOCKETS);
} /* Endif */
addr.sin_family = AF_INET;
addr.sin_port = IPPORT_BOOTPS;
addr.sin_addr.s_addr = INADDR_ANY;
error = bind(state.SOCKET, &addr, sizeof(sockaddr_in));
if (error != RTCS_OK) {
RTCS_task_exit(creator, error);
} /* Endif */
DHCPSRV_cfg = &state;
RTCS_task_resume_creator(creator, RTCS_OK);
for (;;) {
/* Wait for a message */
timeout = DHCPSRV_expire(&state) * 1000;
error = RTCS_selectset(&state.SOCKET, 1, timeout);
if ((error == 0) || (error == RTCS_ERROR)) continue;
/* Received a message, respond accordingly */
error = recvfrom(state.SOCKET, state.RCV_BUFFER, sizeof(state.RCV_BUFFER), 0, NULL, NULL);
if (error == RTCS_ERROR) continue;
/* The datagram must contain at least a header and a magic cookie */
if (error < sizeof(DHCP_HEADER) + DHCPSIZE_MAGIC) continue;
msgptr = state.RCV_BUFFER + sizeof(DHCP_HEADER);
if (ntohl(msgptr) != DHCP_MAGIC) continue;
msgptr += DHCPSIZE_MAGIC;
msglen = error - sizeof(DHCP_HEADER) - DHCPSIZE_MAGIC;
state.RCV_BUFFER_LEN = error;
/* Update the time before starting any new events */
DHCPSRV_expire(&state);
/* Service the packet */
msgtype = DHCPSRV_find_msgtype(msgptr, msglen);
switch (msgtype) {
case DHCPTYPE_DHCPDISCOVER:
DHCPSRV_service_discover(&state);
break;
case DHCPTYPE_DHCPREQUEST:
DHCPSRV_service_request(&state);
break;
case DHCPTYPE_DHCPRELEASE:
DHCPSRV_service_release(&state);
break;
case DHCPTYPE_DHCPDECLINE:
DHCPSRV_service_decline(&state);
break;
} /* Endswitch */
} /* Endwhile */
} /* 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 */
