static rt_err_t rt_serial_close(struct rt_device *dev) { struct rt_serial_device *serial; RT_ASSERT(dev != RT_NULL); serial = (struct rt_serial_device *)dev; /* this device has more reference count */ if (dev->ref_count > 1) return RT_EOK; if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) { struct rt_serial_rx_fifo* rx_fifo; rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx; RT_ASSERT(rx_fifo != RT_NULL); rt_free(rx_fifo); serial->serial_rx = RT_NULL; dev->open_flag &= ~RT_DEVICE_FLAG_INT_RX; /* configure low level device */ serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX); } else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX) { struct rt_serial_rx_dma* rx_dma; rx_dma = (struct rt_serial_rx_dma*)serial->serial_tx; RT_ASSERT(rx_dma != RT_NULL); rt_free(rx_dma); serial->serial_rx = RT_NULL; dev->open_flag &= ~RT_DEVICE_FLAG_DMA_RX; } if (dev->open_flag & RT_DEVICE_FLAG_INT_TX) { struct rt_serial_tx_fifo* tx_fifo; tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_rx; RT_ASSERT(tx_fifo != RT_NULL); rt_free(tx_fifo); serial->serial_tx = RT_NULL; dev->open_flag &= ~RT_DEVICE_FLAG_INT_TX; /* configure low level device */ serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX); } else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX) { struct rt_serial_tx_dma* tx_dma; tx_dma = (struct rt_serial_tx_dma*)serial->serial_tx; RT_ASSERT(tx_dma != RT_NULL); rt_free(tx_dma); serial->serial_tx = RT_NULL; dev->open_flag &= ~RT_DEVICE_FLAG_DMA_TX; } return RT_EOK; }
void msh_auto_complete_path(char *path) { DIR* dir = RT_NULL; struct dirent *dirent = RT_NULL; char *full_path, *ptr, *index; full_path = (char*)rt_malloc(256); if (full_path == RT_NULL) return; /* out of memory */ ptr = full_path; if (*path != '/') { getcwd(full_path, 256); if (full_path[rt_strlen(full_path) - 1] != '/') strcat(full_path, "/"); } else *full_path = '\0'; index = RT_NULL; ptr = path; for (;;) { if (*ptr == '/') index = ptr + 1; if (!*ptr) break; ptr ++; } if (index == RT_NULL) index = path; if (index != RT_NULL) { char *dest = index; /* fill the parent path */ ptr = full_path; while (*ptr) ptr ++; for (index = path; index != dest;) *ptr++ = *index++; *ptr = '\0'; dir = opendir(full_path); if (dir == RT_NULL) /* open directory failed! */ { rt_free(full_path); return; } /* restore the index position */ index = dest; } /* auto complete the file or directory name */ if (*index == '\0') /* display all of files and directories */ { for (;;) { dirent = readdir(dir); if (dirent == RT_NULL) break; rt_kprintf("%s\n", dirent->d_name); } } else { int length, min_length; min_length = 0; for (;;) { dirent = readdir(dir); if (dirent == RT_NULL) break; /* matched the prefix string */ if (strncmp(index, dirent->d_name, rt_strlen(index)) == 0) { if (min_length == 0) { min_length = rt_strlen(dirent->d_name); /* save dirent name */ strcpy(full_path, dirent->d_name); } length = str_common(dirent->d_name, full_path); if (length < min_length) { min_length = length; } } } if (min_length) { if (min_length < rt_strlen(full_path)) { /* list the candidate */ rewinddir(dir); for (;;) { dirent = readdir(dir); if (dirent == RT_NULL) break; if (strncmp(index, dirent->d_name, rt_strlen(index)) == 0) rt_kprintf("%s\n", dirent->d_name); } } length = index - path; memcpy(index, full_path, min_length); path[length + min_length] = '\0'; } } closedir(dir); rt_free(full_path); }
void tcpecho_socket_entry(void *parameter) { char *recv_data; rt_uint32_t sin_size; int sock = -1, connected, bytes_received; struct sockaddr_in server_addr, client_addr; recv_data = rt_malloc(TCP_SOCKET_BUFFER_SIZE); if (recv_data == RT_NULL) { rt_kprintf("no memory\n"); goto _exit; } /* create a TCP socket */ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { rt_kprintf("create socket error\n"); goto _exit; } /* initialize server address */ server_addr.sin_family = AF_INET; server_addr.sin_port = htons(TCP_SOCKET_ECHO_PORT); server_addr.sin_addr.s_addr = INADDR_ANY; rt_memset(&(server_addr.sin_zero),8, sizeof(server_addr.sin_zero)); /* bind to server address */ if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { rt_kprintf("bind address failed\n"); goto _exit; } /* listen */ if (listen(sock, 5) == -1) { rt_kprintf("listen error\n"); goto _exit; } sin_size = sizeof(struct sockaddr_in); while(1) { /* accept client connected */ connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size); if (connected > 0) { int timeout; /* set timeout option */ timeout = 5000; /* 5second */ setsockopt(connected, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); /* handle this client */ while (1) { /* receive data from this connection */ bytes_received = recv(connected,recv_data, TCP_SOCKET_BUFFER_SIZE, 0); if (bytes_received <= 0) { rt_kprintf("close client connection, errno: %d, socket error: %d\n", rt_get_errno(), lwip_get_error()); /* connection closed. */ lwip_close(connected); break; } /* send data to client */ send(connected, recv_data, bytes_received, 0); } } } _exit: /* close socket */ if (sock != -1) lwip_close(sock); rt_free(recv_data); return ; }
URET rt_free_link(struct uffs_DeviceSt *dev, void *p) { rt_free(p); return 0; }
void fs_test(const char* filename) { unsigned int i = 512; unsigned int speed; float speed_mb[32][2]; //read and write speed int fd; char *buff_ptr; rt_size_t total_length; //file length unsigned int readspeed_avg = 0; unsigned int writespeed_avg = 0; unsigned int speed_count = 0; rt_kprintf("\nStart test...\n"); for(i = 512;i < 4096000 ; i+= i) { total_length = 256*i; if(total_length > TEST_FILE_SIZE_MAX) total_length = TEST_FILE_SIZE_MAX; //write speed test fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0); if (fd < 0) { rt_kprintf("open file:%s failed\n", filename); break; } buff_ptr = rt_malloc(i); if (buff_ptr == RT_NULL) { rt_kprintf("no more RAM for test.\n"); close(fd); break; } rt_kprintf("BlockSize:%6d Byte ->| ", i); speed = writespeed(fd, buff_ptr, total_length,i); rt_kprintf("WriteSpeed:%8d byte/s ", speed); writespeed_avg += speed; speed_mb[speed_count][0] = (float)speed/(1024.f*1024.f); //writespeed in float close(fd); rt_free(buff_ptr); //read speed test fd = open(filename, O_RDONLY, 0); if (fd < 0) { rt_kprintf("open file:%s failed\n", filename); break; } buff_ptr = rt_malloc(i); if (buff_ptr == RT_NULL) { rt_kprintf("no memory\n"); close(fd); break; } speed = readspeed(fd, buff_ptr, total_length, i); rt_kprintf("| ReadSpeed:%8d byte/s\n", speed); readspeed_avg += speed; speed_mb[speed_count][1] = (float)speed/(1024.f*1024.f); //read_speed in float close(fd); rt_free(buff_ptr); // speed_count ++; } //draw graph { char buf[32]; int block_max = i; int block = 0; int count_of_chars; float max = speed_mb[speed_count-1][1]; float scale = (1.f/max)*50.f; speed_count = 0; rt_kprintf("\nBlock Size (byte) Writespeed = \"WR\" Readspeed = \"RD\"\n"); for(block=512; block<block_max; block+=block) { //write speed rt_kprintf("%6d->| ",block); count_of_chars = 1+ speed_mb[speed_count][0] * scale; while(count_of_chars--) { // rt_thread_delay(15); rt_kprintf(">"); } sprintf(buf, " WR:%3.2f MB/s\n", speed_mb[speed_count][0]); rt_kprintf(buf); //readspeed rt_kprintf(" ->| ",block); count_of_chars = 1+ speed_mb[speed_count][1] * scale; while(count_of_chars--) { //rt_thread_delay(15); rt_kprintf(">"); } sprintf(buf, " RD:%3.2f MB/s\n", speed_mb[speed_count][1]); rt_kprintf(buf); if(block < block_max/2) rt_kprintf(" | \n"); speed_count ++; } } if(speed_count > 0) rt_kprintf("Write Speed AVG: %d Byte/s | Read Speed AVG: %d Byte/s\n",writespeed_avg/speed_count, readspeed_avg/speed_count); unlink(filename); }
/** * @brief This function prepares command of key_material. * * @param priv A pointer to WlanCard structure * @param cmd A pointer to HostCmd_DS_COMMAND structure * @param cmd_action the action: GET or SET * @param cmd_oid OID: ENABLE or DISABLE * @param pdata_buf A pointer to data buffer * @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE */ int wlan_cmd_802_11_key_material(WlanCard *cardinfo, u16 cmd_action, WLAN_OID cmd_oid, void *pdata_buf) { WlanCard *card = cardinfo; HostCmd_DS_COMMAND *CmdPtr = NULL; HostCmd_DS_802_11_KEY_MATERIAL *pKeyMaterial; WLAN_802_11_KEY *pKey = (WLAN_802_11_KEY *) pdata_buf; u16 KeyParamSet_len; int ret = WLAN_STATUS_SUCCESS; CmdPtr = rt_malloc(sizeof(HostCmd_DS_COMMAND)); if (CmdPtr == NULL) { WlanDebug(WlanErr,"memory allocate failed for set Key\r\n"); return WLAN_STATUS_FAILURE; } card->SeqNum++; CmdPtr->SeqNum = card->SeqNum; CmdPtr->Command = HostCmd_CMD_802_11_KEY_MATERIAL; CmdPtr->Result = 0; pKeyMaterial = &CmdPtr->params.keymaterial; pKeyMaterial->Action = cmd_action; if (cmd_action == HostCmd_ACT_GET) { CmdPtr->Size = 2 + S_DS_GEN; ret = WLAN_STATUS_SUCCESS; goto done; } rt_memset(&pKeyMaterial->KeyParamSet, 0, sizeof(MrvlIEtype_KeyParamSet_t)); if (pKey->KeyLength == WPA_AES_KEY_LEN) { pKeyMaterial->KeyParamSet.KeyTypeId = KEY_TYPE_ID_AES; if (cmd_oid == (WLAN_OID) KEY_INFO_ENABLED) pKeyMaterial->KeyParamSet.KeyInfo = KEY_INFO_AES_ENABLED; else pKeyMaterial->KeyParamSet.KeyInfo = !(KEY_INFO_AES_ENABLED); if (pKey->KeyIndex & 0x40000000) pKeyMaterial->KeyParamSet.KeyInfo |= KEY_INFO_AES_UNICAST; else pKeyMaterial->KeyParamSet.KeyInfo |= KEY_INFO_AES_MCAST; } else if (pKey->KeyLength == WPA_TKIP_KEY_LEN) { pKeyMaterial->KeyParamSet.KeyTypeId = KEY_TYPE_ID_TKIP; pKeyMaterial->KeyParamSet.KeyInfo = KEY_INFO_TKIP_ENABLED; if (pKey->KeyIndex & 0x40000000) pKeyMaterial->KeyParamSet.KeyInfo |= KEY_INFO_TKIP_UNICAST; else pKeyMaterial->KeyParamSet.KeyInfo |= KEY_INFO_TKIP_MCAST; } if (pKeyMaterial->KeyParamSet.KeyTypeId) { pKeyMaterial->KeyParamSet.Type = TLV_TYPE_KEY_MATERIAL; pKeyMaterial->KeyParamSet.KeyLen = pKey->KeyLength; rt_memcpy(pKeyMaterial->KeyParamSet.Key, pKey->KeyMaterial, pKey->KeyLength); pKeyMaterial->KeyParamSet.Length = pKey->KeyLength + 6; #define TYPE_LEN_FIELDS_LEN (4) #define ACTION_FIELD_LEN (2) KeyParamSet_len = (pKey->KeyLength + 6) + TYPE_LEN_FIELDS_LEN; CmdPtr->Size = KeyParamSet_len + ACTION_FIELD_LEN + S_DS_GEN; } ret = WlanExecuteCommand(cardinfo, CmdPtr); if (ret) { WlanDebug(WlanErr,"Falure for Wlan Set Key\r\n"); ret = WLAN_STATUS_FAILURE; } rt_free(CmdPtr); ret = WLAN_STATUS_SUCCESS; done: return ret; }
int ftp_process_request(struct ftp_session* session, char *buf) { int fd; struct timeval tv; fd_set readfds; char filename[256]; int numbytes; char *sbuf; char *parameter_ptr, *ptr; rt_uint32_t addr_len = sizeof(struct sockaddr_in); struct sockaddr_in local, pasvremote; sbuf =(char *)rt_malloc(FTP_BUFFER_SIZE); tv.tv_sec=3, tv.tv_usec=0; local.sin_family=PF_INET; local.sin_addr.s_addr=INADDR_ANY; /* remove \r\n */ ptr = buf; while (*ptr) { if (*ptr == '\r' || *ptr == '\n') *ptr = 0; ptr ++; } /* get request parameter */ parameter_ptr = strchr(buf, ' '); if (parameter_ptr != NULL) parameter_ptr ++; // debug: rt_kprintf("%s requested: \"%s\"\n", inet_ntoa(session->remote.sin_addr), buf); // //----------------------- if(str_begin_with(buf, "USER")==0) { rt_kprintf("%s sent login \"%s\"\n", inet_ntoa(session->remote.sin_addr), parameter_ptr); // login correct if(strcmp(parameter_ptr, "anonymous") == 0) { session->is_anonymous = RT_TRUE; rt_sprintf(sbuf, "331 Anonymous login OK send e-mail address for password.\r\n", parameter_ptr); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if (strcmp(parameter_ptr, FTP_USER) == 0) { session->is_anonymous = RT_FALSE; rt_sprintf(sbuf, "331 Password required for %s\r\n", parameter_ptr); send(session->sockfd, sbuf, strlen(sbuf), 0); } else { // incorrect login rt_sprintf(sbuf, "530 Login incorrect. Bye.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return -1; } return 0; } else if(str_begin_with(buf, "PASS")==0) { rt_kprintf("%s sent password \"%s\"\n", inet_ntoa(session->remote.sin_addr), parameter_ptr); if (strcmp(parameter_ptr, FTP_PASSWORD)==0 || session->is_anonymous == RT_TRUE) { // password correct rt_sprintf(sbuf, "230 User logged in\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return 0; } // incorrect password rt_sprintf(sbuf, "530 Login or Password incorrect. Bye!\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return -1; } else if(str_begin_with(buf, "LIST")==0 ) { memset(sbuf,0,FTP_BUFFER_SIZE); rt_sprintf(sbuf, "150 Opening Binary mode connection for file list.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); do_list(session->currentdir, session->pasv_sockfd); closesocket(session->pasv_sockfd); session->pasv_active = 0; rt_sprintf(sbuf, "226 Transfert Complete.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "NLST")==0 ) { memset(sbuf, 0, FTP_BUFFER_SIZE); rt_sprintf(sbuf, "150 Opening Binary mode connection for file list.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); do_simple_list(session->currentdir, session->pasv_sockfd); closesocket(session->pasv_sockfd); session->pasv_active = 0; rt_sprintf(sbuf, "226 Transfert Complete.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "PWD")==0 || str_begin_with(buf, "XPWD")==0) { rt_sprintf(sbuf, "257 \"%s\" is current directory.\r\n", session->currentdir); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "TYPE")==0) { // Ignore it if(strcmp(parameter_ptr, "I")==0) { rt_sprintf(sbuf, "200 Type set to binary.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } else { rt_sprintf(sbuf, "200 Type set to ascii.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } } else if(str_begin_with(buf, "PASV")==0) { int dig1, dig2; int sockfd; char optval='1'; session->pasv_port = 10000; session->pasv_active = 1; local.sin_port=htons(session->pasv_port); local.sin_addr.s_addr=INADDR_ANY; dig1 = (int)(session->pasv_port/256); dig2 = session->pasv_port % 256; FD_ZERO(&readfds); if((sockfd=socket(PF_INET, SOCK_STREAM, 0))==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); goto err1; } if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); goto err1; } if(bind(sockfd, (struct sockaddr *)&local, addr_len)==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); goto err1; } if(listen(sockfd, 1)==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); goto err1; } rt_kprintf("Listening %d seconds @ port %d\n", tv.tv_sec, session->pasv_port); rt_sprintf(sbuf, "227 Entering passive mode (%d,%d,%d,%d,%d,%d)\r\n", 127, 0, 0, 1, dig1, dig2); send(session->sockfd, sbuf, strlen(sbuf), 0); FD_SET(sockfd, &readfds); select(0, &readfds, 0, 0, &tv); if(FD_ISSET(sockfd, &readfds)) { if((session->pasv_sockfd = accept(sockfd, (struct sockaddr*)&pasvremote, &addr_len))==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); goto err1; } else { rt_kprintf("Got Data(PASV) connection from %s\n", inet_ntoa(pasvremote.sin_addr)); session->pasv_active = 1; closesocket(sockfd); } } else { err1: closesocket(session->pasv_sockfd); session->pasv_active = 0; rt_free(sbuf); return 0; } } else if (str_begin_with(buf, "RETR")==0) { int file_size; strcpy(filename, buf + 5); build_full_path(session, parameter_ptr, filename, 256); file_size = ftp_get_filesize(filename); if (file_size == -1) { rt_sprintf(sbuf, "550 \"%s\" : not a regular file\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); session->offset=0; rt_free(sbuf); return 0; } fd = open(filename, O_RDONLY, 0); if (fd < 0) { rt_free(sbuf); return 0; } if(session->offset>0 && session->offset < file_size) { lseek(fd, session->offset, SEEK_SET); rt_sprintf(sbuf, "150 Opening binary mode data connection for partial \"%s\" (%d/%d bytes).\r\n", filename, file_size - session->offset, file_size); } else { rt_sprintf(sbuf, "150 Opening binary mode data connection for \"%s\" (%d bytes).\r\n", filename, file_size); } send(session->sockfd, sbuf, strlen(sbuf), 0); while((numbytes = read(fd, sbuf, FTP_BUFFER_SIZE))>0) { send(session->pasv_sockfd, sbuf, numbytes, 0); } rt_sprintf(sbuf, "226 Finished.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); close(fd); closesocket(session->pasv_sockfd); } else if (str_begin_with(buf, "STOR")==0) { if(session->is_anonymous == RT_TRUE) { rt_sprintf(sbuf, "550 Permission denied.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return 0; } build_full_path(session, parameter_ptr, filename, 256); fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0); if(fd < 0) { rt_sprintf(sbuf, "550 Cannot open \"%s\" for writing.\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return 0; } rt_sprintf(sbuf, "150 Opening binary mode data connection for \"%s\".\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); FD_ZERO(&readfds); FD_SET(session->pasv_sockfd, &readfds); rt_kprintf("Waiting %d seconds for data...\n", tv.tv_sec); while(select(session->pasv_sockfd+1, &readfds, 0, 0, &tv)>0 ) { if((numbytes=recv(session->pasv_sockfd, sbuf, FTP_BUFFER_SIZE, 0))>0) { write(fd, sbuf, numbytes); } else if(numbytes==0) { close(fd); closesocket(session->pasv_sockfd); rt_sprintf(sbuf, "226 Finished.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); break; } else if(numbytes==-1) { close(fd); closesocket(session->pasv_sockfd); rt_free(sbuf); return -1; } } closesocket(session->pasv_sockfd); } else if(str_begin_with(buf, "SIZE")==0) { int file_size; build_full_path(session, parameter_ptr, filename, 256); file_size = ftp_get_filesize(filename); if( file_size == -1) { rt_sprintf(sbuf, "550 \"%s\" : not a regular file\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); } else { rt_sprintf(sbuf, "213 %d\r\n", file_size); send(session->sockfd, sbuf, strlen(sbuf), 0); } } else if(str_begin_with(buf, "MDTM")==0) { rt_sprintf(sbuf, "550 \"/\" : not a regular file\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "SYST")==0) { rt_sprintf(sbuf, "215 %s\r\n", "RT-Thread RTOS"); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "CWD")==0) { build_full_path(session, parameter_ptr, filename, 256); rt_sprintf(sbuf, "250 Changed to directory \"%s\"\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); strcpy(session->currentdir, filename); rt_kprintf("Changed to directory %s", filename); } else if(str_begin_with(buf, "CDUP")==0) { rt_sprintf(filename, "%s/%s", session->currentdir, ".."); rt_sprintf(sbuf, "250 Changed to directory \"%s\"\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); strcpy(session->currentdir, filename); rt_kprintf("Changed to directory %s", filename); } else if(str_begin_with(buf, "PORT")==0) { int i; int portcom[6]; char tmpip[100]; i=0; portcom[i++]=atoi(strtok(parameter_ptr, ".,;()")); for(; i<6; i++) portcom[i]=atoi(strtok(0, ".,;()")); rt_sprintf(tmpip, "%d.%d.%d.%d", portcom[0], portcom[1], portcom[2], portcom[3]); FD_ZERO(&readfds); if((session->pasv_sockfd=socket(AF_INET, SOCK_STREAM, 0))==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); closesocket(session->pasv_sockfd); session->pasv_active = 0; rt_free(sbuf); return 0; } pasvremote.sin_addr.s_addr=inet_addr(tmpip); pasvremote.sin_port=htons(portcom[4] * 256 + portcom[5]); pasvremote.sin_family=PF_INET; if(connect(session->pasv_sockfd, (struct sockaddr *)&pasvremote, addr_len)==-1) { // is it only local address?try using gloal ip addr pasvremote.sin_addr=session->remote.sin_addr; if(connect(session->pasv_sockfd, (struct sockaddr *)&pasvremote, addr_len)==-1) { rt_sprintf(sbuf, "425 Can't open data connection.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); closesocket(session->pasv_sockfd); rt_free(sbuf); return 0; } } session->pasv_active=1; session->pasv_port = portcom[4] * 256 + portcom[5]; rt_kprintf("Connected to Data(PORT) %s @ %d\n", tmpip, portcom[4] * 256 + portcom[5]); rt_sprintf(sbuf, "200 Port Command Successful.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "REST")==0) { if(atoi(parameter_ptr)>=0) { session->offset=atoi(parameter_ptr); rt_sprintf(sbuf, "350 Send RETR or STOR to start transfert.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } } else if(str_begin_with(buf, "MKD")==0) { if (session->is_anonymous == RT_TRUE) { rt_sprintf(sbuf, "550 Permission denied.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return 0; } build_full_path(session, parameter_ptr, filename, 256); if(mkdir(filename, 0) == -1) { rt_sprintf(sbuf, "550 File \"%s\" exists.\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); } else { rt_sprintf(sbuf, "257 directory \"%s\" successfully created.\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); } } else if(str_begin_with(buf, "DELE")==0) { if (session->is_anonymous == RT_TRUE) { rt_sprintf(sbuf, "550 Permission denied.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return 0; } build_full_path(session, parameter_ptr, filename, 256); if(unlink(filename)==0) rt_sprintf(sbuf, "250 Successfully deleted file \"%s\".\r\n", filename); else { rt_sprintf(sbuf, "550 Not such file or directory: %s.\r\n", filename); } send(session->sockfd, sbuf, strlen(sbuf), 0); } else if(str_begin_with(buf, "RMD")==0) { if (session->is_anonymous == RT_TRUE) { rt_sprintf(sbuf, "550 Permission denied.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return 0; } build_full_path(session, parameter_ptr, filename, 256); if(unlink(filename) == -1) { rt_sprintf(sbuf, "550 Directory \"%s\" doesn't exist.\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); } else { rt_sprintf(sbuf, "257 directory \"%s\" successfully deleted.\r\n", filename); send(session->sockfd, sbuf, strlen(sbuf), 0); } } else if(str_begin_with(buf, "QUIT")==0) { rt_sprintf(sbuf, "221 Bye!\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); rt_free(sbuf); return -1; } else { rt_sprintf(sbuf, "502 Not Implemented.\r\n"); send(session->sockfd, sbuf, strlen(sbuf), 0); } rt_free(sbuf); return 0; }
/* update fileview */ void rtgui_fileview_update_current(rtgui_fileview_t* fview) { rtgui_fileview_item_t *item; rtgui_rect_t rect, item_rect, image_rect; rtgui_dc_t *dc; RT_ASSERT(fview != RT_NULL); /* begin drawing */ dc = rtgui_dc_begin_drawing(fview); if(dc == RT_NULL)return; /* if directory is null, no dispost */ if(fview->items==RT_NULL)return; rtgui_widget_get_rect(fview, &rect); if(fview->sbar && !RTGUI_WIDGET_IS_HIDE(fview->sbar)) rect.x2 -= RC_W(fview->sbar->parent.extent); if((fview->old_item >= fview->first_item) && (fview->old_item < fview->first_item+fview->item_per_page) && (fview->old_item != fview->now_item)) { /* these condition dispell blinked when drawed */ /* get old item rect */ item_rect = rect; item_rect.x1 += RTGUI_WIDGET_BORDER_SIZE(fview); item_rect.x2 -= RTGUI_WIDGET_BORDER_SIZE(fview); item_rect.y1 += RTGUI_WIDGET_BORDER_SIZE(fview); item_rect.y1 += ((fview->old_item-fview->first_item) % fview->item_per_page) * (1 + RTGUI_SEL_H); item_rect.y2 = item_rect.y1 + (1 + RTGUI_SEL_H); /* get image rect */ image_rect.x1 = RTGUI_MARGIN; image_rect.y1 = 0; image_rect.x2 = RTGUI_MARGIN + file_image->w; image_rect.y2 = file_image->h; rtgui_rect_moveto_align(&item_rect, &image_rect, RTGUI_ALIGN_CENTER_VERTICAL); /* draw old item */ item = &(fview->items[fview->old_item]); if(item->type == RTGUI_FITEM_FILE) /* draw item image */ rtgui_image_paste(file_image, dc, &image_rect, Black); else rtgui_image_paste(folder_image, dc, &image_rect,Black); item_rect.x1 += RTGUI_MARGIN + file_image->w + 2; item_rect.x2 = item_rect.x1 + rtgui_font_get_string_width(RTGUI_DC_FONT(dc), item->name); RTGUI_DC_BC(dc) = theme.blankspace; RTGUI_DC_FC(dc) = theme.foreground; rtgui_dc_fill_rect(dc,&item_rect); rtgui_dc_draw_text(dc, item->name, &item_rect); } /* draw current item */ item_rect = rect; item_rect.x1 += RTGUI_WIDGET_BORDER_SIZE(fview); item_rect.x2 -= RTGUI_WIDGET_BORDER_SIZE(fview); item_rect.y1 += RTGUI_WIDGET_BORDER_SIZE(fview); item_rect.y1 += ((fview->now_item-fview->first_item) % fview->item_per_page) * (1 + RTGUI_SEL_H); item_rect.y2 = item_rect.y1 + (1 + RTGUI_SEL_H); /* get image base rect */ image_rect.x1 = RTGUI_MARGIN; image_rect.y1 = 0; image_rect.x2 = RTGUI_MARGIN + file_image->w; image_rect.y2 = file_image->h; rtgui_rect_moveto_align(&item_rect, &image_rect, RTGUI_ALIGN_CENTER_VERTICAL); item = &(fview->items[fview->now_item]); if(item->type == RTGUI_FITEM_FILE) /* draw item image */ rtgui_image_paste(file_image, dc, &image_rect, Black); else rtgui_image_paste(folder_image, dc, &image_rect, Black); if(fview->dlg != RT_NULL) { if(fview->dlg->filename != RT_NULL) { rt_free(fview->dlg->filename); fview->dlg->filename = RT_NULL; } fview->dlg->filename = rt_strdup(item->name); } item_rect.x1 += RTGUI_MARGIN + file_image->w + 2; item_rect.x2 = item_rect.x1 + rtgui_font_get_string_width(RTGUI_DC_FONT(dc), item->name); { if(RTGUI_WIDGET_IS_FOCUSED(fview)) { RTGUI_DC_BC(dc) = DarkBlue; RTGUI_DC_FC(dc) = theme.blankspace; } else { RTGUI_DC_BC(dc) = Gray; RTGUI_DC_FC(dc) = theme.foreground; } rtgui_dc_fill_rect(dc, &item_rect); rtgui_dc_draw_text(dc, item->name, &item_rect); } if(fview->dlg != RT_NULL) { if(item->type == RTGUI_FITEM_FILE) { if(fview->dlg->tbox_filename != RT_NULL) { rtgui_textbox_set_value(fview->dlg->tbox_filename,fview->dlg->filename); RTGUI_DC_FC(dc) = theme.foreground; rtgui_textbox_ondraw(fview->dlg->tbox_filename); } } } rtgui_dc_end_drawing(dc); }
void rtgui_fileview_set_directory(rtgui_fileview_t* fview, const char* directory) { char fullpath[256]; rtgui_fileview_item_t *item; fview->first_item = 0; fview->item_count = 0; /* clear file information */ rtgui_fileview_clear(fview); if(directory != RT_NULL) { DIR* dir; struct stat s; rt_uint32_t i; struct dirent* dirent; fview->item_count = 0; /* open directory */ dir = opendir(directory); if(dir == RT_NULL) return; /* set current directory */ if(fview->current_dir != RT_NULL) { rt_free(fview->current_dir); fview->current_dir = RT_NULL; } fview->current_dir = rt_strdup(directory); if(fview->dlg != RT_NULL) { if(fview->dlg->path != RT_NULL) rt_free(fview->dlg->path); fview->dlg->path = rt_strdup(fview->current_dir); if(fview->dlg->tbox_path != RT_NULL) { rtgui_textbox_set_value(fview->dlg->tbox_path,fview->dlg->path); rtgui_textbox_ondraw(fview->dlg->tbox_path); } } do { dirent = readdir(dir); if(dirent == RT_NULL) break; fview->item_count ++; } while(dirent != RT_NULL); closedir(dir); if((fview->item_count > fview->item_per_page) && fview->sbar!=RT_NULL) { RTGUI_WIDGET_SHOW(fview->sbar); rtgui_scrollbar_set_line_step(fview->sbar,1); rtgui_scrollbar_set_page_step(fview->sbar, fview->item_per_page); rtgui_scrollbar_set_range(fview->sbar, fview->item_count); } else { RTGUI_WIDGET_HIDE(fview->sbar); } rtgui_widget_update_clip(fview); /* apply to memory for store all items. */ fview->items = (rtgui_fileview_item_t*) rt_malloc(sizeof(rtgui_fileview_item_t) * fview->item_count); if(fview->items == RT_NULL) goto __return; /* under the folder has not sub files. */ /* reopen directory */ dir = opendir(directory); if(dir == RT_NULL) goto __return; for(i=0; i < fview->item_count; i ++) { dirent = readdir(dir); if(dirent == RT_NULL) break; item = &(fview->items[i]); item->name = rt_strdup(dirent->d_name); rt_memset(&s, 0, sizeof(struct stat)); /* get fullpath of file */ dfs_get_fullpath(fullpath, directory, dirent->d_name); stat(fullpath, &s); if(s.st_mode & S_IFDIR) { item->type = RTGUI_FITEM_DIR; item->size = 0; } else { item->type = RTGUI_FITEM_FILE; item->size = s.st_size; } } closedir(dir); } fview->now_item = 0; __return: /* update view */ rtgui_widget_update(fview); }
static rt_err_t _block_device_test(rt_device_t device) { rt_err_t result; struct rt_device_blk_geometry geometry; rt_uint8_t * read_buffer = RT_NULL; rt_uint8_t * write_buffer = RT_NULL; rt_kprintf("\r\n"); if( (device->flag & RT_DEVICE_FLAG_RDWR) == RT_DEVICE_FLAG_RDWR ) { // device can read and write. // step 1: open device result = rt_device_open(device,RT_DEVICE_FLAG_RDWR); if( result != RT_EOK ) { return result; } // step 2: get device info rt_memset(&geometry, 0, sizeof(geometry)); result = rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); if( result != RT_EOK ) { rt_kprintf("device : %s cmd RT_DEVICE_CTRL_BLK_GETGEOME failed.\r\n"); return result; } rt_kprintf("device info:\r\n"); rt_kprintf("sector size : %d byte\r\n", geometry.bytes_per_sector); rt_kprintf("sector count : %d \r\n", geometry.sector_count); rt_kprintf("block size : %d byte\r\n", geometry.block_size); rt_kprintf("\r\n"); read_buffer = rt_malloc(geometry.bytes_per_sector); if( read_buffer == RT_NULL ) { rt_kprintf("no memory for read_buffer!\r\n"); goto __return; } write_buffer = rt_malloc(geometry.bytes_per_sector); if( write_buffer == RT_NULL ) { rt_kprintf("no memory for write_buffer!\r\n"); goto __return; } /* step 3: R/W test */ { rt_uint32_t i,err_count, sector_no; rt_uint8_t * data_point; i = rt_device_read(device, 0, read_buffer, 1); if(i != 1) { rt_kprintf("read device :%s ", device->parent.name); rt_kprintf("the first sector failed.\r\n"); goto __return; } data_point = write_buffer; for(i=0; i<geometry.bytes_per_sector; i++) { *data_point++ = (rt_uint8_t)i; } /* write first sector */ sector_no = 0; data_point = write_buffer; *data_point++ = (rt_uint8_t)sector_no; i = rt_device_write(device, sector_no, write_buffer,1); if( i != 1 ) { rt_kprintf("read the first sector success!\r\n"); rt_kprintf("but write device :%s ", device->parent.name); rt_kprintf("the first sector failed.\r\n"); rt_kprintf("maybe readonly!\r\n"); goto __return; } /* write the second sector */ sector_no = 1; data_point = write_buffer; *data_point++ = (rt_uint8_t)sector_no; i = rt_device_write(device,sector_no,write_buffer,1); if( i != 1 ) { rt_kprintf("write device :%s ",device->parent.name); rt_kprintf("the second sector failed.\r\n"); goto __return; } /* write the end sector */ sector_no = geometry.sector_count-1; data_point = write_buffer; *data_point++ = (rt_uint8_t)sector_no; i = rt_device_write(device,sector_no,write_buffer,1); if( i != 1 ) { rt_kprintf("write device :%s ",device->parent.name); rt_kprintf("the end sector failed.\r\n"); goto __return; } /* verify first sector */ sector_no = 0; i = rt_device_read(device,sector_no,read_buffer,1); if( i != 1 ) { rt_kprintf("read device :%s ",device->parent.name); rt_kprintf("the first sector failed.\r\n"); goto __return; } err_count = 0; data_point = read_buffer; if( (*data_point++) != (rt_uint8_t)sector_no) { err_count++; } for(i=1; i<geometry.bytes_per_sector; i++) { if( (*data_point++) != (rt_uint8_t)i ) { err_count++; } } if( err_count > 0 ) { rt_kprintf("verify device :%s ",device->parent.name); rt_kprintf("the first sector failed.\r\n"); goto __return; } /* verify sector sector */ sector_no = 1; i = rt_device_read(device,sector_no,read_buffer,1); if( i != 1 ) { rt_kprintf("read device :%s ",device->parent.name); rt_kprintf("the second sector failed.\r\n"); goto __return; } err_count = 0; data_point = read_buffer; if( (*data_point++) != (rt_uint8_t)sector_no) { err_count++; } for(i=1; i<geometry.bytes_per_sector; i++) { if( (*data_point++) != (rt_uint8_t)i ) { err_count++; } } if( err_count > 0 ) { rt_kprintf("verify device :%s ",device->parent.name); rt_kprintf("the second sector failed.\r\n"); goto __return; } /* verify the end sector */ sector_no = geometry.sector_count-1; i = rt_device_read(device,sector_no,read_buffer,1); if( i != 1 ) { rt_kprintf("read device :%s ",device->parent.name); rt_kprintf("the end sector failed.\r\n"); goto __return; } err_count = 0; data_point = read_buffer; if( (*data_point++) != (rt_uint8_t)sector_no) { err_count++; } for(i=1; i<geometry.bytes_per_sector; i++) { if( (*data_point++) != (rt_uint8_t)i ) { err_count++; } } if( err_count > 0 ) { rt_kprintf("verify device :%s ",device->parent.name); rt_kprintf("the end sector failed.\r\n"); goto __return; } rt_kprintf("device R/W test pass!\r\n"); } /* step 3: I/O R/W test */ rt_kprintf("\r\nRT_TICK_PER_SECOND:%d\r\n", RT_TICK_PER_SECOND); // step 4: continuous single sector speed test { rt_uint32_t tick_start,tick_end; rt_uint32_t i; rt_kprintf("\r\ncontinuous single sector speed test:\r\n"); if( geometry.sector_count < 10 ) { rt_kprintf("device sector_count < 10, speed test abort!\r\n"); } else { unsigned int sector; // sign sector write rt_kprintf("write: "); sector = 0; tick_start = rt_tick_get(); for(i=0; i<200; i++) { sector += rt_device_write(device, i, read_buffer, 1); if((i != 0) && ((i%4) == 0) ) { if(sector < 4) { rt_kprintf("#"); } else { rt_kprintf("<"); } sector = 0; } } tick_end = rt_tick_get(); rt_kprintf("\r\nwrite 200 sector from %d to %d, ",tick_start,tick_end); calculate_speed_print( (geometry.bytes_per_sector*200UL*RT_TICK_PER_SECOND)/(tick_end-tick_start) ); rt_kprintf("\r\n"); // sign sector read rt_kprintf("read : "); sector = 0; tick_start = rt_tick_get(); for(i=0; i<200; i++) { sector += rt_device_read(device, i, read_buffer, 1); if((i != 0) && ((i%4) == 0) ) { if(sector < 4) { rt_kprintf("#"); } else { rt_kprintf(">"); } sector = 0; } } tick_end = rt_tick_get(); rt_kprintf("\r\nread 200 sector from %d to %d, ",tick_start,tick_end); calculate_speed_print( (geometry.bytes_per_sector*200UL*RT_TICK_PER_SECOND)/(tick_end-tick_start) ); rt_kprintf("\r\n"); } }// step 4: speed test // step 5: random single sector speed test { rt_uint32_t tick_start,tick_end; rt_uint32_t i; rt_kprintf("\r\nrandom single sector speed test:\r\n"); if( geometry.sector_count < 10 ) { rt_kprintf("device sector_count < 10, speed test abort!\r\n"); } else { unsigned int sector; // sign sector write rt_kprintf("write: "); sector = 0; tick_start = rt_tick_get(); for(i=0; i<200; i++) { sector += rt_device_write(device, (geometry.sector_count / 10) * (i%10) + (i%10), read_buffer, 1); if((i != 0) && ((i%4) == 0) ) { if(sector < 4) { rt_kprintf("#"); } else { rt_kprintf("<"); } sector = 0; } } tick_end = rt_tick_get(); rt_kprintf("\r\nwrite 200 sector from %d to %d, ",tick_start,tick_end); calculate_speed_print( (geometry.bytes_per_sector*200UL*RT_TICK_PER_SECOND)/(tick_end-tick_start) ); rt_kprintf("\r\n"); // sign sector read rt_kprintf("read : "); sector = 0; tick_start = rt_tick_get(); for(i=0; i<200; i++) { sector += rt_device_read(device, (geometry.sector_count / 10) * (i%10) + (i%10), read_buffer, 1); if((i != 0) && ((i%4) == 0) ) { if(sector < 4) { rt_kprintf("#"); } else { rt_kprintf(">"); } sector = 0; } } tick_end = rt_tick_get(); rt_kprintf("\r\nread 200 sector from %d to %d, ",tick_start,tick_end); calculate_speed_print( (geometry.bytes_per_sector*200UL*RT_TICK_PER_SECOND)/(tick_end-tick_start) ); rt_kprintf("\r\n"); } }// step 4: speed test /* step 6: multiple sector speed test */ { rt_uint8_t * multiple_buffer; rt_uint8_t * ptr; rt_uint32_t tick_start,tick_end; rt_uint32_t sector,i; rt_kprintf("\r\nmultiple sector speed test\r\n"); for(sector=2; sector<256; sector=sector*2) { multiple_buffer = rt_malloc(geometry.bytes_per_sector * sector); if(multiple_buffer == RT_NULL) { rt_kprintf("no memory for %d sector! multiple sector speed test abort!\r\n", sector); break; } rt_memset(multiple_buffer, sector, geometry.bytes_per_sector * sector); rt_kprintf("write: "); tick_start = rt_tick_get(); for(i=0; i<10; i++) { rt_size_t n; n = rt_device_write(device, 50, multiple_buffer, sector); if(n == sector) { rt_kprintf("<"); } else { rt_kprintf("#"); } } tick_end = rt_tick_get(); rt_kprintf("\r\n"); rt_kprintf("multiple write %d sector speed : ", sector); calculate_speed_print( (geometry.bytes_per_sector * sector * 10 * RT_TICK_PER_SECOND)/(tick_end-tick_start) ); rt_kprintf("\r\n"); rt_memset(multiple_buffer, ~sector, geometry.bytes_per_sector * sector); rt_kprintf("read : "); tick_start = rt_tick_get(); for(i=0; i<10; i++) { rt_size_t n; n = rt_device_read(device, 50, multiple_buffer, sector); if(n == sector) { rt_kprintf(">"); } else { rt_kprintf("#"); } } tick_end = rt_tick_get(); rt_kprintf("\r\n"); rt_kprintf("multiple read %d sector speed : ", sector); calculate_speed_print( (geometry.bytes_per_sector * sector * 10 * RT_TICK_PER_SECOND)/(tick_end-tick_start) ); ptr = multiple_buffer; for(i=0; i<geometry.bytes_per_sector * sector; i++) { if(*ptr != sector) { rt_kprintf(" but data verify fail!"); break; } ptr++; } rt_kprintf("\r\n\r\n"); rt_free(multiple_buffer); } } /* step 5: multiple sector speed test */ return RT_EOK; }// device can read and write. else { // device read only return RT_EOK; }// device read only __return: if( read_buffer != RT_NULL ) { rt_free(read_buffer); } if( write_buffer != RT_NULL ) { rt_free(write_buffer); } return RT_ERROR; }
/** * This function will do a executable program with main function and parameters. * * @param path the full path of application module * @param cmd_line the command line of program * @param size the size of command line of program * * @return the module object */ rt_module_t rt_module_exec_cmd(const char *path, const char* cmd_line, int line_size) { struct dfs_filesystem *fs; appentry_t fptr; HINSTANCE hinstlib; rt_module_t module; char * winpath = RT_NULL; char * name = RT_NULL; char *full_path = RT_NULL; RT_DEBUG_NOT_IN_INTERRUPT; /* check parameters */ RT_ASSERT(path != RT_NULL); if (*path != '/') { full_path = dfs_normalize_path(RT_NULL, path); } else { full_path = (const char*)path; } /* app module should only in DFS_WIN32 */ fs = dfs_filesystem_lookup(full_path); if ((fs == RT_NULL) || (strcmp(fs->ops->name,"wdir") != 0)) { rt_kprintf("invalid path: %s\n", path); goto __exit; } /* change path */ // len = strlen(full_path + 1); if ((winpath = dfs_win32_dirdup((char *)full_path)) == RT_NULL) { rt_kprintf("out of memory, exit", path); goto __exit; } hinstlib = LoadLibrary(winpath); if (hinstlib == NULL) { rt_kprintf("error: unable to open %s\n", winpath); goto __exit; } fptr = (appentry_t)GetProcAddress(hinstlib, "main"); if (fptr == NULL) { rt_kprintf("error: unable to find function in %s\n", winpath); FreeLibrary(hinstlib); goto __exit; } /* release winpath */ rt_free(winpath); /* get the name of the module */ name = _module_name(path); /* allocate module */ module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module, name); if (!module) { goto __exit; } module->nref = 0; module->module_entry = fptr; /* init module object container */ rt_module_init_object_container(module); /* increase module reference count */ module->nref ++; if (module->module_entry != 0) { /* set module argument */ module->module_cmd_line = (rt_uint8_t*)rt_malloc(line_size + 1); rt_memcpy(module->module_cmd_line, cmd_line, line_size); module->module_cmd_line[line_size] = '\0'; module->module_cmd_size = line_size; #ifdef RT_USING_SLAB /* init module memory allocator */ module->mem_list = RT_NULL; /* create page array */ module->page_array = (void *)rt_malloc(PAGE_COUNT_MAX * sizeof(struct rt_page_info)); module->page_cnt = 0; #endif /* create module thread */ module->module_thread = rt_thread_create(name, module_main_entry, module, 2048, RT_THREAD_PRIORITY_MAX - 2, 10); /* set module id */ module->module_thread->module_id = (void *)module; module->parent.flag = RT_MODULE_FLAG_WITHENTRY; /* startup module thread */ rt_thread_startup(module->module_thread); } else { /* without entry point */ module->parent.flag |= RT_MODULE_FLAG_WITHOUTENTRY; } #ifdef RT_USING_HOOK if (rt_module_load_hook != RT_NULL) { rt_module_load_hook(module); } #endif rt_free(name); return module; __exit: if (full_path != path) rt_free(full_path); if (name != RT_NULL) rt_free(full_path); if (winpath != RT_NULL)rt_free(winpath); return RT_NULL; /* FreeLibrary(hinstlib); */ }
static void _calc_line(rtgui_textview_t *textview, const char* text) { char* line; const unsigned char* ptr; rt_ubase_t line_index, line_position; if (textview->lines != RT_NULL) { rt_free(textview->lines); textview->lines = RT_NULL; textview->line_count = 0; } /* get line count */ line_index = 0; line_position = 0; ptr = (const unsigned char*)text; if (*ptr == 0) return; while (*ptr != '\0') { if (*ptr == '\n') { line_index ++; line_position = 0; } else if (*ptr == '\r') { ptr ++; continue; } else if (*ptr == '\t') { line_position += 4; if (line_position >= textview->line_width - 1) { line_index ++; line_position = 0; } } else { if ((*ptr) >= 0x80) { /* fill cjk character */ if (line_position + 1 >= (textview->line_width - 1)) { /* split to next line */ line_index ++; line_position = 0; } line_position ++; line_position ++; } else { line_position ++; } if (line_position >= textview->line_width - 1) { line_index ++; line_position = 0; } } ptr ++; } /* set line count */ textview->line_count = line_index + 1; /* allocate lines */ textview->lines = rt_malloc(textview->line_count * textview->line_width); rt_memset(textview->lines, 0, (textview->line_count * textview->line_width)); /* fill lines */ line_index = 0; line_position = 0; ptr = (const unsigned char*)text; line = _get_line_text(textview, line_index); while (*ptr) { if (*ptr == '\n') { line_index ++; line_position = 0; line = _get_line_text(textview, line_index); } else if (*ptr == '\r') { /* ignore '\r' */ ptr ++; continue; } else if (*ptr == '\t') { line[line_position++] = ' '; line[line_position++] = ' '; line[line_position++] = ' '; line[line_position++] = ' '; if (line_position >= textview->line_width - 1) { line_index ++; line_position = 0; line = _get_line_text(textview, line_index); } } else { if ((*ptr) >= 0x80) { /* fill cjk character */ if (line_position + 1 >= (textview->line_width - 1)) { /* split to next line */ line_index ++; line_position = 0; line = _get_line_text(textview, line_index); } line[line_position ++] = *ptr ++; line[line_position ++] = *ptr; } else { line[line_position ++] = *ptr; } if (line_position >= textview->line_width - 1) { line_index ++; line_position = 0; line = _get_line_text(textview, line_index); } } ptr ++; } textview->line_current = 0; }
static void _rtgui_textview_destructor(rtgui_textview_t *textview) { /* release line memory */ rt_free(textview->lines); textview->lines = RT_NULL; }
static void _rtgui_label_destructor(rtgui_label_t *label) { /* release text memory */ rt_free(label->text); label->text = RT_NULL; }
/** * @brief This function prepares command of snmp_mib. * * @param priv A pointer to wlan_private structure * @param cmd A pointer to HostCmd_DS_COMMAND structure * @param cmd_action the action: GET or SET * @param cmd_oid the OID of SNMP MIB * @param pdata_buf the pointer to data buffer * @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE */ int wlan_cmd_802_11_snmp_mib(WlanCard *cardinfo, int cmd_action, int cmd_oid, void *pdata_buf) { WlanCard *card = cardinfo; HostCmd_DS_802_11_SNMP_MIB *pSNMPMIB = NULL; HostCmd_DS_COMMAND *CmdPtr = NULL; u8 ucTemp; int ret = WLAN_STATUS_SUCCESS; CmdPtr = rt_malloc(sizeof(HostCmd_DS_COMMAND)); if (CmdPtr == NULL) { WlanDebug(WlanErr,"memory allocate failed for set SNMP\r\n"); return WLAN_STATUS_FAILURE; } card->SeqNum++; CmdPtr->SeqNum = card->SeqNum; CmdPtr->Command = HostCmd_CMD_802_11_SNMP_MIB; CmdPtr->Result = 0; pSNMPMIB = &CmdPtr->params.smib; CmdPtr->Size = (sizeof(HostCmd_DS_802_11_SNMP_MIB) + S_DS_GEN); switch (cmd_oid) { case OID_802_11_INFRASTRUCTURE_MODE: pSNMPMIB->QueryType = (HostCmd_ACT_GEN_SET); pSNMPMIB->OID = ((u16) DesiredBssType_i); pSNMPMIB->BufSize = (sizeof(u8)); if (card->InfrastructureMode == Wlan802_11Infrastructure) ucTemp = SNMP_MIB_VALUE_INFRA; else ucTemp = SNMP_MIB_VALUE_ADHOC; rt_memmove(pSNMPMIB->Value, &ucTemp, sizeof(u8)); break; case OID_802_11D_ENABLE: { u32 ulTemp; pSNMPMIB->OID = (u16) Dot11D_i; if (cmd_action == HostCmd_ACT_SET) { pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET; pSNMPMIB->BufSize = sizeof(u16); ulTemp = *(u32 *) pdata_buf; *((u16*) (pSNMPMIB->Value)) = ((u16) ulTemp); } break; } case OID_802_11_FRAGMENTATION_THRESHOLD: { WLAN_802_11_FRAGMENTATION_THRESHOLD ulTemp; pSNMPMIB->OID = ((u16) FragThresh_i); if (cmd_action == HostCmd_ACT_GET) { pSNMPMIB->QueryType = (HostCmd_ACT_GEN_GET); } else if (cmd_action == HostCmd_ACT_SET) { pSNMPMIB->QueryType = (HostCmd_ACT_GEN_SET); pSNMPMIB->BufSize = (sizeof(u16)); ulTemp = *((WLAN_802_11_FRAGMENTATION_THRESHOLD *) pdata_buf); *((u16*) (pSNMPMIB->Value)) = ((u16) ulTemp); } break; } case OID_802_11_RTS_THRESHOLD: { WLAN_802_11_RTS_THRESHOLD ulTemp; pSNMPMIB->OID = ((u16) RtsThresh_i); if (cmd_action == HostCmd_ACT_GET) { pSNMPMIB->QueryType = HostCmd_ACT_GEN_GET; } else if (cmd_action == HostCmd_ACT_SET) { pSNMPMIB->QueryType = (HostCmd_ACT_GEN_SET); pSNMPMIB->BufSize = (sizeof(u16)); ulTemp = *((WLAN_802_11_RTS_THRESHOLD *) pdata_buf); *(u16*) (pSNMPMIB->Value) = ((u16) ulTemp); } break; } case OID_802_11_TX_RETRYCOUNT: pSNMPMIB->OID = ((u16) ShortRetryLim_i); if (cmd_action == HostCmd_ACT_GET) { pSNMPMIB->QueryType = (HostCmd_ACT_GEN_GET); } else if (cmd_action == HostCmd_ACT_SET) { pSNMPMIB->QueryType = (HostCmd_ACT_GEN_SET); pSNMPMIB->BufSize = (sizeof(u16)); *((u16*) (pSNMPMIB->Value)) = ((u16) card->TxRetryCount); } break; default: break; } WlanDebug(WlanCmd,"SNMP_CMD: Action=0x%x, OID=0x%x, OIDSize=0x%x, Value=0x%x\r\n", pSNMPMIB->QueryType, pSNMPMIB->OID, pSNMPMIB->BufSize, *(u16 *) pSNMPMIB->Value); ret = WlanExecuteCommand(card, CmdPtr); if (ret) { WlanDebug(WlanErr,"Failure for set SNMP\r\n"); ret = WLAN_STATUS_FAILURE; } rt_free(CmdPtr); return WLAN_STATUS_SUCCESS; }
void mem_free_debug(void *p) { rt_free(p); }
/** * @brief This function prepares command of set_wep. * * @param card A pointer to WlanCard structure * @param cmd_oid OID: ADD_WEP KEY or REMOVE_WEP KEY * @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE */ int wlan_cmd_802_11_set_wep(WlanCard *cardinfo, u32 cmd_oid) { WlanCard *card = cardinfo; HostCmd_DS_802_11_SET_WEP *wep = NULL; HostCmd_DS_COMMAND *CmdPtr = NULL; int ret = WLAN_STATUS_SUCCESS; CmdPtr = rt_malloc(sizeof(HostCmd_DS_COMMAND)); if (CmdPtr == NULL) { WlanDebug(WlanErr,"memory allocate failed for set wep\r\n"); return WLAN_STATUS_FAILURE; } cardinfo->SeqNum++; CmdPtr->SeqNum = cardinfo->SeqNum; CmdPtr->Result = 0; wep = &CmdPtr->params.wep; if (cmd_oid == OID_802_11_ADD_WEP) { CmdPtr->Command = HostCmd_CMD_802_11_SET_WEP; CmdPtr->Size = (sizeof(HostCmd_DS_802_11_SET_WEP) + S_DS_GEN); wep->Action = HostCmd_ACT_ADD; wep->KeyIndex = (card->CurrentWepKeyIndex & HostCmd_WEP_KEY_INDEX_MASK); switch (card->WepKey[0].KeyLength) { case WEP_40_BIT_LEN: wep->WEPTypeForKey1 = HostCmd_TYPE_WEP_40_BIT; rt_memmove(wep->WEP1, card->WepKey[0].KeyMaterial, card->WepKey[0].KeyLength); break; case WEP_104_BIT_LEN: wep->WEPTypeForKey1 = HostCmd_TYPE_WEP_104_BIT; rt_memmove(wep->WEP1, card->WepKey[0].KeyMaterial, card->WepKey[0].KeyLength); break; case 0: break; default: WlanDebug(WlanErr,"Set Wep key0 length %d\r\n",card->WepKey[0].KeyLength); ret = WLAN_STATUS_FAILURE; goto done; } switch (card->WepKey[1].KeyLength) { case WEP_40_BIT_LEN: wep->WEPTypeForKey2 = HostCmd_TYPE_WEP_40_BIT; rt_memmove(wep->WEP2, card->WepKey[1].KeyMaterial, card->WepKey[1].KeyLength); break; case WEP_104_BIT_LEN: wep->WEPTypeForKey2 = HostCmd_TYPE_WEP_104_BIT; rt_memmove(wep->WEP2, card->WepKey[1].KeyMaterial, card->WepKey[1].KeyLength); break; case 0: break; default: WlanDebug(WlanErr,"Set Wep Key1 Length = %d \n",card->WepKey[1].KeyLength); ret = WLAN_STATUS_FAILURE; goto done; } switch (card->WepKey[2].KeyLength) { case WEP_40_BIT_LEN: wep->WEPTypeForKey3 = HostCmd_TYPE_WEP_40_BIT; rt_memmove(wep->WEP3, card->WepKey[2].KeyMaterial, card->WepKey[2].KeyLength); break; case WEP_104_BIT_LEN: wep->WEPTypeForKey3 = HostCmd_TYPE_WEP_104_BIT; rt_memmove(wep->WEP3, card->WepKey[2].KeyMaterial, card->WepKey[2].KeyLength); break; case 0: break; default: WlanDebug(WlanErr,"Set Wep Key2 Length = %d \n",card->WepKey[1].KeyLength); ret = WLAN_STATUS_FAILURE; goto done; } switch (card->WepKey[3].KeyLength) { case WEP_40_BIT_LEN: wep->WEPTypeForKey4 = HostCmd_TYPE_WEP_40_BIT; rt_memmove(wep->WEP4, card->WepKey[3].KeyMaterial, card->WepKey[3].KeyLength); break; case WEP_104_BIT_LEN: wep->WEPTypeForKey4 = HostCmd_TYPE_WEP_104_BIT; rt_memmove(wep->WEP4, card->WepKey[3].KeyMaterial, card->WepKey[3].KeyLength); break; case 0: break; default: WlanDebug(WlanErr,"Set Wep Key3 Length = %d \n",card->WepKey[1].KeyLength); ret = WLAN_STATUS_FAILURE; goto done; } } else if (cmd_oid == OID_802_11_REMOVE_WEP) { CmdPtr->Command = (HostCmd_CMD_802_11_SET_WEP); CmdPtr->Size = (sizeof(HostCmd_DS_802_11_SET_WEP)) + S_DS_GEN; wep->Action = HostCmd_ACT_REMOVE; /* default tx key index */ wep->KeyIndex = ((u16) (card->CurrentWepKeyIndex & (u32) HostCmd_WEP_KEY_INDEX_MASK)); } ret = WlanExecuteCommand(cardinfo, CmdPtr); if (ret) { WlanDebug(WlanErr,"cmd Set Wep Key failed \n"); ret = WLAN_STATUS_FAILURE; } rt_free(CmdPtr); ret = WLAN_STATUS_SUCCESS; done: return ret; }
static int dfs_uffs_open(struct dfs_fd* file) { int fd; int oflag, mode; char * file_path; oflag = file->flags; if (oflag & DFS_O_DIRECTORY) /* operations about dir */ { uffs_DIR * dir; if (oflag & DFS_O_CREAT) /* create a dir*/ { if (uffs_mkdir(file->path) < 0) return uffs_result_to_dfs(uffs_get_error()); } /* open dir */ file_path = rt_malloc(FILE_PATH_MAX); if(file_path == RT_NULL) return -DFS_STATUS_ENOMEM; if (file->path[0] == '/' && !(file->path[1] == 0)) rt_snprintf(file_path, FILE_PATH_MAX, "%s/", file->path); else { file_path[0] = '/'; file_path[1] = 0; } dir = uffs_opendir(file_path); if (dir == RT_NULL) { rt_free(file_path); return uffs_result_to_dfs(uffs_get_error()); } /* save this pointer,will used by dfs_uffs_getdents*/ file->data = dir; rt_free(file_path); return DFS_STATUS_OK; } /* regular file operations */ /* int uffs_open(const char *name, int oflag, ...); what is this? * uffs_open can open dir!! **/ mode = 0; if (oflag & DFS_O_RDONLY) mode |= UO_RDONLY; if (oflag & DFS_O_WRONLY) mode |= UO_WRONLY; if (oflag & DFS_O_RDWR) mode |= UO_RDWR; /* Opens the file, if it is existing. If not, a new file is created. */ if (oflag & DFS_O_CREAT) mode |= UO_CREATE; /* Creates a new file. If the file is existing, it is truncated and overwritten. */ if (oflag & DFS_O_TRUNC) mode |= UO_TRUNC; /* Creates a new file. The function fails if the file is already existing. */ if (oflag & DFS_O_EXCL) mode |= UO_EXCL; fd = uffs_open(file->path, mode); if (fd < 0) { return uffs_result_to_dfs(uffs_get_error()); } /* save this pointer, it will be used when calling read()£¬write(), * flush(), seek(), and will be free when calling close()*/ file->data = (void *)fd; file->pos = uffs_seek(fd, 0, USEEK_CUR); file->size = uffs_seek(fd, 0, USEEK_END); uffs_seek(fd, file->pos, USEEK_SET); if (oflag & DFS_O_APPEND) { file->pos = uffs_seek(fd, 0, USEEK_END); } return 0; }
/* * Create a UDP based client handle. * If *sockp<0, *sockp is set to a newly created UPD socket. * If raddr->sin_port is 0 a binder on the remote machine * is consulted for the correct port number. * NB: It is the clients responsibility to close *sockp. * NB: The rpch->cl_auth is initialized to null authentication. * Caller may wish to set this something more useful. * * wait is the amount of time used between retransmitting a call if * no response has been heard; retransmition occurs until the actual * rpc call times out. * * sendsz and recvsz are the maximum allowable packet sizes that can be * sent and received. */ CLIENT *clntudp_bufcreate(struct sockaddr_in *raddr, unsigned long program, unsigned long version, struct timeval wait, int *sockp, unsigned int sendsz, unsigned int recvsz) { CLIENT *cl; register struct cu_data *cu = NULL; struct rpc_msg call_msg; static int xid_count = 0; cl = (CLIENT *) rt_malloc (sizeof(CLIENT)); if (cl == NULL) { rt_kprintf("clntudp_create: out of memory\n"); goto fooy; } sendsz = ((sendsz + 3) / 4) * 4; recvsz = ((recvsz + 3) / 4) * 4; cu = (struct cu_data *) rt_malloc (sizeof(*cu) + sendsz + recvsz); if (cu == NULL) { rt_kprintf("clntudp_create: out of memory\n"); goto fooy; } cu->cu_outbuf = &cu->cu_inbuf[recvsz]; if (raddr->sin_port == 0) { unsigned short port; if ((port = pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) { goto fooy; } raddr->sin_port = htons(port); } cl->cl_ops = &udp_ops; cl->cl_private = (char*) cu; cu->cu_raddr = *raddr; cu->cu_rlen = sizeof(cu->cu_raddr); cu->cu_wait = wait; cu->cu_total.tv_sec = -1; cu->cu_total.tv_usec = -1; cu->cu_sendsz = sendsz; cu->cu_recvsz = recvsz; call_msg.rm_xid = ((unsigned long)rt_thread_self()) ^ ((unsigned long)rt_tick_get()) ^ (xid_count++); call_msg.rm_direction = CALL; call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; call_msg.rm_call.cb_prog = program; call_msg.rm_call.cb_vers = version; xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE); if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) { goto fooy; } cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs)); if (*sockp < 0) { int dontblock = 1; *sockp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (*sockp < 0) { rt_kprintf("create socket error\n"); goto fooy; } cu->cu_closeit = TRUE; } else { cu->cu_closeit = FALSE; } cu->cu_sock = *sockp; cl->cl_auth = authnone_create(); return (cl); fooy: if (cu) rt_free(cu); if (cl) rt_free(cl); return ((CLIENT *) NULL); }
/* return the size of struct dirent*/ static int dfs_uffs_getdents( struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) { rt_uint32_t index; char * file_path; struct dirent* d; uffs_DIR* dir; struct uffs_dirent * uffs_d; dir = (uffs_DIR*)(file->data); RT_ASSERT(dir != RT_NULL); /* round count, count is always 1 */ count = (count / sizeof(struct dirent)) * sizeof(struct dirent); if (count == 0) return -DFS_STATUS_EINVAL; /* allocate file name */ file_path = rt_malloc(FILE_PATH_MAX); if (file_path == RT_NULL) return -DFS_STATUS_ENOMEM; index = 0; /* usually, the while loop should only be looped only once! */ while (1) { struct uffs_stat s; d = dirp + index; uffs_d = uffs_readdir(dir); if (uffs_d == RT_NULL) { rt_free(file_path); return (uffs_result_to_dfs(uffs_get_error())); } if (file->path[0] == '/' && !(file->path[1] == 0)) rt_snprintf(file_path, FILE_PATH_MAX, "%s/%s", file->path, uffs_d->d_name); else rt_strncpy(file_path, uffs_d->d_name, FILE_PATH_MAX); uffs_stat(file_path, &s); switch(s.st_mode & US_IFMT) /* file type mark */ { case US_IFREG: /* directory */ d->d_type = DFS_DT_REG; break; case US_IFDIR: /* regular file */ d->d_type = DFS_DT_DIR; break; case US_IFLNK: /* symbolic link */ case US_IREAD: /* read permission */ case US_IWRITE:/* write permission */ default: d->d_type = DFS_DT_UNKNOWN; break; } /* write the rest args of struct dirent* dirp */ d->d_namlen = rt_strlen(uffs_d->d_name); d->d_reclen = (rt_uint16_t)sizeof(struct dirent); rt_strncpy(d->d_name, uffs_d->d_name, rt_strlen(uffs_d->d_name) + 1); index ++; if (index * sizeof(struct dirent) >= count) break; } /* free file name buf */ rt_free(file_path); if (index == 0) return uffs_result_to_dfs(uffs_get_error()); file->pos += index * sizeof(struct dirent); return index * sizeof(struct dirent); }
int main(int argc, char *argv[]) { pthread_t thread_wdt; pthread_t thread_log; pthread_t thread_fifoSrv; pthread_t thread_snmpSrv; pthread_t thread_sendfifo; pthread_t thread_ch1, thread_ch2; pthread_t thread_rtSend, thread_rtRecv; struct wdt_thread_arg wdt_targ; struct log_thread_arg log_targ; struct fifo_thread_arg fifoSrv_targ; struct snmp_thread_arg snmpSrv_targ; struct sfifo_thread_arg sendfifo_targ; struct chan_thread_arg ch1_targ, ch2_targ; struct rt_thread_arg rtSend_targ, rtRecv_targ; int result; char cfile[64]; char lfile[64]; char lfile_old[64]; char lifeFile[64]; int rs_parity, rs_databits, rs_stopbit; int rs_speed; unsigned int utxdel; int tscan; int tout, nretries; int wdt_en; unsigned long wdt_tm; int ch1_enable, ch2_enable; char ip[16]; unsigned int fifo_port; char rt_ipSend[16]; char rt_ipRecv[16]; unsigned int rt_portSend, rt_portRecv; char logSend_ip[16]; unsigned int logSend_port, logMaxLines; int snmp_n, snmp_uso; char *tempip; char ls_gen[32]; char req_ag[32]; char req_ns[32]; char req_gl[32]; char req_ms[32]; int cdDest; int cdaId; int cdnsId; int cdquLogId; int cdmsId; int i; char key[7] = {0}; TOHT *cfg; if( argc == 2) sprintf(cfile, argv[1]); else { sprintf(cfile, "mslave_default.cfg"); gen_moxa_default_cfg(cfile); /** Генерация slave конфиг файла * по умолчанию */ } cfg = cfg_load(cfile); /** Загрузили общий конфиг */ /** Установка лог файла */ sprintf(lfile, cfg_getstring(cfg, "moxa:log", NULL)); sprintf(lfile_old, cfg_getstring(cfg, "moxa:log_old", NULL)); bo_setLogParam(lfile, lfile_old, 0, 1000); /** Генерация таблицы для расчета контрольной суммы * кадра сети RS485 по алгоритму CRC16-MODBUS */ gen_tbl_crc16modbus(); /** Установка таймеров */ tscan = cfg_getint(cfg, "moxa:Tscan", -1); tout = cfg_getint(cfg, "moxa:Tout", -1); nretries = cfg_getint(cfg, "moxa:nRetries", -1); /** Установка параметров WatchDog */ wdt_targ.tsec = cfg_getint(cfg, "WDT:Tsec", -1); wdt_targ.tusec = cfg_getint(cfg, "WDT:Tusec", -1); wdt_tm = (unsigned long)cfg_getint(cfg, "WDT:Tms", -1); wdt_en = cfg_getint(cfg, "WDT:enable", -1); /** Инициализация файла для контроля жизни программы через CRON */ sprintf(lifeFile, cfg_getstring(cfg, "WDT:lifeFile", NULL)); /* gen_moxa_cron_life(lifeFile); */ /** IP адрес узла */ sprintf(ip, cfg_getstring(cfg, "eth0:ip", NULL)); /** FIFO сервер */ fifo_port = (unsigned int)cfg_getint(cfg, "FIFO:port", -1); fifoSrv_targ.qu_len = cfg_getint(cfg, "FIFO:queue_len", -1); fifoSrv_targ.len = cfg_getint(cfg, "FIFO:len", -1); /** RT SEND server IP, port */ sprintf(rt_ipSend, cfg_getstring(cfg, "RT:sendIp", NULL)); rt_portSend = (unsigned int)cfg_getint(cfg, "RT:sendPort", -1); /** RT RECV server IP, port */ sprintf(rt_ipRecv, cfg_getstring(cfg, "RT:recvIp", NULL)); rt_portRecv = (unsigned int)cfg_getint(cfg, "RT:recvPort", -1); /** LOGGER server IP, port, максимальное количество строк */ sprintf(logSend_ip, cfg_getstring(cfg, "LOGGER:sendIp", NULL)); logSend_port = (unsigned int)cfg_getint(cfg, "LOGGER:sendPort", -1); logMaxLines = (unsigned int)cfg_getint(cfg, "LOGGER:maxLines", -1); /** SNMP */ snmp_n = cfg_getint(cfg, "SNMP:n", -1); /** Адрес УСО */ snmp_uso = cfg_getint(cfg, "SNMP:uso", -1); if (snmp_n > 0 && snmp_n <= SNMP_IP_MAX) for (i=0; i<snmp_n; i++) { sprintf(key, "SNMP:%01d", i+1); snmpSrv_targ.ip[i] = malloc(sizeof(char) * 16); tempip = cfg_getstring(cfg, key, NULL); memcpy(*(snmpSrv_targ.ip+i), tempip, strlen(tempip)+1); } /** Загрузка параметров серийного порта */ /** 0: none, 1: odd, 2: even, 3: space, 4: mark */ rs_parity = cfg_getint(cfg, "RS:prmParity", -1); /** 5 .. 8 */ rs_databits = cfg_getint(cfg, "RS:prmDatabits", -1); /** 1, 2 */ rs_stopbit = cfg_getint(cfg, "RS:prmStopbit", -1); /** Скорость канала RS485 */ rs_speed = cfg_getint(cfg, "RS:speed", -1); /** Длительность одного бита (в микросекундах) вычисляется по формуле: T= 1000000 / V, где V - скорость передачи в бодах. Например, для скорости 19200 бод длительность одного бита составляет 1000000/19200= 52 мкс. */ /** коэффициент для задержки на время передачи по серийному каналу */ utxdel = 1000000 / rs_speed * 10; /** Главная подсистема ЛС 'General' */ sprintf(ls_gen, cfg_getstring(cfg, "LS:gen", NULL)); cdDest = mfnv1a(ls_gen); /** Разрешение на выдачу данных 'AccessGranted' */ sprintf(req_ag, cfg_getstring(cfg, "REQ:ag", NULL)); cdaId = mfnv1a(req_ag); /** Состояние сети RS485 */ sprintf(req_ns, cfg_getstring(cfg, "REQ:ns", NULL)); cdnsId = mfnv1a(req_ns); /** Запрос лога */ sprintf(req_gl, cfg_getstring(cfg, "REQ:gl", NULL)); cdquLogId = mfnv1a(req_gl); /** Состояние магистрали */ sprintf(req_ms, cfg_getstring(cfg, "REQ:ms", NULL)); cdmsId = mfnv1a(req_ms); /** Установка параметров и открытие порта 1 RS485 */ ch1_targ.port = cfg_getint(cfg, "RS485_1:port", -1) - 1; ch1_targ.src = cfg_getint(cfg, "RS485_1:adr", -1); ch1_targ.dst_beg = cfg_getint(cfg, "RS485_1:dstBeg", -1); ch1_targ.dst_end = cfg_getint(cfg, "RS485_1:dstEnd", -1); ch1_enable = cfg_getint(cfg, "RS485_1:enable", -1); if (ch1_enable) { SerialSetParam(ch1_targ.port, rs_parity, rs_databits, rs_stopbit); SerialOpen(ch1_targ.port); SerialSetSpeed(ch1_targ.port, rs_speed); printf("Open port%d, speed= %d\n", ch1_targ.port+1, rs_speed); } else printf("Port1 disabled\n"); /** Установка параметров и открытие порта 2 RS485 */ ch2_targ.port = cfg_getint(cfg, "RS485_2:port", -1) - 1; ch2_targ.src = cfg_getint(cfg, "RS485_2:adr", -1); ch2_targ.dst_beg = cfg_getint(cfg, "RS485_2:dstBeg", -1); ch2_targ.dst_end = cfg_getint(cfg, "RS485_2:dstEnd", -1); ch2_enable = cfg_getint(cfg, "RS485_2:enable", -1); if (ch2_enable) { SerialSetParam(ch2_targ.port, rs_parity, rs_databits, rs_stopbit); SerialOpen(ch2_targ.port); SerialSetSpeed(ch2_targ.port, rs_speed); printf("Open port%d, speed2= %d\n", ch2_targ.port+1, rs_speed); } else printf("Port2 disabled\n"); cfg_free(cfg); /** Выделение памяти под буфер для глобальной таблицы * маршрутов загружаемой с контроллера master */ rtBuf = (unsigned char *)malloc(BO_MAX_TAB_BUF); if(rtBuf == NULL) { bo_log("main() ERROR %s", "can't alloc mem for rtBuf"); return 1; } bo_log("Init ok"); printf("Init ok\n"); if (bo_init_fifo_out(10) == -1) { bo_log("bo_init_fifo_out() ERROR"); return 1; } /** Установка атрибутов функционирования нитей PTHREAD: * - инициализирует структуру, указываемую pattr, значениями "по умолчанию"; * - область действия конкуренции (scope) определяет связность * потока с LWP; * - отсоединенность (detachstate); * - область действия блокировки PTHREAD_PROCESS_PRIVATE. */ pthread_attr_init(&pattr); pthread_attr_setscope(&pattr, PTHREAD_SCOPE_SYSTEM); pthread_attr_setdetachstate(&pattr, PTHREAD_CREATE_JOINABLE); pthread_mutex_init(&mx_psv, NULL); pthread_mutex_init(&mx_actFIFO, NULL); pthread_mutex_init(&mx_rtl, NULL); pthread_mutex_init(&mx_rtg, NULL); pthread_mutex_init(&mx_sendSocket, NULL); init_thrState(&psvdata_ready); init_thrState(&psvAnsdata_ready); init_thrState(&actFIFOdata_ready); init_thrRxBuf(&rxBuf); init_thrTxBuf(&txBuf); init_thrDstBuf(&dstBuf); init_thrRxBuf(&rx2Buf); init_thrTxBuf(&tx2Buf); init_thrDstBuf(&dst2Buf); /** Инициализация условных переменных с выделением памяти */ pthread_cond_init(&psvdata, NULL); pthread_cond_init(&psvAnsdata, NULL); pthread_cond_init(&actFIFOdata, NULL); /** Таблицы маршрутов */ rtl = ht_new(0); /** собственный узел */ rtg = ht_new(0); /** внешние узлы */ rtSend_sock = 0; rtRecv_sock = 0; logSend_sock = 0; fifo_idx = 0; log_targ.logSend_ip = logSend_ip; log_targ.logSend_port = logSend_port; result = pthread_create(&thread_log, &pattr, &logSendSock_connect, &log_targ); if (result) { printf("th_log: result = %d: %s\n", result, strerror(errno)); return 1; } rtRecv_targ.ip = rt_ipRecv; rtRecv_targ.port = rt_portRecv; rtRecv_targ.host_ip = ip; result = pthread_create(&thread_rtRecv, &pattr, &rtbl_recv, &rtRecv_targ); if (result) { printf("th_rtRecv: result = %d: %s\n", result, strerror(errno)); return 1; } rtSend_targ.ip = rt_ipSend; rtSend_targ.port = rt_portSend; rtSend_targ.host_ip = ip; result = pthread_create(&thread_rtSend, &pattr, &rtbl_send, &rtSend_targ); if (result) { printf("th_rtSend: result = %d: %s\n", result, strerror(errno)); return 1; } if (snmp_n > 0 && snmp_n <= SNMP_IP_MAX) { snmpSrv_targ.n = snmp_n; printf("ip=%s, n=%d\n", (snmpSrv_targ.ip[0]), snmpSrv_targ.n); result = pthread_create(&thread_snmpSrv, &pattr, &snmp_serv, &snmpSrv_targ); if (result) { printf("th_snmpSrv: result = %d: %s\n", result, strerror(errno)); return 1; } printf("snmp start ok\n"); } fifoSrv_targ.port = fifo_port; result = pthread_create(&thread_fifoSrv, &pattr, &fifo_serv, &fifoSrv_targ); if (result) { printf("th_fifoSrv: result = %d: %s\n", result, strerror(errno)); return 1; } write(1, "fifo start ok\n", 14); sendfifo_targ.port = fifo_port; result = pthread_create(&thread_sendfifo, &pattr, &send_fifo, &sendfifo_targ); if (result) { printf("th_sendfifo: result = %d: %s\n", result, strerror(errno)); return 1; } write(1, "send_fifo start ok\n", 14); ch1_targ.ch1_enable = ch1_enable; ch1_targ.ch2_enable = ch2_enable; ch1_targ.tscan = tscan; ch1_targ.tout = tout; ch1_targ.utxdel = utxdel; ch1_targ.wdt_en = wdt_en; ch1_targ.nretries = nretries; ch1_targ.ip = ip; ch1_targ.fifo_port = fifo_port; ch1_targ.snmp_n = snmp_n; ch1_targ.snmp_uso = snmp_uso; ch1_targ.logMaxLines = logMaxLines; ch1_targ.cdDest = cdDest; ch1_targ.cdaId = cdaId; ch1_targ.cdnsId = cdnsId; ch1_targ.cdquLogId = cdquLogId; ch1_targ.cdmsId = cdmsId; result = pthread_create(&thread_ch1, &pattr, &chan1, &ch1_targ); if (result) { printf("th_ch1: result = %d: %s\n", result, strerror(errno)); return 1; } write(1, "ch1 start ok\n", 13); ch2_targ.ch1_enable = ch1_enable; ch2_targ.ch2_enable = ch2_enable; ch2_targ.tscan = tscan; ch2_targ.tout = tout; ch2_targ.utxdel = utxdel; ch2_targ.wdt_en = wdt_en; ch2_targ.nretries = nretries; ch2_targ.ip = ip; ch2_targ.fifo_port = fifo_port; ch2_targ.snmp_n = snmp_n; ch2_targ.snmp_uso = snmp_uso; ch2_targ.logMaxLines = logMaxLines; ch2_targ.cdDest = cdDest; ch2_targ.cdaId = cdaId; ch2_targ.cdnsId = cdnsId; ch2_targ.cdquLogId = cdquLogId; ch2_targ.cdmsId = cdmsId; result = pthread_create(&thread_ch2, &pattr, &chan2, &ch2_targ); if (result) { printf("th_ch2: result = %d: %s\n", result, strerror(errno)); return 1; } write(1, "ch2 start ok\n", 13); #if defined (__MOXA_TARGET__) && defined (__WDT__) if (wdt_en) { /* set watch dog timer, must be refreshed in 5ms..60s */ wdt_fd = mxwdg_open(wdt_tm); if (wdt_fd < 0) { printf("fail to open the watch dog !: %d [%s]\n", wdt_fd, strerror(errno)); return 1; } init_thrWdtlife(&wdt_life); printf("WatchDog enabled ok\n"); } #endif wdt_targ.wdt_en = wdt_en; wdt_targ.lifeFile = lifeFile; result = pthread_create(&thread_wdt, &pattr, &wdt, &wdt_targ); if (result) { printf("th_wdt: result = %d: %s\n", result, strerror(errno)); return 1; } /** Ожидаем завершения потоков */ if (!pthread_equal(pthread_self(), thread_log)) pthread_join(thread_log, NULL); if (!pthread_equal(pthread_self(), thread_rtRecv)) pthread_join(thread_rtRecv, NULL); if (!pthread_equal(pthread_self(), thread_rtSend)) pthread_join(thread_rtSend, NULL); if (snmp_n > 0 && snmp_n <= SNMP_IP_MAX) if (!pthread_equal(pthread_self(), thread_snmpSrv)) pthread_join(thread_snmpSrv, NULL); if (!pthread_equal(pthread_self(), thread_fifoSrv)) pthread_join(thread_fifoSrv, NULL); if (!pthread_equal(pthread_self(), thread_sendfifo)) pthread_join(thread_sendfifo, NULL); if (!pthread_equal(pthread_self(), thread_ch1)) pthread_join(thread_ch1, NULL); if (!pthread_equal(pthread_self(), thread_ch2)) pthread_join(thread_ch2, NULL); if (!pthread_equal(pthread_self(), thread_wdt)) pthread_join(thread_wdt, NULL); /** Разрушаем блокировки и условные переменные, освобождаем память. */ pthread_mutex_destroy(&mx_psv); pthread_mutex_destroy(&mx_actFIFO); pthread_mutex_destroy(&mx_rtl); pthread_mutex_destroy(&mx_rtg); pthread_mutex_destroy(&mx_sendSocket); destroy_thrRxBuf(&rxBuf); destroy_thrTxBuf(&txBuf); destroy_thrDstBuf(&dstBuf); destroy_thrRxBuf(&rx2Buf); destroy_thrTxBuf(&tx2Buf); destroy_thrDstBuf(&dst2Buf); pthread_cond_destroy(&psvdata); pthread_cond_destroy(&psvAnsdata); pthread_cond_destroy(&actFIFOdata); destroy_thrState(&psvdata_ready); destroy_thrState(&psvAnsdata_ready); destroy_thrState(&actFIFOdata_ready); #if defined (__MOXA_TARGET__) && defined (__WDT__) if (wdt_en) { destroy_thrWdtlife(&wdt_life); mxwdg_close(wdt_fd); } #endif if(rtBuf != NULL) free(rtBuf); rt_free(rtl); rt_free(rtg); return 0; }
static inline void lxrt_fun_call_wbuf(RT_TASK *rt_task, void *fun, int narg, long *arg, unsigned long type) { int rsize, r2size, wsize, w2size, msg_size; long *wmsg_adr, *w2msg_adr, *fun_args; rsize = r2size = wsize = w2size = 0 ; wmsg_adr = w2msg_adr = NULL; fun_args = arg - 1; if (NEED_TO_R(type)) { rsize = USP_RSZ1(type); rsize = rsize ? fun_args[rsize] : sizeof(long); if (NEED_TO_R2ND(type)) { r2size = USP_RSZ2(type); r2size = r2size ? fun_args[r2size] : sizeof(long); } } if (NEED_TO_W(type)) { wsize = USP_WSZ1(type); wsize = wsize ? fun_args[wsize] : sizeof(long); if (NEED_TO_W2ND(type)) { w2size = USP_WSZ2(type); w2size = w2size ? fun_args[w2size] : sizeof(long); } } if ((msg_size = rsize > wsize ? rsize : wsize) > 0) { if (msg_size > rt_task->max_msg_size[0]) { rt_free(rt_task->msg_buf[0]); rt_task->max_msg_size[0] = (msg_size << 7)/100; rt_task->msg_buf[0] = rt_malloc(rt_task->max_msg_size[0]); } if (rsize) { long *buf_arg = fun_args + USP_RBF1(type); rt_copy_from_user(rt_task->msg_buf[0], (long *)buf_arg[0], rsize); buf_arg[0] = (long)rt_task->msg_buf[0]; } if (wsize) { long *buf_arg = fun_args + USP_WBF1(type); wmsg_adr = (long *)buf_arg[0]; buf_arg[0] = (long)rt_task->msg_buf[0]; } } if ((msg_size = r2size > w2size ? r2size : w2size) > 0) { if (msg_size > rt_task->max_msg_size[1]) { rt_free(rt_task->msg_buf[1]); rt_task->max_msg_size[1] = (msg_size << 7)/100; rt_task->msg_buf[1] = rt_malloc(rt_task->max_msg_size[1]); } if (r2size) { long *buf_arg = fun_args + USP_RBF2(type); rt_copy_from_user(rt_task->msg_buf[1], (long *)buf_arg[0], r2size); buf_arg[0] = (long)rt_task->msg_buf[1]; } if (w2size) { long *buf_arg = fun_args + USP_WBF2(type); w2msg_adr = (long *)buf_arg[0]; buf_arg[0] = (long)rt_task->msg_buf[1]; } } lxrt_fun_call(rt_task, fun, narg, arg); if (wsize) { rt_copy_to_user(wmsg_adr, rt_task->msg_buf[0], wsize); if (w2size) { rt_copy_to_user(w2msg_adr, rt_task->msg_buf[1], w2size); } } }
/** * this function will normalize a path according to specified parent directory * and file name. * * @param directory the parent path * @param filename the file name * * @return the built full file path (absolute path) */ char *dfs_normalize_path(const char *directory, const char *filename) { char *fullpath; char *dst0, *dst, *src; /* check parameters */ RT_ASSERT(filename != RT_NULL); #ifdef DFS_USING_WORKDIR if (directory == RT_NULL) /* shall use working directory */ directory = &working_directory[0]; #else if ((directory == RT_NULL) && (filename[0] != '/')) { rt_kprintf(NO_WORKING_DIR); return RT_NULL; } #endif if (filename[0] != '/') /* it's a absolute path, use it directly */ { fullpath = (char *)rt_malloc(strlen(directory) + strlen(filename) + 2); /* join path and file name */ rt_snprintf(fullpath, strlen(directory) + strlen(filename) + 2, "%s/%s", directory, filename); } else { fullpath = rt_strdup(filename); /* copy string */ } src = fullpath; dst = fullpath; dst0 = dst; while (1) { char c = *src; if (c == '.') { if (!src[1]) src ++; /* '.' and ends */ else if (src[1] == '/') { /* './' case */ src += 2; while ((*src == '/') && (*src != '\0')) src ++; continue; } else if (src[1] == '.') { if (!src[2]) { /* '..' and ends case */ src += 2; goto up_one; } else if (src[2] == '/') { /* '../' case */ src += 3; while ((*src == '/') && (*src != '\0')) src ++; goto up_one; } } } /* copy up the next '/' and erase all '/' */ while ((c = *src++) != '\0' && c != '/') *dst ++ = c; if (c == '/') { *dst ++ = '/'; while (c == '/') c = *src++; src --; } else if (!c) break; continue; up_one: dst --; if (dst < dst0) { rt_free(fullpath); return RT_NULL; } while (dst0 < dst && dst[-1] != '/') dst --; } *dst = '\0'; /* remove '/' in the end of path if exist */ dst --; if ((dst != fullpath) && (*dst == '/')) *dst = '\0'; return fullpath; }
static inline RT_TASK* __task_init(unsigned long name, int prio, int stack_size, int max_msg_size, int cpus_allowed) { void *msg_buf0, *msg_buf1; RT_TASK *rt_task; if ((rt_task = current->rtai_tskext(TSKEXT0))) { if (num_online_cpus() > 1 && cpus_allowed) { cpus_allowed = hweight32(cpus_allowed) > 1 ? get_min_tasks_cpuid() : ffnz(cpus_allowed); } else { cpus_allowed = rtai_cpuid(); } put_current_on_cpu(cpus_allowed); return rt_task; } if (rt_get_adr(name)) { return 0; } if (prio > RT_SCHED_LOWEST_PRIORITY) { prio = RT_SCHED_LOWEST_PRIORITY; } if (!max_msg_size) { max_msg_size = USRLAND_MAX_MSG_SIZE; } if (!(msg_buf0 = rt_malloc(max_msg_size))) { return 0; } if (!(msg_buf1 = rt_malloc(max_msg_size))) { rt_free(msg_buf0); return 0; } rt_task = rt_malloc(sizeof(RT_TASK) + 3*sizeof(struct fun_args)); if (rt_task) { rt_task->magic = 0; if (num_online_cpus() > 1 && cpus_allowed) { cpus_allowed = hweight32(cpus_allowed) > 1 ? get_min_tasks_cpuid() : ffnz(cpus_allowed); } else { cpus_allowed = rtai_cpuid(); } if (!set_rtext(rt_task, prio, 0, 0, cpus_allowed, 0)) { rt_task->fun_args = (long *)((struct fun_args *)(rt_task + 1)); rt_task->msg_buf[0] = msg_buf0; rt_task->msg_buf[1] = msg_buf1; rt_task->max_msg_size[0] = rt_task->max_msg_size[1] = max_msg_size; if (rt_register(name, rt_task, IS_TASK, 0)) { rt_task->state = 0; #ifdef __IPIPE_FEATURE_ENABLE_NOTIFIER ipipe_enable_notifier(current); #else current->flags |= PF_EVNOTIFY; #endif #if (defined VM_PINNED) && (defined CONFIG_MMU) ipipe_disable_ondemand_mappings(current); #endif RTAI_OOM_DISABLE(); return rt_task; } else { clr_rtext(rt_task); } } rt_free(rt_task); } rt_free(msg_buf0); rt_free(msg_buf1); return 0; }
/* Return 0 on module executed. Other value indicate error. */ int msh_exec_module(const char* cmd_line, int size) { int ret; int fd = -1; char *pg_name; int length, cmd_length = 0; if (size == 0) return -RT_ERROR; /* get the length of command0 */ while ((cmd_line[cmd_length] != ' ' && cmd_line[cmd_length] != '\t') && cmd_length < size) cmd_length ++; /* get name length */ length = cmd_length + 32; /* allocate program name memory */ pg_name = (char*) rt_malloc(length); if (pg_name == RT_NULL) return -RT_ENOMEM; /* copy command0 */ memcpy(pg_name, cmd_line, cmd_length); pg_name[cmd_length] = '\0'; if (strstr(pg_name, ".mo") != RT_NULL || strstr(pg_name, ".MO") != RT_NULL) { /* try to open program */ fd = open(pg_name, O_RDONLY, 0); /* search in /bin path */ if (fd < 0) { rt_snprintf(pg_name, length - 1, "/bin/%.*s", cmd_length, cmd_line); fd = open(pg_name, O_RDONLY, 0); } } else { /* add .mo and open program */ /* try to open program */ strcat(pg_name, ".mo"); fd = open(pg_name, O_RDONLY, 0); /* search in /bin path */ if (fd < 0) { rt_snprintf(pg_name, length - 1, "/bin/%.*s.mo", cmd_length, cmd_line); fd = open(pg_name, O_RDONLY, 0); } } if (fd >= 0) { /* found program */ close(fd); rt_module_exec_cmd(pg_name, cmd_line, size); ret = 0; } else { ret = -1; } rt_free(pg_name); return ret; }
static inline long long handle_lxrt_request (unsigned int lxsrq, long *arg, RT_TASK *task) { #define larg ((struct arg *)arg) union {unsigned long name; RT_TASK *rt_task; SEM *sem; MBX *mbx; RWL *rwl; SPL *spl; int i; void *p; long long ll; } arg0; int srq; if (likely((srq = SRQ(lxsrq)) < MAX_LXRT_FUN)) { unsigned long type; struct rt_fun_entry *funcm; /* * The next two lines of code do a lot. It makes possible to extend the use of * USP to any other real time module service in user space, both for soft and * hard real time. Concept contributed and copyrighted by: Giuseppe Renoldi * ([email protected]). */ if (unlikely(!(funcm = rt_fun_ext[INDX(lxsrq)]))) { rt_printk("BAD: null rt_fun_ext, no module for extension %d?\n", INDX(lxsrq)); return -ENOSYS; } if (!(type = funcm[srq].type)) { return ((RTAI_SYSCALL_MODE long long (*)(unsigned long, ...))funcm[srq].fun)(RTAI_FUN_ARGS); } if (unlikely(NEED_TO_RW(type))) { lxrt_fun_call_wbuf(task, funcm[srq].fun, NARG(lxsrq), arg, type); } else { lxrt_fun_call(task, funcm[srq].fun, NARG(lxsrq), arg); } return task->retval; } arg0.name = arg[0]; switch (srq) { case LXRT_GET_ADR: { arg0.p = rt_get_adr(arg0.name); return arg0.ll; } case LXRT_GET_NAME: { arg0.name = rt_get_name(arg0.p); return arg0.ll; } case LXRT_TASK_INIT: { struct arg { unsigned long name; long prio, stack_size, max_msg_size, cpus_allowed; }; arg0.rt_task = __task_init(arg0.name, larg->prio, larg->stack_size, larg->max_msg_size, larg->cpus_allowed); return arg0.ll; } case LXRT_TASK_DELETE: { arg0.i = __task_delete(arg0.rt_task ? arg0.rt_task : task); return arg0.ll; } case LXRT_SEM_INIT: { if (rt_get_adr(arg0.name)) { return 0; } if ((arg0.sem = rt_malloc(sizeof(SEM)))) { struct arg { unsigned long name; long cnt; long typ; }; lxrt_typed_sem_init(arg0.sem, larg->cnt, larg->typ); if (rt_register(larg->name, arg0.sem, IS_SEM, current)) { return arg0.ll; } else { rt_free(arg0.sem); } } return 0; } case LXRT_SEM_DELETE: { if (lxrt_sem_delete(arg0.sem)) { arg0.i = -EFAULT; return arg0.ll; } rt_free(arg0.sem); arg0.i = rt_drg_on_adr(arg0.sem); return arg0.ll; } case LXRT_MBX_INIT: { if (rt_get_adr(arg0.name)) { return 0; } if ((arg0.mbx = rt_malloc(sizeof(MBX)))) { struct arg { unsigned long name; long size; int qtype; }; if (lxrt_typed_mbx_init(arg0.mbx, larg->size, larg->qtype) < 0) { rt_free(arg0.mbx); return 0; } if (rt_register(larg->name, arg0.mbx, IS_MBX, current)) { return arg0.ll; } else { rt_free(arg0.mbx); } } return 0; } case LXRT_MBX_DELETE: { if (lxrt_mbx_delete(arg0.mbx)) { arg0.i = -EFAULT; return arg0.ll; } rt_free(arg0.mbx); arg0.i = rt_drg_on_adr(arg0.mbx); return arg0.ll; } case LXRT_RWL_INIT: { if (rt_get_adr(arg0.name)) { return 0; } if ((arg0.rwl = rt_malloc(sizeof(RWL)))) { struct arg { unsigned long name; long type; }; lxrt_typed_rwl_init(arg0.rwl, larg->type); if (rt_register(larg->name, arg0.rwl, IS_SEM, current)) { return arg0.ll; } else { rt_free(arg0.rwl); } } return 0; } case LXRT_RWL_DELETE: { if (lxrt_rwl_delete(arg0.rwl)) { arg0.i = -EFAULT; return arg0.ll; } rt_free(arg0.rwl); arg0.i = rt_drg_on_adr(arg0.rwl); return arg0.ll; } case LXRT_SPL_INIT: { if (rt_get_adr(arg0.name)) { return 0; } if ((arg0.spl = rt_malloc(sizeof(SPL)))) { struct arg { unsigned long name; }; lxrt_spl_init(arg0.spl); if (rt_register(larg->name, arg0.spl, IS_SEM, current)) { return arg0.ll; } else { rt_free(arg0.spl); } } return 0; } case LXRT_SPL_DELETE: { if (lxrt_spl_delete(arg0.spl)) { arg0.i = -EFAULT; return arg0.ll; } rt_free(arg0.spl); arg0.i = rt_drg_on_adr(arg0.spl); return arg0.ll; } case MAKE_HARD_RT: { rt_make_hard_real_time(task); return 0; if (!task || task->is_hard) { return 0; } steal_from_linux(task); return 0; } case MAKE_SOFT_RT: { rt_make_soft_real_time(task); return 0; if (!task || !task->is_hard) { return 0; } if (task->is_hard < 0) { task->is_hard = 0; } else { give_back_to_linux(task, 0); } return 0; } case PRINT_TO_SCREEN: { struct arg { char *display; long nch; }; arg0.i = rtai_print_to_screen("%s", larg->display); return arg0.ll; } case PRINTK: { struct arg { char *display; long nch; }; arg0.i = rt_printk("%s", larg->display); return arg0.ll; } case NONROOT_HRT: { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) current->cap_effective |= ((1 << CAP_IPC_LOCK) | (1 << CAP_SYS_RAWIO) | (1 << CAP_SYS_NICE)); #else set_lxrt_perm(CAP_IPC_LOCK); set_lxrt_perm(CAP_SYS_RAWIO); set_lxrt_perm(CAP_SYS_NICE); #endif return 0; } case RT_BUDDY: { arg0.rt_task = task && current->rtai_tskext(TSKEXT1) == current ? task : NULL; return arg0.ll; } case HRT_USE_FPU: { struct arg { RT_TASK *task; long use_fpu; }; if(!larg->use_fpu) { clear_lnxtsk_uses_fpu((larg->task)->lnxtsk); } else { init_fpu((larg->task)->lnxtsk); } return 0; } case GET_USP_FLAGS: { arg0.name = arg0.rt_task->usp_flags; return arg0.ll; } case SET_USP_FLAGS: { struct arg { RT_TASK *task; unsigned long flags; }; arg0.rt_task->usp_flags = larg->flags; arg0.rt_task->force_soft = (arg0.rt_task->is_hard > 0) && (larg->flags & arg0.rt_task->usp_flags_mask & FORCE_SOFT); return 0; } case GET_USP_FLG_MSK: { arg0.name = arg0.rt_task->usp_flags_mask; return arg0.ll; } case SET_USP_FLG_MSK: { task->usp_flags_mask = arg0.name; task->force_soft = (task->is_hard > 0) && (task->usp_flags & arg0.name & FORCE_SOFT); return 0; } case FORCE_TASK_SOFT: { extern void rt_do_force_soft(RT_TASK *rt_task); struct task_struct *ltsk; if ((ltsk = find_task_by_pid(arg0.name))) { if ((arg0.rt_task = ltsk->rtai_tskext(TSKEXT0))) { if ((arg0.rt_task->force_soft = (arg0.rt_task->is_hard != 0) && FORCE_SOFT)) { rt_do_force_soft(arg0.rt_task); } return arg0.ll; } } return 0; } case IS_HARD: { arg0.i = arg0.rt_task || (arg0.rt_task = current->rtai_tskext(TSKEXT0)) ? arg0.rt_task->is_hard : 0; return arg0.ll; } case GET_EXECTIME: { struct arg { RT_TASK *task; RTIME *exectime; }; if ((larg->task)->exectime[0] && (larg->task)->exectime[1]) { larg->exectime[0] = (larg->task)->exectime[0]; larg->exectime[1] = (larg->task)->exectime[1]; larg->exectime[2] = rtai_rdtsc(); } return 0; } case GET_TIMEORIG: { struct arg { RTIME *time_orig; }; if (larg->time_orig) { RTIME time_orig[2]; rt_gettimeorig(time_orig); rt_copy_to_user(larg->time_orig, time_orig, sizeof(time_orig)); } else { rt_gettimeorig(NULL); } return 0; } case LINUX_SERVER: { struct arg { struct linux_syscalls_list syscalls; }; if (larg->syscalls.nr) { if (larg->syscalls.task->linux_syscall_server) { RT_TASK *serv; rt_get_user(serv, &larg->syscalls.serv); rt_task_masked_unblock(serv, ~RT_SCHED_READY); } larg->syscalls.task->linux_syscall_server = larg->syscalls.serv; rtai_set_linux_task_priority(current, (larg->syscalls.task)->lnxtsk->policy, (larg->syscalls.task)->lnxtsk->rt_priority); arg0.rt_task = __task_init((unsigned long)larg->syscalls.task, larg->syscalls.task->base_priority >= BASE_SOFT_PRIORITY ? larg->syscalls.task->base_priority - BASE_SOFT_PRIORITY : larg->syscalls.task->base_priority, 0, 0, 1 << larg->syscalls.task->runnable_on_cpus); larg->syscalls.task->linux_syscall_server = arg0.rt_task; arg0.rt_task->linux_syscall_server = larg->syscalls.serv; return arg0.ll; } else { if (!larg->syscalls.task) { larg->syscalls.task = RT_CURRENT; } if ((arg0.rt_task = larg->syscalls.task->linux_syscall_server)) { larg->syscalls.task->linux_syscall_server = NULL; arg0.rt_task->suspdepth = -RTE_HIGERR; rt_task_masked_unblock(arg0.rt_task, ~RT_SCHED_READY); } } return 0; } default: { rt_printk("RTAI/LXRT: Unknown srq #%d\n", srq); arg0.i = -ENOSYS; return arg0.ll; } } return 0; }
/*按键处理,拍照或上传过程中如何判断?*/ static void keypress( unsigned int key ) { switch( key ) { case KEY_MENU: if( scr_mode == SCR_PHOTO_MENU ) { pMenuItem = &Menu_3_InforInteract; pMenuItem->show( ); break; } if( scr_mode == SCR_PHOTO_SELECT_ITEM ) /*回退到主菜单*/ { scr_mode = SCR_PHOTO_MENU; rt_free( pHead ); pHead = RT_NULL; }else if( scr_mode == SCR_PHOTO_SELECT_DETAILED) /*回退到拍照照片条目显示*/ { scr_mode = SCR_PHOTO_SELECT_ITEM; } else if(scr_mode == SCR_PHOTO_TAKE) { scr_mode = SCR_PHOTO_MENU; } display(); break; case KEY_OK: if( scr_mode == SCR_PHOTO_MENU ) { if( pos == 0 ) /*图片记录*/ { pic_count = 0; rt_free(pHead); pHead == RT_NULL; pHead = Cam_Flash_SearchPicHead( 0x00000000, 0xFFFFFFFF, 0, 0xFF, &pic_count ,BIT(0)); scr_mode = SCR_PHOTO_SELECT_ITEM; }else /*图片拍照*/ { scr_mode = SCR_PHOTO_TAKE; if(Cam_get_state() == 0) Cam_takepic(0xFF,1,1,Cam_TRIGGER_OTHER); } }else if( scr_mode == SCR_PHOTO_SELECT_ITEM ) { if(pic_count) { scr_mode = SCR_PHOTO_SELECT_DETAILED; } } else if(scr_mode == SCR_PHOTO_SELECT_DETAILED) { ; } else if(scr_mode == SCR_PHOTO_TAKE) { scr_mode = SCR_PHOTO_MENU; } display( ); break; case KEY_UP: pos--; display( ); break; case KEY_DOWN: pos++; display( ); break; } }
void thread_gps_upgrade_uart( void* parameter ) { #define BD_SYNC_40 0 #define BD_SYNC_0D 1 #define BD_SYNC_0A 2 /*定义一个函数指针,用作结果处理 */ void ( *msg )( void *p ); unsigned int resultcode; rt_uint8_t buf[256]; rt_uint8_t info[32]; rt_uint8_t *p; rt_uint16_t count = 0; rt_uint16_t i; rt_size_t len; rt_uint32_t baud = 9600; rt_uint16_t packetnum = 0; rt_uint8_t bd_packet_status = BD_SYNC_40; /*北斗升级报文接收状态*/ rt_uint8_t last_char = 0x0; rt_tick_t last_sendtick = 0; /*北斗更新时记录收到应答的时刻*/ msg = parameter; ptr_mem_packet = rt_malloc( 1200 ); if( ptr_mem_packet == RT_NULL ) { resultcode = BDUPG_RES_RAM; msg( "E内存不足" ); return; } flag_bd_upgrade_uart = 1; dev_vuart.flag &= ~RT_DEVICE_FLAG_STREAM; rt_device_control( &dev_vuart, 0x03, &baud ); p = ptr_mem_packet; while( 1 ) { if( ( last_sendtick > 0 ) && ( rt_tick_get( ) - last_sendtick > RT_TICK_PER_SECOND * 12 ) ) { /*升级程序发送数据,收到应答,再次发送数据。超时10s*/ resultcode = BDUPG_RES_TIMEOUT; msg( "E超时错误" ); goto end_upgrade_uart_memfree; } while( ( len = rt_device_read( &dev_vuart, 0, buf, 256 ) ) > 0 ) { for( i = 0; i < len; i++ ) { switch( bd_packet_status ) { case BD_SYNC_40: if( buf[i] == 0x40 ) { *p++ = 0x40; bd_packet_status = BD_SYNC_0A; count = 1; } break; case BD_SYNC_0A: if( ( buf[i] == 0x0a ) && ( last_char == 0x0d ) ) { *p = 0x0a; count++; dev_gps_write( &dev_gps, 0, ptr_mem_packet, count ); packetnum++; /*显示传递的包数*/ sprintf( info, "I发送第%d包", packetnum ); msg( info ); last_sendtick = rt_tick_get( ); if( memcmp( ptr_mem_packet, "\x40\x41\xc0", 3 ) == 0 ) /*修改波特率*/ { baud = ( *( ptr_mem_packet + 4 ) << 24 ) | ( *( ptr_mem_packet + 5 ) << 16 ) | ( *( ptr_mem_packet + 6 ) << 8 ) | *( ptr_mem_packet + 7 ); gps_baud( baud ); uart1_baud( baud ); } if( memcmp( ptr_mem_packet, "\x40\x34\xc0", 3 ) == 0 ) /*模块软件复位*/ { resultcode = 0; msg( "E更新完成" ); /*通知lcd显示完成*/ goto end_upgrade_uart_memfree; } p = ptr_mem_packet; bd_packet_status = BD_SYNC_40; }else { *p++ = buf[i]; count++; } break; } last_char = buf[i]; } } rt_thread_delay( RT_TICK_PER_SECOND / 50 ); } end_upgrade_uart_memfree: rt_free( ptr_mem_packet ); ptr_mem_packet = RT_NULL; //end_upgrade_uart: baud = 115200; uart1_baud( baud ); flag_bd_upgrade_uart = 0; }
void freeHiddenClasses(HiddenClass* hcls) { for (const auto& p : hcls->children) { freeHiddenClasses(p.second); } rt_free(hcls); }
void rtgui_theme_draw_textbox(rtgui_textbox_t* box) { /* draw button */ struct rtgui_dc* dc; struct rtgui_rect rect; rtgui_color_t fc; /* begin drawing */ dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box)); if (dc == RT_NULL) return; /* get widget rect */ rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect); fc = RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(box)); /* fill widget rect with white color */ RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(box)) = white; rtgui_dc_fill_rect(dc, &rect); /* draw border */ RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(box)) = RTGUI_RGB(123, 158, 189); rtgui_dc_draw_rect(dc, &rect); /* draw text */ RTGUI_WIDGET_FOREGROUND(RTGUI_WIDGET(box)) = fc; if (box->text != RT_NULL) { rect.x1 += RTGUI_TEXTBOX_MARGIN; if (box->flag & RTGUI_TEXTBOX_MASK) { /* draw '*' */ rt_size_t len = rt_strlen(box->text); if (len > 0) { char *text_mask = rtgui_malloc(len + 1); rt_memset(text_mask, '*', len + 1); text_mask[len] = 0; rtgui_dc_draw_text(dc, text_mask, &rect); rt_free(text_mask); } } else { rtgui_dc_draw_text(dc, box->text, &rect); } /* draw caret */ if (box->flag & RTGUI_TEXTBOX_CARET_SHOW) { rect.x1 += box->position * box->font_width; rect.x2 = rect.x1 + box->font_width; rect.y2 -= 2; rect.y1 = rect.y2 - 3; RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(box)) = black; rtgui_dc_fill_rect(dc, &rect); } } /* end drawing */ rtgui_dc_end_drawing(dc); }