广播、组播 socket编程，附带可以编译运行的例子

有个任务需要组播的socket编程

平台qnx，借鉴一下linux的方法。

开始......

首先，什么是单播：

(1) 单播

之前在进行UDP和TCP编程的时候，客户端把数据发送到指定IP地址，此时接收方只有一个，这种数据包发送方式称为“单播”。

什么是组播？

(2) 多播（组播）
如果是把数据发送给某个局域网中的一组IP地址，这种发送方式称为“多播”，这个组称为“多播组”，只有加入多播组的主机才能收到数据。

广播是发给某一局域网中的所有主机。过多的广播会大量占用网络带宽，造成广播风暴，影响正常的通信。
多播是一种折中的方式，既能发送给多个主机，又能避免象广播那样带来过多的负载

什么是广播？

(3) 广播
如果是把数据发送某个局域网中的所有主机，这种数据包的发送方式称为“广播”

发送出去的数据会被 广播地址所在网段的所有主机接收
每个局域网的最大主机地址代表该网段的广播地址。
以192.168.1.0 (255.255.255.0) 网段为例，192.168.1.255代表该网段的广播地址
255.255.255.255 在所有网段中都代表广播地址。
如果主机A向 255.255.255.255 发数据，那么当前局域网里的所有主机都会收到数据。

2、多播 socket编程（只能是UDP通信）
多播socket编程的侧重点在接收方（服务端），接收方要创建一个多播组（类似于QQ群），然后把当前套接字加入到多播组中；而发送方发送数据的目标地址不是服务端的IP地址，而是多播组的IP地址。

创建数据报套接字
绑定IP地址和端口号
创建多播组（类似于创建QQ群）
将当前套接字加入到多播组（类似于加群）
接收数据

1. #define SERV_PORT 9090
   
2. #define MULTICAST_IP "192.168.11.170"
   
3. #define BUFSIZE 128
   
4. 
   
5. int fd = -1;
   
6. 
   
7. /* 1. 创建socket fd */
   
8. if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) < 0) {        //udp程序
   
9.     perror ("socket");
   
10.     exit (1);
    
11. }
    
12. 
    
13. /* 2. 绑定IP地址和端口号 */
    
14. struct sockaddr_in sin;
    
15. memset(&sin, 0, sizeof(sin))
    
16. sin.sin_family = AF_INET;
    
17. sin.sin_port = htons(SERV_PORT);                 // 网络字节序的端口号
    
18. sin.sin_addr.s_addr = htonl(INADDR_ANY);    // 服务端可以绑定任意IP
    
19. if (bind (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
    
20.     perror ("bind");
    
21.     exit (1);
    
22. }
    
23. 
    
24. /* 3. 创建多播组，初始化多播组结构体 */
    
25. struct ip_mreq mreq;
    
26. memset(&mreq, 0, sizeof(mreq))
    
27. mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_IP);
    
28. mreq.imr_interface.s_addr = htonl(INADDR_ANY);
    
29. 
    
30. /* 4. 把当前套接字加入到多播组 */
    
31. setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
    
32. 
    
33. /* 5. 接收数据 */
    
34. char buf[BUFSIZE ];
    
35. struct sockaddr_in cin;
    
36. socklen_t addrlen = sizeof(cin);
    
37. recvfrom (fd, buf, BUFSIZE - 1, 0, (struct sockaddr *)&cin, &addrlen);

复制代码

3、广播 socket编程（只能是UDP通信）
广播socket编程的侧重点在发送方（客户端），而且只有使用UDP协议才能广播。接收方的代码可以沿用单播的代码。发送方的数据发送步骤如下：

创建用户数据报套接字
套接字默认不允许广播数据包（因为可能引发广播风暴），需要使用 setsockopt设置属性
目标地址(接收方地址) 指定为广播地址
指定目标端口
发送数据包

1. #define DST_PORT 9090
   
2. 
   
3. /* 1. 创建socket fd */
   
4. if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) < 0) {        //UDP编程
   
5.     perror ("socket");
   
6.     exit (1);
   
7. }
   
8. 
   
9. /* 2. 允许广播设置 */
   
10. int b_br = 1;
    
11. setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &b_br, sizeof(int));
    
12. 
    
13. /*3. 指定目标IP和端口号填充 */
    
14. struct sockaddr_in sin;
    
15. memset(&sin, 0, sizeof(sin))
    
16. sin.sin_family = AF_INET;
    
17. sin.sin_port = htons (SERV_PORT);                          //网络字节序的端口号
    
18. sin.sin_addr.s_addr = inet_addr("192.168.11.255");    // 广播地址
    
19. 
    
20. 
    
21. /*4. 发送数据 */
    
22. char buf[128] = {'1','2','3','4','5','6','\0'};
    
23. sendto (fd, buf, strlen(buf), 0, (struct sockaddr *)&sin, sizeof(sin));

复制代码

LINUX SOCKET PART 13: MULTICAST

概述

组播提供了在网络中进行一对多的发送的机制，组播可以是在一个网段内，也可以是跨网段的，不过跨网段需要交换机、路由器等网络设备支持组播。
Hosts可以在任何时间加入或者离开组播组，对于组播组的成员没有所处位置的限制，也没有数量的限制，D类互联网地址是用于组播的：224.0.0.0 - 239.255.255.255。
通过无连接Socket编程可以实现组播数据的发送和接收。组播数据只能通过一个网络接口发送，即使设备上有多个网络接口。

组播是一对多的传输机制，不能通过面向连接的Socket实现组播。

组播,  是路由器的功能? 还是服务器的功能?
路由器记录组播是不是有成本?

一个组播包发送的例子：

1. /* Send Multicast Datagram code example. */
   
2. 
   
3. #include <sys/types.h>
   
4. 
   
5. #include <sys/socket.h>
   
6. 
   
7. #include <arpa/inet.h>
   
8. 
   
9. #include <netinet/in.h>
   
10. 
    
11. #include <stdio.h>
    
12. 
    
13. #include <stdlib.h>
    
14. 
    
15. struct in_addr localInterface;
    
16. 
    
17. struct sockaddr_in groupSock;
    
18. 
    
19. int sd;
    
20. 
    
21. char databuf[1024] = "Multicast test message lol!";
    
22. 
    
23. int datalen = sizeof(databuf);
    
24. 
    
25. 
    
26. 
    
27. int main (int argc, char *argv[ ])
    
28. 
    
29. {
    
30. 
    
31. /* Create a datagram socket on which to send. */
    
32. 
    
33. sd = socket(AF_INET, SOCK_DGRAM, 0);
    
34. 
    
35. if(sd < 0)
    
36. 
    
37. {
    
38. 
    
39.   perror("Opening datagram socket error");
    
40. 
    
41.   exit(1);
    
42. 
    
43. }
    
44. 
    
45. else
    
46. 
    
47.   printf("Opening the datagram socket...OK.\n");
    
48. 
    
49. 
    
50. 
    
51. /* Initialize the group sockaddr structure with a */
    
52. 
    
53. /* group address of 225.1.1.1 and port 5555. */
    
54. 
    
55. memset((char *) &groupSock, 0, sizeof(groupSock));
    
56. 
    
57. groupSock.sin_family = AF_INET;
    
58. 
    
59. groupSock.sin_addr.s_addr = inet_addr("226.1.1.1");
    
60. 
    
61. groupSock.sin_port = htons(4321);
    
62. 
    
63. 
    
64. 
    
65. /* Disable loopback so you do not receive your own datagrams.
    
66. 
    
67. {
    
68. 
    
69. char loopch = 0;
    
70. 
    
71. if(setsockopt(sd, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&loopch, sizeof(loopch)) < 0)
    
72. 
    
73. {
    
74. 
    
75. perror("Setting IP_MULTICAST_LOOP error");
    
76. 
    
77. close(sd);
    
78. 
    
79. exit(1);
    
80. 
    
81. }
    
82. 
    
83. else
    
84. 
    
85. printf("Disabling the loopback...OK.\n");
    
86. 
    
87. }
    
88. 
    
89. */
    
90. 
    
91. 
    
92. 
    
93. /* Set local interface for outbound multicast datagrams. */
    
94. 
    
95. /* The IP address specified must be associated with a local, */
    
96. 
    
97. /* multicast capable interface. */
    
98. 
    
99. localInterface.s_addr = inet_addr("203.106.93.94");
    
100. 
     
101. if(setsockopt(sd, IPPROTO_IP, IP_MULTICAST_IF, (char *)&localInterface, sizeof(localInterface)) < 0)
     
102. 
     
103. {
     
104. 
     
105.   perror("Setting local interface error");
     
106. 
     
107.   exit(1);
     
108. 
     
109. }
     
110. 
     
111. else
     
112. 
     
113.   printf("Setting the local interface...OK\n");
     
114. 
     
115. /* Send a message to the multicast group specified by the*/
     
116. 
     
117. /* groupSock sockaddr structure. */
     
118. 
     
119. /*int datalen = 1024;*/
     
120. 
     
121. if(sendto(sd, databuf, datalen, 0, (struct sockaddr*)&groupSock, sizeof(groupSock)) < 0)
     
122. 
     
123. {perror("Sending datagram message error");}
     
124. 
     
125. else
     
126. 
     
127.   printf("Sending datagram message...OK\n");
     
128. 
     
129. 
     
130. 
     
131. /* Try the re-read from the socket if the loopback is not disable
     
132. 
     
133. if(read(sd, databuf, datalen) < 0)
     
134. 
     
135. {
     
136. 
     
137. perror("Reading datagram message error\n");
     
138. 
     
139. close(sd);
     
140. 
     
141. exit(1);
     
142. 
     
143. }
     
144. 
     
145. else
     
146. 
     
147. {
     
148. 
     
149. printf("Reading datagram message from client...OK\n");
     
150. 
     
151. printf("The message is: %s\n", databuf);
     
152. 
     
153. }
     
154. 
     
155. */
     
156. 
     
157. return 0;
     
158. 
     
159. }
     
160. 
     

复制代码

icecut 发表于 2023-9-8 13:59
组播,  是路由器的功能? 还是服务器的功能?
路由器记录组播是不是有成本?
...

下面这个程序可以对多个组播地址发数据，刚刚写的，测试过了：

1. #include "fun_interface.h"
   
2. #include <unistd.h>
   
3. #include <string>
   
4. struct in_addr localInterface;
   
5. struct sockaddr_in groupSock;
   
6. int sd;
   
7. char databuf[1024] = "Multicast test message lol!";
   
8. 
   
9. int datalen = sizeof(databuf);
   
10. 
    
11. typedef struct {
    
12.     std::string dip;
    
13.     int sock;
    
14.     struct sockaddr_in gsock;
    
15. } test_item_t;
    
16. 
    
17. test_item_t sock_items[] = {
    
18. {
    
19.     .dip = "225.0.0.128"
    
20. },
    
21. {
    
22.     .dip = "225.0.0.120"
    
23. },
    
24. {
    
25.     .dip = "225.0.0.111"
    
26. },
    
27. {
    
28.     .dip = "225.0.0.110"
    
29. },
    
30. {
    
31.     .dip = "239.202.0.11"
    
32. },
    
33. {
    
34.     .dip = "239.202.255.251"
    
35. }
    
36. };
    
37. 
    
38. int init_sock()
    
39. {
    
40.     int sd;
    
41.     int items_size = sizeof(sock_items)/sizeof(test_item_t);
    
42.     printf("== size:%d\n",items_size);
    
43.     for(int i = 0;i < items_size;i ++) {
    
44.         sd = socket(AF_INET, SOCK_DGRAM, 0);
    
45.         if(sd < 0) {
    
46.             perror("Opening datagram socket error");
    
47.             return -1;
    
48.         } else {
    
49.             printf("open socket ....ok\n");
    
50.             sock_items[i].sock = sd;
    
51.         }
    
52. 
    
53.         memset((char *) &sock_items[i].gsock, 0, sizeof(sock_items[i].gsock));
    
54.         sock_items[i].gsock.sin_family = AF_INET;
    
55.         //groupSock.sin_addr.s_addr = inet_addr("226.1.1.1");
    
56.         sock_items[i].gsock.sin_addr.s_addr = inet_addr(sock_items[i].dip.c_str());
    
57.         sock_items[i].gsock.sin_port = htons(4321);
    
58. 
    
59.         localInterface.s_addr = inet_addr("192.168.1.12");
    
60.         //localInterface.s_addr = inet_addr("172.16.16.90");
    
61. 
    
62.         if(setsockopt(sd, IPPROTO_IP, IP_MULTICAST_IF, (char *)&localInterface, sizeof(localInterface)) < 0){
    
63.             perror("Setting local interface error");
    
64.             return -1;
    
65.         }else
    
66.             printf("Setting the local interface...OK\n");
    
67.     }
    
68. 
    
69.     return 0;
    
70. }
    
71. 
    
72. int main()
    
73. {
    
74.     int items_size = sizeof(sock_items)/sizeof(test_item_t);
    
75.    
    
76.     if(init_sock() != 0) {
    
77.         exit(1);
    
78.     }
    
79.     /* Send a message to the multicast group specified by the*/
    
80.     /* groupSock sockaddr structure. */
    
81.     /*int datalen = 1024;*/
    
82.     for(int i = 0;i < 100;i ++) {
    
83.         for(int j = 0;j < items_size;j ++ ) {
    
84.             if(sendto(sock_items[j].sock, databuf, datalen, 0, (struct sockaddr*)&sock_items[j].gsock, sizeof(sock_items[j].gsock)) < 0) {
    
85.                 perror("Sending datagram message error");
    
86.             } else
    
87.                 printf("Sending datagram message...OK\n");
    
88.         }
    
89.         sleep(3);
    
90.     }
    
91.    
    
92.     return 0;
    
93. }
    

复制代码

只收到两个，其它地址被rtl9072过滤掉了。

这个是没有过滤的版本