试着编写了一个客户－服务器程序

kj501

这是我在阅读＜用TCP/IP进行网际互联＞时为了加深对客户－服务器的理解所编写的小程序。程序设计的目的是用socket模拟一个server/client模型。其中client人终端接受输入的指令并传递到server，server执行传递过来的指令后把结果反馈给client。运行时先以root身份执行./server.o，然后再以普通用户身份执行./client.o，就可以输入诸如ls，mkdir等指令并看到执行结果（执行一次即退出）。 由于没有考虑安全性问题，我在单机上的试验表明：这个程序事实上给普通用户提供了访问/root目录的机会（而正常情况下普通这用户访问/root会被拒绝）。不知道在局域网上是不是也是这样，我没有条件测试，有兴起的兄弟可以试验一下。只要把socket_client.c中的地址从127.0.0.1改为server所在的主机地址就行了。
下面是socket_client.c的代码：

1. 
   
2. #include<sys/types.h>
   
3. #include<sys/socket.h>
   
4. #include<stdio.h>
   
5. #include<netinet/in.h>
   
6. #include<arpa/inet.h>
   
7. #include<unistd.h>
   
8. 
   
9. /* exec_command()负责在与服务器连接成功后传送指令并显示结果。 */
   
10. void exec_command(int sockfd)
    
11. {
    
12.     char buf[BUFSIZ];                /* 用于处理输入的缓冲区 */
    
13.     FILE *tty = NULL;                /* 用户终端 */
    
14.     int n;
    
15. 
    
16.     /* 打开用户终端。这果没有使用标准输入输出，因为在重定向时，标准输入输出不会指向用户终端，
    
17.      * 用户输入带来困难。
    
18.      */
    
19.     tty = fopen("/dev/tty", "r");
    
20.     if (tty == NULL) {
    
21.         perror("can't open /dev/tty.");
    
22.         exit(1);
    
23.     }
    
24. 
    
25.     if (fgets(buf, BUFSIZ, tty) == NULL || buf[0] == 'q')
    
26.         exit(0);
    
27.     else                         /* 接受用户输入后，传递到server. */
    
28.         write(sockfd, buf, sizeof(buf));
    
29.     if((n = read(sockfd, buf, sizeof(buf))) > 0)
    
30.             //write(1, buf, n);
    
31.     //buf[n] = '\0';
    
32.     //printf("%d %d %s", n, strlen(buf), buf);
    
33.     fputs(buf, stdout);
    
34. }
    
35. 
    
36. int main()
    
37. {
    
38.     int sockfd;                        /* 套接字描述符 */
    
39.     struct sockaddr_in address;        /* Internet 套接字地址结构 */
    
40.     int result;                        /* 与server连接的结果 */
    
41. 
    
42.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
43. 
    
44.     address.sin_family = AF_INET;
    
45.     address.sin_addr.s_addr = inet_addr("127.0.0.1");
    
46.     address.sin_port = htons(19734);
    
47. 
    
48.     result =
    
49.         connect(sockfd, (struct sockaddr *) &address, sizeof(address));
    
50.     if (result == -1) {
    
51.         perror("connect to server failed.");
    
52.         exit(0);
    
53.     }
    
54.        
    
55.     exec_command(sockfd);        /* 处理通信的内容 */
    
56. 
    
57.     close(sockfd);
    
58.     exit(0);
    
59. }
    

复制代码

kj501

socket_server.c的代码：

1. 
   
2. #include<sys/types.h>
   
3. #include<sys/socket.h>
   
4. #include<stdio.h>
   
5. #include<netinet/in.h>
   
6. #include<arpa/inet.h>
   
7. #include<unistd.h>
   
8. 
   
9. void exec_command(int c_sockfd)
   
10. {
    
11.     char buf[BUFSIZ];
    
12.     int n;
    
13. 
    
14.     close(1);
    
15.     dup(c_sockfd);
    
16.     close(2);
    
17.     dup(c_sockfd);
    
18.    
    
19.     n = read(c_sockfd, buf, sizeof(buf));
    
20.     if (n > 0) {
    
21.         printf("server%s", buf);
    
22.         system(buf);
    
23.     }
    
24. }
    
25. 
    
26. int main()
    
27. {
    
28.     int server_sockfd, client_sockfd;
    
29.     int client_len;
    
30.     struct sockaddr_in server_address;
    
31.     struct sockaddr_in client_address;
    
32.     char buf[BUFSIZ];
    
33. 
    
34.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
35. 
    
36.     server_address.sin_family = AF_INET;
    
37.     server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    
38.     server_address.sin_port = htons(19734);
    
39.     client_len = sizeof(client_address);
    
40. 
    
41.     bind(server_sockfd, (struct sockaddr *) &server_address,
    
42.          sizeof(server_address));
    
43.     listen(server_sockfd, 5);
    
44.     while (1) {
    
45.         client_sockfd = accept(server_sockfd, (struct sockaddr *) &client_address,
    
46.                    &client_len);
    
47.         exec_command(client_sockfd);
    
48.         close(client_sockfd);
    
49.         printf("client_socket closed");
    
50.     }
    
51. }
    

复制代码

kj501

这是Makefile。

1. 
   
2. all: server.o client.o
   
3. server.o : socket_server.c
   
4.         gcc -o server.o socket_server.c
   
5. client.o : socket_client.c
   
6.         gcc -o client.o socket_client.c
   

复制代码

把socket_server.c，socket_client.c，Makefile保存在一个目录下，执行make 即可生成server.o和client.o。

kj501

编写这个程序的意外收获就是加深了对端口的理解，过去一直不知道端口所起的作用，现在明白了，如果没有进程打开端口号，在/etc/services下的端口根本没有用处。而服务器端的编程之所以比客户端困难，是因为服务器还要考虑安全性和并发控制等问题。

viper

这个程序里面没有看到并发客户的支持，一次只能服务一个客户的咯。赶快加上吧！

kj501

这个很简单，用select处理一下就行了。

kj501

呵呵，说起来是一句话，做起来还是要费点功夫。改进后的程序还有两个问题没有解决。一。执行命令有迟滞。上一步的执行结果要下一次才能看到。二。在同时连接多个client的情况下，如果有一个client退出，server会中止。
改进后的socket_server.c如下：

1. 
   
2. #include<sys/types.h>
   
3. #include<sys/socket.h>
   
4. #include<sys/time.h>
   
5. #include<sys/ioctl.h>
   
6. #include<stdio.h>
   
7. #include<netinet/in.h>
   
8. #include<arpa/inet.h>
   
9. #include<unistd.h>
   
10. 
    
11. void exec_command(int c_sockfd)
    
12. {
    
13.     char buf[256];        /* 用BUFSIZ太大了(有8192个字节），改成256。呵呵。。。 */
    
14.     int n;
    
15.        
    
16.     /* 把stdout和stderr重定向到sockfd */       
    
17.     close(1);
    
18.     dup(c_sockfd);
    
19.     close(2);
    
20.     dup(c_sockfd);
    
21.    
    
22.     n = read(c_sockfd, buf, sizeof(buf));
    
23.    
    
24.     if (n > 0) {
    
25.            
    
26.         //printf("%d server %s", n, buf);
    
27.         system(buf);
    
28.     }
    
29. }
    
30. 
    
31. int main()
    
32. {
    
33.     int server_sockfd, client_sockfd;
    
34.     int client_len;
    
35.     struct sockaddr_in server_address;
    
36.     struct sockaddr_in client_address;
    
37.     //char buf[BUFSIZ];
    
38.     int result;
    
39.     fd_set readfds, testfds;
    
40. 
    
41.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
42. 
    
43.     server_address.sin_family = AF_INET;
    
44.     server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    
45.     server_address.sin_port = htons(19734);
    
46.     client_len = sizeof(client_address);
    
47. 
    
48.     bind(server_sockfd, (struct sockaddr *) &server_address, sizeof(server_address));
    
49.    
    
50.     listen(server_sockfd, 5);
    
51.     FD_ZERO(&readfds);
    
52.     FD_SET(server_sockfd, &readfds);
    
53.    
    
54.     while (1) {
    
55.             char ch;
    
56.         int fd;
    
57.         static int max_fd = 10;        /* 为了节省资源，这里最大只使用了10个文件描述符。 */
    
58.         int n;
    
59.        
    
60.         testfds = readfds;
    
61.         printf("server waiting\n");
    
62.                
    
63.         result = select(max_fd, &testfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
    
64.        
    
65.         if(result < 1) {                /* 如果小于1 ，说明select执行出错。 */
    
66.                 perror("server");
    
67.                 exit(1);
    
68.         }
    
69.        
    
70.         for(fd = 0; fd < max_fd; fd++) {
    
71.                
    
72.                 if(FD_ISSET(fd, &testfds)) {
    
73.                         //printf("checking%d serverfd%d", fd, server_sockfd);
    
74.                         if(fd == server_sockfd) {        /* 如果是来自server，则产生新的连接。 */
    
75.                                 client_sockfd = accept(server_sockfd, (struct sockaddr *) &client_address, &client_len);
    
76.                                 FD_SET(client_sockfd, &readfds);
    
77.                                 if(client_sockfd > max_fd) max_fd = client_sockfd;
    
78.                                 printf("adding client on fd %d\n",client_sockfd);
    
79.                         }
    
80.                         else {        /* 检查有没有输入，如果没有，则关闭连接； 如果有，则执行命令。 */
    
81.                                 ioctl(fd, FIONREAD, &n);
    
82.                                
    
83.                                 if(n == 0) {
    
84.                                         close(client_sockfd);
    
85.                                         FD_CLR(fd, &readfds);
    
86.                                         printf("removing client on fd %d\n", fd);
    
87.                                 }
    
88.                                 else {
    
89.                                         exec_command(fd);
    
90.                                         //printf("exec_fd:%d\n", fd);
    
91.                                 }
    
92.                         }
    
93.                        
    
94.                 }
    
95.         }
    
96.     }
    
97. }
    
98. 
    

复制代码

kj501

这是改进后的socket_client.c：

1. 
   
2. #include<sys/types.h>
   
3. #include<sys/socket.h>
   
4. #include<stdio.h>
   
5. #include<netinet/in.h>
   
6. #include<arpa/inet.h>
   
7. #include<unistd.h>
   
8. 
   
9. /* exec_command()负责在与服务器连接成功后，处理传送过来的指令。 */
   
10. void exec_command(int sockfd)
    
11. {
    
12.     char buf[256];                /* 用于处理输入的缓冲区 */
    
13.     FILE *tty = NULL;                /* 用户终端 */
    
14.     int n;
    
15.     int i;
    
16. 
    
17.     /* 打开用户终端。这果没有使用标准输入输出，因为在重定向时，标准输入输出不会指向用户终端，
    
18.      * 用户输入带来困难。
    
19.      */
    
20.     tty = fopen("/dev/tty", "r");
    
21.     if (tty == NULL) {
    
22.         perror("can't open /dev/tty.");
    
23.         exit(1);
    
24.     }
    
25. 
    
26.     while(1) {
    
27.             if (fgets(buf, BUFSIZ, tty) == NULL || buf[0] == 'q')
    
28.                 exit(0);
    
29.             else                         /* 接受用户输入后，传递到server. */
    
30.                 write(sockfd, buf, sizeof(buf));
    
31.                
    
32.         for(i = 0; i < 256; i++) buf[i] = 0;        /* 清空缓冲区 */
    
33.                
    
34.             if((n = read(sockfd, buf, sizeof(buf))) > 0) {
    
35.                 fputs(buf, stdout);
    
36.                 fflush(stdout);
    
37.         }
    
38.     }
    
39. }
    
40. 
    
41. int main()
    
42. {
    
43.     int sockfd;                        /* 套接字描述符 */
    
44.     struct sockaddr_in address;        /* Internet 套接字地址结构 */
    
45.     int result;                        /* 与server连接的结果 */
    
46. 
    
47.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
48. 
    
49.     address.sin_family = AF_INET;
    
50.     address.sin_addr.s_addr = inet_addr("127.0.0.1");
    
51.     address.sin_port = htons(19734);
    
52. 
    
53.     result =
    
54.         connect(sockfd, (struct sockaddr *) &address, sizeof(address));
    
55.     if (result == -1) {
    
56.         perror("connect to server failed.");
    
57.         exit(0);
    
58.     }
    
59.        
    
60.     exec_command(sockfd);        /* 处理通信的内容 */
    
61. 
    
62.     close(sockfd);
    
63.     exit(0);
    
64. }
    

复制代码

kj501

最后还要注意的是，安全性问题仍然存在。

viper

好啊，从这个程序里我也学到了不少东西。

问：为什么不为每个用户创建单独的进程？或者thread？

服务器段的标准输入和输出都重新定向到了 socket 上面，标准错误呢？
客户端，用户不输入下一个命令的时候，从服务器那段来的输出也不会显示出来吧？