LinuxC实现FTP云盘

已于 2023-07-24 09:24:37 修改
阅读量2.2k 收藏 44
点赞数 7
分类专栏： Linux 文章标签： linux 网络 c语言
于 2022-11-12 15:31:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54076783/article/details/127807745
版权

目录

基础知识

实现思路

服务器

客户端

实现功能

服务器功能

客户端功能

运行展示

服务器

客户端

完整代码 

服务器

客户端

相关调用函数

socket()：创建一个网络通信端点

atoi()：将字符串转变成整型数据

htons()：将16位无符号数从主机字节序转换成网络字节序

inet_aton()：将IP地址从字符串类型转换成网络字节序

inet_ntoa()：将IP地址从网络字节序转换成字符串类型

bind()：为套接字添加信息（协议族、IP地址、端口号）

listen()：监听客户端的连接

accept()：等待客户端的连接，当没有客户端连接时，accept()会阻塞等待

connect()：客户端连接服务器

fork()：创建一个子进程

open()：打开一个文件

read()：从某个文件中读取数据，没读到数据时会阻塞等待

write()：向某个文件写入数据

lseek()：移动文件的光标，通常用lseek(fd,0,SEEK_END)获取文件长度

close()，一般不用主动关闭文件，在进程终止时，内核自动关闭该进程打开的文件

strtok()：字符串分割函数

strcmp()：字符串比较函数

strstr()：字符串包含函数

strcat()：字符串拼接函数

strcpy()：字符串复制函数

memset()：将一块内存设定成指定的值

system()：执行某个命令，命令执行后继续从调用点执行程序

popen()：执行某个命令，并将执行命令后得到的数据存放到一个文件流中

fread()：从某个文件流中读取数据

fflush()：刷新缓冲区，将某个流未写的数据传送至内核

chdir()：修改当前的工作目录

access()：查看文件是否具有某个权限

代码分析

服务器

客户端

 

基础知识

FTP云盘使用C语言进行编写，在ubuntu环境下运行，相关知识有Linux进程，Linux网络编程、Linux文件编程、结构体、字符串等等。

实现思路

服务器

  1. 与客户端建立socket连接
  2. 读取客户端发送的命令
  3. 进行相关的命令识别和处理，将执行命令所获得的数据发送给客户端。

客户端

  1. 与服务器建立socket连接
  2. 获取用户输入的命令，进行相关的命令识别和处理
  3. 客户端会进行系统调用执行带l前缀命令，不带l前缀的命令将会发送给服务器
  4. 对服务器发送的数据进行处理

实现功能

服务器功能

  • 监听客户端的连接，允许多个客户端连接
  • 接收和区别不同客户端发来的命令，对相关命令进行处理

客户端功能

  • 输入命令“lls”查看客户端当前工作目录下的文件列表

  • 输入命令“lcd 路径名”修改当前工作目录，支持相对路径和绝对路径

  • 输入命令“lpwd”查看当前工作目录的绝对路径名

  • 输入命令“lquit”退出与服务器的连接

  • 输入命令“ls”查看服务器当前工作目录下的文件列表

  • 输入命令“cd”修改服务器当前工作目录，支持相对路径和绝对路径

  • 输入命令“pwd”查看服务器当前工作目录的绝对路径名

  • 输入命令“get 文件名”获取服务器服务器的当前目录下的文件

  • 输入命令“put 文件名”将文件存放到服务器的当前目录下

运行展示

由于我只有两台Linux虚拟机，所以用一台作为服务器，一台作为客户端，客户端那台开设多个终端连接服务器

服务器

9d5b4f5425fb4b22b57b95b8102d8d2d.png

客户端

  • ls命令
    f4be2b344ef940f9ac979ef8d9f7e5ab.png
  • cd命令和pwd命令
    741e4b0349d34a85891283abb99d2d9a.png
  • lls命令
    42e336d558e74a7ebf9509e5a76f1c9d.png
  • lcd命令和lpwd命令
    b01cf39a1be9487dbde2f5893acf4911.png
  • get命令
    749862404fc34e83a4eab800821ea16d.png
  • put命令
    60ae2457fafc47c18f3a5b649b62106f.png
  • lquit命令
    e24408467ce3480b9ddd0ac7b7ea4740.png

完整代码 

服务器

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <linux/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

#define LS 1
#define CD 2
#define PWD 3
#define PUT 5
#define GET 15

struct Msg 
{
	int type;
	char cmd[50];
	char data[5120];
};

int cmd_distinguish(char *cmd)
{
	int ret;
	cmd = strtok(cmd,"\n");
	if(!strcmp("ls",cmd)){
		ret = LS;
	}else if(strstr(cmd,"cd") != NULL){
		ret = CD;
	}else if(strstr(cmd,"get") != NULL){
		ret = GET;
	}else if(strstr(cmd,"put") != NULL){
		ret = PUT;
	}else if(!strcmp("pwd",cmd)){
		ret = PWD;
	}else{
		ret = 0;
	}
	return ret;
}


char *str_decompose(char *cmd)
{
	strtok(cmd," ");
	cmd = strtok(NULL," ");
	return cmd;
}

void cmd_handle(int ret,struct Msg msg,int a_fd)
{

	FILE *fp = NULL;
	int n_fread;
	char file_path[20] = "./";
	switch(ret){
		case PWD:
			fp = popen("pwd","r");
			memset(msg.data,0,sizeof(msg.data));
			n_fread = fread(msg.data,1,sizeof(msg.data),fp);
			msg.type = 0;
			write(a_fd,&msg,sizeof(msg));
			fflush(stdout);
			break;
		case LS:
			fp = popen("ls","r");
			memset(msg.data,0,sizeof(msg.data));
			n_fread = fread(msg.data,1,sizeof(msg.data),fp);
			msg.type = 0;
			write(a_fd,&msg,sizeof(msg));
			fflush(stdout);
			break;
		case CD:
			if(chdir(str_decompose(msg.cmd)) <0){
				perror("chdir");
			}
			break;
		case GET:
			strcat(file_path,str_decompose(msg.cmd));
			if(access(file_path,F_OK) < 0){
				perror("access");
				memset(msg.data,0,sizeof(msg.data));
				msg.type = 0;
				strcpy(msg.data,"Target file does not exist");
				write(a_fd,&msg,sizeof(msg));
			}else if(access(file_path,R_OK) < 0){
				memset(msg.data,0,sizeof(msg.data));
				msg.type = 0;
				strcpy(msg.data,"The target file does not have read permission");
				write(a_fd,&msg,sizeof(msg));
			}else{
				int file_fd = open(file_path,O_RDONLY,0600);
				if(file_fd < 0){
					perror("open");
				}
				int file_size = lseek(file_fd,0,SEEK_END);
				if(file_size < 0){
					perror("lseek");
				}
				lseek(file_fd,0,SEEK_SET);
				memset(msg.data,0,sizeof(msg.data));
				msg.type = GET;
				if(read(file_fd,msg.data,file_size) < 0){
					perror("read");
				}
				close(file_fd);
				write(a_fd,&msg,sizeof(msg));
			}
			break;
		case PUT:
			strcat(file_path,str_decompose(msg.cmd));
			int file_fd = open(file_path,O_RDWR|O_CREAT,0666);
			if(file_fd < 0){
				perror("open");
			}
			if(write(file_fd,msg.data,strlen(msg.data)) < 0){
				perror("write");
			}
			close(file_fd);
			break;
	}
}



int main(int argc,char *argv[])
{

	struct sockaddr_in so_addr;
	struct sockaddr_in cl_addr;

	if(argc != 3){
		printf("Insufficient or inconsistent parameters\n");
		exit(-1);
	}

	memset(&so_addr,0,sizeof(struct sockaddr_in));
	memset(&cl_addr,0,sizeof(struct sockaddr_in));

	int s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		printf("socket is failusr\n");
		perror("socket");
		exit(-1);
	}

	so_addr.sin_family = AF_INET;
	so_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&so_addr.sin_addr);

	int bd = bind(s_fd,(struct sockaddr *)&so_addr,sizeof(struct sockaddr_in));
	if(bd == -1){
		printf("bind is failusr\n");
		perror("bind");
		exit(-1);
	}

	int ln = listen(s_fd,10);
	if(ln == -1){
		printf("listen is failusr\n");
		perror("listen");
		exit(-1);
	}

	int a_fd;
	int mark = 0;
	int clean = sizeof(struct sockaddr_in);
	pid_t pid;
	while(1){
		a_fd = accept(s_fd,(struct sockaddr *)&cl_addr,&clean);
		if(a_fd == -1){
			printf("accept is failusr\n");
			perror("accept:");
			exit(-1);
		}
		mark++;
		printf("get No.%d connect: %s\n",mark,inet_ntoa(cl_addr.sin_addr));

		pid = fork();
		if(pid < 0){		
			perror("fork");
			exit(-1);
		}
		else if(pid == 0){
			char *fp = NULL;
			struct Msg msg;
			int ret = 0;
			int c_read;
			while(1){
				memset(msg.cmd,0,sizeof(msg.cmd));
				c_read = read(a_fd,&msg,sizeof(msg));
				if(c_read <= 0){
					perror("read");
					break;
				}else{
					printf("get size is %d's cmd from NO.%d client:%s\n",c_read,mark,msg.cmd);
					ret = cmd_distinguish(msg.cmd);
					cmd_handle(ret,msg,a_fd);

				}

			}
		}
		close(a_fd);
	}

	close(s_fd);
	return 0;
}

客户端

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>

struct Msg
{
	int type;
	char cmd[50];
	char data[5120];
};

#define LLS 1
#define LCD 2
#define LPWD 3
#define CD 4
#define LQUIT 7
#define PUT 8
#define CMD 9
#define QUIT 12
#define LS 13
#define PWD 14
#define GET 15


int cmd_distinguish(char *cmd)
{
	int ret;
	cmd = strtok(cmd,"\n");
	if(!strcmp("lls",cmd)){
		ret = LLS;
	}else if(strstr(cmd,"lcd") != NULL){
		ret = LCD;
	}else if(!strcmp("lpwd",cmd)){
		ret = LPWD;
	}else if(!strcmp("ls",cmd)){
		ret = LS;
	}else if(!strcmp("lquit",cmd)){
		ret = LQUIT;
	}else if(strstr(cmd,"cd") != NULL){
		ret = CD;
	}else if(strstr(cmd,"get") != NULL){
		ret = GET;
	}else if(strstr(cmd,"put") != NULL){
		ret = PUT;
	}else if(!strcmp("pwd",cmd)){
		ret = PWD;
	}else{
		ret = 0;
	}
	return ret;
}


char *str_decompose(char *cmd)
{
	strtok(cmd," ");
	cmd = strtok(NULL," ");
	return cmd;
}


int cmd_handle(int ret,struct Msg msg,int s_fd)
{

	FILE *fp = NULL;
	int n_fread;
	char file_path[20] = "./";
	char tmp_cmd[50];
	switch(ret){
		case LPWD:
			printf("--------------------------------------\n");
			printf("\n");
			system("pwd");
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			break;
		case LLS:
			printf("--------------------------------------\n");
			printf("\n");
			system("ls");
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			break;
		case LCD:
			if(chdir(str_decompose(msg.cmd)) < 0){
				perror("chdir");
			}                       
			printf("\n");
			break;
		case LQUIT:
			printf("--------------------------------------\n");
			printf("\n");
			printf("client is quit\n");
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			exit(0);
			break;
		case LS:	
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));
			break;
		case PWD:
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));
			break;
		case CD:
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));
			break;
		case GET:
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));
			break;
		case PUT:
			memset(tmp_cmd,0,sizeof(tmp_cmd));
			strcpy(tmp_cmd,msg.cmd);
			strcat(file_path,str_decompose(msg.cmd));
			memset(msg.cmd,0,sizeof(msg.cmd));
			strcpy(msg.cmd,tmp_cmd);
			if(access(file_path,F_OK) < 0){
				printf("--------------------------------------\n");
				printf("\n");
				printf("Target file does not exist\n");
				printf("\n");
				printf("--------------------------------------\n");
				printf("\n");

			}else if(access(file_path,R_OK) < 0){
				printf("--------------------------------------\n");
				printf("\n");
				printf("The target file does not have read permission\n");   	
				printf("\n");
				printf("--------------------------------------\n");
				printf("\n");
			}else{
				int pfile_fd = open(file_path,O_RDONLY,0666);
				if(pfile_fd < 0){
					perror("open");
				}
				int file_size = lseek(pfile_fd,0,SEEK_END);
				if(file_size < 0){
					perror("lseek");
				}
				lseek(pfile_fd,0,SEEK_SET);
				memset(msg.data,0,sizeof(msg.data));
				if(read(pfile_fd,msg.data,file_size) < 0){
					perror("read");
				}
				close(pfile_fd);
				write(s_fd,&msg,sizeof(msg));
				printf("--------------------------------------\n");
				printf("\n");
				printf("Target file is on server\n");   	
				printf("\n");
				printf("--------------------------------------\n");
				printf("\n");
			}
			break;
		default:
			printf("--------------------------------------\n");
			printf("\n");
			printf("Input error, please re-enter\n");   	
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			break;

	}
	return ret;
}

void from_sorket_data_handle(struct Msg msg,int s_fd)
{
	struct Msg sorket_msg;
	int n_read;
	int file_fd;
	char file_path[20] = "./";

	n_read = read(s_fd,&sorket_msg,sizeof(sorket_msg));
	if(n_read == -1){
		perror("read sorket");
		exit(-1);
	}else if(sorket_msg.type == GET){
		strcat(file_path,str_decompose(msg.cmd));
		file_fd = open(file_path,O_RDWR|O_CREAT,0666);
		write(file_fd,sorket_msg.data,strlen(sorket_msg.data));
		fflush(stdout);
		close(file_fd);
		printf("--------------------------------------\n");
		printf("\n");
		printf("%s\n","Get target file from server\n");
		printf("--------------------------------------\n");
		printf("\n");
	}else{
		printf("--------------------------------------\n");
		printf("\n");
		printf("%s\n",sorket_msg.data);
		printf("\n");
		printf("--------------------------------------\n");
		printf("\n");
	}

}

int main(int argc,char *argv[])
{
	struct sockaddr_in c_addr;
	memset(&c_addr,0,sizeof(struct sockaddr_in));

	int s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		printf("socket is failusr\n");
		perror("socket");
		exit(-1);
	}

	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);

	if(connect(s_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){
		perror("connect");
		exit(-1);
	}

	int n_read;
	struct Msg msg;
	int ret = 0;
	int mark = 0;
	int tmp = 0;
	while(1){
		memset(msg.cmd,0,sizeof(msg.cmd));
		memset(msg.data,0,sizeof(msg.data));

		fgets(msg.cmd,sizeof(msg.cmd),stdin);
		ret = cmd_distinguish(msg.cmd);
		tmp = cmd_handle(ret,msg,s_fd);
		if(tmp > CMD){
			from_sorket_data_handle(msg,s_fd);
		}

		fflush(stdout);

	}	
	close(s_fd);
	return 0;
}

相关调用函数

socket()：创建一个网络通信端点

原型：int socket(int domain, int type, int protocol);

返回值：调用成功返回套接字描述符，调用失败返回-1

参数：

  • int domain：选择协议族
    87f892ebefe6494ea2bb7c87d2ce5d87.jpeg
  • int type：选择套接字的类型
    768e96f458764bcab084aa74e44e4d09.jpeg
  • int protocol：选择协议，通常为0, 表示type参数对应的默认协议
    9df3584ce2974f568419560d1e52d4a9.jpeg

     

atoi()：将字符串转变成整型数据

原型：int atoi(const char *nptr);

返回值：返回转换之后得到的int型数据

参数：

  • const char *nptr：需要进行转换的字符串

     

htons()：将16位无符号数从主机字节序转换成网络字节序

原型：uint16_t htons(uint16_t hostshort);

返回值：转换之后的TCP/IP网络字节序

参数：

  • uint16_t hostshort：16位无符号整数

     

inet_aton()：将IP地址从字符串类型转换成网络字节序

原型：int inet_aton(const char *cp, struct in_addr *inp);

返回值：调用成功返回非0，调用失败返回0

参数：

  • const char *cp：字符串类型的IP地址
  • struct in_addr *inp：sockaddr_in类型结构体里的in_addr类型结构体地址
    723dce770db448e081b1078e93394e02.jpeg

     

inet_ntoa()：将IP地址从网络字节序转换成字符串类型

原型：char *inet_ntoa(struct in_addr in);

返回值：指向字符串类型IP地址的字符串指针

参数：

  • struct in_addr in：sockaddr_in类型结构体里的in_addr类型结构体
    723dce770db448e081b1078e93394e02.jpeg

     

bind()：为套接字添加信息（协议族、IP地址、端口号）

原型：int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

返回值：调用成功返回0，调用失败返回-1

参数：

  • int sockfd：套接字描述符
  • const struct sockaddr *addr：sockaddr类型结构体地址，在IPv4因特网域中，存储套接字信息用sockaddr_in类型结构体，因此在传入bind()参数时要对该结构体进行强制转换
    eaa86253906b4ad39ae3fae7a6b080d1.jpeg
  • socklen_t addrlen：参数二的内存空间大小 

     

listen()：监听客户端的连接

原型：int listen(int sockfd, int backlog);

返回值：调用成功返回0，调用失败返回-1

参数：

  • int sockfd：套接字描述符
  • int backlog：指定在请求队列中允许的最大连接数

     

accept()：等待客户端的连接，当没有客户端连接时，accept()会阻塞等待

原型：int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

返回值：调用成功返回0，调用失败返回-1

参数：

  • int sockfd：套接字描述符
  • const struct sockaddr *addr：sockaddr类型结构体地址
  • socklen_t *addrlen：参数二内存空间大小的值的地址
    650a069e49c84207a68c81e81b1d6383.jpeg 

     

connect()：客户端连接服务器

原型：int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

返回值：调用成功返回套接字描述符，调用失败返回-1

参数：

  • int sockfd：套接字描述符
  • const struct sockaddr *addr：sockaddr类型结构体地址，在IPv4因特网域中，存储套接字信息用sockaddr_in类型结构体，因此在传入bind()参数时要对该结构体进行强制转换
    eaa86253906b4ad39ae3fae7a6b080d1.jpeg
  • socklen_t *addrlen：参数二内存空间大小

     

fork()：创建一个子进程

原型：pid_t fork(void)

返回值：调用成功返回两次，0或非负整数，调用失败返回-1

  • 0：                                       子进程
  • 非负整数（子进程的pid）：父进程

     

open()：打开一个文件

原型：int open(const char *pathname, int flags, mode_t mode);

返回值：调用成功返回一个文件描述符，调用失败返回-1

参数：

  • const char *pathname：文件名（相对路径）
  • int flags：打开文件的方式及附带操作
    acd8a4d2fe7e4dfbb7089d6d90cb9007.png
  • mode_t mode：（可选参数）文件访问的权限

     

read()：从某个文件中读取数据，没读到数据时会阻塞等待

原型：int read(int fd, void *buf, size_t count);

返回值：读入成功时，返回读取的字节数（如果读文件开始前光标到达文件尾端则返回0）读入失败时，返回-1

参数：

  • fd：文件描述符
  • void *buf：读取的数据存放位置
  • size_t count：读取的字节数

     

write()：向某个文件写入数据

原型：int write(int fd, const void *buf, size_t count);

返回值：写入成功时，返回写入的字节数，写入数据为空返回0，写入失败返回-1

参数：

  • fd：文件描述符
  • void *buf：写入文件的数据
  • size_t count：写入文件的字节数

     

lseek()：移动文件的光标，通常用lseek(fd,0,SEEK_END)获取文件长度

原型：int lseek(int fd, off_t offset, int whence);

返回值：调用成功返回光标偏移字节，调用失败返回-1

参数：

  • fd：文件描述符
  • off_t offset：偏移字节，0为不偏移，-a为往前偏移a个字节，b为往前偏移b个字节
  • int whence：光标位置
    b22f30c5b379496a886f3be0fa4abee6.png 

     

close()，一般不用主动关闭文件，在进程终止时，内核自动关闭该进程打开的文件

原型：int close(int fd)

返回值：调用成功返回0，调用失败时返回-1

参数：

  • fd：文件描述符

     

strtok()：字符串分割函数

原型：char *strtok(char *str, const char *delim);

返回值：

  • 第一次传入字符串和分隔符时，返回分割的字符串
  • 第二次传入NULL和分隔符时，返回分隔的字符串
  • 直到最后一次传入NULL和空字符串时，返回最后一个分割的字符串
  • 其中第一次字符串被分割后，值和大小为第一次分割出来的字符串

参数：

  • char *str：字符串
  • const char *delim：分隔符

     

strcmp()：字符串比较函数

原型：int strcmp(const char *s1, const char *s2);

返回值：如果两个字符串相等返回0，两个字符串不相等返回其他值

参数：

  • const char *s1：字符串1
  • const char *s2：字符串2

     

strstr()：字符串包含函数

原型：char *strstr(const char *s1, const char *s2);

返回值：如果字符串s1包含字符串s2，返回包含字符及后面字符，如果字符串s1不包含字符串s2则返回NULL

参数：

  • const char *s1：字符串1
  • const char *s2：字符串2

     

strcat()：字符串拼接函数

原型：char *strcat(char *str1, const char *str2);

返回值：返回指向字符串2拼接到字符串1的字符串地址的指针

参数：

  • const char *s1：字符串1
  • const char *s2：字符串2

     

strcpy()：字符串复制函数

原型：char *strcpy(char *str1, const char *str2)

返回值：返回指向字符串2复制到字符串1尾端的字符串地址的指针

参数：

  • const char *s1：字符串1
  • const char *s2：字符串2

     

memset()：将一块内存设定成指定的值

原型：void *memset(void *s, int c, size_t n);

返回值：返回一个指向内存s的指针

参数：

  • void *s：内存块
  • int c：指定值
  • size_t n：要被设置该值的字符数

     

system()：执行某个命令，命令执行后继续从调用点执行程序

原型：int system(const char *command);

返回值：

  • 调用/bin/sh失败时返回127，其他失败原因返回-1
  • const char *command参数为NULL时返回非0值
  • 调用成功返回执行shell命令后的返回值

参数：

  • const char *command：命令

     

popen()：执行某个命令，并将执行命令后得到的数据存放到一个文件流中

原型：FILE *popen(const char *command, const char *type);

返回值：调用成功返回文件流，调用失败返回NULL

参数：

  • const char *command：命令
  • const char *type：返回的文件流权限，w：文件流可写，r： 文件流可读（与system等价）

     

fread()：从某个文件流中读取数据

原型：int fread(void *ptr, size_t size, size_t nmemb,FILE *stream);

返回值：读入成功时，返回读取的字节数，读入失败时，返回-1

参数：

  • const void *ptr：读取数据存放位置
  • size_t size：每次读的字节数
  • size_t nmemb：读的次数
  • FILE *stream：文件流

     

fflush()：刷新缓冲区，将某个流未写的数据传送至内核

原型：int fflush(FILE *stream);

返回值：调用成功返回0，调用失败返回EOF

参数：

  • FILE *stream：文件流
  • fflush(stdin)：刷新标准输入缓冲区，把输入缓冲区里的东西丢弃
  • fflush(stdout)：刷新标准输出缓冲区，把输出缓冲区里的东西强制打印到标准输出设备上

     

chdir()：修改当前的工作目录

原型：int chdir(const char *path);

返回值：调用成功返回0，调用失败返回-1

参数：

  • const char *path：新的当前工作目录，绝对路径或者相对路径

     

access()：查看文件是否具有某个权限

原型： int access(const char * pathname,int mode);

返回值：如果文件具有某种权限返回0，不具有某种权限返回-1

参数：

  • const char *pathname：文件名（相对路径）
  • int mode：权限
    df6597bab0d548149204da65ed183943.png

代码分析

  • 服务器和客户端建立socket连接在往期文章《Linux网络编程》
  • 由于使用结构体在网络中传输，因此，能够将命令和其他数据分开

服务器

主函数（建立socket连接），并读取客户端发送的命令

int main(int argc,char *argv[])
{
	//建立socket连接
	struct sockaddr_in so_addr;  
	struct sockaddr_in cl_addr;

	if(argc != 3){
		printf("Insufficient or inconsistent parameters\n");
		exit(-1);
	}

	memset(&so_addr,0,sizeof(struct sockaddr_in));
	memset(&cl_addr,0,sizeof(struct sockaddr_in));

	int s_fd = socket(AF_INET,SOCK_STREAM,0);  //创建套接字：IPV4因特网域，流式套接字、TCP传输协议
	if(s_fd == -1){
		printf("socket is failusr\n");
		perror("socket");
		exit(-1);
	}

	so_addr.sin_family = AF_INET;  //IPV4因特网域
	so_addr.sin_port = htons(atoi(argv[2]));  //将端口号转化成网络字节序
	inet_aton(argv[1],&so_addr.sin_addr);  //将IP地址转化为网络字节序

	int bd = bind(s_fd,(struct sockaddr *)&so_addr,sizeof(struct sockaddr_in));  //为套接字添加网络信息
	if(bd == -1){
		printf("bind is failusr\n");
		perror("bind");
		exit(-1);
	}

	int ln = listen(s_fd,10);  //监听客户端的连接
	if(ln == -1){
		printf("listen is failusr\n");
		perror("listen");
		exit(-1);
	}

	int a_fd;  //连接文件描述符
	int mark = 0;  //客户端数量标志
	int clean = sizeof(struct sockaddr_in);
	pid_t pid;
	while(1){
		a_fd = accept(s_fd,(struct sockaddr *)&cl_addr,&clean);  //等待客户端的连接
		if(a_fd == -1){
			printf("accept is failusr\n");
			perror("accept:");
			exit(-1);
		}
		mark++;  //客户端标志+1
		printf("get No.%d connect: %s\n",mark,inet_ntoa(cl_addr.sin_addr));

		pid = fork();  //当有客户端连接时，创造一个子进程去读取客户端发送的命令
			perror("fork");
			exit(-1);
		if(pid < 0){
            perror("fork");
            exit(-1);
        }else if(pid == 0){
			char *fp = NULL;
			struct Msg msg;
			int ret = 0;
			int c_read;
			while(1){
				memset(msg.cmd,0,sizeof(msg.cmd));
				c_read = read(a_fd,&msg,sizeof(msg));  //读取客户端发送的命令
				if(c_read <= 0){
					perror("read");
					break;
				}else{
					printf("get size is %d  cmd from NO.%d client:%s\n",c_read,mark,msg.cmd);
					ret = cmd_distinguish(msg.cmd);  //对客户端传送的命令进行识别
					cmd_handle(ret,msg,a_fd);  //对相关命令进行处理

				}

			}
		}
		close(a_fd);
	}

	close(s_fd);
	return 0;
}

命令识别

int cmd_distinguish(char *cmd)
{
        cmd = strtok(cmd,"\n");  //由于客户端获取用户输入时，会使用enter键，因此传输到服务器的命令都带有换行符
        if(!strcmp("ls",cmd)) return LS;
        if(strstr(cmd,"cd") != NULL) return CD;
        if(strstr(cmd,"get") != NULL) return GET;
        if(strstr(cmd,"put") != NULL) return PUT;
        if(!strcmp("pwd",cmd)) return PWD;
}

 命令分割

char *str_decompose(char *cmd)  //将带有文件名、路径名的命令进行处理分割
{								//如命令“get 1.c”，该函数就会返回1.c
	strtok(cmd," ");
	cmd = strtok(NULL," ");
	return cmd;
}

命令处理

void cmd_handle(int ret,struct Msg msg,int a_fd)
{
	FILE *fp = NULL;
	int n_fread;
	char file_path[20] = "./";  //当前路径
	switch(ret){
		case PWD:
			fp = popen("pwd","r");  //调用终端执行pwd命令，并将数据存放到fp文件流中
			memset(msg.data,0,sizeof(msg.data)); 
			n_fread = fread(msg.data,1,sizeof(msg.data),fp);  //读取文件流的数据
			msg.type = 0;
			write(a_fd,&msg,sizeof(msg));  //向客户端发送数据
			fflush(stdout);  //刷新标准输出缓冲区，把输出缓冲区里的东西强制打印到标准输出设备上
			break;
		case LS:
			fp = popen("ls","r");
			memset(msg.data,0,sizeof(msg.data));
			n_fread = fread(msg.data,1,sizeof(msg.data),fp);
			msg.type = 0;
			write(a_fd,&msg,sizeof(msg));
			fflush(stdout);
			break;
		case CD:
			if(chdir(str_decompose(msg.cmd)) <0){  //修改当前工作目录
				perror("chdir");
			}
			break;
		case GET:
			strcat(file_path,str_decompose(msg.cmd));
			if(access(file_path,F_OK) < 0){  //判断服务器是否拥有客户端想要获取的文件
				memset(msg.data,0,sizeof(msg.data));
				msg.type = 0;
				strcpy(msg.data,"Target file does not exist");
				write(a_fd,&msg,sizeof(msg));
			}else if(access(file_path,R_OK) < 0){  //判断服务器是否对该文件有读权限
				memset(msg.data,0,sizeof(msg.data));
				msg.type = 0;
				strcpy(msg.data,"The target file does not have read permission");
				write(a_fd,&msg,sizeof(msg));
			}else{  //获取该文件的内容，发送给客户端
				int file_fd = open(file_path,O_RDONLY,0600);
				if(file_fd < 0){
					perror("open");
				}
				int file_size = lseek(file_fd,0,SEEK_END);
				if(file_size < 0){
					perror("lseek");
				}
				lseek(file_fd,0,SEEK_SET);
				memset(msg.data,0,sizeof(msg.data));
				msg.type = GET;
				if(read(file_fd,msg.data,file_size) < 0){
					perror("read");
				}
				close(file_fd);
				write(a_fd,&msg,sizeof(msg));
			}
			break;
		case PUT:  //创建一个文件，写入客户端想要存放的文件的数据
			strcat(file_path,str_decompose(msg.cmd));
			int file_fd = open(file_path,O_RDWR|O_CREAT,0666);
			if(file_fd < 0){
				perror("open");
			}
			if(write(file_fd,msg.data,strlen(msg.data)) < 0){
				perror("write");
			}
			close(file_fd);
			break;
	}
}

客户端

主函数（建立socket连接），获取用户输入的命令

int main(int argc,char *argv[])
{
	//建立socket连接
	struct sockaddr_in c_addr;
	memset(&c_addr,0,sizeof(struct sockaddr_in));

	int s_fd = socket(AF_INET,SOCK_STREAM,0);  //创建套接字：IPV4因特网域，流式套接字、TCP传输协议
	if(s_fd == -1){
		printf("socket is failusr\n");
		perror("socket");
		exit(-1);
	}

	c_addr.sin_family = AF_INET;  //IPV4因特网域
	c_addr.sin_port = htons(atoi(argv[2]));  //将端口号转化成网络字节序
	inet_aton(argv[1],&c_addr.sin_addr);  //将IP地址转化为网络字节序

	if(connect(s_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){  //客户端连接服务器
		perror("connect");
		exit(-1);
	}

	int n_read;
	struct Msg msg;
	int ret = 0;
	int mark = 0;
	int tmp = 0;
	while(1){
		memset(msg.cmd,0,sizeof(msg.cmd));
		memset(msg.data,0,sizeof(msg.data));

		fgets(msg.cmd,sizeof(msg.cmd),stdin);  //获取用户输入的命令
		ret = cmd_distinguish(msg.cmd);  //对用户键入的命令进行识别
		tmp = cmd_handle(ret,msg,s_fd);  //对命令进行处理
		if(tmp > CMD){  
			from_sorket_data_handle(msg,s_fd);  //对服务器传送的数据进行处理
		}

		fflush(stdout);

	}	
	close(s_fd);
	return 0;
}

 命令识别

//命令识别
int cmd_distinguish(char *cmd)
{
	int ret;
	cmd = strtok(cmd,"\n");  由于客户端获取用户输入时，会使用enter键
	if(!strcmp("lls",cmd)){
		ret = LLS;
	}else if(strstr(cmd,"lcd") != NULL){
		ret = LCD;
	}else if(!strcmp("lpwd",cmd)){
		ret = LPWD;
	}else if(!strcmp("ls",cmd)){
		ret = LS;
	}else if(!strcmp("lquit",cmd)){
		ret = LQUIT;
	}else if(strstr(cmd,"cd") != NULL){
		ret = CD;
	}else if(strstr(cmd,"get") != NULL){
		ret = GET;
	}else if(strstr(cmd,"put") != NULL){
		ret = PUT;
	}else if(!strcmp("pwd",cmd)){
		ret = PWD;
	}else{
		ret = 0;
	}
	return ret;
}

 命令分割

//命令分割
char *str_decompose(char *cmd)  //将带有文件名、路径名的命令进行处理分割
{								//如命令“put 1.c”，该函数就会返回1.c
	strtok(cmd," ");
	cmd = strtok(NULL," ");
	return cmd;
}

命令处理 

//命令处理 
int cmd_handle(int ret,struct Msg msg,int s_fd)
{

	FILE *fp = NULL;
	int n_fread;
	char file_path[20] = "./";
	char tmp_cmd[50];
	switch(ret){
		case LPWD:
			printf("--------------------------------------\n");
			printf("\n");
			system("pwd");  //调用终端执行pwd命令，并将数据输出到标准输出上
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			break;
		case LLS:
			printf("--------------------------------------\n");
			printf("\n");
			system("ls");  //调用终端执行ls命令，并将数据输出到标准输出上
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			break;
		case LCD:
			if(chdir(str_decompose(msg.cmd)) < 0){  //修改当前工作目录
				perror("chdir");
			}                       
			printf("\n");
			break;
		case LQUIT:
			printf("--------------------------------------\n");
			printf("\n");
			printf("client is quit\n");
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			exit(0);  //退出当前进程
			break;
		case LS:	
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));  //将用户输入发送给服务器，让服务器根据命令进行相应的行为
			break;
		case PWD:
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));  //将用户输入发送给服务器，让服务器根据命令进行相应的行为
			break;
		case CD:
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));  //将用户输入发送给服务器，让服务器根据命令进行相应的行为
			break;
		case GET:
			msg.type = 0;	
			write(s_fd,&msg,sizeof(msg));  //将用户输入发送给服务器，让服务器根据命令进行相应的行为
			break;
		case PUT:
			memset(tmp_cmd,0,sizeof(tmp_cmd)); 
			strcpy(tmp_cmd,msg.cmd);  //put 1.c ->tmp.cmd
			strcat(file_path,str_decompose(msg.cmd));  // ./1.c->file_path
			memset(msg.cmd,0,sizeof(msg.cmd));
			strcpy(msg.cmd,tmp_cmd);  //put 1.c -> msg.cmd
			if(access(file_path,F_OK) < 0){  //判断客户端是否拥有想要存放到服务器的文件
				printf("--------------------------------------\n");
				printf("\n");
				printf("Target file does not exist\n");
				printf("\n");
				printf("--------------------------------------\n");
				printf("\n");

			}else if(access(file_path,R_OK) < 0){  //判断客户端是否对该文件有读权限
				printf("--------------------------------------\n");
				printf("\n");
				printf("The target file does not have read permission\n");   	
				printf("\n");
				printf("--------------------------------------\n");
				printf("\n");
			}else{  //获取该文件的内容，发送给服务器
				int pfile_fd = open(file_path,O_RDONLY,0666);
				if(pfile_fd < 0){
					perror("open");
				}
				int file_size = lseek(pfile_fd,0,SEEK_END);
				if(file_size < 0){
					perror("lseek");
				}
				lseek(pfile_fd,0,SEEK_SET);
				memset(msg.data,0,sizeof(msg.data));
				if(read(pfile_fd,msg.data,file_size) < 0){
					perror("read");
				}
				close(pfile_fd);
				write(s_fd,&msg,sizeof(msg));
				printf("--------------------------------------\n");
				printf("\n");
				printf("Target file is on server\n");   	
				printf("\n");
				printf("--------------------------------------\n");
				printf("\n");
			}
			break;
		default:
			printf("--------------------------------------\n");
			printf("\n");
			printf("Input error, please re-enter\n");   	
			printf("\n");
			printf("--------------------------------------\n");
			printf("\n");
			break;

	}
	return ret;
}

对服务器发送的数据进行处理

//对服务器发送的数据进行处理
void from_sorket_data_handle(struct Msg msg,int s_fd)
{
	struct Msg sorket_msg;
	int n_read;
	int file_fd;
	char file_path[20] = "./";
	n_read = read(s_fd,&sorket_msg,sizeof(sorket_msg));
	if(n_read == -1){
		perror("read sorket");
		exit(-1);
	}else if(sorket_msg.type == GET){  //如果是GET指令返回的数据，就存进文件中
		strcat(file_path,str_decompose(msg.cmd));  // ./1.c -> file_path
		file_fd = open(file_path,O_RDWR|O_CREAT,0666);
		write(file_fd,sorket_msg.data,strlen(sorket_msg.data));
		fflush(stdout);
		close(file_fd);
		printf("--------------------------------------\n");
		printf("\n");
		printf("%s\n","Get target file from server\n");
		printf("--------------------------------------\n");
		printf("\n");
	}else{  //如果是其他数据就直接打印出来
		printf("--------------------------------------\n");
		printf("\n");
		printf("%s\n",sorket_msg.data);
		printf("\n");
		printf("--------------------------------------\n");
		printf("\n");
	}

}

 

工厂模式---FTP云盘项目
weixin_61921209的博客
11-12 152
一.云盘概述二.命令介绍（1）服务器命令介绍（2）客户端命令介绍三.FTP框架（1）服务端命令工厂操作函数主函数socket函数（2）客户端命令工厂操作函数主函数socket函数四.函数的解释一.云盘概述FTP服务器(File Transfer ProtocolServer)是在互联网上提供文件存储和访问服务的计算机，它们依照FTP协议提供服务。FTP是File Transfer Protoco(文件传输协议)。
简单实现基于Linux的FTP网络云盘项目
qiao代码的木偶人的博客
11-20 976
1.服务端代码实现 #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #include <netinet/in.h> #include "config.h" #incl
ftp服务器的简单实现（二）——客户端
weixin_30621711的博客
06-30 173
客户端： #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <stdio.h> #include <unistd.h> #include <string.h...
LINUX上用C语言实现FTP客户端与服务器
12-08
在linux系统中用c语言实现ftp客户端与服务器，功能全面，并附有详细文档。
Linux C语言开发FTP服务器程序实战指南
最新发布
weixin_42509888的博客
09-09 1214
本文还有配套的精品资源，点击获取 简介：本项目着重于使用Linux C语言实现一个FTP服务器程序，涉及操作系统底层、网络通信和并发处理。该程序遵循FTP协议，包括控制通道和数据通道的建立，文件传输，以及断点续传。同时，需处理多线程并发请求，并考虑安全性，支持SSL/TLS加密。该程序可作为深入理解网络编程和提高C语言技能的实践项目。 1. FTP协议原理与工作方...
linux c 实现ftp客户端,linux C  ftp客户端
weixin_42525106的博客
05-06 426
#include #include #include #include #include #include #include #include #include #include #include #define PORT 21//#define ILLIGEL -1#define OPEN 0#define GET 1#define PUT 2#define PWD 3#define DIR 4...
linux C 实现简易 ftp（内含客户端及服务端代码及个人理解）
HermanIu的博客
10-30 1090
Llinux网络及系统文件编程暂时告一段落，这个课其实9月底就学完了，期间因为工作缘故加上个人惰性，迟迟没有学习，今天好不容易抽出时间整理了一下这个小demo，算是监督一下自己吧。有看到这部分的朋友，存在疑惑的点可以相互交流。
Linux下C语言实现的FTP系统
03-11
一个在Linux系统下以C语言实现的FTP服务系统，包括服务器和客户端，以Makefile编译，功能有基本的FTP服务功能，创建删除下载上传等，有些地方还有待完善。
Linux——FTP云盘
m0_49830036的博客
10-07 498
server端一直在accept，等待客户端连接，有客户端接入就创建子进程对接处理指令。分为三个文件：server.c 、client.c、config.h。
Linux网络编程--FTP云盘项目
lijianhua003的博客
08-12 500
FTP就是文件传输协议。用于互联网双向传输，控制文件下载空间在服务器复制文件从本地计算机或本地上传文件复制到服务器上的空间。
Linux 通过socket实现服务器和客户端的之间的相互操作，也叫ftp（云盘项目）
asd25415129591的博客
07-08 627
ftp，C语言
Linux C 实现简单FTP
11-22
Linux C语言 实现简单FTP服务器与客户端
LINUX下C语言编写的FTP服务器
12-26
本人这一阶段的实践项目。在LINUX下运行的FTP服务器程序，涉及linux编程，网络编程，进程间通信，多线程、多进程编程等知识点。
linux c下的ftp客户端和服务器端
04-26
linux c下的ftp客户端和服务器端，比较标准的一个例子，实现了ftp的基本所有功能，十分具有学习价值。
Linux下C/C++模拟云盘项目的实现方法
资源摘要信息: "Linux下C、C++模拟实现云盘项目" Linux操作系统自诞生以来，以其开源、稳定和高效的特点深受开发者的喜爱，尤其是在服务器领域占据着重要的地位。在Linux环境下使用C和C++语言开发软件，可以充分...
FTP云盘
zhuguanlin121的博客
08-21 4828
项目简介 FTP服务器（File Transfer Protocol Server）是在互联网上提供文件存储和访问服务的计算机，它们依照FTP协议提供服务。 FTP是File Transfer Protocol(文件传输协议)。 程序运行，服务端不断接收客户端指令，服务端可同时处理多个客户端接入并对指令作出解析，并把执行结果返回给客户端，客户端根据服务端对指令的解析并把由服务端传递过来的处理信息通过客户端呈现给客户，实现文件的各种操作。 功能说明 本文是基于Linux网络编程实现的FTP服务器，服务器由
Linux系统编程，使用C语言实现简单的FTP（服务器/客户端）
m0_72442663的博客
03-23 3412
Linxu 网络编程 实现简单的FTP
linux网络——ftp云盘
小伟的博客
01-06 726
目录1、功能1.1服务端1.2客户端2、相关API2.1初始化变量memset2.2判断文件是否存在access2.3执行系统命令popen3、实现思路4、代码展示 1、功能 1.1服务端 1.接收客户端指令，实现如下的操作： ls，rm，cd，pwd 上传和下载文件操作（get，put） 断开连接quit 1.2客户端 1.给服务器发送指令，实现相关操作 ls，rm，cd，pwd，get，put 2.客户端自身指令 lls，lrm，lcd，lpwd 3.退出程序指令quit 2、相关API 2.1初始化变
linux FTP云盘
weixin_59349642的博客
06-01 555
牛逼
linux的ftp云盘
08-19
Linux的FTP云盘是一个基于Linux平台的项目，主要包括客户端和服务端两部分。客户端通过网络IP地址和端口号连接到服务端，并可以远程获取服务端磁盘上的文件夹内容。这个项目类似于Linux开源的FTP服务器，客户端可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值