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 */