• 基于Linux并结合socket网络编程的ftp服务器的实现

    项目需求

    • 客户端能够通过调用“get”指令，来获取服务器的文件
    • 客户端能通过“server_ls”指令，来获取服务器路径下的文件列表
    • 客户端能通过“server_cd”指令，进入服务器路径下的某文件夹
    • 客户端可以通过“upload”指令，上传自己的本地文件到服务器
    • 客户端可以通过“client_ls”指令，来查看本地路径下的文件列表
    • 客户端可以通过“client_cd”指令，进入本地路径下的某文件夹

    预备知识

    1. char s1={'A','B','C'};
    2. sprintf(str,"aaa %.*s",2,s1); //取字符串s1的前2个字符并和“aaa ”拼接
    3. 执行完后str字符串为“aaa AB”
    size = lseek(fd_file, 0L, SEEK_END);

    实现思路

    “get”指令实现思路：

    对于客户端：

    检测用户是否输入了“get”，若输入之后，就让服务器发送文件过来，并自己创建一个同名文件写入服务器发来的数据

    对于服务端：

    检测客户端是否发来了“get”，如果是，就检测服务器要哪个文件，并将文件的内容全部读取然后发给客户端

    “server_ls”指令实现思路：

    对于客户端：

    啥也不用干，输入指令后等着接受

    对于服务端：

    检测客户端是否发来了“server_ls”，如果是，就popen执行“ls -l”并读取运行结果，将结果发给客户端

    “server_cd”指令实现思路：

    对于客户端：

    啥也不用干，输入指令后等着接受

    对于服务端：

    测客户端是否发来了“server_cd”，如果是，就检测后面cd的地址，然后调用chdir函数执行这个地址，然后popen执行“pwd”并读取运行结果，将结果发给客户端

    “upload”指令实现思路：

    对于客户端：

    检测用户是否输入了“upload”，若输入之后，就检测用户要上传哪个文件，将文件内容全部复制并发送给服务器

    对于服务端：

    检测客户端是否发来了“upload”，如果是，就检测用户上传的文件名并接受所有文件数据，然后创建一个同名的文件将数据全部写进去

    “client_ls”指令实现思路：

    对于客户端：

    检测用户是否输入了“clien_ls”，若输入之后，就调用system函数执行“ls -l”

    对于服务端：

    啥也不用干

    “client_cd”指令实现思路：

    对于客户端：

    检测用户是否输入了“clien_cd”，若输入之后，就检测cd之后的地址，然后调用chdir函数执行这个地址，然后调用system函数执行“pwd”

    对于服务端：

    啥也不用干

    具体代码

     注意，为了接收到带空格的字符串，我使用了fgets函数，但是fgets函数在长度足够的情况下，会将换行符“\n”也读进字符串，所以strlen也会多计算一位，所以服务器使用fgets得到字符串并发送给客户端，客户端接受之后打印就不需要再换行了；反之亦然，服务器的接收端再接受之后也不需要再加换行符了！

    切记切记切记！！以下的写法是完全错误的！！！

    1. char *file_name;
    2. char *readbuf = "tyytt";
    3.  
    4. file_name = readbuf; //错错错错错错错错

    原因: 字符串常量本质是一个指针，而变量名相当于首地址，这句话相当于地址的赋值！！所以只要写了这句代码，不管readbuf的值变成了什么样，file_name就会跟着变成什么样，所以字符串的赋值一定要用strcpy！！血与泪的教训，自查了好久...

    而使用strcpy则要注意，第一个参数不能是字符串常量！而需要是字符串变量！！

    • 同时，在代码逻辑中，服务端对于flag_upload的置位和对其的判断都在子进程中，所以可以直接用if判断，但是对于客户端，flag_get的置位在负责写的父进程，对flag_get的判断却在负责读的子进程，正如一直强调的，fork之后的存储空间是独立的，所以父进程将flag置位子进程并不知道，所以不能简单的使用flag_get，需要使用进程间的通信来解决！
    • 同样，file_name在服务端可以直接修改，但是客户端也需要使用进程间通信！

    在子进程两个while中使用进程间通信就会涉及到上节出现的问题，即负责发数据的父进程写入fifo后，负责接数据的子进程还在阻塞等待服务器的消息，程序无法运行到检测fifo的代码处，解决方法就是让服务器立刻回复一个数据，对于file_name的传输，服务器正好要回复file_name；对于是否要跳转到get_handler，服务器正好要发送文件的内容。所以在这个代码逻辑中，不需要额外再设置服务器回复，如果在日后遇到了同样的情况，服务器又不需要回复什么，那么记得要随便写一条内容来回复。

    server.c：

    1. #include      
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. int flag_upload = 0;
    16. int flag_exist = 0;
    17. char *file_name=NULL;
    18.  
    19. int cmd_handler(int fd, char readbuf[10000])
    20. {
    21. 	int fd_file; 判断为get命令后，用来存放即将发送的文件的文件标识符
    22. 	int size; //判断为get命令后，用来存放即将发送的文件的大小
    23. 	char *file_buf = NULL; //判断为get命令后，用来存放即将发送的文件的内容
    24. 	int ret;
    25. 	int i = 0;
    26. 	char result[4096] = {0}; //用来存放popen执行指令的结果
    27. 	FILE *fp; //popen返回的文件流标识符
    28. 	char str[10000]; //将读到的数据备份在这里
    29. 	char* stat[5] ={NULL,NULL,NULL,NULL,NULL}; //用来存放拆分后的字符串
    30. 	char cmd[128]; //用来存放加工后的字符串，比如去除“\n”，比如再加上“./”
    31.  
    32. 	strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
    33.  
    34. 	char* ptr = strtok(str, " "); //通过空格符号分隔字符串
    35. 	for(; ptr != NULL; )
    36. 	{
    37. 		stat[i] = ptr;
    38. 		//printf("%s\n", stat[i]);
    39. 		i++;
    40. 		ptr = strtok(NULL, " ");
    41. 	}
    42.  
    43. 	if(strcmp(stat[0],"get")==0){ //如果是get命令
    44. 		sprintf(cmd, "find . -name %.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    45. 		fp = popen(cmd,"r"); //运行指令查看文件是否存在
    46. 		fread(&result, sizeof(char), sizeof(result), fp);
    47. 		pclose(fp);
    48. 		if(strlen(result)==0){
    49. 			ret = write(fd,"file not exist\n",20); //不存在就发送给客户端来通知
    50. 			if(ret == -1){
    51. 				perror("write");
    52. 				return 1;
    53. 			}
    54.  
    55. 			return 1;
    56. 		}else{
    57. 			sprintf(cmd, "./%.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    58. 			ret = write(fd,cmd,strlen(cmd)); //如果存在，就先将文件名传给客户端
    59. 			if(ret == -1){
    60. 				perror("write");
    61. 				return 1;
    62. 			}
    63. 		}
    64. 		memset(&result,0,sizeof(result));
    65.  
    66. 		//sleep(2);
    67.  
    68. 		sprintf(cmd, "./%.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    69. 		fd_file = open(cmd,O_RDWR); //然后打开这个文件，将内容全部复制
    70. 		size = lseek(fd_file, 0L, SEEK_END);
    71. 		printf("file size = %d\n",size);
    72. 		file_buf = (char *)malloc(sizeof(char)*size + 1);
    73. 		lseek(fd_file, 0, SEEK_SET);
    74. 		ret = read(fd_file,file_buf,size);
    75. 		if(ret == -1){
    76. 			perror("read2");
    77. 			return 1;
    78. 		}
    79. 		close(fd_file);
    80. 		ret = write(fd,file_buf,size); //将文件的内容发送给客户端
    81. 		if(ret == -1){
    82. 			perror("write");
    83. 			return 1;
    84. 		}
    85.  
    86. 	}else if(strcmp(stat[0],"server_cd")==0){ //如果是server_cd命令
    87. 		sprintf(cmd, "%.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    88. 		chdir(cmd); //将目录cd到客户端要求的位置
    89. 		fp = popen("pwd","r"); //然后执行pwd，将结果发回给客户端
    90. 		fread(&result, sizeof(char), 1024, fp);
    91. 		pclose(fp);
    92. 		ret = write(fd,&result,strlen(result));
    93. 		if(ret == -1){
    94. 			perror("write");
    95. 			return 1;
    96. 		}
    97.  
    98. 		memset(&result,0,sizeof(result));
    99.  
    100. 	}else if(strcmp(stat[0],"upload")==0){ //如果是upload命令
    101. 		flag_upload = 1; //表示准备upload
    102. 		sprintf(cmd, "./%.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    103. 		file_name = cmd; //接收客户端发来的，即将发送过来的文件名
    104. 	}else if(strcmp(stat[0],"exist")==0){
    105. 		flag_exist = 1;  //和准备upload的标识符配合使用，只有客户端判断用户输入的upload文件存在时，才会发送exist，此时服务端将文件存在的标识符也置1
    106. 	}else if(strcmp(stat[0],"server_ls\n")==0){ //如果是server_ls命令
    107. 		fp = popen("ls -l","r"); //执行ls-l命令，然后把结果发回客户端
    108. 		fread(&result, sizeof(char), 1024, fp);
    109. 		pclose(fp);
    110. 		ret = write(fd,&result,strlen(result));
    111. 		if(ret == -1){
    112. 			perror("write");
    113. 			return 1;
    114. 		}
    115.  
    116. 		memset(&result,0,sizeof(result));
    117. 	}else if(strcmp(stat[0],"quit\n")==0){ //如果客户端打出了quit
    118. 		ret = write(fd,"Bye\n",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
    119. 		if(ret == -1){
    120. 			perror("write");
    121. 			return 1;
    122. 		}
    123. 	}
    124.  
    125.  
    126. 	return 0;
    127. }
    128.  
    129. void upload_handler(char readbuf[10000]) //upload指令如果被最终判断为可以执行，则会调用这个函数来通过客户端发来的文件名和文件内容来创建文件
    130. {
    131. 	int fd_file;
    132. 	int n_write;
    133. 	fd_file = open(file_name,O_RDWR|O_CREAT|O_TRUNC,S_IRWXU);
    134. 	n_write = write(fd_file, (char *)readbuf, strlen((char *)readbuf));
    135. 	printf("create new file %s, %d bytes have been written\n",file_name, n_write);
    136.  
    137. 	close(fd_file);
    138.  
    139. }
    140.  
    141. int main(int argc, char **argv) //main函数
    142. {
    143. 	int conn_num = 0;
    144. 	int flag = 0;
    145. 	int sockfd;
    146. 	int conn_sockfd;
    147. 	int ret;
    148. 	int n_read;
    149. 	int n_write;
    150. 	int len = sizeof(struct sockaddr_in);
    151. 	char readbuf[10000];
    152. 	char msg[10000];
    153.  
    154.  
    155. 	pid_t fork_return;
    156. 	pid_t fork_return_1;
    157.  
    158. 	struct sockaddr_in my_addr;
    159. 	struct sockaddr_in client_addr;
    160. 	memset(&my_addr,0,sizeof(struct sockaddr_in));
    161. 	memset(&client_addr,0,sizeof(struct sockaddr_in));
    162.  
    163. 	if(argc != 3){
    164. 		printf("param error!\n");
    165. 		return 1;
    166. 	}
    167.  
    168. 	//socket
    169. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    170. 	if(sockfd == -1){
    171. 		perror("socket");
    172. 		return 1;
    173. 	}else{
    174. 		printf("socket success, sockfd = %d\n",sockfd);
    175. 	}
    176.  
    177. 	//bind
    178. 	my_addr.sin_family = AF_INET;
    179. 	my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    180. 	inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format
    181.  
    182. 	ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
    183. 	if(ret == -1){
    184. 		perror("bind");
    185. 		return 1;
    186. 	}else{
    187. 		printf("bind success\n");
    188. 	}
    189.  
    190. 	//listen
    191. 	ret = listen(sockfd,10);
    192. 	if(ret == -1){
    193. 		perror("listen");
    194. 		return 1;
    195. 	}else{
    196. 		printf("listening...\n");
    197. 	}
    198.  
    199. 	while(1){
    200. 		//accept
    201. 		conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
    202. 		if(conn_sockfd == -1){
    203. 			perror("accept");
    204. 			return 1;
    205. 		}else{
    206. 			printf("accept success, client IP = %s\n",inet_ntoa(client_addr.sin_addr));
    207.  
    208. 		}
    209.  
    210. 		fork_return = fork();
    211.  
    212. 		if(fork_return > 0){//father keeps waiting for new request
    213. 			//do nothing	
    214. 		}else if(fork_return < 0){
    215. 			perror("fork");
    216. 			return 1;
    217. 		}else{//son deals with request
    218. 			while(1){
    219. 				//read
    220. 				memset(&readbuf,0,sizeof(readbuf));
    221. 				ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
    222. 				if(ret == 0){ //如果recv函数返回0表示连接已经断开
    223. 					printf("client has quit\n");
    224. 					close(conn_sockfd);
    225. 					break;
    226. 				}else if(ret == -1){
    227. 					perror("recv");
    228. 					return 1;
    229. 				}
    230.  
    231. 				if(flag_upload == 1 && flag_exist == 1){ //当准备upload的标识位和文件存在的标识位同时置1时，才会进入这段代码
    232. 					flag_exist = 0; //立刻将两个标识位重新置0
    233. 					flag_upload = 0;
    234. 					upload_handler(readbuf); //并执行upload所对应的函数
    235. 				}
    236.  
    237. 				cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
    238.  
    239. 				//printf("\nclient: %s",readbuf); //dont need to add"\n"
    240.  
    241.  
    242. 			}
    243. 			exit(2);
    244. 		}
    245.  
    246. 	}
    247.  
    248.  
    249. 	return 0;
    250. }

    client.c：

    1. #include      
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. int flag_quit = 0;
    16.  
    17. int cmd_handler(int fd,char msg[10000]) 
    18. {
    19. 	int fd_file; //如果判断为upload,则用来存放即将发送的文件的标识符
    20. 	int size; //如果判断为upload,则用来存放即将发送的文件的大小
    21. 	int fd_fifo; //用来存放fifo的标识符
    22. 	char *fifo_msg = "quit";
    23. 	char *fifo_msg_get = "get";
    24. 	char *file_buf = NULL; //如果判断为upload,则用来存放即将发送的文件的内容
    25. 	char result[4096] = {0}; //用来存放popen函数调用指令后的结果
    26. 	FILE *fp; //用来存放popen返回的标识符
    27. 	int ret;
    28. 	int i = 0;
    29. 	char str[10000]; //用来存放客户端读取数据的备份，方便进行数据操作
    30. 	char* stat[5] ={NULL,NULL,NULL,NULL,NULL}; //用来存放分隔后的字符串
    31. 	char cmd[128]; //用来存放进行加工后的字符串
    32.  
    33. 	strcpy(str,msg); //so split will not affect original data，原因详见server.c
    34.  
    35. 	char* ptr = strtok(str, " "); //用空格分隔字符串
    36. 	for(; ptr != NULL; )
    37. 	{
    38. 		stat[i] = ptr;
    39. 		//printf("%s\n", stat[i]);
    40. 		i++;
    41. 		ptr = strtok(NULL, " ");
    42. 	}
    43.  
    44. 	if(strcmp(stat[0],"client_ls\n")==0){ //如果是client_ls指令
    45. 		system("ls -l"); //执行ls-l
    46. 	}else if(strcmp(stat[0],"client_cd")==0){ //如果是client_cd指令
    47. 		sprintf(cmd, "%.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    48. 		chdir(cmd); //cd到用户指定的目录
    49. 		system("pwd"); //然后执行pwd
    50. 	}else if(strcmp(stat[0],"get")==0){ //如果是get指令
    51. 		fd_fifo = open("./fifo",O_WRONLY); //阻塞的只写打开fifo，阻塞直到fifo被只读打开
    52. 		write(fd_fifo,fifo_msg_get,strlen(fifo_msg_get)); //向fifo中写信息，告诉负责读的子进程：用户调用了get指令
    53. 		close(fd_fifo);
    54. 	}else if(strcmp(stat[0],"quit\n")==0){ //如果是quit指令
    55. 		//printf("quit detected!\n");
    56. 		fd_fifo = open("./fifo",O_WRONLY); //阻塞的只写打开fifo，阻塞直到fifo被只读打开
    57. 		write(fd_fifo,fifo_msg,strlen(fifo_msg)); //向fifo中写信息，告诉负责读的子进程：用户调用了quit指令
    58. 		close(fd_fifo);
    59. 		close(fd); //关闭套接字
    60. 		wait(NULL); //等待子进程退出
    61. 		flag_quit = 1; //将退出标识符置1
    62.  
    63. 	}else if(strcmp(stat[0],"upload")==0){ //如果是upload指令
    64. 		sprintf(cmd, "find . -name %.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    65. 		fp = popen(cmd,"r"); //通过调用find查看要上传的文件是否存在
    66. 		fread(&result, sizeof(char), sizeof(result), fp);
    67. 		pclose(fp);
    68. 		if(strlen(result)==0){
    69. 			printf("file not exit!\n");
    70. 			return 1;
    71. 		}else{
    72. 			ret = write(fd,"exist",20); //只有文件存在，才向服务器发送exist
    73. 			if(ret == -1){
    74. 				perror("write");
    75. 				return 1;
    76. 			}
    77. 		}
    78.  
    79. 		memset(&result,0,sizeof(result));
    80.  
    81. 		sprintf(cmd, "./%.*s",(int)(strlen(stat[1])-1),stat[1]); //remove "\n"
    82. 		fd_file = open(cmd,O_RDWR); //打开要发送的文件，将内容全部复制，发送给服务器
    83. 		size = lseek(fd_file, 0L, SEEK_END);
    84. 		printf("file size = %d\n",size);
    85. 		file_buf = (char *)malloc(sizeof(char)*size + 1);
    86. 		lseek(fd_file, 0, SEEK_SET);
    87. 		ret = read(fd_file,file_buf,size);
    88. 		if(ret == -1){
    89. 			perror("read2");
    90. 			return 1;
    91. 		}
    92. 		close(fd_file);
    93. 		sleep(2); //ensure the "flag_upload" is set to 1 in server
    94. 		ret = write(fd,file_buf,size);
    95. 		if(ret == -1){
    96. 			perror("write");
    97. 			return 1;
    98. 		}
    99.  
    100. 	}
    101.  
    102. 	return 0;
    103. }
    104.  
    105. void get_handler(char *file_name, char readbuf[10000]) //当确定要执行get命令时，会调用这个函数，通过服务器发来的文件名和文件内容创建文件
    106. {
    107. 	int fd_file;
    108. 	int n_write;
    109. 	fd_file = open(file_name,O_RDWR|O_CREAT|O_TRUNC,S_IRWXU);
    110. 	n_write = write(fd_file, (char *)readbuf, strlen((char *)readbuf));
    111. 	printf("\ncreate new file %s, %d bytes have been written\n",file_name, n_write);
    112.  
    113. 	close(fd_file);
    114.  
    115. }
    116.  
    117.  
    118.  
    119. int main(int argc, char **argv) //main函数
    120. {
    121. 	int cnt = 0;
    122. 	char file_name[20]={0};
    123. 	int no_print = 0;
    124. 	int sockfd;
    125. 	int ret;
    126. 	int n_read;
    127. 	int n_write;
    128. 	char readbuf[10000];
    129. 	char msg[10000];
    130.  
    131. 	int fd; //fifo
    132. 	char fifo_readbuf[20] = {0};
    133. 	int fd_get;
    134.  
    135.  
    136. 	pid_t fork_return;
    137.  
    138. 	if(argc != 3){
    139. 		printf("param error!\n");
    140. 		return 1;
    141. 	}
    142.  
    143.  
    144. 	struct sockaddr_in server_addr;
    145. 	memset(&server_addr,0,sizeof(struct sockaddr_in));
    146.  
    147. 	//socket
    148. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    149. 	if(sockfd == -1){
    150. 		perror("socket");
    151. 		return 1;
    152. 	}else{
    153. 		printf("socket success, sockfd = %d\n",sockfd);
    154. 	}
    155.  
    156. 	//connect
    157. 	server_addr.sin_family = AF_INET;
    158. 	server_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    159. 	inet_aton(argv[1],&server_addr.sin_addr); 
    160. 	ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
    161. 	if(ret == -1){
    162. 		perror("connect");
    163. 		return 1;
    164. 	}else{
    165. 		printf("connect success!\n");
    166. 	}
    167.  
    168. 	//fifo
    169. 	if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
    170. 	{
    171. 		perror("fifo");
    172. 	}
    173.  
    174. 	//fork
    175. 	fork_return = fork();
    176.  
    177. 	if(fork_return > 0){//father keeps writing msg
    178. 		while(1){
    179. 			//write
    180. 			memset(&msg,0,sizeof(msg));
    181. 			fgets(msg,sizeof(msg),stdin);
    182. 			n_write = write(sockfd,&msg,strlen(msg));
    183.  
    184. 			cmd_handler(sockfd,msg); //负责处理并判断用户输入的总函数
    185. 			if(flag_quit == 1){ //如果退出标识符被置位
    186. 				flag_quit = 0;
    187. 				break; //则父进程退出循环，然后退出
    188. 			}
    189.  
    190. 			if(n_write == -1){
    191. 				perror("write");
    192. 				return 1;
    193. 			}else{
    194. 				//printf("%d bytes msg sent\n",n_write);
    195. 			}
    196. 		}
    197. 	}else if(fork_return < 0){
    198. 		perror("fork");
    199. 		return 1;
    200. 	}else{//son keeps reading 
    201. 		while(1){
    202. 			fd = open("./fifo",O_RDONLY|O_NONBLOCK); //非阻塞的只读打开FIFO
    203. 			lseek(fd, 0, SEEK_SET); //光标移到最前
    204.  
    205. 			read(fd,&fifo_readbuf,20); //从FIFO读取数据
    206. 			if(strcmp(fifo_readbuf,"quit")==0){ //如果FIFO中是quit
    207. 				exit(1); //则子进程立刻退出
    208. 			}else if(cnt == 1){ //如果判断为get指令，服务器将发送两次消息，第一次为文件名，第二次为文件内容，使用cnt和fifo消息的读取来配合，第一次将读来的值赋值给文件名，第二次将读来的值作为文件内容传入get_handler用来创建文件
    209. 				get_handler(file_name, readbuf);
    210. 				cnt = 0;
    211. 				no_print = 0; //将静止打印标识符重新归0
    212. 			}else if(strcmp(fifo_readbuf,"get")==0){ //如上一个else if的注释所言，能进入这个循环，说明是get指令后服务器发送的第一次消息
    213. 				strcpy(file_name,readbuf); //重要！字符串的赋值要用strcpy!!
    214. 				if(strcmp(file_name,"file not exist\n")==0){ //如果服务器第一次发来的消息是文件不存在，则啥都不用干，就当这次get没发生
    215. 					//do nothing
    216. 				}else{ //此时，将cnt++，使得服务器下一次发送的消息会被准确的判断为文件的内容
    217. 					cnt++;
    218. 					no_print = 1; //并且使得静止打印的标识符为1，防止在界面中打印文件内容
    219. 				}
    220. 			}
    221. 			memset(&fifo_readbuf,0,sizeof(fifo_readbuf)); //重要，不要忘记
    222.  
    223. 			//read
    224. 			memset(&readbuf,0,sizeof(readbuf));
    225. 			n_read = read(sockfd,&readbuf,sizeof(readbuf));
    226. 			if(ret == -1){
    227. 				perror("read1");
    228. 				return 1;
    229. 			}else if(ret != -1 && no_print == 0){ //只有静止打印标识符为0时，才打印服务器发来的消息，为了防止当get指令生效时，将服务器发来的大量文件内容打在屏幕上影响观感
    230. 				printf("\nserver: %s",readbuf); //dont need to add"\n"
    231. 			}
    232.  
    233. 		}
    234.  
    235. 	}
    236.  
    237. 	return 0;
    238. }

    对于客户端中使用FIFO配合服务器的回复实现get指令的详细说明

    实现效果

    编译并运行服务端和客户端，建立连接：

    “server_ls”指令演示

    观察server的目录来验证：

     

    “server_cd”指令演示

    “client_ls”指令演示

    观察client的目录来验证：

    “client_cd”指令演示

    “upload”指令演示

    客户端：

    服务端：

     

    再看服务端的目录，可见文件已经被成功上传：

     

    也可以用“server_ls” 来验证： 

    “get”指令演示

    客户端：

    服务端：

    再看客户端的目录，可见文件已经被成功获取：

    也可以用“client_ls” 来验证：

    “quit”指令演示：

    客户端：

    服务端：

     

  • 相关阅读:
    WSO2 API Manager代码问题漏洞(CVE-2022-29464）
    Jmeter之接口测试
    算法训练——双指针专题
    【DaVinci Developer工具实战】03 -导入xml文件
    DataFrame与DataSet的互操作_大数据培训
    【vue】vue本地储存、会话存储插件vue-ls的使用：
    conda: error: argument COMMAND: invalid choice: ‘activate‘
    python爬虫之BeautifulSoup4使用
    AutoEncoder和VAE
    从油猴脚本管理器的角度审视Chrome扩展
  • 原文地址：https://blog.csdn.net/mjmmm/article/details/132613439