6. 分析多播消息接收流程

多播消息的接收流程如图2-14所示。此过程用于创建多播套接字、设置套接字、加入多播组等。服务于多播信息发送和接收模块。在程序中，首先创建UDP套接字，然后设置本地地址和多播地址，并将套接字和本地地址绑定；绑定成功后则设置多播数据的TTL值，在默认情况下，TTL值是1。也就是说，多播数据遇到第一个路由器，便会被它放弃，并不允许传出本地网络之外，即只有同一个网络内的多播成员才能收到数据。如果增大TTL值，多播数据就可以经历多个路由器传到其他网络。为了设置TTL值，需要将套接字值设置为IPPROTO_IP，类型为IP_MULTICAST_TTL，当TTL值设置成功后，程序将判断是否允许返还。这是针对发送者而言的，通过设置套接字的IP_MULTICAST_LOOP选项来实现。此选项决定了程序是否接收自己的多播数据，其级别也是RPPRTO_IP。在最后，通过调用WSAJoinLeaf()函数加入指定的多播组。

图2-14  多播消息控制流程图

7. 设计数据结构

在本项目中，并没有定义专门的数据结构，只是在广播和多播中定义的常量和全局变量。

(1) 广播常量有如下两个。

BCASTPORT：广播的端口号，默认是5050。

BCOUNT：广播的最大消息数，用于设置发送或接收的最多消息数量，超过此值将停止发送或接收。默认值是10。

(2) 多播常量有如下4个。

MCASTADDR：是多播组的地址，默认值是224.3.5.8。

MCASTPORT：多播的端口号，默认值是25000。

BUFSIZE：设置缓冲区的大小，默认值是1024。

MCOUNT：设置多播的最大消息数，用于设置发送或接收的最多消息数量，超过此值将停止发送或接收。默认值是10。

(3) 定义广播全局变量。

SOCKET socketBro：广播信息发送端的UDP套接字。

SOCKET socketRec：广播信息接收端的UDP套接字。

struct sockaddr_in addrBro：广播地址结构，其IP地址部分通过另一个全局变量bcastAddr转换而来。

struct sockaddr_in addrRec：接收广播信息的本地地址。

BOOL broadSendFlag：广播信息身份的标志，如果为FALSE，表示是消息接收者，否则是消息发送者。

BOOL broadFlag：广播标志，如果为TRUE，表示该程序进行广播操作。

DWORD bCoun：双字节表示消息数量的变量，该变量的初始赋值为BCOUNT。

DWORD bcastAddr：表示广播地址参数的双字节变量，初始赋值是INADDR_ BROADCAST，表示全1的广播地址，用于接收用户提供的参数。

short bPort：广播的端口号，默认是BCASTPORT。

(4) 多播全局变量。

SOCKET socketMul：UDP多播套接字。

SOCKET sockJoin：加入多播组套接字。

struct sockaddr_in addrLocal：本地地址结构，其IP地址部分默认为0，即INADDR_ANY，通过另一个全局变量dwInterface获得。

struct sockaddr_in addrMul：多播组地址，默认为MCASTADDR。

BOOL multiSendFlag：多播信息身份标志，如果为默认值FALSE，表示是消息接收者，否则是发送者。

BOOL bLoopBack：消息返回禁止标志，如果为TRUE，表示禁止返还。

BOOL multiFlag：多播标志，如果为TRUE，表示该程序进行广播操作。

DWORD dwInterface：表示多播地址参数的双字节变量，初始赋值是INADDR_ ANY，表示0，用于接收用户提供的参数。

DWORD dwMulticastGroup：双字节，表示消息数量的变量，该变量的初始赋值为MCASTADDR，用于接收用户提供的参数。

DWORD mCount：双字节，表示消息数量的变量，该变量的初始赋值为MCOUNT。

Short mPort：多播的端口号，默认是MCASTPORT。

8. 规划函数

(1) 初始化全局变量。

函数原型：int initial()

功能：用于初始化全局变量，包括初始化广播全局变量和多播全局变量。

(2) 接收用户提供的参数。

函数原型：void GetArgments(int argc, char **argv)

功能：用于获取用户提供的参数，分为如下三种情况。

如果参数个数小于两个：执行用户帮助。

获取广播选项：广播标志设置为真，通过case，分别实现如果是发送者、广播的地址、广播的端口号、广播(接收或者发送)的数量、其他情况，进行对应的操作。

获取多播选项：通过case，分别实现如果是发送者、多播的地址、多播的端口号、本地接口地址、返回标志设置为真、发送(接收)的数量和其他情况，进行对应的操作。

(3) 全局用户帮助函数。

函数原型：void userHelpAll()

功能：用于显示全局用户帮助函数。

(4) 多播用户帮助函数。

函数原型：void userHelpMul()

功能：用于显示多播用户帮助信息。

(5) 广播用户帮助函数。

函数原型：void userHelpBro()

功能：用于显示广播用户帮助信息。

(6) 广播消息发送函数。

函数原型：void broadcastSend()

功能：用于在指定的广播地址上发送广播信息。

(7) 广播消息接收函数。

函数原型：void broadcastRec()

功能：用于在指定的广播地址上接收广播信息。

(8) 多播控制函数。

函数原型：void mulControl()

功能：服务于多播信息发送和接收函数，用于创建多播套接字、设置多播地址和本地地址、套接字绑定、设置套接字选项、加入指定多播组。

(9) 多播消息发送函数。

函数原型：void multicastSend()

功能：用于在指定的多播组地址上发送多播消息。

(10) 多播消息接收函数。

函数原型：void multicastSend()

功能：用于在指定的多播组地址上接收多播消息。

9. 具体编码

(1) 预处理

程序预处理包括库文件的导入、头文件的加载、广播和常量定义以及广播全局变量和多播全局变量的定义。具体实现代码如下：

1. /*加载库文件*/  
2. #pragma comment(lib, "ws2_32.lib")  
3. /*加载头文件*/  
4. #include <winsock2.h> 
5. #include <ws2tcpip.h> 
6. #include <stdio.h> 
7. #include <stdlib.h> 
8.  
9. /*定义多播常量*/  
10. #define MCASTADDR     "224.3.5.8"  
11. #define MCASTPORT     25000  
12. #define BUFSIZE       1024  
13. #define MCOUNT        10  
14.  
15. /*定义广播常量*/  
16. #define BCASTPORT     5050  
17. #define BCOUNT        10  
18.  
19. /*定义广播全局变量*/  
20. SOCKET             socketBro;  
21. SOCKET             socketRec;  
22. struct sockaddr_in addrBro;  
23. struct sockaddr_in addrRec;  
24. BOOL               broadSendFlag;  
25. BOOL               broadFlag;  
26.  
27. DWORD              bCount;  
28. DWORD              bcastAddr;  
29. short              bPort;  
30.  
31. /*定义多播全局变量*/  
32. SOCKET             socketMul;  
33. SOCKET             sockJoin;  
34. struct sockaddr_in addrLocal;  
35. struct sockaddr_in addrMul;  
36.  
37. BOOL               multiSendFlag;  
38. BOOL               bLoopBack;      
39. BOOL               multiFlag;  
40.  
41. DWORD              dwInterface;    
42. DWORD              dwMulticastGroup;  
43. DWORD              mCount;           
44. short              mPort;             
45.  
46. /*自定义函数*/  
47. void initial();  
48. void GetArgments(int argc, char **argv);  
49.  
50. void userHelpAll();  
51. void userHelpBro();  
52. void userHelpMul();  
53.  
54. void broadcastSend();  
55. void broadcastRec();  
56.  
57. void mulControl();  
58. void multicastSend();  
59. void multicastRec();  

(2) 初始化模块

初始化模块用于为广播全局变量和多播全局变量赋初始值，由initial()函数实现。具体代码如下：

1. /*初始化全局变量函数*/  
2. void initial()  
3. {  
4. /*初始化广播全局变量*/  
5. bPort = BCASTPORT;  
6. bCount = BCOUNT;  
7. bcastAddr = INADDR_BROADCAST;  
8. broadSendFlag = FALSE;  
9. broadFlag = FALSE;  
10. multiFlag = FALSE;  
11.  
12. /*初始化多播全局变量*/  
13. dwInterface = INADDR_ANY;  
14. dwMulticastGroup = inet_addr(MCASTADDR);  
15. mPort = MCASTPORT;  
16. mCount = MCOUNT;  
17. multiSendFlag = FALSE;  
18. bLoopBack = FALSE;  
19. }  

(3) 获取参数

参数获取模块用于获取用户提供的选项，包括全局选项(即广播和多播选择选项)、广播选项和多播选项，该模块由GetArgment()函数实现。具体实现代码如下：

1. /*参数获取函数*/  
2. void GetArgments(int argc, char **argv)  
3. {  
4. int i;  
5. /*如果参数个数小于2个*/  
6. if(argc <= 1)  
7. {  
8. userHelpAll();  
9. return ;  
10. }  
11. /*获取广播选项*/  
12. if(argv[1][0]==‘-‘ && argv[1][1]==‘b‘)  
13. {  
14. /*广播标志设置为真*/  
15. broadFlag = TRUE;  
16. for(i=2; i<argc; i++)  
17. {  
18. if (argv[i][0] == ‘-‘)  
19. {  
20. switch (tolower(argv[i][1]))  
21. {  
22. /*如果是发送者*/  
23. case ‘s‘:   
24. broadSendFlag = TRUE;  
25. break;  
26. /*广播的地址*/  
27. case ‘h‘:  
28. if (strlen(argv[i]) > 3)  
29. bcastAddr = inet_addr(&argv[i][3]);  
30. break;  
31. /*广播的端口号*/  
32. case ‘p‘:  
33. if (strlen(argv[i]) > 3)  
34. bPort = atoi(&argv[i][3]);  
35. break;  
36. /*广播(接收或者发送)的数量*/  
37. case ‘n‘:   
38. bCount = atoi(&argv[i][3]);  
39. break;  
40. /*其他情况显示用户帮助，终止程序*/  
41. default:  
42. {  
43. userHelpBro();  
44. ExitProcess(-1);  
45. }  
46. break;  
47. }  
48. }  
49. }  
50. return ;  
51. }  
52.  
53. /*获取多播选项*/  
54. if(argv[1][0]==‘-‘&&argv[1][1]==‘m‘)  
55. {  
56. /*多播标志设置为真*/  
57. multiFlag = TRUE;  
58. for(i=2; i<argc; i++)  
59. {  
60. if (argv[i][0] == ‘-‘)  
61. {  
62. switch (tolower(argv[i][1]))  
63. {  
64. /*如果是发送者*/  
65. case ‘s‘:   
66. multiSendFlag = TRUE;  
67. break;  
68. /*多播地址*/  
69. case ‘h‘:   
70. if (strlen(argv[i]) > 3)  
71. dwMulticastGroup = inet_addr(&argv[i][3]);  
72. break;  
73. /*本地接口地址*/  
74. case ‘i‘:   
75. if (strlen(argv[i]) > 3)  
76. dwInterface = inet_addr(&argv[i][3]);  
77. break;  
78. /*多播端口号*/  
79. case ‘p‘:   
80. if (strlen(argv[i]) > 3)  
81. mPort = atoi(&argv[i][3]);  
82. break;  
83. /*环回标志设置为真*/  
84. case ‘l‘:   
85. bLoopBack = TRUE;  
86. break;  
87. /*发送(接收)的数量*/  
88. case ‘n‘:  
89. mCount = atoi(&argv[i][3]);  
90. break;  
91. /*其他情况，显示用户帮助，终止程序*/  
92. default:  
93. userHelpMul();  
94. break;  
95. }  
96. }  
97. }  
98. }  
99. return;  
100. }  

(4) 用户帮助模块

用户帮助模块包括全局用户帮助、广播用户帮助和多播用户帮助，具体实现函数如下。

userHelpAll()：实现全局用户帮助。

userHelpBro()：实现广播用户帮助。

userHelpMul()：实现多播用户帮助。

具体实现代码如下：

1. /*全局用户帮助函数*/  
2. void userHelpAll()  
3. {  
4. printf("Please choose broadcast[-b] or multicast[-m] !\n");   
5. printf("userHelpAll: -b [-s][p][-h][-n] | -m[-s][-h][-p][-i][-l][-n]\n");  
6. userHelpBro();  
7. userHelpMul();  
8. }  
9.  
10. /*广播用户帮助函数*/  
11. void userHelpBro()  
12. {  
13. printf("Broadcast: -b -s:str -p:int -h:str -n:int\n");  
14. printf("           -b     Start the broadcast program.\n");  
15. printf("           -s     Act as server (send data); otherwise\n");  
16. printf("                  receive data. Default is receiver.\n");  
17. printf("           -p:int Port number to use\n ");  
18. printf("                  The default port is 5050.\n");  
19. printf("           -h:str The decimal broadcast IP address.\n");  
20. printf("           -n:int The Number of messages to send/receive.\n");  
21. printf("                  The default number is 10.\n");  
22. }  
23.  
24. /*多播用户帮助函数*/  
25. void userHelpMul()  
26. {  
27. printf("Multicast: -m -s -h:str -p:int -i:str -l -n:int\n");  
28. printf("           -m     Start the multicast program.\n");  
29. printf("           -s      Act as server (send data); otherwise\n");  
30. printf("                   receive data. Default is receiver.\n");  
31. printf("           -h:str  The decimal multicast IP address to join\n");  
32. printf("                   The default group is: %s\n", MCASTADDR);  
33. printf("           -p:int  Port number to use\n");  
34. printf("                   The default port is: %d\n", MCASTPORT);  
35. printf("           -i:str  Local interface to bind to; by default \n");  
36. printf("                   use INADDRY_ANY\n");  
37. printf("           -l      Disable loopback\n");  
38. printf("           -n:int  Number of messages to send/receive\n");  
39. ExitProcess(-1);  
40. }  

(5) 广播信息发送模块

广播消息发送模块实现广播消息的发送功能，即在指定广播地址和端口上发送指定数量的消息。该模块由函数broadcastSend()来实现，该函数需要接收选项"-h(广播地址)"、"-p(端口号)"、"-n(发送数量)"，如果用户没有提供这些选项，函数将以默认值执行。具体代码如下：

1. /*广播消息发送函数*/  
2. void broadcastSend()  
3. {  
4. /*设置广播的消息*/  
5. char *smsg = "The message received is from sender!";  
6. BOOL opt = TRUE;  
7. int nlen = sizeof(addrBro);  
8. int ret;  
9. DWORD i=0;  
10.  
11. /*创建UDP套接字*/  
12. socketBro = WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED);  
13. /*如果创建失败*/  
14. if(socketBro==INVALID_SOCKET)  
15. {  
16. printf("Create socket failed:%d\n", WSAGetLastError());  
17. WSACleanup();  
18. return;  
19. }  
20.  
21. /*设置广播地址各个选项*/  
22. addrBro.sin_family = AF_INET;  
23. addrBro.sin_addr.s_addr = bcastAddr;  
24. addrBro.sin_port = htons(bPort);  
25.  
26. /*设置该套接字为广播类型*/  
27. if (setsockopt(socketBro,SOL_SOCKET,SO_BROADCAST,(char FAR *)&opt,  
28.       sizeof(opt)) == SOCKET_ERROR)  
29. /*如果设置失败*/  
30. {  
31. printf("setsockopt failed:%d", WSAGetLastError());  
32. closesocket(socketBro);  
33. WSACleanup();  
34. return;  
35. }  
36. /*循环发送消息*/  
37. while(i < bCount)  
38. {  
39. /*延迟1秒*/  
40. Sleep(1000);  
41. /*从广播地址发送消息*/  
42. ret = sendto(socketBro,smsg,256,0,(struct sockaddr*)&addrBro,nlen);  
43. /*如果发送失败*/  
44. if(ret == SOCKET_ERROR)  
45. printf("Send failed:%d", WSAGetLastError());  
46. /*如果发送成功*/  
47. else  
48. {         
49. printf("Send message %d!\n", i);      
50. }  
51. i++;  
52. }  
53. /*发送完毕后关闭套接字、释放占用资源*/  
54. closesocket(socketBro);  
55. WSACleanup();  
56. }  

(6) 广播信息接收模块

广播消息接收模块实现广播消息的接收功能，即在指定广播地址和端口上接收指定数量的消息。该模块由函数broadcastRec()来实现。同发送广播消息一样，该函数也需要接收选项"-h(广播地址)"、"-p(端口号)"、"-n(发送数量)"，如果用户没有提供这些选项，函数将以默认值执行。需要注意的是，如果发送端不是采用默认的广播地址和端口号，则接收端也要使用相应的广播地址和端口号，即通过选项来提供与发送端相同的广播地址和端口号。具体实现代码如下：

1. /*广播消息接收函数*/  
2. void broadcastRec()  
3. {     
4.     BOOL optval = TRUE;  
5. int addrBroLen;  
6. char buf[256];  
7. DWORD i = 0;  
8. /*该地址用来绑定套接字*/  
9. addrRec.sin_family = AF_INET;  
10. addrRec.sin_addr.s_addr = 0;  
11. addrRec.sin_port = htons(bPort);  
12.  
13. /*该地址用来接收网路上广播的消息*/  
14. addrBro.sin_family = AF_INET;  
15. addrBro.sin_addr.s_addr = bcastAddr;  
16. addrBro.sin_port = htons(bPort);  
17.  
18. addrBroLen = sizeof(addrBro);  
19. //创建UDP套接字  
20. socketsocketRec = socket(AF_INET, SOCK_DGRAM, 0);  
21. /*如果创建失败*/  
22. if(socketRec == INVALID_SOCKET)  
23. {  
24. printf("Create socket error:%d", WSAGetLastError());  
25. WSACleanup();  
26. return;  
27. }  
28.  
29. /*设置该套接字为可重用类型*/  
30. if(setsockopt(socketRec,SOL_SOCKET,SO_REUSEADDR,(char FAR *)&optval,  
31. sizeof(optval)) == SOCKET_ERROR)  
32. /*如果设置失败*/  
33. {  
34. printf("setsockopt failed:%d", WSAGetLastError());  
35. closesocket(socketRec);  
36. WSACleanup();  
37. return;  
38. }  
39. /*绑定套接字和地址*/  
40. if(bind(socketRec,(struct sockaddr *)&addrRec,  
41. sizeof(struct sockaddr_in)) == SOCKET_ERROR)  
42. /*如果绑定失败*/  
43. {  
44. printf("bind failed with: %d\n", WSAGetLastError());  
45. closesocket(socketRec);  
46. WSACleanup();  
47. return;  
48. }  
49. /*从广播地址接收消息*/  
50. while(i < bCount)  
51. {  
52. recvfrom(socketRec,buf,256,0,  
53. (struct sockaddr FAR *)&addrBro,  
54. (int FAR *)&addrBroLen);  
55. /*延迟2秒钟*/  
56. Sleep(2000);  
57. /*输出接收到缓冲区的消息*/  
58. printf("%s\n", buf);  
59. /*清空缓冲区*/  
60. ZeroMemory(buf, 256);  
61. i++;  
62. }  
63. /*接收完毕后关闭套接字，释放占用资源*/  
64. closesocket(socketRec);  
65. WSACleanup();  
66. }  

(7) 多播功能控制模块

多播功能控制模块是为多播发送模块和多播接收模块服务的，它实现多播的套接创建和绑定功能、套接字选项设置功能、多播组加入功能等。具体实现代码如下：

1. /*多播控制函数*/  
2. void mulControl()  
3. {  
4. int optval;   
5. /*创建UDP套接字，用于多播*/  
6. if ((socketMul = WSASocket(AF_INET, SOCK_DGRAM, 0, NULL, 0,  
7. WSA_FLAG_MULTIPOINT_C_LEAF   
8. | WSA_FLAG_MULTIPOINT_D_LEAF   
9. | WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)  
10. {  
11. printf("socket failed with: %d\n", WSAGetLastError());  
12. WSACleanup();  
13. return;  
14. }  
15.  
16. /*设置本地接口地址*/  
17. addrLocal.sin_family = AF_INET;  
18. addrLocal.sin_port = htons(mPort);  
19. addrLocal.sin_addr.s_addr = dwInterface;  
20.  
21. /*将UDP套接字绑定到本地地址上*/  
22. if (bind(socketMul, (struct sockaddr *)&addrLocal,   
23. sizeof(addrLocal)) == SOCKET_ERROR)  
24. /*如果绑定失败*/  
25. {  
26. printf("bind failed with: %d\n", WSAGetLastError());  
27. closesocket(socketMul);  
28. WSACleanup();  
29. return;  
30. }  
31.  
32. /*设置多播地址各个选项*/  
33. addrMul.sin_family      = AF_INET;  
34. addrMul.sin_port        = htons(mPort);  
35. addrMul.sin_addr.s_addr = dwMulticastGroup;  
36.  
37. /*重新设置TTL值*/  
38. optval = 8;  
39. /*设置多播数据的TTL(存在时间)值。默认情况下，TTL值是1*/  
40. if (setsockopt(socketMul, IPPROTO_IP, IP_MULTICAST_TTL,   
41. (char*)&optval, sizeof(int)) == SOCKET_ERROR)  
42. /*如果设置失败*/  
43. {  
44. printf("setsockopt(IP_MULTICAST_TTL) failed: %d\n",  
45. WSAGetLastError());  
46. closesocket(socketMul);  
47. WSACleanup();  
48. return;  
49. }  
50.  
51. /*如果指定了返还选项*/  
52. if (bLoopBack)  
53. {  
54. /*设置返还选项为假，禁止将发送的数据返还给本地接口*/  
55. optval = 0;  
56. if (setsockopt(socketMul, IPPROTO_IP, IP_MULTICAST_LOOP,  
57. (char*)&optval, sizeof(optval)) == SOCKET_ERROR)  
58. /*如果设置失败*/  
59. {  
60. printf("setsockopt(IP_MULTICAST_LOOP) failed: %d\n",  
61. WSAGetLastError());  
62. closesocket(socketMul);  
63. WSACleanup();  
64. return;  
65. }  
66. }  
67.  
68. /*加入多播组*/  
69. if ((sockJoin=WSAJoinLeaf(socketMul, (SOCKADDR*)&addrMul,   
70. sizeof(addrMul), NULL, NULL, NULL, NULL,   
71. JL_BOTH)) == INVALID_SOCKET)  
72. /*如果加入不成功*/  
73. {  
74. printf("WSAJoinLeaf() failed: %d\n", WSAGetLastError());  
75. closesocket(socketMul);  
76. WSACleanup();  
77. return;  
78. }  
79. }  

(8) 多播消息发送模块

多播消息发送模块实现多播消息的发送，即发送者(需提高"-s"选项标识)在指定的多播组、端口发送指定数量的多播消息，消息发送过程中还可以设置是否允许消息返还(通过"-1"设置)。该模块由函数multicastSend()来实现，其实现过程是先调用mulControl()函数实现准备工作(多播的套接创建和绑定功能、套接字选项设置功能、多播级加入功能等)，然后发送指定数量的消息。与广播函数一样，该函数也需要接收选项"-h(广播地址)"、"-p(端口号)"、"-i(本地接口)"和"-n(发送数量)"，如果用户没有提供这些选项，函数将以默认值执行。具体实现代码如下：

1. /*多播消息发送函数*/  
2. void multicastSend()  
3. {  
4.       
5. TCHAR sendbuf[BUFSIZE];  
6. DWORD i;  
7. int ret;  
8.  
9. mulControl();  
10. /*发送mCount条消息*/  
11. for(i=0; i<mCount; i++)  
12. {  
13. /*将待发送的消息写入发送缓冲区*/  
14. sprintf(sendbuf, "server 1: This is a test: %d", i);  
15. ret = sendto(socketMul, (char*)sendbuf, strlen(sendbuf), 0,  
16.   (struct sockaddr *)&addrMul, sizeof(addrMul));  
17. /*如果发送失败*/  
18. if(ret == SOCKET_ERROR)  
19. {  
20. printf("sendto failed with: %d\n", WSAGetLastError());  
21. closesocket(sockJoin);  
22. closesocket(socketMul);  
23. WSACleanup();  
24. return;  
25. }  
26. /*如果发送成功*/  
27. else  
28. printf("Send message %d\n", i);  
29. Sleep(500);  
30. }  
31. /*关闭套接字、释放占用资源*/  
32. closesocket(socketMul);  
33. WSACleanup();  
34. }  

(9) 多播消息接收模块

多播消息接收模块可实现多播消息的接收，即接收者在指定的多播级、端口来接收指定数量的多播消息。该模块由函数multicastRec()实现，其实现过程是先调用mulControl()函数实现准备工作(多播的套接创建和绑定功能、套接字选项设置功能、多播级加入功能等)，然后接收指定数量的消息。该函数也需要接收选项"-h(广播地址)"、"-p(端口号)"、"-n(发送数量)"，如果用户没有提供这些选项，函数将以默认值执行。具体实现代码如下：

1. /*多播消息接收函数*/  
2. void multicastRec()  
3. {  
4. DWORD i;  
5. struct sockaddr_in  from;  
6. TCHAR recvbuf[BUFSIZE];  
7. int ret;  
8. int len = sizeof(struct sockaddr_in);  
9. mulControl();  
10. /*接收mCount条消息*/  
11. for(i=0; i<mCount; i++)  
12. {  
13. /*将接收的消息写入接收缓冲区*/  
14. if ((ret = recvfrom(socketMul, recvbuf, BUFSIZE, 0,  
15. (struct sockaddr *)&from, &len)) == SOCKET_ERROR)  
16. /*如果接收不成功*/  
17. {  
18. printf("recvfrom failed with: %d\n", WSAGetLastError());  
19. closesocket(sockJoin);  
20. closesocket(socketMul);  
21. WSACleanup();  
22. return;  
23. }  
24. /*接收成功，输出接收的消息*/  
25. recvbuf[ret] = 0;  
26. printf("RECV: ‘%s‘ from <%s>\n", recvbuf, inet_ntoa(from.sin_addr));  
27. }  
28. /*关闭套接字、释放占用资源*/  
29. closesocket(socketMul);  
30. WSACleanup();  
31. }  

(10) 主函数

主函数main()实现Winsock的初始化、广播与多播的选择以及发送者与接收者身份选择等功能。具体实现代码如下：

1. /*主函数*/  
2. int main(int argc, char **argv)  
3. {  
4. WSADATA wsd;  
5. initial();  
6. GetArgments(argc, argv);  
7. /*初始化Winsock*/  
8. if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)  
9. {  
10. printf("WSAStartup() failed\n");  
11. return -1;  
12. }  
13. if(broadFlag) /*如果是执行广播程序*/  
14. {  
15. /*以发送者身份发送消息*/  
16. if(broadSendFlag)  
17. {  
18. broadcastSend();  
19. return 0;  
20. }  
21. /*以接收者身份接收消息*/  
22. else  
23. {  
24. broadcastRec();  
25. return 0;  
26. }  
27. }  
28. if(multiFlag) /*如果是执行多播程序*/  
29. {  
30. /*以发送者身份发送消息*/  
31. if(multiSendFlag)   
32. {  
33. multicastSend();  
34. return 0;  
35. }  
36. /*以接收者身份接收消息*/  
37. else      
38. {  
39. multicastRec();  
40. return 0;  
41. }  
42. }  
43. return 0;  
44. }  

 

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

（点击查看大图）图2-15  执行效果