编译运行：
文档说明：
1、整体程序设计
服务器程序是一个死循环，处理一次连接之后不退出，而客户端程序只处理一个连接就可以了。
2、客户端程序设计
客户端程序的主要任务：
a、分析用户输入的命令；
b、根据命令向服务器端发出请求；
c、等待服务器返回请求的结果。
cd命令和ls命令处理客户机文件系统中的目录，不需要和服务器进行通信，因此不需要建立连接。其它的除了quit命令外，都需要和服务器建立连接，将请求发送给服务器，等待服务器返回结果。quit命令向服务器发出连接结束的请求，之后客户端程序退出，因此不需要等待服务器返回结果。
3、服务器端程序设计
a、分析请求代码；
b、根据请求代码做相应的处理；
c、等待返回结果或应答信息。
有两个主要的环节需要明确：通信协议与服务器模型。
本程序的通信协议分为两种：对于get命令、put命令和!ls命令需要传输文件内容的命令，采用”四次握手“的通信协议；对于!cd命令不需要传输文件内容的命令，采用”两次握手“的通信协议。
“四次握手”：
例如get命令：首先发出GET请求，服务器程序接收到请求后发送确认信息或错误应答码，接收到确认信息后客户端程序发送RDY应答信息，服务器端开始传输文件内容。
“两次握手”:
由于客户端程序是交互式的，因此本程序采用多进程并发服务器模型，如下：
int main(void)
{
socker();
bind();
listen();
while(1)
{
accept();
if(fork() == 0) // 子进程处理客户端请求
{
while(1)
{
close(); // 子进程关闭监听套接字
read(); write();
}
close(); exit(); // 子进程关闭连接套接字并退出
}
else
close(); // 父进程关闭连接套接字
}
close(); return 0; // 父进程关闭监听套接字
}服务器程序采用并发的方式处理客户端的连接，因此main函数调用fork函数创建一个子进程与客户端的通信，而父进程继续监听其他连接请求。对于交互式的网络程序，这种服务器程序模型不仅仅是可以提高程序执行的效率，更重要的是只有这样才能保证服务器程序不会因为一个连接请求而产生时间阻塞，导致其他连接请求得不到处理。
附：
#include <stdlib.h> // exit
#include <unistd.h> // STDOUT_FILENO
#include <sys/stat.h> // struct stat 获取文件状态
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
宏定义调试语句
#define DEBUG_PRINT 1
#ifdef DEBUG_PRINT
#define DEBUG(format, ...) printf(“FILE: “__FILE__”, LINE: %d: “format”\n”, __LINE__, ##__VA_ARGS)
#else
#define DEBUG(format, ...)
#endif
Fflsuh(stdout); // 冲洗缓冲区，保证提示符显示
Bzero(&command, sizeof(struct str_command)); // 清零内存空间
Perror(“fail to close”); // 错误提示，系统将自动输出错误号对应的错误信息，此处无需自己添加换行符
System(“ls . > temp.txt”); // system 执行命令
Char *path; chdir(path); // 改变当前工作目录
网络编程
客户端
Struct sockaddr_in serv_addr;
Bzero(serv_addr, sizeof(struct sockaddr_in)); // bzero 清空地址结构
Serv_addr->sin_family = AF_INET; // AF_INET为IPv4地址族
Inet_pton(AF_INET, ip, &(serv_addr->sin_addr)); // inet_pton 将点分十进制ip转换为二进制形式，并存储在地址结构中
Serv_addr->sin_port = htons(PORT); // htons 将端口号转换为网络字节序存储在地址结构中
*sock_fd = socket(AF_INET, SOCK_STREAM, 0); // socket创建套接字
Connect(*sock_fd, (struct sockaddr *)serv_addr, sizeof(struct sockaddr_in)); // connect 使用该套接字，和填充好的地址结构进行连接
服务端
Struct sockaddr_in ser_addr;
Bzero(ser_addr, sizeof(struct sockaddr_in));
Ser_addr->sin_family = AF_INET;
Ser_addr->sin_addr.s_addr = htonl(INADDR_ANY);
Ser_addr->sin_port = htons(PORT);
Int listenfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听套接字
Int sock_opt;
Setsockopt(listenfd, SOL_SOCKET, SO_REUESADDR, &sock_opt, sizeof(int)); // setsockopt 设置套接字选项
Bind(listenfd, (struct sockaddr *)ser_addr, sizeof(struct sockaddr_in)); // bind 绑定客户端地址，具体地址没有限制，为INADDR_ANY
Listen(listenfd, 20); // listen 监听套接字，与客户端的connect函数相互作用
Int connectfd = accept(listenfd, (struct sockaddr *)&cli_addr)； // accept
读写套接字
Write(sock_fd, buf, strlen(buf)+1);
Len = Read(sock_fd, buf, MAXBUF);
字符串操作函数
忽略大小写进行比较 Strcasecmp(command.name, “get”)
复制 strcpy(dest_file, dest);
寻找指定字符在字符串中最后出现的位置 Char *p = rindex(src, ‘/’);
连接字符串 strcat(dest_file, p+1);
是否为其字串，若是则返回首次出现的地址 strstr(buf, “GET”);
文件操作
Int fd = open(dest_file, O_WRONLY | O_CREAT | O_TRUNC, 0644); // open 打开
Struct stat stat_buf; fstat(fd, &stat_buf); // struct stat 文件状态
S_ISREG(stat_buf.st_mode) // S_ISREG 是否为普通文件
FIEL *fp = fopen(“temp.txt”, “r”); // fopen打开文件
Fgets(buf, MAXBUF, fp); // fgets
Fputs(buf, stdout); // fputs
Unlink(“temp.txt”); // unlink 删除文件
所有源代码文件汇总：
1 /*
2 * FILE: common.h
3 * DATE: 20180201
4 * ==============
5 */
6
7 #include <stdio.h>
8 #include <stdlib.h> // exit
9 #include <unistd.h> // STDOUT_FILENO
10 #include <string.h>
11
12 #include <sys/stat.h> // struct stat
13 #include <fcntl.h> // O_WRONLY
14
15 #include <sys/socket.h> // struct sockaddr_in
16 #include <netinet/in.h>
17 #define PORT 8000
18
19 #define BUFFSIZE 32
20 #define MAXBUFF 128
21
22 #define DEBUG_PRINT 1
23 #ifdef DEBUG_PRINT
24 #define DEBUG(format, ...) printf("FILE: "__FILE__", LINE: %d: "format"\n", __LINE__, ##__VA_ARGS__)
25 #else
26 #define DEBUG(format, ...)
27 #endif
28
29 // 全局变量声明：命令结构，存储用户输入的命令和参数
30 struct str_command{
31 char *name;
32 char *argv[10];
33 };
34
35 /* 函数接口声明 */
36
37 // 文件input.c中，处理用户输入
38 extern int split(struct str_command *command, char *cline);
39
40 // 文件command.c中，命令处理
41
42 extern int do_connect(char *ip, struct sockaddr_in *serv_addr, int *sock_fd);
43
44 extern int do_get(const char *src, const char *dest, int sock_fd);
45
46 extern int do_put(const char *src, const char *dest, int sock_fd);
47
48 extern int do_cd(char *path);
49
50 extern int do_ls(char *path);
51
52 extern int do_ser_ls(char *path, int sockfd);
53
54 extern int do_ser_cd(char *path, int sockfd);
55
56 extern int do_quit(int sock_fd);
57
58
59
60
61
62 /*
63 * FILE: main.c
64 * DATE: 20180201
65 * ===============
66 */
67
68 #include "common.h"
69
70 int main(void)
71 {
72 char cline[MAXBUFF]; // 缓冲区，存储用户输入的命令
73 struct str_command command; // 命令结构，存储分解后的命令
74 int sock_fd;
75 struct sockaddr_in serv_addr; // 服务器端的地址结构
76
77 printf("myftp$: "); // 打印提示符
78 fflush(stdout); // fflush 冲洗，保证提示符显示
79
80 while(fgets(cline, MAXBUFF, stdin) != NULL) // fgets 得到一行命令
81 {
82 // 自定义split 将命令行拆分为命令和参数
83 if(split(&command, cline) < 0)
84 exit(-1);
85
86 // strcasecmp 忽略大小写进行比较
87 if(strcasecmp(command.name, "get") == 0)
88 {
89 if(do_get(command.argv[1], command.argv[2], sock_fd) < 0)
90 exit(-2);
91 }
92 else if(strcasecmp(command.name, "put") == 0)
93 {
94 if(do_put(command.argv[1], command.argv[2], sock_fd) < 0)
95 exit(-3);
96 }
97 else if(strcasecmp(command.name, "cd") == 0)
98 {
99 if(do_cd(command.argv[1]) < 0)
100 exit(-4);
101 }
102 else if(strcasecmp(command.name, "ls") == 0)
103 {
104 if(do_ls(command.argv[1]) < 0)
105 exit(-5);
106 }
107 else if(strcasecmp(command.name, "connect") == 0)
108 {
109 if(do_connect(command.argv[1], &serv_addr, &sock_fd) < 0)
110 exit(-6);
111 }
112 else if(strcasecmp(command.name, "!ls") == 0)
113 {
114 if(do_ser_ls(command.argv[1], sock_fd))
115 exit(-9);
116 }
117 else if(strcasecmp(command.name, "!cd") == 0)
118 {
119 if(do_ser_cd(command.argv[1], sock_fd))
120 exit(-10);
121 }
122 else if(strcasecmp(command.name, "quit") == 0)
123 {
124 if(do_quit(sock_fd) < 0)
125 exit(-8);
126 }
127 else
128 {
129 printf("ERROR: wrong command\n");
130 printf("Usage: command argv1 argv2, ...\n");
131 }
132 bzero(&command, sizeof(struct str_command));
133 printf("myftp$: "); // 再次打印提示符，准备接受新的命令
134 fflush(stdout);
135 }
136
137 if(close(sock_fd) < 0)
138 {
139 perror("fail to close");
140 exit(-7);
141 }
142 return 0;
143 }
144
145
146
147
148
149
150 /*
151 * FILE: input.c
152 * DATE: 20180201
153 * ==============
154 */
155
156 #include "common.h"
157
158 // 宏定义的续行符后 不能有空格或其它内容
159 #define del_blank(p, cline) do{ \
160 while(cline[p]!='\0' && (cline[p]==' ' || cline[p]=='\t')) \
161 p++; \
162 }while(0)
163
164 // 宏定义中的变量 不能与函数中的变量 同名
165 #define get_arg(arg, p, cline) do{ \
166 int j = 0; \
167 while(cline[p]!='\0' && cline[p]!=' ' && cline[p]!='\t') \
168 arg[j++] = cline[p++]; \
169 }while(0)
170 /* 将用户输入的命令字符串分割为命令和参数，
171 * 并存储在自定义的 struct str_command中
172 * command: 存储命令和参数的结构体； cline 用户输入的命令字符串
173 */
174 int split(struct str_command *command, char *cline)
175 {
176 int i=0, p=0;
177
178 cline[strlen(cline)-1] = '\0'; // 将换行符\n替换为结束符\0
179 del_blank(p, cline); // 过滤空格，直到遇到第一个参数
180
181 while(cline[p] != '\0')
182 {
183 if((command->argv[i]=(char *)malloc(sizeof(char) * BUFFSIZE)) == NULL)
184 {
185 perror("fail to malloc");
186 return -1;
187 }
188 get_arg(command->argv[i], p, cline);
189 /*{
190 int j = 0;
191 while(cline[p]!='\0' && cline[p]!=' ' && cline[p]!='\t')
192 command->argv[i][j++] = cline[p++];
193
194 }*/
195 i++;
196 del_blank(p, cline);
197 }
198
199 command->argv[i] = NULL; // 命令参数数组以NULL结尾
200 command->name = command->argv[0]; // 命令名和第一个参数指向同一内存区域
201 return i;
202 }
203
204
205
206
207
208
209 /*
210 * FILE: command.c
211 * DATE: 20180201
212 * ===============
213 */
214
215 #include "common.h"
216 /* 处理connect命令：connect <ip-address>
217 * 与服务器进行连接
218 * ip: 字符指针，指向服务器地址
219 * serv_addr: 地址结构指针，指向服务器地质结构，在connect函数中填充
220 * sock_fd: 整型指针，指向通信套接字描述符，在connect函数中设置
221 */
222 int do_connect(char *ip, struct sockaddr_in *serv_addr, int *sock_fd)
223 {
224 bzero(serv_addr, sizeof(struct sockaddr_in)); // bzero 清空地址结构
225 serv_addr->sin_family = AF_INET; // 使用IPv4地址族
226 // inet_pton 将点分十进制的ip地址转换为二进制形式，并存储在地址结构中
227 inet_pton(AF_INET, ip, &(serv_addr->sin_addr));
228 serv_addr->sin_port = htons(PORT); // htons 将端口号转换为网络字节序存储在地址结构中
229
230 *sock_fd = socket(AF_INET, SOCK_STREAM, 0); // 创建套接字
231 if(*sock_fd < 0)
232 {
233 perror("fail to creat socket");
234 return -1;
235 }
236 // 使用该套接字，和填充好的地址结构进行连接
237 if(connect(*sock_fd, (struct sockaddr *)serv_addr, sizeof(struct sockaddr_in)) < 0)
238 {
239 perror("fail to connect");
240 return -2;
241 }
242 return 0;
243 }
244
245 /* 处理get命令：get arg1 arg2
246 * 从服务器端取得文件，文件已存在则覆盖
247 * src：源文件的绝对路径，dest：目的目录的绝对路径，sock_fd: 通信用的套接字描述符
248 * client将src_filename传递给server，由server读取文件内容并写入套接字，client读取套接字并写入至文件
249 */
250 int do_get(const char *src, const char *dest, int sock_fd)
251 {
252 char *dest_file; // 目的路径，dest+filename
253 struct stat stat_buf; // struct stat 文件状态
254 char *p, buf[MAXBUFF];
255 int fd, len;
256 int res = -1; // 返回值
257
258 if(src==NULL || dest==NULL) // 检查源文件和目的地址是不是空串
259 {
260 printf("ERROR: wrong command\n");
261 return -1;
262 }
263 // 如果源文件路径的最后一个字符是/，则说明源文件不是普通文件，而是目录
264 if(src[strlen(src)-1] == '/')
265 {
266 printf("source file should be a regular file\n");
267 return -2;
268 }
269
270 // malloc 为目标文件路径分配存储空间，由目标目录dest和源文件名组成
271 if((dest_file=(char *)malloc(sizeof(char)*(strlen(dest)+strlen(src)))) == NULL)
272 {
273 perror("fail to malloc");
274 return -3;
275 }
276 strcpy(dest_file, dest);
277 if(dest_file[strlen(dest)-1] != '/')
278 strcat(dest_file, "/");
279 p = rindex(src, '/'); // rindex 取源文件路径中最后一个/的位置指针
280 strcat(dest_file, p+1);
281
282 if((fd=open(dest_file, O_WRONLY | O_CREAT | O_TRUNC, 0644)) < 0)
283 {
284 perror("fail to open dest_file");
285 goto end2;
286 }
287
288 if(fstat(fd, &stat_buf) < 0)
289 {
290 perror("fail to stat dest_file");
291 goto end1;
292 }
293 // S_ISREG
294 // 如果目标文件已存在，但不是一个普通文件，则无法传输
295 // 否则会造成已存在的目录等其它特殊文件被覆盖
296 if(!S_ISREG(stat_buf.st_mode))
297 {
298 printf("dest-file should be a regular file\n");
299 goto end1;
300 }
301
302 // 向服务器server发送GET请求
303 sprintf(buf, "GET %s", src);
304 write(sock_fd, buf, strlen(buf)+1);
305 // 服务器的确认信息格式为：“OK 文件名”
306 len = read(sock_fd, buf, MAXBUFF);
307 // 如果收到的信息是ERR，表示出错
308 if(buf[0] == 'E')
309 {
310 write(STDOUT_FILENO, buf, len);
311 res = 0;
312 goto end1;
313 }
314 // len = atoi(&buf[3]);
315 // 告知服务器已准备好RDY，服务器将开始传送文件内容
316 write(sock_fd, "RDY", 3);
317 // 循环读写
318 // read 套接字中服务器传入的内容，write 将读取的内容写至目标文件
319 while((len = read(sock_fd, buf, MAXBUFF)) > 0)
320 {
321 write(fd, buf, len);
322 }
323 if(len < 0)
324 {
325 printf("ERROR: read\n");
326 goto end1;
327 }
328 printf("OK\n");
329 res = 0;
330 end1:
331 close(fd);
332 end2:
333 free(dest_file); // free 释放malloc分配的内存空间
334 return res;
335 }
336
337 /*
338 * 处理put命令：put arg1 arg2
339 * 向服务器传送文件，若已存在则覆盖
340 * src：源文件的绝对路径，dest: 目标目录的绝对路径, sock_fd 通信用的套接字描述符
341 * client读取用户指定的src_filename文件内容，并写入至通信套接字；server读取套接字，并写入至文件
342 */
343 int do_put(const char *src, const char *dest, int sock_fd)
344 {
345 char *dest_file; // 目标文件路径，由dest+filename
346 struct stat stat_buf; // struct stat 文件状态
347 char *p, buf[MAXBUFF];
348 int fd, len;
349
350 if(src==NULL || dest==NULL) // 检查源文件和目的地址是不是空串
351 {
352 printf("ERROR: wrong command\n");
353 return -1;
354 }
355 if(src[strlen(src)-1] == '/') // 源文件名及其绝对路径
356 {
357 printf("source file should be a regular file.\n");
358 return -1;
359 }
360 // malloc 为目标文件名及其路径分配内存空间
361 if((dest_file=(char *)malloc(sizeof(char)*(strlen(src)+strlen(dest)))) == NULL)
362 {
363 perror("fail to malloc");
364 return -1;
365 }
366 strcpy(dest_file, dest);
367 if(dest_file[strlen(dest_file)-1] != '/')
368 strcat(dest_file, "/");
369 p = rindex(src, '/');
370 strcat(dest_file, p+1);
371 // open 打开需要传输的源文件
372 if((fd=open(src, O_RDONLY)) < 0) // open, int fd, write read
373 {
374 perror("fail to src-file");
375 goto end1;
376 }
377 if(fstat(fd, &stat_buf) < 0) // struct stat 源文件状态
378 {
379 perror("fail to open src-file");
380 goto end2;
381 }
382 if(!S_ISREG(stat_buf.st_mode)) // 只能是普通文件
383 {
384 fprintf(stderr, "src-file should be a regular file\n");
385 goto end2;
386 }
387 sprintf(buf, "PUT %s", dest_file); // 向服务器发送PUT请求
388 write(sock_fd, buf, strlen(buf)+1);
389 read(sock_fd, buf, BUFFSIZE); // 接收服务器的确认信息
390 if(buf[0] == 'E') // 若收到的信息是ERR，表示出错；否则得到RDY应答
391 {
392 write(STDOUT_FILENO, buf, strlen(buf)+1);
393 goto end2;
394 }
395 // 循环读取文件内容，并写入至通信套接字传输给服务端
396 while((len=read(fd, buf, MAXBUFF)) > 0)
397 write(sock_fd, buf, len);
398 if(len<0) // 读操作出错
399 {
400 perror("fail to read");
401 goto end2;
402 }
403 printf("OK\n");
404 end1:
405 close(fd);
406 end2:
407 free(dest_file); // free 释放malloc分配的内存空间
408 return 0;
409 }
410
411 /*
412 * 处理ls命令：ls arg1
413 * path: 指定的目录，绝对路径
414 */
415 int do_ls(char *path)
416 {
417 char cmd[64], buf[MAXBUFF];
418 FILE *fp;
419 sprintf(cmd, "ls %s > temp.txt", path); // 拼接命令
420 system(cmd); // system 执行命令
421 if((fp = fopen("temp.txt", "r")) == NULL) // fopen, FILE *fp, fgets fputs
422 {
423 perror("fail to ls");
424 return -1;
425 }
426 while(fgets(buf, MAXBUFF, fp) != NULL) // fgets, fputs
427 fputs(buf, stdout);
428 fclose(fp);
429 //unlink("temp.txt");
430 return 0;
431 }
432
433 /* 处理!ls命令: !ls arg1
434 * 列出服务器中指定目录的所有文件
435 * path: 指定的目录，绝对路径
436 */
437 int do_ser_ls(char *path, int sockfd)
438 {
439 char cmd[BUFFSIZE], buf[MAXBUFF];
440 int len;
441
442 sprintf(cmd, "LS %s", path);
443 if(write(sockfd, cmd, strlen(cmd)+1) < 0) // write 向服务器发送LS请求
444 return -1;
445 DEBUG("===to server: %s", cmd);
446 if((len=read(sockfd, cmd, BUFFSIZE)) < 0) // read 读取服务器的应答码
447 return -2;
448 if(cmd[0] == 'E') // 若应答码为ERR，表示出错
449 {
450 write(STDOUT_FILENO, cmd, len);
451 return 0;
452 }
453 //len = atoi(&buf[3]);
454 DEBUG("===from server: %s", cmd);
455 if(write(sockfd, "RDY", 4) < 0) // 告知服务器已准备好RDY
456 return -3;
457 // read, write 循环读取服务端传输的内容，并输出到屏幕
458 while((len=read(sockfd, buf, MAXBUFF))>0)
459 write(STDOUT_FILENO, buf, len);
460 if(len < 0)
461 {
462 perror("fail to read");
463 return -4;
464 }
465 printf("!ls OK\n");
466 return 0;
467 }
468
469 /* 处理cd命令：cd arg1
470 * path: 指定的目录，绝对路径
471 */
472 int do_cd(char *path)
473 {
474 if(chdir(path) < 0) // chdir 改变当前工作目录
475 {
476 perror("fail to change directory");
477 return -1;
478 }
479 return 0;
480 }
481
482 /*
483 * 处理!cd命令: !cd arg1
484 * 进入服务器中指定的目录
485 * path: 指定的目录，绝对路径
486 * sockfd: 通信套接字描述符
487 */
488 int do_ser_cd(char *path, int sockfd)
489 {
490 char buf[BUFFSIZE];
491 int len;
492
493 sprintf(buf, "CD %s", path);
494 if(write(sockfd, buf, strlen(buf)) < 0) // write 向服务器发送CD请求
495 return -1;
496 if((len=read(sockfd, buf, BUFFSIZE)) < 0) // read 读取服务器的应答信息
497 return -2;
498 if(buf[0] == 'E') // 若应答码为ERR，表示出错
499 write(STDOUT_FILENO, buf, len);
500 return 0;
501
502 }
503
504 /* 处理quit命令: quit
505 * 向服务器发送 关闭连接的请求，然后退出客户端程序
506 * sockfd: 通信用的套接字描述符
507 * 这次通信不需要应答码，因为客户端程序发送命令后已退出，无法处理应答码
508 */
509 int do_quit(int sock_fd)
510 {
511 char buf[4];
512 sprintf(buf, "BYE");
513 // write 向服务器发送关闭连接的请求
514 if(write(sock_fd, buf, strlen(buf)+1) != strlen(buf))
515 return -1;
516 return 0;
517 }
518
519
520
521
522
523 #
524 # FILE: Makefile
525 # DATE: 20180201
526 # ==============
527
528 OBJECTS = main.o input.o command.o
529
530 clinet: $(OBJECTS)
531 gcc -o client -g $(OBJECTS)
532
533 main.o: common.h main.c
534 gcc -c -g main.c
535 input.o: common.h input.c
536 gcc -c -g input.c
537 command.o: common.h command.c
538 gcc -c -g command.c
539
540 .PHONY: clean
541 clean:
542 rm *.o
543
547
548
549
550
551 // ================================================
552 // server 服务端
553 // ================================================
554
555
556 /*
557 * FILE: common.h
558 * DATE: 20180201
559 * ==============
560 */
561
562 #include <stdio.h>
563 #include <stdlib.h>
564 #include <string.h>
565 #include <fcntl.h>
566 #include <sys/stat.h>
567 #include <errno.h>
568
569 #include <sys/socket.h>
570 #include <netinet/in.h>
571 #define PORT 8000 // 端口号
572
573 #define BUFFSIZE 64
574 #define MAXBUFF 128
575
576 /* 函数结构声明， command.c文件中定义函数 */
577 int init(struct sockaddr_in *ser_addr, int *lis_fd, int sock_opt);
578 int do_put(int sockfd, char *file);
579 int do_get(int sockfd, char *file);
580 int do_ls(int sockfd, char *path);
581 int do_cd(int sockfd, char *path);
582
583
584
585
586 /* FILE: main.c
587 * DATE: 20180201
588 * ==============
589 */
590
591 #include "common.h"
592
593 int main(void)
594 {
595 struct sockaddr_in ser_addr, cli_addr; // 服务/客户端地址结构
596 char buf[BUFFSIZE];
597 int listenfd, connfd;
598 int sock_opt, len;
599 pid_t pid;
600
601 // 自定义init初始化，得到地址结构和监听套接字描述符
602 if(init(&ser_addr, &listenfd, sock_opt) < 0)
603 exit(-1);
604 printf("waiting connections ...\n");
605 while(1) // while死循环，处理客户端请求
606 {
607 // accept 接收请求
608 if((connfd=accept(listenfd, (struct sockaddr *)&cli_addr, &len)) < 0)
609 {
610 perror("fail to accept");
611 exit(-2);
612 }
613 if((pid=fork()) < 0) // fork 创建子进程
614 {
615 perror("fail to fork");
616 exit(-3);
617 }
618 if(pid == 0) // 子进程处理连接请求，父进程继续监听
619 {
620 close(listenfd); // 子进程中关闭继承而来的监听套接字
621 // 本程序的客户端是一个交互式程序，服务器端也是交互的
622 while(1)
623 {
624 if(read(connfd, buf, BUFFSIZE) < 0)
625 exit(-4);
626 // strstr(str1, str2) 判断str2是否为str1的字串。
627 // 若是，则返回str2在str1中首次出现的地址；否则，返回NULL
628 if(strstr(buf, "GET") == buf)
629 {
630 if(do_put(connfd, &buf[4]) < 0)
631 printf("error occours while putting\n");
632 }
633 else if(strstr(buf, "PUT") == buf)
634 {
635 if(do_get(connfd, &buf[4]) < 0)
636 printf("error occours while getting\n");
637 }
638 else if(strstr(buf, "CD") == buf)
639 {
640 if(do_cd(connfd, &buf[4]) < 0)
641 printf("error occours while changing directory\n");
642 }
643 else if(strstr(buf, "LS") == buf)
644 {
645 if(do_ls(connfd, &buf[3]) < 0)
646 printf("error occours while listing\n");
647 }
648 else if(strstr(buf, "BYE") == buf)
649 break;
650 else
651 {
652 printf("wrong command\n");
653 exit(-5);
654 }
655 }
656 close(connfd); // 跳出循环后关闭连接套接字描述符，通信结束
657 exit(0); // 子进程退出
658 }
659 else
660 close(connfd); // 父进程关闭连接套接字，继续监听
661 }
662 return 0;
663 }
664
665
666
667
668
669 /*
670 * FILE: command.c
671 * DATE: 20180201
672 * ===============
673 */
674
675 #include "common.h"
676
677 // 初始化服务器
678 // ser_addr: 服务端地址结构指针; lis_fd: 监听套接字描述符; sock_opt: 套接字选项
679 int init(struct sockaddr_in *ser_addr, int *lis_fd, int sock_opt)
680 {
681 int fd;
682
683 bzero(ser_addr, sizeof(struct sockaddr_in)); // bzero
684 ser_addr->sin_family = AF_INET; // AF_INET
685 ser_addr->sin_addr.s_addr = htonl(INADDR_ANY); // htonl(INADDR_ANY)
686 ser_addr->sin_port = htons(PORT); // htons(PORT)
687
688 if((fd=socket(AF_INET, SOCK_STREAM, 0)) < 0) // socket 创建监听套接字
689 {
690 perror("fail to creat socket");
691 return -1;
692 }
693 // 设置套接字选项
694 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &sock_opt, sizeof(int));
695 // bind 绑定客户端地址
696 if(bind(fd, (struct sockaddr *)ser_addr, sizeof(struct sockaddr_in)) < 0)
697 {
698 perror("fail to bind");
699 return -2;
700 }
701 // listen 监听套接字，与客户端的connec函数相互作用
702 if(listen(fd, 20) < 0)
703 {
704 perror("fail to listen");
705 return -3;
706 }
707 *lis_fd = fd;
708 return 0;
709 }
710
711 /* 处理来自客户端的GET命令: GET arg1 arg2
712 * 服务端读取客户端指定的文件，并写入至套接字
713 * sock_fd: 连接套接字描述符
714 * file: 客户端请求的文件及其路径
715 */
716 int do_put(int sockfd, char *file)
717 {
718 struct stat stat_buf;
719 int len, fd;
720 char buf[BUFFSIZE];
721 int res = -1;
722
723 if((fd=open(file, O_RDONLY)) < 0) // open 客户端请求的文件
724 {
725 write(sockfd, "ERROR: fail to open server file\n",
726 strlen("ERROR: fail to open server file\n"));
727 return -1;
728 }
729 if(fstat(fd, &stat_buf) < 0) // struct stat 文件状态
730 {
731 write(sockfd, "ERROR: fail to stat server file\n",
732 strlen("ERROR: fail to stat server file\n"));
733 goto end;
734 }
735 if(!S_ISREG(stat_buf.st_mode)) // 若不是普通文件，则报错
736 {
737 write(sockfd, "ERROR: not a regular file\n",
738 strlen("ERROR: not a regular file\n"));
739 goto end;
740 }
741 sprintf(buf, "OK. FILE SIZE: %d", stat_buf.st_size);
742 write(sockfd, buf, strlen(buf)); // 向客户端发送应答信息：OK 文件大小
743 read(sockfd, buf, MAXBUFF); // 等待客户端的应答信息，应答码为RDY
744 while((len=read(fd, buf, MAXBUFF)) > 0) // 循环读取文件内容，并写入通信套接字
745 write(sockfd, buf, len);
746 if(len<0 && errno==EINTR)
747 {
748 perror("fail to read");
749 goto end;
750 }
751 printf("OK\n");
752 res = 0;
753 end:
754 close(fd); // 关闭文件，注意不是关闭套接字
755 return res;
756 }
757
758 /* 处理客户端的PUT请求: put arg1 arg2
759 * 读取客户端写在通信套接字中的文件内容，并写入至文件
760 * sockfd: 连接套接字的描述符
761 * file: 指定的目标文件名及其路径
762 */
763 int do_get(int sockfd, char *file)
764 {
765 struct stat stat_buf;
766 char buf[MAXBUFF];
767 int fd, len;
768 int res = -1;
769 fprintf(stdout, "===getting file: %s\n", file);
770 // open 打开文件。打开方式是覆盖写，若文件存在则覆盖，但若是一个同名的目录则报错
771 if((fd=open(file, O_RDONLY | O_CREAT | O_TRUNC, 0644)) < 0)
772 {
773 if(errno == EISDIR) // 不是普通文件，而是一个目录
774 {
775 write(sockfd, "ERROR: server has a dir with the same name\n",
776 strlen("ERROR: server has a dir with the same name\n"));
777 goto end;
778 }
779 else
780 {
781 write(sockfd, "ERROR: fail to open server file\n",
782 strlen("ERROR: fail to open server file\n"));
783 goto end;
784 }
785 }
786 if(fstat(fd, &stat_buf) < 0) // fstat 获取文件状态
787 {
788 write(sockfd, "ERROR: fail to stat server file\n",
789 strlen("ERROR: fail to stat server file\n"));
790 goto end;
791 }
792 if(!S_ISREG(stat_buf.st_mode)) // 如果不是普通文件，则报错
793 {
794 write(sockfd, "ERROR: not a regular file\n",
795 strlen("ERROR: not a regular file\n"));
796 res = 0;
797 goto end;
798 }
799 // 向客户端发送应答码
800 write(sockfd, "OK\n", 4);
801 while((len=read(sockfd, buf, MAXBUFF)) > 0)
802 write(fd, buf, len);
803 if(len<0 && errno==EINTR)
804 {
805 perror("fail to read");
806 goto end;
807 }
808 printf("OK\n");
809 res = 0;
810 end:
811 close(fd);
812 return res;
813 }
814
815 /* 处理LS命令: LS arg1
816 * sockfd: 已连接的通信套接字描述符
817 * path: 客户端指定的路径
818 */
819 int do_ls(int sockfd, char *path)
820 {
821 struct stat stat_buf;
822 char cmd[BUFFSIZE], buf[MAXBUFF];
823 int fd, len;
824 int res = -1;
825
826 sprintf(cmd, "ls %s > temp.txt", path); // 拼接命令
827 fprintf(stdout, "===from client: system(%s)\n", cmd);
828 system(cmd); // system 执行命令
829
830 if((fd=open("temp.txt", O_RDONLY)) < 0) // open 打开文件
831 {
832 write(sockfd, "ERROR: fail to ls server file\n",
833 strlen("ERROR: fail to ls server file\n"));
834 return -1;
835 }
836 /* if(fstat(fd, &stat_buf) < 0)
837 {
838 write(sockfd, "ERROR: fail to stat server file\n",
839 strlen("ERROR: fail to stat server file\n"));
840 goto end;
841 }
842 if(!S_ISREG(stat_buf.st_mode))
843 {
844 write(sockfd, "ERROR: not a regular file\n",
845 strlen("ERROR: not a regular file\n"));
846 res = 0;
847 goto end;
848 }
849 fprintf(stdout, "===to client: OK %d\n", stat_buf.st_size);
850 sprintf(cmd, "OK %d", stat_buf.st_size);
851 write(sockfd, cmd, strlen(cmd)+1);
852 */
853 write(sockfd, "OK\n", 4); // 向客户端发送应答信息
854 read(sockfd, cmd, BUFFSIZE); // 等待客户端的应答信息，应答码为RDY
855
856 while((len=read(fd, buf, MAXBUFF)) > 0) // 循环读写文件内容，并写入至通信套接字
857 write(sockfd, buf, len);
858 if(len < 0)
859 {
860 perror("fail to read");
861 goto end;
862 }
863 printf("!ls OK\n");
864 res = 0;
865
866 end:
867 close(fd);
868 // unlink("temp.txt"); // unlink 删除该临时文件
869 return res;
870 }
871
872 /* 处理客户端的CD命令: CD arg1 */
873 int do_cd(int sockfd, char *path)
874 {
875 if(chdir(path) < 0) // chdir 改变当前工作目录，进入指定目录
876 {
877 perror("fail to change directory\n");
878 write(sockfd, "ERROR: cannot change server directory\n",
879 strlen("ERROR: cannot change server directory\n"));
880 return -1;
881 }
882 write(sockfd, "OK\n", 3);
883 return 0;
884 }
885
886
887
888
889
890
891 # FILE: Makefile
892 # DATE: 20180201
893 # ==============
894
895
896 #OBJECTS = common.h main.c command.c
897
898 #all: server
899 #server: $(OBJECTS)
900 # gcc -o server $(OBJECTS)
901 #
902 OBJECTS = main.o command.o
903
904 server: $(OBJECTS)
905 gcc -o server -g $(OBJECTS)
906
907 main.o: common.h main.c
908 gcc -c -g main.c
909
910 command.o: common.h command.c
911 gcc -c -g command.c