static DHCPSRV_ADDR_STRUCT_PTR _PTR_ DHCPSRV_update_clientid
(
DHCPSRV_ADDR_STRUCT_PTR _PTR_ addrhead,
uchar_ptr cid_ptr,
uint_32 cid_len
)
{ /* Body */
DHCPSRV_ADDR_STRUCT_PTR addr = *addrhead;
uchar_ptr cid;
cid = RTCS_mem_alloc(cid_len);
if (!cid) return NULL;
_mem_set_type(cid, MEM_TYPE_DHCPSRV_CID);
if (addr->CLIENTID_PTR) _mem_free(addr->CLIENTID_PTR);
_mem_copy(cid_ptr, cid, cid_len);
addr->CLIENTID_PTR = cid;
addr->CLIENTID_LEN = cid_len;
return addrhead;
} /* Endbody */
_mqx_int _io_socket_ioctl
(
MQX_FILE_PTR fd_ptr,
_mqx_uint cmd,
pointer param_ptr
)
{ /* Body */
IO_SOCKET_PTR io_ptr;
_mqx_int result = IO_ERROR, bytes;
uint_32 size;
io_ptr = fd_ptr->DEV_DATA_PTR;
if (io_ptr != NULL) {
switch (cmd) {
case IO_IOCTL_CHAR_AVAIL:
if (RTCS_selectset(&io_ptr->SOCKET, 1, (uint_32)-1)) {
*(boolean _PTR_)param_ptr = TRUE;
} else {
*(boolean _PTR_)param_ptr = FALSE;
} /* Endif */
result=MQX_OK;
break;
case IO_IOCTL_FLUSH_OUTPUT:
if (io_ptr->COUNT) {
bytes = send(io_ptr->SOCKET, io_ptr->BUFFER, io_ptr->COUNT, 0);
if (bytes==io_ptr->COUNT) {
io_ptr->COUNT = 0;
result = MQX_OK;
}
} else {
result = MQX_OK;
}
break;
case IO_IOCTL_SET_BLOCK_MODE:
size = *(uint_32_ptr)param_ptr;
result=MQX_OK;
if (size != io_ptr->SIZE) {
// First, clear out the old buffer
if (io_ptr->BUFFER) {
if (io_ptr->COUNT) {
bytes = send(io_ptr->SOCKET, io_ptr->BUFFER, io_ptr->COUNT, 0);
io_ptr->COUNT = 0;
}
_mem_free(io_ptr->BUFFER);
io_ptr->BUFFER = NULL;
}
if (size) {
// Size is set, entering block mode
if (size < SOCKIO_MIN_BUFFER) {
size = SOCKIO_MIN_BUFFER;
}
if (size > SOCKIO_MAX_BUFFER) {
size = SOCKIO_MAX_BUFFER;
}
io_ptr->BUFFER = RTCS_mem_alloc(size);
if (io_ptr->BUFFER==NULL) {
size = 0;
result = IO_ERROR;
} else {
_io_socket_set_send_push(io_ptr->SOCKET, TRUE);
}
}
io_ptr->SIZE = size;
}
break;
case IO_IOCTL_GET_BLOCK_SIZE:
result=MQX_OK;
*(boolean _PTR_)param_ptr = io_ptr->SIZE;
break;
}
}
return result;
} /* Endbody */
/* Task for reading/writing file */
void ftpsrv_transfer_task(void* init_ptr, void* creator)
{
FTPSRV_TRANSFER_PARAM* param = (FTPSRV_TRANSFER_PARAM*) init_ptr;
MQX_FILE_PTR file = param->file;
uint32_t mode = param->mode;
uint32_t sock = param->sock;
FTPSRV_SESSION_STRUCT* session = param->session;
void* data_buffer;
char* msg_str;
if (session->state == FTPSRV_STATE_TRANSFER)
{
RTCS_task_resume_creator(creator, (uint32_t) RTCS_ERROR);
return;
}
data_buffer = RTCS_mem_alloc(FTPSRVCFG_DATA_BUFFER_SIZE);
if (data_buffer == NULL)
{
RTCS_task_resume_creator(creator, (uint32_t) RTCS_ERROR);
return;
}
session->transfer_tid = _task_get_id();
session->state = FTPSRV_STATE_TRANSFER;
RTCS_task_resume_creator(creator, (uint32_t) RTCS_OK);
while (1)
{
FTPSRV_TRANSFER_MSG message;
_mqx_uint retval;
/* Reading from file */
if (mode == FTPSRV_MODE_READ)
{
uint32_t length;
int32_t error;
length = fread((void*) data_buffer, 1, FTPSRVCFG_DATA_BUFFER_SIZE, file);
if ((length != FTPSRVCFG_DATA_BUFFER_SIZE) && ferror(file) && !feof(file))
{
msg_str = (char*) ftpsrvmsg_locerr;
break;
}
error = send(sock, data_buffer, length, 0);
if (error == RTCS_ERROR)
{
msg_str = (char*) ftpsrvmsg_locerr;
break;
}
if (feof(file))
{
msg_str = (char*) ftpsrvmsg_trans_complete;
break;
}
}
/* Writing to file */
else if ((mode == FTPSRV_MODE_WRITE) || (mode == FTPSRV_MODE_APPEND))
{
uint32_t length;
int32_t received;
received = recv(sock, data_buffer, FTPSRVCFG_DATA_BUFFER_SIZE, 0);
if (received == RTCS_ERROR)
{
msg_str = (char*) ftpsrvmsg_trans_complete;
break;
}
length = fwrite((void*) data_buffer, 1, received, file);
if (length != received)
{
if (length == IO_ERROR)
{
msg_str = (char*) ftpsrvmsg_no_space;
}
else
{
msg_str = (char*) ftpsrvmsg_writefail;
}
break;
}
}
retval = _lwmsgq_receive((void*) session->msg_queue, (uint32_t *)&message, LWMSGQ_TIMEOUT_FOR, 1, NULL);
if (retval != MQX_OK)
{
continue;
}
if (message.command == FTPSRV_CMD_ABORT)
{
msg_str = (char*) ftpsrvmsg_trans_abort;
break;
}
else if (message.command == FTPSRV_CMD_STAT)
{
/* TODO: Add code to print out transfer statistics */
}
}
_mem_free(data_buffer);
fclose(file);
ftpsrv_send_msg(session, msg_str);
shutdown(sock, FLAG_CLOSE_TX);
session->state = FTPSRV_STATE_IDLE;
}
uint_32 TFTP_open
(
pointer ft_data
/* [IN] the address and filename of the bootimage */
)
{ /* Body */
TFTP_DATA_STRUCT_PTR tftp;
sockaddr_in local_addr;
char_ptr str_ptr;
uchar_ptr packet;
uint_32 sock;
uint_32 error;
uint_32 fn_len, fm_len;
uint_32 pkt_len;
tftp = (TFTP_DATA_STRUCT_PTR) ft_data;
/* Get a socket */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == RTCS_SOCKET_ERROR) {
return RTCSERR_TFTP_SOCKET;
} /* Endif */
/* Must be initialized in order for TFTP_close to be able to release socket and memory */
TFTP_config.SOCK = sock;
TFTP_config.RRQ_PTR = NULL;
/* Bind it */
local_addr.sin_family = AF_INET;
local_addr.sin_port = 0;
local_addr.sin_addr.s_addr = INADDR_ANY;
error = bind(sock, &local_addr, sizeof(local_addr));
if (error != RTCS_OK) {
TFTP_close();
return error;
} /* Endif */
if ( (tftp->FILENAME == NULL) || (tftp->FILEMODE == NULL) ){
TFTP_close();
return TFTPERR_FILE_NOT_FOUND;
} /* Endif */
/* Prepare a read request (RRQ) */
str_ptr = tftp->FILENAME;
while (*str_ptr++) {};
fn_len = str_ptr - tftp->FILENAME;
str_ptr = tftp->FILEMODE;
while (*str_ptr++) {};
fm_len = str_ptr - tftp->FILEMODE;
pkt_len = 2 + fn_len + fm_len;
packet = RTCS_mem_alloc(pkt_len);
if (packet == NULL) {
TFTP_close();
return RTCSERR_TFTP_RRQ_ALLOC;
} /* Endif */
_mem_set_type(packet, MEM_TYPE_TFTP_PACKET);
TFTP_config.RRQ_PTR = packet;
htons(packet, TFTPOP_RRQ);
_mem_copy(tftp->FILENAME, &packet[ 2], fn_len);
_mem_copy(tftp->FILEMODE, &packet[fn_len+2], fm_len);
/* Send the RRQ */
TFTP_config.SOCK = sock;
TFTP_config.SADDR.sin_family = AF_INET;
TFTP_config.SADDR.sin_port = IPPORT_TFTP;
TFTP_config.SADDR.sin_addr.s_addr = tftp->SERVER;
TFTP_timeout_init(&TFTP_config.TIMEOUT);
error = sendto(sock, packet, pkt_len, 0,
&TFTP_config.SADDR, sizeof(TFTP_config.SADDR));
if (error != pkt_len) {
TFTP_close();
return RTCSERR_TFTP_RRQ_SEND;
} /* Endif */
/* Initialize the TFTP client */
TFTP_config.RRQ_PTR = packet;
TFTP_config.RRQ_LEN = pkt_len;
TFTP_config.LAST = FALSE;
htons(TFTP_config.ACK.OP, TFTPOP_ACK);
htons(TFTP_config.ACK.BLOCK, 0);
return RTCS_OK;
} /* Endbody */
uint_32 IPCP_init
(
IP_IF_PTR if_ptr
/* [IN] the IP interface structure */
)
{ /* Body */
_ppp_handle handle = if_ptr->HANDLE;
IPCP_CFG_STRUCT_PTR ipcp_ptr;
PPPFSM_CFG_PTR fsm;
uint_32 error;
if (handle==NULL)
{
return RTCSERR_INVALID_PARAMETER;
} /* Endif */
/* Allocate state for this interface */
ipcp_ptr = RTCS_mem_alloc(sizeof(IPCP_CFG_STRUCT));
if (!ipcp_ptr) {
return RTCSERR_IPCP_CFG;
} /* Endif */
/* Initialize the IPCP FSM */
fsm = &ipcp_ptr->FSM;
error = PPPFSM_init(fsm, handle, &IPCP_FSM_CALL, if_ptr);
if (error) {
_mem_free(ipcp_ptr);
return PPP_TO_RTCS_ERROR(error);
} /* Endif */
/* Register IPCP */
error = PPP_register(handle, PPP_PROT_IPCP, PPPFSM_input, fsm);
if (error) {
PPPFSM_destroy(fsm);
_mem_free(ipcp_ptr);
return PPP_TO_RTCS_ERROR(error);
} /* Endif */
/* Register IP */
error = PPP_register(handle, PPP_PROT_IP, IPCP_recv, if_ptr);
if (error) {
PPP_unregister(handle, PPP_PROT_IPCP);
PPPFSM_destroy(fsm);
_mem_free(ipcp_ptr);
return PPP_TO_RTCS_ERROR(error);
} /* Endif */
ipcp_ptr->HANDLE = handle;
if_ptr->HANDLE = ipcp_ptr;
if_ptr->MTU = IP_DEFAULT_MTU;
if_ptr->ARP = NULL;
if_ptr->DEV_TYPE = 20;
if_ptr->DEV_ADDRLEN = 1;
if_ptr->DEV_ADDR[0] = 0xFF;
#if RTCSCFG_ENABLE_SNMP
if_ptr->SNMP_IF_TYPE = IPIFTYPE_PPP;
#endif
return RTCS_OK;
} /* Endbody */
