實驗2 基於數據報套接字的網絡程序設計（計算機網絡Ⅱ）

 

一、實驗環境

操作系統：Win10

開發工具：VS2017

使用語言：C

二、實驗內容

1.設計思路

（1）基於數據報套接字的循環服務器回射程序設計

實現基於數據報套接字的循環服務器回射程序編程模型如（1）數據報套接字編程模型。對於數據報循環服務器，服務器每次接收到一個客戶的請求並處理后，繼續接收進入套接字接收緩沖區的其他請求，因此調用recvfrom()，而后調用sendto()回射數據是循環進行的。這是最常見的無連接服務器的形式，適用於要求對每個請求進行少量處理的服務器設計。

（2）基於數據報套接字的並發服務器回射程序設計

對於並發服務器，則要求當服務器與一個客戶進行通信的過程中，可以同時接收其他客戶的服務請求，並且服務器要為每一個客戶創建一個單獨的子線程。  

為了實現客戶與服務器多次交互數據的並發服務器，本實驗采取讓服務器在新線程中為每個客戶創建一個新的套接字，在其上綁定一個臨時端口，然后使用這個套接字處理該客戶的后續所有數據交互。而新客戶的請求還是用服務器最初創建的套接字以及綁定的端口號進行接收。交互過程如圖2-2所示。

 

圖2-2  多次交互的客戶請求過程

  首先客戶端向服務器綁定源端口4502發送請求報文，服務器接收后為其創建子線程，並在線程中創建新的套接口，綁定臨時端口號4503（代碼具體實現中，每個臨時端口依次遞增1），之后便可以進行正確的並發服務和通信，即recvfrom()接收數據，sendto()回射消息。

（3）無連接應用程序丟包率測試

用戶可以在客戶端設置好發包次數sCount，調用sCount次sendto()函數將緩沖區數據發送給服務器。

服務器通過套接字選項SO_RCVBUF選項設置緩沖區大小，通過SO_RCVTIMEO選項設置超時時間，然后開始每隔1000ms接收一次數據。統計接收次數，即收到的數據報個數，最后在服務器計算出丟包率。

2.程序清單（要求有詳細的注釋）

（1）基於數據報套接字的循環服務器回射程序設計

①服務器

1. #include <stdio.h>  
2. #include "winsock2.h"  
3. #pragma comment(lib, "ws2_32.lib")  
4. #define SERVER_PORT 4501  
5. #define MAXLINE 1024    //緩沖區長度  
6. int main()  
7. {  
8. WSADATA wsd; //WSADATA變量  
9. SOCKET sConnfd;//連接套接字  
10. sockaddr_in Cliaddr, Servaddr;//通信地址  
11. char sendBuf[MAXLINE]; //發送緩沖區  
12. char recvBuf[MAXLINE];//接收緩沖區  
13. int len = sizeof(SOCKADDR);  
14. int dwError;  
15. //初始化套結字動態庫  
16. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
17. {  
18. printf("WSAStartup failed!\n");  
19. return -1;  
20. }  
21. if (LOBYTE(wsd.wVersion) != 2 ||HIBYTE(wsd.wVersion) != 2)   
22. {  
23. WSACleanup();  
24. return -1;  
25. }  
26. //創建監聽套接字  
27. sConnfd = socket(AF_INET, SOCK_DGRAM, 0);  
28. if (INVALID_SOCKET == sConnfd)  
29. {  
30. printf("socket failed!\n");  
31. WSACleanup();//釋放套接字資源;  
32. return  -1;  
33. }  
34. memset(&Servaddr, 0, sizeof(Servaddr));  
35. //服務器監聽套接字地址   
36. Servaddr.sin_family = AF_INET;  
37. Servaddr.sin_port = htons(SERVER_PORT);  
38. Servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//將IP地址指定為INADDR_ANY，允許套接字向任何分配給本地機器的IP地址發送或接收數據。  
39. //綁定監聽套接字  
40. if (SOCKET_ERROR == bind(sConnfd, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))  
41. {  
42. dwError = WSAGetLastError();  
43. printf("bind函數調用錯誤，錯誤號: %d\n", dwError);  
44. closesocket(sConnfd);   //關閉套接字  
45. WSACleanup();           //釋放套接字資源  
46. return -1;  
47. }  
48. for(;;)  
49. {  
50. //接收數據，連接套接字，接收緩沖區，緩沖區長度，正常發送方式，源地址指針，地址大小  
51. if(SOCKET_ERROR==(recvfrom(sConnfd, recvBuf, MAXLINE, 0, (SOCKADDR*)&Cliaddr, &len)))  
52. {  
53. printf("recvfrom函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
54. closesocket(sConnfd);   //關閉套接字  
55. WSACleanup();           //釋放套接字資源  
56. return -1;  
57. }  
58. sprintf(sendBuf, "echo: %s",recvBuf);  
59. printf("%s\n", sendBuf);  
60. //回射消息  
61. if(SOCKET_ERROR==(sendto(sConnfd, recvBuf, strlen(recvBuf) + 1, 0, (SOCKADDR*)&Cliaddr, len)))  
62. {  
63. printf("sendto函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
64. closesocket(sConnfd);   //關閉套接字  
65. WSACleanup();           //釋放套接字資源  
66. return -1;  
67. }  
68. }  
69. closesocket(sConnfd);  
70. WSACleanup();  
71. return 0;  
72. }  

②客戶端

1. #include <stdio.h>  
2. #include "winsock2.h"  
3. #pragma comment(lib, "ws2_32.lib")  
4. #define SERVER_PORT 4501  
5. #define MAXLINE 1024    //接收緩沖區長度  
6. int main()  
7. {  
8. WSADATA wsd; //WSADATA變量  
9. SOCKET cConnfd;//連接套接字  
10. sockaddr_in Servaddr;//通信地址  
11. char sendBuf[MAXLINE]; //發送緩沖區  
12. char recvBuf[MAXLINE];//接收緩沖區  
13. int len = sizeof(SOCKADDR);  
14. //初始化套結字動態庫  
15. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
16. {  
17. printf("WSAStartup failed!\n");  
18. return -1;  
19. }  
20. if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2)  
21. {  
22. WSACleanup();  
23. return -1;  
24. }  
25. //創建監聽套接字  
26. cConnfd = socket(AF_INET, SOCK_DGRAM, 0);  
27. if (INVALID_SOCKET == cConnfd)  
28. {  
29. printf("socket failed!\n");  
30. WSACleanup();//釋放套接字資源;  
31. return  -1;  
32. }  
33. memset(&Servaddr, 0, sizeof(Servaddr));  
34. //設置服務器地址  
35. Servaddr.sin_family = AF_INET;  
36. Servaddr.sin_port = htons(SERVER_PORT);  
37. Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
38. for(;;)  
39. {  
40. gets_s(sendBuf);  
41. if (sendBuf[0] == 'q')  
42. {  
43. printf("程序退出\n");  
44. return -1;  
45. }  
46. sendto(cConnfd, sendBuf, strlen(sendBuf) + 1, 0,(SOCKADDR*)&Servaddr, len);//發送數據  
47. recvfrom(cConnfd, recvBuf, MAXLINE, 0, (SOCKADDR*)&Servaddr, &len);//接收數據  
48. printf("echo: %s\n", recvBuf);  
49. }  
50. closesocket(cConnfd);  
51. WSACleanup();  
52. return 0;  
53. }  

（2）基於數據報套接字的並發服務器回射程序設計

①服務器

1. #include <stdio.h>  
2. #include <winsock2.h>  
3. #pragma comment(lib, "WS2_32")  // 鏈接到WS2_32.lib  
4. #define SERVER_PORT 4502  
5. #define MAXLINE 1024  
6. int tempPort = SERVER_PORT;//臨時端口號  
7. DWORD WINAPI str_echo(LPVOID sd)  
8. {     
9. char recvBuf[MAXLINE];        
10. char szBuf[MAXLINE];          
11. SOCKADDR_IN Cliaddr;  
12. int iClilen = sizeof(SOCKADDR);  
13. int tmp = tempPort;  
14. int retVal = 0;  
15. //在新的套接口上綁定臨時端口  
16. SOCKET tempSocket = socket(AF_INET, SOCK_DGRAM, 0);  
17. SOCKADDR_IN Servaddr;  
18. Servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
19. Servaddr.sin_family = AF_INET;  
20. Servaddr.sin_port = htons(tmp);  
21. //綁定  
22. if (SOCKET_ERROR == bind(tempSocket, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))  
23. {  
24. printf("bind函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
25. closesocket(tempSocket);    //關閉套接字  
26. WSACleanup();           //釋放套接字資源  
27. return -1;  
28. }  
29. for(;;)  
30. {  
31. retVal = recvfrom(tempSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Cliaddr, &iClilen);  
32. if (retVal == SOCKET_ERROR)  
33. {  
34. printf("recvfrom函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
35. closesocket(tempSocket);  
36. WSACleanup();  
37. return -1;  
38. }             
39. sprintf_s(szBuf, "%d echo：%s", ntohs(Servaddr.sin_port),recvBuf);  
40. printf("%s\n", szBuf);  
41. retVal = sendto(tempSocket, szBuf, strlen(szBuf) + 1, 0, (SOCKADDR*)&Cliaddr, iClilen);  
42. if (SOCKET_ERROR == retVal)  
43. {  
44. printf("sendto函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
45. closesocket(tempSocket);  
46. WSACleanup();  
47. return -1;  
48. }  
49. }  
50. closesocket(tempSocket);  
51. return 0;  
52. }  
53. int main()  
54. {  
55. WSADATA wsd; //WSADATA變量  
56. SOCKET sSocket;//監聽套接字\連接套接字  
57. sockaddr_in Cliaddr, Servaddr;//通信地址  
58. DWORD dwError = 0;  
59. int iClilen = sizeof(SOCKADDR);//客戶端地址長度  
60. char sendBuf[MAXLINE];//發送緩沖區  
61. char recvBuf[MAXLINE];//接收緩沖區  
62. HANDLE  hThread = NULL; //新線程  
63. //初始化套結字動態庫  
64. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
65. {  
66. printf("WSAStartup failed!\n");  
67. return -1;  
68. }  
69. //創建監聽套接字  
70. sSocket = socket(AF_INET, SOCK_DGRAM, 0);  
71. if (INVALID_SOCKET == sSocket)  
72. {  
73. printf("socket failed!\n");  
74. WSACleanup();//釋放套接字資源;  
75. return  -1;  
76. }  
77. memset(&Servaddr, 0, sizeof(Servaddr));  
78. memset(&Cliaddr, 0, sizeof(Cliaddr));  
79. //建立套接字  
80. Servaddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);  
81. Servaddr.sin_family = AF_INET;  
82. Servaddr.sin_port = htons(SERVER_PORT);  
83. //綁定監聽套接字  
84. if (SOCKET_ERROR == bind(sSocket, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))  
85. {  
86. dwError = WSAGetLastError();  
87. printf("bind函數調用錯誤，錯誤號: %d\n", dwError);  
88. closesocket(sSocket);   //關閉套接字  
89. WSACleanup();           //釋放套接字資源  
90. return -1;  
91. }  
92. for(;;)  
93. {  
94. recvfrom(sSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Cliaddr, &iClilen);  
95. ++tempPort;//給新客戶的臨時端口號  
96. sprintf_s(sendBuf, "%d", tempPort);  
97. //將臨時端口號發給客戶端  
98. sendto(sSocket, sendBuf, sizeof(sendBuf), 0, (SOCKADDR*)&Cliaddr, iClilen);  
99. sprintf_s(sendBuf, "%d echo：%s",tempPort, recvBuf);  
100. printf("%s\n", sendBuf);  
101. sendto(sSocket, sendBuf, sizeof(sendBuf), 0, (SOCKADDR*)&Cliaddr, iClilen);  
102. //利用新的端口號建立新線程  
103. hThread = CreateThread(NULL, 0, str_echo, (LPVOID)sSocket, 0, NULL);  
104. if (hThread == NULL)  
105. {  
106. printf("創建線程失敗！\n");  
107. return -1;  
108. }  
109. }  
110. closesocket(sSocket);  
111. WSACleanup();  
112. return 0;  
113. }  

②客戶端

1. #include <Winsock2.h>  
2. #include <stdio.h>  
3. #pragma comment(lib,"wsock32.lib")  
4. #define MAXLINE 1024  
5. #define SERVER_PORT 4502  
6. int main()  
7. {  
8. WSADATA wsd; //WSADATA變量  
9. SOCKET cSocket;//連接套接字  
10. sockaddr_in Servaddr;//通信地址  
11. DWORD dwError = 0;  
12. int retVal = 0;  
13. int srvLen = sizeof(SOCKADDR);  
14. char sendBuf[MAXLINE];//發送緩沖區  
15. char recvBuf[MAXLINE];//接收緩沖區  
16. int tempPort = SERVER_PORT;  
17. //初始化套結字動態庫  
18. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
19. {  
20. printf("WSAStartup failed!\n");  
21. return -1;  
22. }  
23. //創建監聽套接字  
24. cSocket = socket(AF_INET, SOCK_DGRAM, 0);  
25. if (INVALID_SOCKET == cSocket)  
26. {  
27. printf("socket failed!\n");  
28. WSACleanup();//釋放套接字資源;  
29. return  -1;  
30. }  
31. memset(&Servaddr, 0, sizeof(Servaddr));  
32. //設置服務器地址  
33. Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
34. Servaddr.sin_family = AF_INET;  
35. Servaddr.sin_port = htons(SERVER_PORT);  
36. gets_s(sendBuf);  
37. //  printf("%s",sendBuf);  
38. if (SOCKET_ERROR == sendto(cSocket, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR*)&Servaddr, srvLen))  
39. {  
40. printf("sendto函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
41. closesocket(cSocket);  
42. WSACleanup();  
43. return -1;  
44. }  
45. recvfrom(cSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Servaddr, &srvLen);  
46. tempPort = atoi(recvBuf);  
47. //回射  
48. recvfrom(cSocket, recvBuf, MAXLINE, 0, (SOCKADDR*)&Servaddr, &srvLen);  
49. printf("%s\n", recvBuf);  
50. memset(&Servaddr, 0, sizeof(Servaddr));  
51. Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
52. Servaddr.sin_family = AF_INET;  
53. Servaddr.sin_port = htons(tempPort);  
54. for(;;)//循環接收數據  
55. {  
56. gets_s(sendBuf);  
57. if (sendBuf[0] == 'q')  
58. {  
59. printf("程序退出\n");  
60. return -1;  
61. }  
62. //發送響應數據  
63. retVal = sendto(cSocket, sendBuf, strlen(sendBuf) + 1, 0,(SOCKADDR*)&Servaddr, srvLen);  
64. if (SOCKET_ERROR == retVal)  
65. {  
66. printf("sendto函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
67. closesocket(cSocket);  
68. WSACleanup();  
69. return -1;  
70. }  
71. //接收請求數據  
72. retVal = recvfrom(cSocket, recvBuf, 100, 0, (SOCKADDR*)&Servaddr, &srvLen);  
73. if (retVal == SOCKET_ERROR)  
74. {  
75. printf("recvfrom函數調用錯誤，錯誤號: %d\n", WSAGetLastError());  
76. closesocket(cSocket);  
77. WSACleanup();  
78. return -1;  
79. }  
80. //打印收到的回顯字符串   
81. printf("%s\n", recvBuf);  
82. }  
83. closesocket(cSocket);  
84. WSACleanup();  
85. return 0;  
86. }  

 

（3）無連接應用程序丟包率測試

①服務器

1. #include <stdio.h>  
2. #include "winsock2.h"  
3. #pragma comment(lib, "ws2_32.lib")  
4. #define SERVER_PORT 6888  
6. int main()  
7. {  
8. WSADATA wsd; //WSADATA變量  
9. SOCKET sSocket;//連接套接字  
10. sockaddr_in Servaddr;//通信地址  
11. DWORD dwError = 0;  
12. int retVal = 0;  
13. int srvLen = sizeof(SOCKADDR);  
15. //初始化套結字動態庫  
16. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
17. {  
18. printf("WSAStartup failed!\n");  
19. return -1;  
20. }  
22. //創建監聽套接字  
23. sSocket = socket(AF_INET, SOCK_DGRAM, 0);  
24. if (INVALID_SOCKET == sSocket)  
25. {  
26. printf("socket failed!\n");  
27. WSACleanup();//釋放套接字資源;  
28. return  -1;  
29. }  
31. memset(&Servaddr, 0, sizeof(Servaddr));  
33. //服務器監聽套接字地址   
34. Servaddr.sin_family = AF_INET;  
35. Servaddr.sin_port = htons(SERVER_PORT);  
36. Servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//將IP地址指定為INADDR_ANY，允許套接字向任何分配給本地機器的IP地址發送或接收數據  
37. //綁定監聽套接字                                                     
38. if (SOCKET_ERROR == bind(sSocket, (SOCKADDR *)&Servaddr, sizeof(Servaddr)))  
39. {  
40. dwError = WSAGetLastError();  
41. printf("bind 函數調用錯誤，錯誤號: %d\n", dwError);  
42. closesocket(sSocket);   //關閉套接字  
43. WSACleanup();           //釋放套接字資源  
44. return -1;  
45. }  
46. //設置緩沖大小及超時時間  
47. int recvBufLen;  
48. int len = sizeof(recvBufLen);  
49. printf("請設置接收緩沖區大小：");  
50. scanf("%d", &recvBufLen);  
51. if (setsockopt(sSocket, SOL_SOCKET, SO_RCVBUF, (const char *)&recvBufLen, len) < 0)  
52. {  
53. printf("setsockopt error\n");  
54. return -1;  
55. }  
56. if (getsockopt(sSocket, SOL_SOCKET, SO_RCVBUF, (char *)&recvBufLen, &len) < 0)  
57. {  
58. printf("getsockopt error\n");  
59. return -1;  
60. }  
61. //設置套接字的接收超時時間  
62. int nTimeOver;  
63. printf("請設置接收超時時間：");  
64. scanf("%d", &nTimeOver);  
65. if (setsockopt(sSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&nTimeOver, sizeof(nTimeOver)) < 0)  
66. {  
67. printf("setsockopt error\n");  
68. return -1;  
69. }  
70. printf("\n系統接收緩存大小被設置為: %d bytes\n", recvBufLen);  
71. printf("系統接收超時時間被設置為: %d ms\n", nTimeOver);  
72. SOCKADDR_IN addrClient;  
73. int addrlen = sizeof(SOCKADDR);  
74. char recvBuf[10];  
75. memset(recvBuf, 0, 10);  
76. double dropRate;//丟包率  
77. int count = 0;  
78. int udpClientCount;  
79. char cCount[10];  
80. recvfrom(sSocket, cCount, 10, 0, (SOCKADDR *)&addrClient, &addrlen);  
81. udpClientCount = atoi(cCount);  
82. printf("客戶端一共發送了%d個數據包\n", udpClientCount);  
83. do {  
84. memset(recvBuf, 0, 10);  
85. Sleep(1000);  
86. //接收數據  
87. retVal = recvfrom(sSocket, recvBuf, 10, 0, (SOCKADDR *)&addrClient, &addrlen);  
88. if (retVal > 0) {  
89. count++;  
90. }  
91. else if (retVal == 0)  
92. {  
93. break;  
94. }  
95. else  
96. {  
97. int err = WSAGetLastError();  
98. printf("recvfrom 函數調用錯誤，錯誤號: %d\n", err);  
99. }  
100. } while (retVal > 0);  
102. printf("服務器端總共收到%d個數據報\n", count);  
103. dropRate = 1 - ((double)count) /udpClientCount;  
104. dropRate = dropRate * 100;  
105. printf("丟包率 = %lf\n", dropRate);  
106. closesocket(sSocket);  
107. WSACleanup();  
108. return 0;  
109. }  

②客戶端

1. #include <Winsock2.h>  
2. #include <stdio.h>  
3. #pragma comment(lib,"wsock32.lib")  
5. #define SERVER_PORT 6888  
7. int main()  
8. {  
9. WSADATA wsd; //WSADATA變量  
10. SOCKET cSocket;//連接套接字  
11. sockaddr_in Servaddr;//通信地址  
12. DWORD dwError = 0;  
13. int retVal = 0;  
14. int srvLen = sizeof(SOCKADDR);  
16. //初始化套結字動態庫  
17. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
18. {  
19. printf("WSAStartup failed!\n");  
20. return -1;  
21. }  
22. //創建監聽套接字  
23. cSocket = socket(AF_INET, SOCK_DGRAM, 0);  
24. if (INVALID_SOCKET == cSocket)  
25. {  
26. printf("socket failed!\n");  
27. WSACleanup();//釋放套接字資源;  
28. return  -1;  
29. }  
30. memset(&Servaddr, 0, sizeof(Servaddr));  
31. //設置服務器地址  
32. Servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
33. Servaddr.sin_family = AF_INET;  
34. Servaddr.sin_port = htons(SERVER_PORT);  
36. char sendBuf[10];  
37. memset(sendBuf, 'h', 9);  
38. sendBuf[9] = 0;  
39. int sCount;  
40. int i = 0;  
41. char sendCount[10];  
42. printf("請設置客戶端發送數據包次數：");  
43. scanf("%d", &sCount);  
44. sprintf_s(sendCount, "%d", sCount);  
45. sendto(cSocket, sendCount, sizeof(sendCount), 0, (SOCKADDR*)&Servaddr, sizeof(SOCKADDR));  
46. while (i<sCount)  
47. {  
48. retVal = sendto(cSocket, sendBuf, sizeof(sendBuf), 0, (SOCKADDR*)&Servaddr, sizeof(SOCKADDR));  
49. if (SOCKET_ERROR == retVal)  
50. {  
51. printf("sendto 函數調用錯誤，錯誤號： %d\n", WSAGetLastError());  
52. return -1;  
53. }  
54. i++;  
55. }  
56. closesocket(cSocket);  
57. WSACleanup();  
58. return 0;  
59. }  

3.用戶使用說明（輸入 / 輸出規定）

（1）基於數據報套接字的循環服務器回射程序設計

輸入：在客戶端輸入要發送的消息或字符’q’，按“回車”鍵；

輸出：客戶端顯示“echo：”並連接剛剛發送的消息。若輸入為“q”，則顯示“程序退出！”。

（2）基於數據報套接字的並發服務器回射程序設計

輸入：在客戶端輸入要發送的消息或字符’q’，按“回車”鍵；

輸出：客戶端顯示“端口號 echo：”並連接剛剛發送的消息。若輸入為“q”，則顯示“程序退出！”。

（3）無連接應用程序丟包率測試

輸入：在客戶端輸入要發送數據包的數量，按“回車”鍵；在服務器根據提示依次輸入設置的緩沖區大小以及超時時間，按“回車”鍵。

輸出：客戶端顯示“端口號 echo：”並連接剛剛發送的消息。若輸入為“q”，則顯示“程序退出！”。

4.運行結果（要求截圖）

（1）基於數據報套接字的循環服務器回射程序設計

基於數據報套接字的循環服務器回射程序如圖2-3所示。

 

圖2-3  數據庫套接字的循環服務器-客戶端運行結果截圖

a．在客戶端輸入消息“你好呀”，按“回車”鍵，服務器顯示“echo：你好呀”，同時客戶端回射消息“你好呀”；

b．如同a，用戶依次發送消息 “hiahia”、“helloWorld”，並回射相應消息；

c．用戶最后輸入“q”，則顯示“程序退出！”，服務器端繼續等待新的請求。

（2）基於數據報套接字的並發服務器回射程序設計

基於數據報套接字的並發服務器-客戶端運行結果如圖2-4所示。

 

圖2-4  並發服務器-客戶端運行結果截圖

a．首先打開服務器等待請求，接着打開三個客戶端，服務器為其創建三個線程；

b．端口號為4503的用戶首先與服務器進行通信，發送“你好呀”，按“回車”鍵，服務器顯示“4503 echo：你好呀”，同時客戶端回射消息“4503 echo：你好呀”；

c．如同b，不同用戶依次發送消息 “hiahia”、“helloWorld”、 “嘻嘻”，並在對應用戶窗口回射相應的端口號連接“echo：”連接剛剛發送的消息；

d．其中端口號為4504用戶最后輸入“q”，則顯示“程序退出！”，服務器端則斷開與端口號為4504的用戶的連接；

e．端口號為4505的用戶繼續與服務器進行通信，發送“哈哈”，按“回車”鍵，服務器顯示“4505 echo：哈哈”，同時客戶端回射消息“4505 echo：哈哈”，服務器與其他用戶通信正常。

（3）無連接應用程序丟包率測試

無連接應用程序丟包率測試結果如圖2-5所示。

 

圖2-5  無連接應用程序丟包率測試結果截圖

a．客戶端設置好要發送的數據包個數“10”，按“回車”鍵，此時數據包放入套接字緩沖區；

b．服務器設置好緩沖區大小，以及系統接收超時時間，按“回車”鍵；

c．服務器返回客戶端發包數，和服務器收包數，並計算出丟包率。

超時時間一定，nTimeOver=1000 ms，服務器接收數據包的速度是1000ms/次，改變緩沖區大小，測得數據如表2-1所示。

表2-1  服務器在接收緩存取不同值時的丟包率

緩沖區大小/bytes	超時時間/ms	客戶端發包/個	服務器收包/個	丟包率/%
9	1000	10	1	90
10	1000	10	1	90
20	1000	10	2	80
30	1000	10	3	70
40	1000	10	4	60
50	1000	10	5	50
60	1000	10	6	40
70	1000	10	7	30
80	1000	10	8	20
90	1000	10	9	10
100	1000	10	10	0
110	1000	10	10	0
120	1000	10	10	0

在該實驗代碼中，客戶端一次發送10個10 bytes的包，由於UDP是面向報文，一次交付的，會將一次發送的全部報文放入緩沖區，超出緩沖區的部分報文丟掉，因此在設置10、20、…、100 bytes的套接字緩沖區后，服務器收包個數是1、2、…、10個，根據丟包率計算公式丟包率=1-(服務器收到的報文個數/客戶端發送的報文個數)×100%，丟包率依次是90%、80%、…、0%。

對於小於一個數據包大小的緩沖區，比如上表中的9 bytes，同樣由於UDP數據處理特點，使服務器可以收到1個數據包的9bytes；對於超過發送報文的全部大小的緩沖區，在服務器接收速度為1000ms/次的條件下，服務器可以把全部包都接收到，丟包率為0%。

//多有不妥，歡迎指正