/*
** Send data from session buffer to client.
**
** IN:
** HTTPSRV_SESSION_STRUCT *session - session to use.
**
** OUT:
** none
**
** Return Value:
** int - number of bytes send.
*/
uint32_t httpsrv_ses_flush(HTTPSRV_SESSION_STRUCT *session)
{
uint32_t length = 0;
while (length != session->buffer.offset)
{
uint32_t remaining;
length = send(session->sock, session->buffer.data, session->buffer.offset, 0);
if (length == RTCS_ERROR)
{
session->state = HTTPSRV_SES_CLOSE;
length = 0;
break;
}
remaining = session->buffer.offset - length;
if (remaining > 0)
{
_mem_zero(session->buffer.data, length);
memmove(session->buffer.data, session->buffer.data+length, remaining);
session->buffer.offset = remaining;
}
else
{
_mem_zero(session->buffer.data, session->buffer.offset);
session->buffer.offset = 0;
break;
}
}
return(length);
}
pointer _partition_alloc_zero
(
/* [IN] the partition from which to obtin the memory block */
_partition_id partition
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
PARTPOOL_STRUCT_PTR partpool_ptr = (PARTPOOL_STRUCT_PTR)partition;
pointer result;
_GET_KERNEL_DATA(kernel_data);
_KLOGE2(KLOG_partition_alloc_zero, partition);
result = _partition_alloc_internal(partpool_ptr, kernel_data->ACTIVE_PTR);
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if ( result == NULL ) {
_KLOGX2(KLOG_partition_alloc_zero, result);
return (result);
} /* Endif */
#endif
_mem_zero(result, (_mem_size)(partpool_ptr->BLOCK_SIZE -
sizeof(INTERNAL_PARTITION_BLOCK_STRUCT)));
_KLOGX2(KLOG_partition_alloc_zero, result);
return (result);
} /* Endbody */
/*FUNCTION*****************************************************************
*
* Function Name : _adc_install
* Returned Value : _mqx_uint a task error code or MQX_OK
* Comments :
* Install a adc driver.
*
*END*********************************************************************/
_mqx_uint _io_adc_install
(
/* [IN] A string that identifies the device for fopen */
char_ptr identifier,
/* pointer to a HW specific structure */
pointer init
)
{ /* Body */
ADC_DRIVER_BUNDLE_PTR adc_driver_bundle;
_mqx_uint result;
if (NULL == (adc_driver_bundle = (ADC_DRIVER_BUNDLE_PTR) _mem_alloc(sizeof(ADC_DRIVER_BUNDLE))))
return ADC_ERROR_ALLOC; /* memory allocation error */
_mem_zero(adc_driver_bundle, sizeof(ADC_DRIVER_BUNDLE));
if (IO_OK == (result = _adc_hw_install(identifier, adc_driver_bundle, init)))
if (IO_OK == (result = _adt_hw_install(identifier, adc_driver_bundle, init)))
result = _io_dev_install(identifier,
_adc_open,
_adc_close,
_adc_read,
_adc_write,
_adc_ioctl,
adc_driver_bundle);
if (result != IO_OK)
_mem_free(adc_driver_bundle);
return result;
} /* Endbody */
void RIP_init_static_rt
(
IP_ROUTE_INDIRECT_PTR gate, /* [IN] the route to init */
uint16_t metric /* [IN] metric of this route. [0,65535] */
)
{ /* Body */
RIP_CFG_STRUCT_PTR ripcfg = RTCS_getcfg(RIP);
_mem_zero(&gate->RIP, sizeof(gate->RIP));
gate->RIP.METRIC = metric / 4096;
/* sanity check */
if (gate->RIP.METRIC < RIP_MIN_METRIC) {
gate->RIP.METRIC = RIP_MIN_METRIC;
} /* Endif */
if (gate->RIP.METRIC > RIP_MAX_METRIC) {
gate->RIP.METRIC = RIP_MAX_METRIC;
} /* Endif */
/* no src interface for a static route */
gate->RIP.IPIFSRC = NULL;
gate->RIP.CHANGED_F = TRUE;
if (ripcfg){
ripcfg->RT_CHANGED_F = TRUE;
RIP_trig_upd();
}
} /* Endbody */
static void IP_route_insert
(
pointer _PTR_ node,
pointer data
)
{ /* Body */
struct ip_route_insert _PTR_ insertdata = data;
IP_ROUTE_PRV_PTR route;
IP_ROUTE_DIRECT_PTR new_route = insertdata->route;
uint_32 i = insertdata->index;
/* Make sure the node is initialized */
if (!*node) {
*node = node;
_mem_zero(((IP_ROUTE_PRV_PTR)*node)->ROUTETYPE, sizeof(route->ROUTETYPE));
} /* endif */
route = *node;
if (!route->ROUTETYPE[i]) {
new_route->NEXT = new_route;
route->ROUTETYPE[i] = new_route;
} else if (insertdata->sort) {
insertdata->sort(&route->ROUTETYPE[i], new_route);
} else {
new_route->NEXT = route->ROUTETYPE[i]->NEXT;
route->ROUTETYPE[i]->NEXT = new_route;
} /* Endif */
insertdata->error = RTCS_OK;
} /* Endbody */
/*!
* \brief Initialize the mmu and set default properties for regions not mapped by
* the ACR registers.
*
* \param[in] mmu_init default properties
*/
void _mmu_init
(
// [IN] default properties
void *mmu_init
)
{ /* Body */
PSP_MMU_INIT_STRUCT_PTR mmu = mmu_init;
KERNEL_DATA_STRUCT_PTR kernel_data;
PSP_SUPPORT_STRUCT_PTR psp_support_ptr;
uint32_t mode;
uint32_t tmp;
_mqx_int i;
_GET_KERNEL_DATA(kernel_data);
psp_support_ptr = (PSP_SUPPORT_STRUCT_PTR)kernel_data->PSP_SUPPORT_PTR;
if (psp_support_ptr == NULL || mmu == 0) {
_mqx_fatal_error(MQX_INVALID_POINTER);
} /* Endif */
/* Stop and invalidate the cache */
_DCACHE_DISABLE();
_ICACHE_DISABLE();
_mem_zero(psp_support_ptr->ACR_VALS, sizeof(psp_support_ptr->ACR_VALS));
mode = mmu->INITIAL_CACR_ENABLE_BITS & ~(MCF54XX_CACR_EUSP) | MCF54XX_CACR_SPA; // do not remove SPA flag - fn for flush/invalidate cache use phy address features
tmp = _PSP_GET_CACR();
tmp |= mode;
_PSP_SET_CACR(tmp);
} /* Endbody */
/*
** Function used to free session structure
**
** IN:
** FTPSRV_SESSION_STRUCT* session - session structure pointer
**
** OUT:
** none
**
** Return Value:
** none
*/
static void ftpsrv_ses_free(FTPSRV_SESSION_STRUCT *session)
{
if (session)
{
if(session->buffer)
{
_mem_free(session->buffer);
session->buffer = NULL;
}
if(session->auth_input.uid)
{
_mem_free(session->auth_input.uid);
session->auth_input.uid = NULL;
}
if(session->auth_input.pass && strcmp(session->auth_input.pass, ""))
{
_mem_free(session->auth_input.pass);
session->auth_input.pass = NULL;
}
if(session->cur_dir)
{
_mem_free(session->cur_dir);
}
if (session->msg_queue != NULL)
{
_lwmsgq_deinit(session->msg_queue);
_mem_zero(session->msg_queue, sizeof(LWMSGQ_STRUCT) + FTPSRV_NUM_MESSAGES*sizeof(FTPSRV_TRANSFER_MSG)*sizeof(_mqx_max_type));
_mem_free(session->msg_queue);
}
_mem_free(session);
}
}
/*
** Read data from HTTP server.
**
** First copy data from session buffer if there are any and than read rest from socket if required.
**
** IN:
** HTTPSRV_SESSION_STRUCT *session - session to use for reading.
** char *dst - user buffer to read to.
** _mqx_int len - size of user buffer.
**
** OUT:
** none
**
** Return Value:
** int - number of bytes read.
*/
_mqx_int httpsrv_read(HTTPSRV_SESSION_STRUCT *session, char *dst, _mqx_int len)
{
int read = 0;
uint_32 data_size = session->buffer.offset;
uint_32 length = (data_size < len) ? data_size : len;
uint_32 received = 0;
/* If there are any data in buffer copy them to user buffer */
if (data_size > 0)
{
uint_32 tail = (HTTPSRVCFG_SES_BUFFER_SIZE & PSP_MEMORY_ALIGNMENT_MASK)-length;
_mem_copy(session->buffer.data, dst, length);
memmove(session->buffer.data, session->buffer.data+length, tail);
_mem_zero(session->buffer.data+tail, length);
session->buffer.offset -= length;
read = length;
}
/* If there is some space remaining in user buffer try to read from socket */
while (read < len)
{
received = recv(session->sock, dst+read, len-read, 0);
if (RTCS_ERROR != received)
{
read += received;
}
else
{
break;
}
}
return read;
}
_mfs_error MFS_Clear_cluster
(
MFS_DRIVE_STRUCT_PTR drive_ptr, /*[IN] the drive on which to operate */
uint_32 cluster /*[IN] the # of the cluster to clear*/
)
{
uint_32 sector,i;
_mfs_error error_code;
#if MFSCFG_READ_ONLY_CHECK
if (MFS_is_read_only (NULL, drive_ptr))
{
return MFS_DISK_IS_WRITE_PROTECTED;
}
#endif
error_code = MFS_Flush_directory_sector_buffer(drive_ptr);
sector = CLUSTER_TO_SECTOR(cluster);
_mem_zero(drive_ptr->DIR_SECTOR_PTR, drive_ptr->BPB.SECTOR_SIZE);
for ( i = 0; ((i<drive_ptr->BPB.SECTORS_PER_CLUSTER) && (error_code==MFS_NO_ERROR));i++ )
{
error_code = MFS_Write_device_sector(drive_ptr,sector+i,drive_ptr->DIR_SECTOR_PTR);
}
drive_ptr->DIR_SECTOR_NUMBER = sector;
return(error_code);
}
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 */
/*FUNCTION*------------------------------------------------
*
* Function Name: PPP_start
* Comments :
*
*
*END*-----------------------------------------------------*/
void PPP_start(void)
{
uint_32 error;
_rtcs_if_handle ihandle;
MQX_FILE_PTR pfile;
_iopcb_handle pio;
_ppp_handle phandle;
IPCP_DATA_STRUCT ipcp_data;
_PPP_PAP_RSECRETS = rsecrets; /* Require authentication, allow PAP */
_PPP_PAP_LSECRET = &lsecret; /* Allow peer to request PAP */
_PPP_CHAP_LNAME = localname; /* Needed by CHAP */
_PPP_CHAP_RSECRETS = rsecrets; /* Require authentication, allow CHAP */
_PPP_CHAP_LSECRETS = lsecrets; /* Allow peer to request CHAP */
/* Install a route for a default gateway */
RTCS_gate_add(GATE_ADDR, INADDR_ANY, INADDR_ANY);
pfile = fopen(PPP_DEVICE, NULL);
#ifdef PPP_DEVICE_DUN
_io_dun_install("dun:");
pfile = fopen("dun:", (char_ptr)pfile);
#endif
pio = _iopcb_ppphdlc_init(pfile);
_PPP_ACCM = 0;
error = PPP_initialize(pio, &phandle);
if (error) {
printf("\nPPP initialize: %lx", error);
_task_block();
} /* Endif */
_iopcb_open(pio, PPP_lowerup, PPP_lowerdown, phandle);
error = RTCS_if_add(phandle, RTCS_IF_PPP, &ihandle);
if (error) {
printf("\nIF add failed, error = %lx", error);
_task_block();
} /* Endif */
_lwsem_create(&ppp_sem, 0);
_mem_zero(&ipcp_data, sizeof(ipcp_data));
ipcp_data.IP_UP = PPP_linkup;
ipcp_data.IP_DOWN = NULL;
ipcp_data.IP_PARAM = &ppp_sem;
ipcp_data.ACCEPT_LOCAL_ADDR = FALSE;
ipcp_data.ACCEPT_REMOTE_ADDR = FALSE;
ipcp_data.LOCAL_ADDR = PPP_LOCADDR;
ipcp_data.REMOTE_ADDR = PPP_PEERADDR;
ipcp_data.DEFAULT_NETMASK = TRUE;
ipcp_data.DEFAULT_ROUTE = TRUE;
error = RTCS_if_bind_IPCP(ihandle, &ipcp_data);
if (error) {
printf("\nIF bind failed, error = %lx", error);
_task_block();
} /* Endif */
printf("\nPlease initiate PPP connection. Waiting...");
_lwsem_wait(&ppp_sem);
printf("\nPPP device %s bound to %d.%d.%d.%d", PPP_DEVICE, IPBYTES(ipcp_data.LOCAL_ADDR));
}
void OS_Mem_zero(void* ptr, uint32_t length)
{
#if MEM_ZERO_ENHANCEMENT
_mem_zero(ptr, length);
#else
memset(ptr, 0, length);
#endif
}
/*!
* \brief This function sets up the stack frame of a new task descriptor.
*
* \param[in] td_ptr the address of the task descriptor
* \param[in] stack_ptr the address of the stack memory block
* \param[in] stack_size the size of the stack
* \param[in] template_ptr the task's template
* \param[in] status_register the status register to use in creating the task
* \param[in] create_parameter the task creation parameter
*/
bool _psp_build_stack_frame
(
/* [IN] the address of the task descriptor */
TD_STRUCT_PTR td_ptr,
/* [IN] the address of the stack memory block */
void *stack_ptr,
/* [IN] the size of the stack */
_mem_size stack_size,
/* [IN] the task's template */
TASK_TEMPLATE_STRUCT_PTR template_ptr,
/* [IN] the status register to use in creating the task */
_mqx_uint status_register,
/* [IN] the task creation parameter */
uint32_t create_parameter
)
{
unsigned char *stack_base_ptr;
PSP_STACK_START_STRUCT_PTR stack_start_ptr;
bool res = TRUE;
stack_base_ptr = (unsigned char *)_GET_STACK_BASE(stack_ptr, stack_size);
stack_start_ptr = (PSP_STACK_START_STRUCT_PTR)(stack_base_ptr - sizeof(PSP_STACK_START_STRUCT));
td_ptr->STACK_BASE = (void *)stack_base_ptr;
td_ptr->STACK_LIMIT = _GET_STACK_LIMIT(stack_ptr, stack_size);
td_ptr->STACK_PTR = stack_start_ptr;
/*
** Build the task's initial stack frame. This contains the initialized
** registers, and an exception frame which will cause the task to
** "return" to the start of the task when it is dispatched.
*/
_mem_zero(stack_start_ptr, (_mem_size)sizeof(PSP_STACK_START_STRUCT));
stack_start_ptr->INITIAL_CONTEXT.LR = (uint32_t)_task_exit_function_internal;
stack_start_ptr->INITIAL_CONTEXT.R0 = (uint32_t)create_parameter;
stack_start_ptr->INITIAL_CONTEXT.PC = (uint32_t)(template_ptr->TASK_ADDRESS) | 1;
stack_start_ptr->INITIAL_CONTEXT.PSR = 0x01000000;
stack_start_ptr->PARAMETER = create_parameter;
#if PSP_MQX_CPU_IS_ARM_CORTEX_M4
stack_start_ptr->INITIAL_CONTEXT.PENDSVPRIOR = 0;
stack_start_ptr->INITIAL_CONTEXT.BASEPRI = status_register;
stack_start_ptr->INITIAL_CONTEXT.LR2 = 0xfffffffd;
#endif
#if MQXCFG_ENABLE_FP && PSP_HAS_FPU
if (td_ptr->FLAGS & MQX_FLOATING_POINT_TASK) {
res = _psp_build_float_context(td_ptr);
}
#endif /* MQXCFG_ENABLE_FP && PSP_HAS_FPU */
return res;
}
/*
* Accept connection from client.
*/
uint32_t ftpsrv_accept(uint32_t sock)
{
struct sockaddr remote_addr;
unsigned short length;
RTCS_ASSERT(sock != RTCS_SOCKET_ERROR);
_mem_zero(&remote_addr, sizeof(remote_addr));
length = sizeof(remote_addr);
return(accept(sock, (sockaddr *) &remote_addr, &length));
}
static void RIP_build_header(
unsigned char *buf, /* [OUT] the rip header */
uint8_t cmd, /* [IN] the commande */
uint8_t version /* [IN] the version */
)
{ /* Body */
RIP_HEADER_PTR hd = (RIP_HEADER_PTR)buf;
_mem_zero(buf, sizeof(RIP_HEADER));
mqx_htonc(hd->COMMAND, cmd);
mqx_htonc(hd->VERSION, version);
mqx_htons(hd->MBZ, 0);
} /* Endbody */
/* Run command, check authentication first */
static void ftpsrv_process_cmd(FTPSRV_SESSION_STRUCT* session)
{
const FTPSRV_COMMAND_STRUCT* row = ftpsrv_commands;
int result = 1;
char* cp = session->command;
uint32_t auth_valid;
/* Convert command to upper case */
while (*cp)
{
*cp = toupper(*cp);
cp++;
}
/* Find function corresponding to command */
while ((row->command != NULL) && strncmp(session->command, row->command, strlen(row->command)))
{
row++;
}
/* Process authentication sequence if required */
auth_valid = ftpsrv_process_auth(session, row->auth_req);
/* Run command if authentication is valid */
if (auth_valid)
{
if (row->function != NULL)
{
row->function(session);
}
else
{
session->message = (char*) ftpsrvmsg_unimp;
}
}
else
{
if (session->message == NULL)
{
session->message = (char*) ftpsrvmsg_not_logged;
}
if (session->auth_input.uid != NULL)
{
_mem_free(session->auth_input.uid);
session->auth_input.uid = NULL;
}
}
ftpsrv_send_msg(session, session->message);
session->message = NULL;
_mem_zero(session->buffer, FTPSRV_BUF_SIZE);
}
void BOOTP_open
(
TCPIP_PARM_BOOTP _PTR_ parms
)
{ /* Body */
IP_IF_PTR if_ptr = (IP_IF_PTR)parms->handle;
BOOTP_CFG_PTR bootp = (BOOTP_CFG_PTR) &parms->config;
uint_32 error;
error = BOOT_open(BOOT_service);
if (error) {
RTCSCMD_complete(parms, error);
return;
} /* Endif */
if_ptr->BOOTFN = BOOTP_service;
/* Pick a random transaction ID */
bootp->XID = RTCS_rand();
/* Set initial timeout */
bootp->TIMEOUT = BOOTP_TIMEOUT_MIN;
bootp->SECS = 0;
/* Build a BOOTREQUEST packet */
htonc(bootp->PACKET.OP, BOOTPOP_BOOTREQUEST);
htonc(bootp->PACKET.HTYPE, if_ptr->DEV_TYPE);
htonc(bootp->PACKET.HLEN, if_ptr->DEV_ADDRLEN);
htonc(bootp->PACKET.HOPS, 0);
htonl(bootp->PACKET.XID, bootp->XID);
htons(bootp->PACKET.FLAGS, 0x8000);
htonl(bootp->PACKET.CIADDR, INADDR_ANY);
htonl(bootp->PACKET.YIADDR, INADDR_ANY);
htonl(bootp->PACKET.SIADDR, INADDR_ANY);
htonl(bootp->PACKET.GIADDR, INADDR_ANY);
_mem_zero(bootp->PACKET.CHADDR, sizeof(bootp->PACKET.CHADDR));
_mem_copy(if_ptr->DEV_ADDR, bootp->PACKET.CHADDR, if_ptr->DEV_ADDRLEN);
/* Start the retransmission timer to start sending immediately */
bootp->RESEND.TIME = 0;
bootp->RESEND.EVENT = BOOTP_send;
bootp->RESEND.PRIVATE = if_ptr;
TCPIP_Event_add(&bootp->RESEND);
if_ptr->BOOT = (pointer)parms;
} /* Endbody */
/*
** Send data from session buffer to client.
**
** IN:
** HTTPSRV_SESSION_STRUCT *session - session to use.
**
** OUT:
** none
**
** Return Value:
** int - number of bytes send.
*/
uint_32 httpsrv_send_buffer(HTTPSRV_SESSION_STRUCT *session)
{
uint_32 length = 0;
length = send(session->sock, session->buffer.data, session->buffer.offset, 0);
if (length != RTCS_ERROR)
{
_mem_zero(session->buffer.data, session->buffer.offset);
session->buffer.offset = 0;
}
else
{
length = 0;
}
return(length);
}
static unsigned char *DNS_parse_answer_name_to_dotted_form
(
unsigned char *buffer_ptr,
unsigned char *name,
uint32_t loc
)
{ /* Body */
unsigned char *compressed_name;
unsigned char *fill_ptr;
unsigned char label_size;
uint32_t i;
uint16_t new_location;
fill_ptr = RTCS_HOST_NAMES[loc];
_mem_zero(fill_ptr, DNS_MAX_CHARS_IN_NAME);
compressed_name = name;
while ( mqx_ntohc(compressed_name) != '\0' ) {
if ( mqx_ntohc(compressed_name) & DNS_COMPRESSED_NAME_MASK ) {
new_location = mqx_ntohs(compressed_name)
& DNS_COMPRESSED_LOCATION_MASK;
compressed_name = buffer_ptr + new_location;
}/* Endif */
label_size = mqx_ntohc(compressed_name);
compressed_name++;
for ( i = 0; i < label_size; i++ ) {
*fill_ptr++ = mqx_ntohc(compressed_name);
compressed_name++;
} /* Endfor */
if ( mqx_ntohc(compressed_name) != '\0' ) {
*fill_ptr++ = '.';
}/* Endif */
} /* Endwhile */
*fill_ptr = '\0';
return( RTCS_HOST_NAMES[loc] );
} /* Endbody */
/* prepares TCD for register to memory copy */
int dma_tcd_reg2mem(DMA_TCD_STRUCT *tcd, volatile void *reg, int regw, void *dst, uint_32 size)
{
uint_32 dst_alignment;
uint_32 reg_alignment;
int endian_swap;
int dstw;
endian_swap = (regw < -1);
regw = (regw < 0) ? -regw : regw;
if ((regw != 1) && (regw != 2) && (regw != 4)) {
return MQX_INVALID_PARAMETER;
}
reg_alignment = alignment_tab[((uint_32)reg | (uint_32)size) & 3];
if (reg_alignment < regw) {
return MQX_INVALID_PARAMETER;
}
_mem_zero(tcd, sizeof(*tcd));
tcd->SRC_ADDR = (uint_32)reg; /* periodic read from the same address */
tcd->SRC_WIDTH = regw;
tcd->SRC_OFFSET = 0;
if (endian_swap) {
tcd->DST_ADDR = (uint_32)dst + regw - 1;
tcd->DST_WIDTH = 1;
tcd->DST_OFFSET = -1;
tcd->LOOP_DST_OFFSET = 2*regw;
}
else {
dst_alignment = alignment_tab[((uint_32)dst | (uint_32)size) & 3];
dstw = (dst_alignment > regw) ? regw : dst_alignment;
tcd->DST_ADDR = (uint_32)dst;
tcd->DST_WIDTH = dstw;
tcd->DST_OFFSET = dstw;
}
tcd->LOOP_BYTES = regw;
tcd->LOOP_COUNT = (size >> (regw/2));
return MQX_OK;
}
/* prepares TCD for memory to register copy */
int dma_tcd_mem2reg(DMA_TCD_STRUCT *tcd, volatile void *reg, int regw, void *src, uint_32 size)
{
uint_32 src_alignment;
uint_32 reg_alignment;
int endian_swap;
int srcw;
endian_swap = (regw < 0);
regw = (regw < 0) ? -regw : regw;
if ((regw != 1) && (regw != 2) && (regw != 4)) {
return MQX_INVALID_PARAMETER;
}
reg_alignment = alignment_tab[((uint_32)reg | (uint_32)size) & 3];
if (reg_alignment < regw) {
return MQX_INVALID_PARAMETER;
}
_mem_zero(tcd, sizeof(*tcd));
if (endian_swap) {
tcd->SRC_ADDR = (uint_32)src + regw - 1;
tcd->SRC_WIDTH = 1;
tcd->SRC_OFFSET = -1;
tcd->LOOP_SRC_OFFSET = 2*regw;
}
else {
src_alignment = alignment_tab[((uint_32)src | (uint_32)size) & 3];
srcw = (src_alignment > regw) ? regw : src_alignment;
tcd->SRC_ADDR = (uint_32)src;
tcd->SRC_WIDTH = srcw;
tcd->SRC_OFFSET = srcw;
}
tcd->DST_ADDR = (uint_32)reg;
tcd->DST_WIDTH = regw;
tcd->DST_OFFSET = 0; /* periodic write to the same address */
tcd->LOOP_BYTES = regw;
tcd->LOOP_COUNT = (size >> (regw/2));
return MQX_OK;
}
int32_t ftpsrv_help(FTPSRV_SESSION_STRUCT* session)
{
const FTPSRV_COMMAND_STRUCT* cmd_ptr = ftpsrv_commands;
uint32_t length = 0;
uint32_t n = 1;
uint32_t space = FTPSRV_BUF_SIZE;
uint32_t max_cmd_length = ftpsrv_max_cmd_length();
char* separator;
char* buffer = session->buffer;
ftpsrv_send_msg(session, ftpsrvmsg_help_start);
while(cmd_ptr->command != NULL)
{
/* After every fifth command print a new line. Commands are separated by spaces */
separator = (n % 4) ? " " : "\r\n";
n++;
length += snprintf(buffer+length, space, "%s%s", cmd_ptr->command, separator);
space = FTPSRV_BUF_SIZE-length;
/* If there is not enough space in the buffer flush it to client and repeat printing */
if (space < (max_cmd_length + sizeof("\r\n")))
{
send(session->control_sock, buffer, FTPSRV_BUF_SIZE-space, 0);
_mem_zero(buffer, length);
space = FTPSRV_BUF_SIZE;
length = 0;
}
cmd_ptr++;
}
if (n)
{
space -= snprintf(buffer+length, space, "\r\n");
}
/* Send command list from the buffer and set message to HELP end text */
send(session->control_sock, buffer, FTPSRV_BUF_SIZE-space, 0);
session->message = (char*) ftpsrvmsg_help_end;
return(FTPSRV_OK);
}
void usb_class_mass_q_init
(
/* [IN] interface structure pointer */
USB_MASS_CLASS_INTF_STRUCT_PTR intf_ptr
)
{ /* Body */
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_q_init");
#endif
// intf_ptr->QUEUE.FIRST = 0;
// intf_ptr->QUEUE.LAST = 0;
// intf_ptr->QUEUE.AVAILABLE = TRUE;
_mem_zero(&intf_ptr->QUEUE, sizeof(intf_ptr->QUEUE));
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_mass_q_init, SUCCESSFUL");
#endif
} /* Endbody */
pointer _mem_alloc_zero
(
/* [IN] the size of the memory block */
_mem_size size
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
_mqx_uint error;
pointer result;
_GET_KERNEL_DATA(kernel_data);
_KLOGE2(KLOG_mem_alloc_zero, size);
_INT_DISABLE();
result = _mem_alloc_internal(size, kernel_data->ACTIVE_PTR,
(MEMPOOL_STRUCT_PTR)&kernel_data->KD_POOL, &error);
/* update the memory allocation pointer in case a lower priority
** task was preempted inside _mem_alloc_internal
*/
kernel_data->KD_POOL.POOL_ALLOC_CURRENT_BLOCK =
kernel_data->KD_POOL.POOL_FREE_LIST_PTR;
_INT_ENABLE();
#if MQX_CHECK_ERRORS
if (error != MQX_OK) {
_task_set_error(error);
} /* Endif */
#endif
if (result != NULL) {
_mem_zero(result, size);
} /* Endif */
_KLOGX3(KLOG_mem_alloc_zero, result,
kernel_data->KD_POOL.POOL_BLOCK_IN_ERROR);
return(result);
} /* 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;
}
static void RIP_build_rte(
unsigned char *buf, /* [OUT] the route entry */
uint16_t family,
uint16_t rt_tag,
_ip_address net_addr,
_ip_address net_mask,
_ip_address next_hop,
uint32_t metric,
uint32_t rip_vers
)
{ /* Body */
RIP_ENTRY_PTR rte = (RIP_ENTRY_PTR)buf;
if (rip_vers == RIP_V2){
mqx_htons(rte->RT_TAG, rt_tag);
mqx_htonl(rte->NETMASK, net_mask);
mqx_htonl(rte->NEXTHOP, next_hop);
}else{
_mem_zero(buf, sizeof(RIP_ENTRY));
}
mqx_htons(rte->FAMILY, family);
mqx_htonl(rte->NETADDR, net_addr);
mqx_htonl(rte->METRIC, metric);
} /* Endbody */
/* prepares TCD for memory to memory copy */
void dma_tcd_memcpy(DMA_TCD_STRUCT *tcd, void *src, void *dst, uint_32 size)
{
int src_alignment;
int dst_alignment;
int loop_alignment;
src_alignment = alignment_tab[((uint_32)src | (uint_32)size) & 3];
dst_alignment = alignment_tab[((uint_32)src | (uint_32)size) & 3];
loop_alignment = (src_alignment > dst_alignment) ? src_alignment : dst_alignment;
_mem_zero(tcd, sizeof(*tcd));
tcd->SRC_ADDR = (uint_32)src;
tcd->SRC_WIDTH = src_alignment;
tcd->SRC_OFFSET = src_alignment;
tcd->DST_ADDR = (uint_32)dst;
tcd->DST_WIDTH = dst_alignment;
tcd->DST_OFFSET = dst_alignment;
tcd->LOOP_BYTES = loop_alignment;
tcd->LOOP_COUNT = (size >> (loop_alignment/2)); /* loop_alignment is one of 1, 2 or 4, more efficient than plain division */
}
static void DHCPSRV_write_header
(
DHCPSRV_STATE_STRUCT_PTR state,
DHCPSRV_ADDR_STRUCT_PTR lease_ptr,
uint_32 lease_time,
uchar msgtype
)
{ /* Body */
DHCP_HEADER_PTR outp;
DHCP_HEADER_PTR inp;
uchar_ptr optptr;
volatile uint_32 optlen;
uint_32 temp_long;
uint_16 temp_short;
uchar temp_char;
outp = (DHCP_HEADER_PTR)state->SND_BUFFER;
inp = (DHCP_HEADER_PTR)state->RCV_BUFFER;
/* Build a DHCPOFFER, DHCPACK, or DHCPNAK packet */
htonc(outp->OP, DHCPOP_BOOTREPLY);
htonc(outp->HTYPE, ARPLINK_ETHERNET);
temp_char = ntohc(inp->HLEN);
htonc(outp->HLEN, temp_char);
htonc(outp->HOPS, 0);
/* Use client's existing transaction ID */
temp_long = ntohl(inp->XID);
htonl(outp->XID, temp_long);
htons(outp->SECS, 0);
if (ntohl(inp->GIADDR) == 0) {
htons(outp->FLAGS, 0);
} else {
temp_short = ntohs(inp->FLAGS);
htons(outp->FLAGS, temp_short);
} /* Endif */
if (msgtype == DHCPTYPE_DHCPOFFER) {
htonl(outp->CIADDR, 0);
} else {
temp_long = ntohl(inp->CIADDR);
htonl(outp->CIADDR, temp_long);
} /* Endif */
if (msgtype == DHCPTYPE_DHCPNAK) {
htonl(outp->YIADDR, 0);
htonl(outp->SIADDR, 0);
} else {
htonl(outp->YIADDR, lease_ptr->IP_ADDR);
htonl(outp->SIADDR, lease_ptr->OPTIONS->SADDR);
} /* Endif */
htonl(outp->GIADDR, 0);
_mem_copy(inp->CHADDR, outp->CHADDR, sizeof(outp->CHADDR));
if (msgtype == DHCPTYPE_DHCPNAK) {
_mem_zero(outp->SNAME, sizeof(outp->SNAME));
_mem_zero(outp->FILE, sizeof(outp->FILE));
} else {
_mem_copy(lease_ptr->OPTIONS->SNAME, outp->SNAME, sizeof(outp->SNAME));
_mem_copy(lease_ptr->OPTIONS->FILE, outp->FILE, sizeof(outp->FILE));
} /* Endif */
/*
** Fill in the required response options. These are message type,
** subnet mask, and server id.
*/
optlen = sizeof(DHCP_HEADER);
optptr = state->SND_BUFFER + optlen;
/* The Magic Cookie must always be the first thing in the OPTIONS */
htonl(optptr, DHCP_MAGIC);
optptr += DHCPSIZE_MAGIC;
optlen += DHCPSIZE_MAGIC;
#define DHCP_OPTION(type,len,val) \
htonc(optptr, DHCPOPT_ ## type); optptr++; optlen++; \
htonc(optptr, DHCPSIZE_ ## type); optptr++; optlen++; \
hton ## len(optptr, val); \
optptr += DHCPSIZE_ ## type; \
optlen += DHCPSIZE_ ## type
DHCP_OPTION(MSGTYPE, c, msgtype);
if (msgtype != DHCPTYPE_DHCPNAK) {
DHCP_OPTION(SERVERID, l, lease_ptr->OPTIONS->SERVERID);
DHCP_OPTION(MASK, l, lease_ptr->OPTIONS->MASK);
DHCP_OPTION(LEASE, l, lease_time);
} /* Endif */
state->SND_BUFFER_LEN = optlen;
} /* Endbody */
_ppp_handle PPP_init
(
PPP_PARAM_STRUCT* params
)
{ /* Body */
#if RTCSCFG_ENABLE_IP4
PPP_CFG_PTR ppp_ptr;
uint32_t error;
IPCP_DATA_STRUCT ipcp_data;
int stage = 0;
/* Allocate the state structure */
ppp_ptr = _mem_alloc_zero(sizeof(PPP_CFG));
if (!ppp_ptr)
{
return(NULL);
}
ppp_ptr->DEVICE_NAME = _mem_alloc_zero(strlen(params->device)+1);
if (ppp_ptr->DEVICE_NAME == NULL)
{
_mem_free(ppp_ptr);
return(NULL);
}
strcpy(ppp_ptr->DEVICE_NAME, params->device);
/* Stage 0 - Open low level device */
ppp_ptr->IOPCB_DEVICE = fopen(params->device, NULL);
if (ppp_ptr->IOPCB_DEVICE == NULL)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 1 - Initialize HDLC and lwsem */
ppp_ptr->DEVICE = _iopcb_ppphdlc_init(ppp_ptr->IOPCB_DEVICE);
if (ppp_ptr->DEVICE == NULL)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
ppp_ptr->RECV_OPTIONS = &PPP_DEFAULT_OPTIONS;
ppp_ptr->SEND_OPTIONS = &PPP_DEFAULT_OPTIONS;
if (_lwsem_create(&ppp_ptr->MUTEX, 1))
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 2 - Initialize LCP */
error = LCP_init(ppp_ptr);
if (error)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 3 - Initialize and open CCP */
/*
error = CCP_init(ppp_ptr);
if (error)
{
PPP_init_fail(ppp_ptr, stage);
return error;
}
CCP_open(ppp_ptr);
*/
stage++;
/* Stage 4 - Create a pool of message buffers */
ppp_ptr->MSG_POOL = RTCS_msgpool_create(sizeof(PPP_MESSAGE), PPP_MESSAGE_INITCOUNT, PPP_MESSAGE_GROWTH, PPP_MESSAGE_LIMIT);
if (ppp_ptr->MSG_POOL == MSGPOOL_NULL_POOL_ID)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 5 - Create the Tx Task */
error = RTCS_task_create("PPP tx", _PPPTASK_priority, _PPPTASK_stacksize + 1000, PPP_tx_task, ppp_ptr);
if (error)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 6 - Create the Rx Task */
ppp_ptr->STOP_RX = FALSE;
error = RTCS_task_create("PPP rx", _PPPTASK_priority, _PPPTASK_stacksize + 1000, PPP_rx_task, ppp_ptr);
if (error)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 7 - Open HDLC layer */
error = _iopcb_open(ppp_ptr->DEVICE, PPP_lowerup, PPP_lowerdown, ppp_ptr);
if (error != PPPHDLC_OK)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
ppp_ptr->VALID = PPP_VALID;
stage++;
/* Stage 8 - Add PPP interface to RTCS */
error = RTCS_if_add(ppp_ptr, RTCS_IF_PPP, &ppp_ptr->IF_HANDLE);
if (error != RTCS_OK)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
stage++;
/* Stage 9 - Bind IP address to PPP interface */
_mem_zero(&ipcp_data, sizeof(ipcp_data));
ipcp_data.IP_UP = params->up;
ipcp_data.IP_DOWN = params->down;
ipcp_data.IP_PARAM = params->callback_param;
if(params->listen_flag == 0)
{
ipcp_data.ACCEPT_LOCAL_ADDR = TRUE;
ipcp_data.ACCEPT_REMOTE_ADDR = TRUE;
}
else
{
ipcp_data.ACCEPT_LOCAL_ADDR = FALSE;
ipcp_data.ACCEPT_REMOTE_ADDR = FALSE;
}
ipcp_data.LOCAL_ADDR = params->local_addr;
ipcp_data.REMOTE_ADDR = params->remote_addr;
ipcp_data.DEFAULT_NETMASK = TRUE;
ipcp_data.DEFAULT_ROUTE = TRUE;
error = RTCS_if_bind_IPCP(ppp_ptr->IF_HANDLE, &ipcp_data);
if (error != RTCS_OK)
{
PPP_init_fail(ppp_ptr, stage);
return(NULL);
}
params->if_handle = ppp_ptr->IF_HANDLE;
stage++;
/* Stage 10 - Init complete, return handle */
return(ppp_ptr);
#else
return(NULL);
#endif /* RTCSCFG_ENABLE_IP4 */
} /* Endbody */
