2.1.2 小试牛刀--模拟实现Windows的TCP程序

实例功能 使用Visual C++开发一个类似于Windows自带的TCP程序

源码路径 光盘\yuanma\2\TCP

本实例的目的是，使用Visual C++ 6.0开发一个类似于Windows自带的TCP程序。

1. 划分模块

项目中TCP模块的功能描述如下。

(1) 服务器端能够以默认选项启动提供服务功能，默认选项包括服务器端的IP或主机名和端口号。

(2) 服务器端能够根据用户指定的选项，提供服务功能，这些选项包括服务器端的IP或主机名和端口号。

(3) 如果服务器以错误选项启动，则提示错误信息，并终止程序。

(4) 客户端连接到服务器端后，可以发送信息到服务器，也可以接收来自服务器端的响应。

(5) 如果客户端不能连接到服务器端，则输出错误信息。

(6) 当客户端以错误选项启动时，会提示错误信息，并终止程序。

根据上述功能分析，得出TCP模块的构成功能如下所示。

服务器端

初始化模块：初始化全局变量，并为全局变量赋值，初始化Winsock，并加载Winsock库。

功能控制模块：是其他模块的调用函数，实现参数获取、用户帮助和错误处理等。

循环控制模块：用于控制服务器端的服务次数，如果超过指定次数则停止服务。

服务模块：为客户提供服务，接收客户端的数据，并发送数据到客户端。

客户端

初始化模块：用于初始化客户端的Winsock，并加载Winsock库。

功能控制模块：是其他模块的调用函数，实现参数获取、用户帮助和错误处理等。

传输控制模块：用于控制整个客户端的数据传输，包括发送和接收。

总体结构如图2-5所示。

图2-5  TCP模块的总体结构

2. 运行流程分析

(1) 服务器端运行流程。

在服务器端，首先调用GetArgments()函数获取用户提供的选项，如果没有提供选项，则直接使用默认值，如果有选项提供并成功获取，则初始化变量和Winsock，并创建TCP流套接字，然后解析主机名或IP地址，解析成功后设置服务器地址的各个参数，包括地址族和IP地址等。接下来将创建的TCP流套接字和设定的服务器地址绑定。绑定成功后开始侦听客户端的连接，并调用循环函数LoopControl()函数和Service()函数进行接收客户端的连接、接收数据和发送数据等操作。当服务次数达到最多服务次数时，则关闭服务器，并释放所占用的资源。

(2) 客户端运行流程。

客户端执行时必须带选项，首先判断用户提供参数的个数，如果参数不是3个，则说明没有提供正确的选项，退出当前程序。如果等于3个，则调用GetArgments()函数获取用户提供的选项，如果获取的选项错误则终止程序，正确则创建TCP流套接字，接着进行和服务器端类似的操作，即解析主机和IP地址，然后进行连接服务器的操作，连接成功则输出连接信息，并发送信息到客户端，然后接收来自服务器端的响应，并将接收到的信息输出。最后关闭套接字并释放所占用的资源。

3. 设计数据结构

(1) 服务器端的全局变量如下：

1. /*定义全局变量*/  
2. char *hostName;  
3. unsigned short maxService;  
4. unsigned short  port; 

 

(2) 客户端的全局变量如下：

1. /*定义全局变量*/  
2. unsigned short port;  
3. char *hostName; 

 

4. 规划函数

(1) 服务器端。服务器端的构成函数如下。

intial()：用于初始化服务器端的全局变量。

InitSockets()：用于初始化Winsock。

GetArgments()：用于获取用户提供的选项。

ErrorPrint()：用于输出错误信息。

LoopControl()：实现循环控制，当服务器次数在指定范围内时，将接收客户端请求，并创建一个线程为客户端服务。

Service()：用于服务客户端。

(2) 客户端。客户端的构成函数如下。

InitSockets()：用于初始化Winsock。

GetArgment()：用于获取用户提供的选项。

ErrorPrint()：用于输出错误信息。

5. 具体编码

(1) 服务器端编码

① 预处理

预处理包括文件导入、头文件加载、定义常量、定义变量等操作。具体代码如下：

 

1. /*导入库文件*/  
2. #pragma comment(lib, "wsock32.lib")  
3. /*加载头文件*/  
4. #include <stdio.h> 
5. #include <winsock2.h> 
6. /*自定义函数原型*/  
7. void initial();  
8. int InitSockets(void);  
9.  
10. void GetArgments(int argc, char **argv);  
11. void ErrorPrint(x);  
12. void userHelp();  
13.  
14. int LoopControl(SOCKET listenfd, int isMultiTasking);  
15.  
16. void Service(LPVOID lpv);  
17.  
18. /*定义常量*/  
19. #define MAX_SER 10  
20. /*定义全局变量*/  
21. char *hostName;  
22. unsigned short maxService;  
23. unsigned short  port;  

② 初始化模块

此处的初始化分为全局变量初始化和Winsock初始化两部分，分别通过如下两个函数来实现：

initial()：用于初始化全局变量，通过设置hostName="127.0.0.1"，说明程序运行时仅限定客户端和服务器在同一台机器上。

InitSockets(void)：用于初始化Winsock。

对应的代码如下：

1. /*初始化全局变量函数*/  
2. void initial()  
3. {  
4. hostName = "127.0.0.1";  
5. maxService = 3;  
6. port = 9999;  
7. }  
8.  
9. /*初始化Winsocket函数*/  
10. int InitSockets(void)  
11. {  
12. WSADATA wsaData;  
13. WORD sockVersion;  
14. int err;  
15.  
16. /*设置Winsock版本号*/  
17. sockVersion = MAKEWORD(2, 2);  
18. /*初始化Winsock*/  
19. err = WSAStartup(sockVersion, &wsaData);  
20. /*如果初始化失败*/  
21. if (err != 0)  
22. {  
23. printf("Error %d: Winsock not available\n", err);  
24. return 1;  
25. }  
26. return 0;  
27. }  

③ 功能控制模块

此模块提供了参数获取、错误输出和用户帮助等功能，上述功能分别通过如下3个函数实现：

GetArgments：用于获取用户提供的选项值。

ErrorPrint：用于输出错误。

userHelp：用于输出帮助信息。

对应的实现代码如下：

1. /*获取选项函数*/  
2. void GetArgments(int argc, char **argv)  
3. {  
4. int i;  
5. for(i=1; i<argc; i++)  
6. {  
7. /*参数的第一个字符若是“-”*/  
8. if (argv[i][0] == '-')  
9. {  
10. /*转换成小写*/  
11. switch (tolower(argv[i][1]))  
12. {  
13. /*若是端口号*/  
14. case 'p':   
15. if (strlen(argv[i]) > 3)  
16. port = atoi(&argv[i][3]);  
17. break;  
18. /*若是主机名*/  
19. case 'h':   
20. hostName = &argv[i][3];  
21. break;  
22. /*最多服务次数*/  
23. case 'n':   
24. maxService = atoi(&argv[i][3]);  
25. break;  
26. /*其他情况*/  
27. default:  
28. userHelp();  
29. break;  
30. }  
31. }  
32. }  
33. return;  
34. }  
35.  
36. /*错误输出函数*/  
37. void ErrorPrint(x)  
38. {   
39. printf("Error %d: %s\n", WSAGetLastError(), x);  
40. }  
41.  
42. /*用户帮助函数*/  
43. void userHelp()  
44. {  
45. printf("userHelp:  -h:str -p:int -n:int\n");  
46. printf("           -h:str  The host name \n");  
47. printf("                   The default host is 127.0.0.1\n");  
48. printf("           -p:int  The Port number to use\n");  
49. printf("                   The default port is 9999\n");  
50. printf("           -n:int  The number of service,below MAX_SER \n");  
51. printf("                   The default number is 3\n");  
52. ExitProcess(-1);  
53. }  

④ 循环控制模块

此模块的功能是通过函数LoopControl实现的，具体代码如下：

1. /*循环控制函数*/  
2. int LoopControl(SOCKET listenfd, int isMultiTasking)  
3. {  
4. SOCKET acceptfd;  
5. struct sockaddr_in clientAddr;  
6. int err;  
7. int nSize;  
8. int serverNum = 0;  
9. HANDLE handles[MAX_SER];  
10. int myID;  
11.  
12. /*服务次数小于最大服务次数*/  
13. while (serverNum < maxService)  
14. {  
15. nSize = sizeof(clientAddr);  
16. /*接收客户端请求*/  
17. acceptacceptfd = accept(listenfd, (struct sockaddr *)  
18.                          &clientAddr, &nSize);  
19. /*如果接收失败*/  
20. if (acceptfd == INVALID_SOCKET)  
21. {  
22. ErrorPrint("Error: accept failed\n");  
23. return 1;  
24. }  
25. /*接收成功*/  
26. printf("Accepted connection from client at %s\n",  
27.              inet_ntoa(clientAddr.sin_addr));  
28. /*如果允许多任务执行*/  
29. if (isMultiTasking)   
30. {  
31. /*创建一个新线程来执行任务，新线程的初始堆栈大小为1000，线程执行函数  
32. 是Service()，传递给Service()的参数为acceptfd*/  
33. handles[serverNum] = CreateThread(NULL, 1000,  
34.                       (LPTHREAD_START_ROUTINE)Service,  
35.                       (LPVOID) acceptfd, 0, &myID);  
36.  
37. }  
38. else  
39. /*直接调用服务客户端的函数*/  
40. Service((LPVOID)acceptfd);  
41. serverNum++;  
42. }  
43.  
44. if (isMultiTasking)  
45. {  
46. /*在一个线程中等待多个事件，当所有对象都被通知时函数才会返回，且等待没有时间限制*/  
47. err = WaitForMultipleObjects(maxService, handles, TRUE, INFINITE);  
48. printf("Last thread to finish was thread #%d\n", err);  
49. }  
50. return 0;  
51. }  

⑤ 服务模块

此模块的功能是通过函数Service()实现的，功能是实现接收、判断来自客户端的数据，并发送数据到客户端。具体代码如下：

1. /*服务函数*/  
2. void Service(LPVOID lpv)  
3. {  
4. SOCKET acceptfd = (SOCKET)lpv;  
5. const char *msg = "HELLO CLIENT";  
6. char response[4096];  
7.  
8. /*用0初始化response[4096]数组*/  
9. memset(response, 0, sizeof(response));  
10. /*接收数据，存入response中*/  
11. recv(acceptfd, response, sizeof(response), 0);  
12.  
13. /*如果接收到的数据和预定义的数据不同*/  
14. if (strcmp(response, "HELLO SERVER"))   
15. {  
16. printf("Application:  client not using expected "  
17. "protocol %s\n", response);  
18. }  
19. else  
20. /*发送服务器端信息到客户端*/  
21. send(acceptfd, msg, strlen(msg)+1, 0);  
22. /*关闭套接字*/  
23. closesocket(acceptfd);  
24. }  

⑥ 主函数模块

主函数是整个程序的入口，里面实现了套接字的创建、绑定、侦听和释放等操作，并且实现了对各个功能函数的调用。具体代码如下：

1. 1. /*主函数*/  
   2. int main(int argc, char **argv)  
   3. {  
   4. SOCKET listenfd;  
   5. int err;  
   6. struct sockaddr_in serverAddr;  
   7. struct hostent *ptrHost;  
   8. initial();  
   9. GetArgments(argc, argv);  
   10. InitSockets();  
   11. /*创建TCP流套接字，在domain参数为PF_INET的SOCK_STREAM的
       套接口中，protocol参数为0意味着告诉内核选择IPPRPTP_TCP，
       这也意味着套接口将使用TCP/IP协议*/  
   12. listenfd = socket(PF_INET, SOCK_STREAM, 0);  
   13. /*如果创建套接字失败*/  
   14. if (listenfd == INVALID_SOCKET)  
   15. {  
   16. printf("Error: out of socket resources\n");  
   17. return 1;  
   18. }  
   19.  
   20. /*如果是IP地址*/  
   21. if (atoi(hostName))   
   22. {  
   23. /*将IP地址转换成32二进制表示法，返回32位二进制的网络字节序*/  
   24. u_long ip_addr = inet_addr(hostName);  
   25. /*根据IP地址找到与之匹配的主机名*/  
   26. ptrHost = gethostbyaddr((char*)&ip_addr,  
   27.                       sizeof(u_long), AF_INET);  
   28. }  
   29. /*如果是主机名*/  
   30. else  
   31. /*根据主机名获取一个指向hosten的指针，该结构中包含了该主机所有的IP地址*/  
   32. ptrHost = gethostbyname(hostName);  
   33.  
   34. /*如果解析失败*/  
   35. if (!ptrHost)  
   36. {  
   37. ErrorPrint("cannot resolve hostname");  
   38. return 1;  
   39. }  
   40.  
   41. /*设置服务器地址*/  
   42. /*设置地址族为PF_INET*/  
   43. serverAddr.sin_family = PF_INET;  
   44. /*将一个通配的Internet地址转换成无符号长整型的网络字节序数*/  
   45. serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   46. /*将端口号转换成无符号短整型的网络字节序数*/  
   47. serverAddr.sin_port = htons(port);  
   48.  
   49. /*将套接字与服务器地址绑定*/  
   50. err = bind(listenfd, (const struct sockaddr *) &serverAddr,  
   51.                sizeof(serverAddr));  
   52. /*如果绑定失败*/  
   53. if (err == INVALID_SOCKET)  
   54. {  
   55. ErrorPrint("Error: unable to bind socket\n");  
   56. return 1;  
   57. }  
   58.  
   59. /*开始侦听，设置等待连接的最大队列长度为SOMAXCONN，默认值为5个*/  
   60. err = listen(listenfd, SOMAXCONN);  
   61. /*如果侦听失败*/  
   62. if (err == INVALID_SOCKET)  
   63. {  
   64. ErrorPrint("Error: listen failed\n");  
   65. return 1;  
   66. }  
   67.  
   68. LoopControl(listenfd, 1);  
   69. printf("Server is down\n");  
   70. /*释放Winscoket初始化时占用的资源*/  
   71. WSACleanup();  
   72. return 0;  
   73. }  

(2) 客户端

① 预处理

预处理包括文件导入、头文件加载、定义常量、定义变量等操作。具体代码如下：

1. /*导入库文件*/  
2. #pragma comment(lib, "wsock32.lib")  
3. /*加载头文件*/  
4. #include <stdio.h> 
5. #include <winsock2.h> 
6.  
7. /*自定义函数*/  
8. int InitSockets(void);  
9.  
10. void GetArgument(int argc, char **argv);  
11. void ErrorPrint(x);  
12. void userHelp();  
13.  
14. /*定义全局变量*/  
15. unsigned short port;  
16. char *hostName;  

② 初始化模块

初始化模块无需对全局变量赋值，只须实现对Winsock的初始化，包括初始化套接字版本号和加载Winsock库。具体代码如下：

1. /*初始化Winsock函数*/  
2. int InitSockets(void)  
3. {  
4. WSADATA wsaData;  
5. WORD sockVersion;  
6. int err;  
7.  
8. /*设置Winsock版本号*/  
9. sockVersion = MAKEWORD(2, 2);  
10. /*初始化Winsock*/  
11. err = WSAStartup(sockVersion, &wsaData);  
12. /*如果初始化失败*/  
13. if (err != 0)  
14. {  
15. printf("Error %d: Winsock not available\n", err);  
16. return 1;  
17. }  
18. return 0;  
19. }  

③ 功能控制模块

此模块提供了参数获取、错误输出和用户帮助等功能，上述功能分别通过如下函数来实现。

GetArgments：用于获取用户提供的选项值。

ErrorPrint：用于输出错误。

userHelp：用于输出帮助信息。

对应的实现代码如下：

1. 1. /*获取选项函数*/  
   2. void GetArgments(int argc, char **argv)  
   3. {  
   4. int i;  
   5. for(i=1; i<argc; i++)  
   6. {  
   7. /*参数的第一个字符若是“-”*/  
   8. if (argv[i][0] == '-')  
   9. {  
   10. /*转换成小写*/  
   11. switch (tolower(argv[i][1]))  
   12. {  
   13. /*若是端口号*/  
   14. case 'p':   
   15. if (strlen(argv[i]) > 3)  
   16. port = atoi(&argv[i][3]);  
   17. break;  
   18. /*若是主机名*/  
   19. case 'h':   
   20. hostName = &argv[i][3];  
   21. break;  
   22. /*其他情况*/  
   23. default:  
   24. userHelp();  
   25. break;  
   26. }  
   27. }  
   28. }  
   29. return;  
   30. }  
   31.  
   32. /*错误输出函数*/  
   33. void ErrorPrint(x)  
   34. {   
   35. printf("Error %d: %s\n", WSAGetLastError(), x);  
   36. }  
   37.  
   38. /*用户帮助函数*/  
   39. void userHelp()  
   40. {  
   41. printf("userHelp:  -h:str -p:int\n");  
   42. printf("           -h:str  The host name \n");  
   43. printf("           -p:int  The Port number to use\n");  
   44. ExitProcess(-1);  
   45. }  

④ 数据传输控制模块

客户端程序会把数据的传入传出部分放在主函数中执行，也就是说此处的数据传输功能是通过主函数实现的。主函数中包括套接字创建、绑定和释放，并实现对服务器连接、数据发送、数据接收等各个模块的调用。具体实现代码如下：

1. /*主函数*/  
2. int main(int argc, char **argv)  
3. {  
4. SOCKET clientfd;  
5. int err;  
6. struct sockaddr_in serverAddr;  
7. struct hostent *ptrHost;  
8. char response[4096];  
9. char *msg = "HELLO SERVER";  
10. GetArgments(argc, argv);  
11. if (argc != 3)   
12. {  
13. userHelp();  
14. return 1;  
15. }  
16. GetArgments(argc,argv);  
17. InitSockets();  
18. /*创建套接字*/  
19. clientfd = socket(PF_INET, SOCK_STREAM, 0);  
20. /*如果创建失败*/  
21. if (clientfd == INVALID_SOCKET)  
22. {  
23. ErrorPrint("no more socket resources");  
24. return 1;  
25. }  
26. /*根据IP地址解析主机名*/  
27. if (atoi(hostName))  
28. {  
29. u_long ip_addr = inet_addr(hostName);  
30. ptrHost = gethostbyaddr((char*)&ip_addr,  
31.             sizeof(u_long), AF_INET);  
32. }  
33. /*根据主机名解析IP地址*/  
34. else  
35. ptrHost = gethostbyname(hostName);  
36.  
37. /*如果解析失败*/  
38. if (!ptrHost)  
39. {  
40. ErrorPrint("cannot resolve hostname");  
41. return 1;  
42. }  
43.  
44. /*设置服务器端地址选项*/  
45. serverAddr.sin_family = PF_INET;  
46. memcpy((char*)&(serverAddr.sin_addr),  
47.         ptrHost->h_addr, ptrHost->h_length);  
48. serverAddr.sin_port = htons(port);  
49.  
50. /*连接服务器*/  
51. err = connect(clientfd, (struct sockaddr *) &serverAddr,  
52.              sizeof(serverAddr));  
53. /*连接失败*/  
54. if (err == INVALID_SOCKET)  
55. {  
56. ErrorPrint("cannot connect to server");  
57. return 1;  
58. }  
59. /*连接成功后，输出信息*/  
60. printf("You are connected to the server\n");  
61. /*发送消息到服务器端*/  
62. send(clientfd, msg, strlen(msg)+1, 0);  
63. memset(response, 0, sizeof(response));  
64. /*接收来自服务器端的消息*/  
65. recv(clientfd, response, sizeof(response), 0);  
66. printf("server says %s\n", response);  
67. /*关闭套接字*/  
68. closesocket(clientfd);  
69. /*释放Winscoket初始化时占用的资源*/  
70. WSACleanup();  
71. return 0;  
72. }  

 

到此为止，整个实例设计完毕，编译执行后的效果如图2-6所示。

图2-6  执行效果

转载于:https://www.cnblogs.com/For-her/p/3939393.html