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;
}
Example #2
0
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);
}
Example #3
0
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 ;
}
Example #4
0
URET rt_free_link(struct uffs_DeviceSt *dev, void *p)
{
	rt_free(p);
	return 0;
}
Example #5
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);
}
Example #6
0
/** 
 *  @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;
}
Example #7
0
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;
}
Example #8
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);
}
Example #9
0
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);
}
Example #10
0
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;
}
Example #11
0
/**
 * 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;
}
Example #14
0
static void _rtgui_label_destructor(rtgui_label_t *label)
{
    /* release text memory */
    rt_free(label->text);
    label->text = RT_NULL;
}
Example #15
0
/** 
 *  @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;
}
Example #16
0
void mem_free_debug(void *p)
{
    rt_free(p);
}
Example #17
0
/** 
 *  @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;
}
Example #18
0
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;
}
Example #19
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);
}
Example #20
0
/* 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);
}
Example #21
0
File: mslave.c Project: 0x42/fire
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;
}
Example #22
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);
		}
	}
}
Example #23
0
/** 
 * 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;
}
Example #24
0
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;
}
Example #25
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;
}
Example #26
0
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;
}
Example #27
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;
	}
}
Example #28
0
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;  
}
Example #29
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);
}