示例#1
0
static ssize_t test_fifo_write(struct cavan_fifo *fifo, const void *buff, size_t size)
{
	println("buff = %p, size = %" PRINT_FORMAT_SIZE, buff, size);

	print_ntext(buff, size);
	print_char('\n');

	return size;
}
示例#2
0
文件: input.c 项目: FuangCao/cavan
static void cavan_input_message_queue_handler_dummy(void *addr, void *data)
{
	int length;
	char buff[1024];

	length = cavan_input_message_tostring(addr, buff, sizeof(buff));
	if (length < (int) sizeof(buff)) {
		buff[length++] = '\n';
	}

	print_ntext(buff, length);
}
示例#3
0
文件: network.c 项目: FuangCao/cavan
static int app_network_cmdline(struct network_client *client)
{
	int ret;
	int length;
	char buff[1024];
	pthread_t thread;

	ret = cavan_pthread_create(&thread, app_network_receive_thread, client, true);
	if (ret < 0) {
		pr_err_info("cavan_pthread_create: %d", ret);
		return ret;
	}

	while (1) {
		print_ntext("> ", 2);

		if (fgets(buff, sizeof(buff), stdin) == NULL) {
			pr_err_info("fgets");
			break;
		}

		length = strlen(buff);
		buff[length] = 0;

		println("send[%d]: %s", length, buff);

		length = client->send(client, buff, length);
		if (length <= 0) {
			break;
		}
	}

	cavan_pthread_join(thread);

	return 0;
}
示例#4
0
文件: ftp.c 项目: Jack19881218/cavan
int ftp_client_read_response(struct network_client *client, char *response, size_t size)
{
	int state;
	ssize_t rwlen;
	char buff[2048], *p = buff, *p_end = p + sizeof(buff);

	while (p < p_end)
	{
		char *q;

		rwlen = network_client_timed_recv(client, p, p_end - p, 5000);
		if (rwlen <= 0)
		{
			return -EFAULT;
		}

		for (q = p, p += rwlen; q < p; q++)
		{
			int step = 0;

			while (q < p && IS_NUMBER(*q))
			{
				q++;
			}

			if (q < p && *q != '-')
			{
				step++;
			}

			while (q < p)
			{
				if (*q == '\n')
				{
					step++;
					break;
				}

				q++;
			}

			if (step == 2)
			{
				goto label_read_complete;
			}
		}
	}

label_read_complete:
	*p = 0;
#if FTP_DEBUG
	print_ntext(buff, p - buff);
#endif
	state = text2value_unsigned(buff, (const char **) &p, 10);

	if (response && size > 0)
	{
		text_ncopy(response, p + 1, size);
	}

	return state;
}
示例#5
0
文件: ftp.c 项目: Jack19881218/cavan
static int ftp_client_receive_file(struct network_client *client, const char *ip, u16 port)
{
	int ret;
	int sockfd, data_sockfd;
	ssize_t rdlen;
	char buff[1024], *p;
	struct sockaddr_in addr;
	socklen_t addrlen;

	sockfd = inet_create_tcp_service(port);
	if (sockfd < 0)
	{
		pr_red_info("inet_create_tcp_service");
		return sockfd;
	}

	p = text_copy(buff, "PORT ");
	p = text_replace_char2(ip, p, '.', ',');
	p += sprintf(p, ",%d,%d\r\n", port >> 8, port & 0xFF);

	rdlen = ftp_client_send_command(client, buff, p - buff, buff, sizeof(buff));
	if (rdlen < 0)
	{
		pr_red_info("ftp_client_send_command");
		return rdlen;
	}

	rdlen = ftp_client_send_command(client, "LIST\r\n", 0, buff, sizeof(buff));
	if (rdlen < 0)
	{
		pr_red_info("ftp_client_send_command");
		return rdlen;
	}

	data_sockfd = inet_accept(sockfd, &addr, &addrlen);
	if (data_sockfd < 0)
	{
		pr_red_info("inet_accept");
		ret = data_sockfd;
		goto out_close_sockfd;
	}

	while (1)
	{
		rdlen = inet_recv(data_sockfd, buff, sizeof(buff));
		if (rdlen < 0)
		{
			pr_red_info("inet_recv");
			ret = rdlen;
			goto out_close_data_link;
		}

		if (rdlen == 0)
		{
			pr_green_info("data receive complete");
			break;
		}

#if FTP_DEBUG
		print_ntext(buff, rdlen);
#endif
	}

	ret = 0;

out_close_data_link:
	shutdown(data_sockfd, SHUT_RDWR);
	inet_close_tcp_socket(data_sockfd);
out_close_sockfd:
	inet_close_tcp_socket(sockfd);

	return ret;
}
示例#6
0
文件: vfat.c 项目: Jack19881218/cavan
int main(int argc, char *argv[])
{
	int fd;
	int ret;
	char *content = NULL;
	struct cavan_vfat_fs fs;
	struct cavan_block_device bdev =
	{
		.block_shift = 0,
		.block_size = VFAT_APP_DEVICE_BLOCK_SIZE,
		.block_mask = 0,
		.read_block = vfat_app_device_read_block,
		.write_block = vfat_app_device_write_block,
		.read_byte = vfat_app_device_read_byte,
		.write_byte = vfat_app_device_write_byte
	};

	assert(argc > 1);

	fd = open(argv[1], O_RDONLY);
	if (fd < 0)
	{
		pr_error_info("open");
		return fd;
	}

	ret = cavan_block_device_init(&bdev, &fd);
	if (ret < 0)
	{
		pr_red_info("cavan_block_device_init");
		goto out_close_fd;
	}

	ret = cavan_vfat_init(&fs, &bdev);
	if (ret < 0)
	{
		pr_red_info("cavan_vfat_init");
		goto out_cavan_block_device_deinit;
	}

	if (argc > 2)
	{
		struct cavan_vfat_file *fp;

		fp = cavan_vfat_open_file(&fs, argv[2]);
		if (fp == NULL)
		{
			ret = -EFAULT;
			pr_red_info("cavan_vfat_open_file");
			goto out_cavan_vfat_deinit;
		}

		if (VFAT_IS_DIRECTORY(&fp->entry))
		{
			ret = cavan_vfat_list_dir(fp, vfat_app_device_list_dir_handler, fp);
			if (ret < 0)
			{
				pr_red_info("cavan_vfat_list_dir");
				goto out_cavan_vfat_deinit;
			}
		}
		else
		{
			ssize_t rdlen;

			if (argc > 3)
			{
				char path_buff[1024];
				const char *pathname;

				if (file_type_test(argv[3], S_IFDIR))
				{
					text_basename_base(text_path_cat(path_buff, sizeof(path_buff), argv[3], NULL), argv[2]);
					pathname = path_buff;
				}
				else
				{
					pathname = argv[3];
				}

				println("%s@%s => %s", argv[1], argv[2], pathname);

				rdlen = cavan_vfat_read_file3(fp, 0, pathname, O_TRUNC);
				if (rdlen < 0)
				{
					pr_red_info("cavan_vfat_read_file3");
					goto out_cavan_vfat_deinit;
				}
			}
			else
			{
				content = malloc(fp->entry.file_size);
				if (content == NULL)
				{
					pr_error_info("malloc");
					goto out_cavan_vfat_deinit;
				}

				rdlen = cavan_vfat_read_file(fp, 0, content, fp->entry.file_size);
				if (rdlen < 0)
				{
					pr_red_info("cavan_vfat_read_file");
					goto out_free_content;
				}

				print_ntext(content, rdlen);
				print_char('\n');
			}
		}

		cavan_vfat_close_file(fp);
	}
	else
	{
		char buff[32];
		ssize_t rdlen;

		println("type = %s", cavan_vfat_type_to_string(fs.type));

		rdlen = cavan_vfat_read_volume_label(&fs, buff, sizeof(buff) - 1);
		if (rdlen < 0)
		{
			pr_red_info("cavan_vfat_read_volume_label");
			goto out_cavan_vfat_deinit;
		}

		buff[rdlen] = 0;
		println("volume label = %s", buff);
	}

out_free_content:
	if (content)
	{
		free(content);
	}
out_cavan_vfat_deinit:
	cavan_vfat_deinit(&fs);
out_cavan_block_device_deinit:
	cavan_block_device_deinit(&bdev);
out_close_fd:
	close(fd);
	return ret;
}