UDP的多点通信

一. 网络属性

setsockopt / getsockopt(设置/获取网络属性)

功能：设置/获取网络属性;
原型：

#include           /* See NOTES */
#include 
int getsockopt(int sockfd, int level, int optname,
void *optval, socklen_t *optlen);
       int setsockopt(int sockfd, int level, int optname,
const void *optval, socklen_t optlen);

参数：

• int sockfd：指定要设置/获取 哪个套接字的属性;

• int level：指定要控制的协议层次;
  SOL_SOCKET：应用层 通用套接字选项; man 7 socket
  IPPROTO_TCP：TCP选项 man 7 TCP
  IPPROTO_UDP：UDP选项 man 7 UDP
  IPPROTO_IP：IP选项; man 7 IP

• int optname：指定要控制的内容，指定控制方式；
  — SOL_SOCKET: man 7 socket -----
  SO_REUSEADDR：允许端口快速重用 optval: int*
  SO_BROADCAST：允许广播 optval: int*
  SO_RCVBUF/SO_SNDBUF：接收缓冲区 发送缓冲区大小
  SO_RCVTIMEO/SO_SNDTIMEO：接收超时时间，发送超时时间

• void *optval：根据optname不同，该类型不同;

• socklen_t optlen/socklen_t *optlen：真实的optval指针指向的内存空间的大小;

返回值：

• 成功，返回0；
• 失败，返回-1，更新errno;

#include 
#include 
#include 
#include 

int main(int argc, const char *argv[])
{
    int sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sfd < 0)
    {
        perror("socket");
        return -1;
    }

    //设置允许广播
    int broad = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_BROADCAST, &broad, sizeof(broad)) < 0)
    {
        perror("setsockopt");
        return -1;
    }
    printf("设置允许广播成功\n");


    //判断默认是否允许广播
    broad = 100;
    socklen_t optlen = sizeof(broad);
    if(getsockopt(sfd, SOL_SOCKET, SO_BROADCAST, &broad, &optlen) < 0)
    {
        perror("getsockopt");
        return -1;
    }
    printf("broad = %d\n", broad);


    close(sfd);                                                              
    return 0;
}

二. 多点通信

2.1. 单播

1. 主机之间一对一的通信模式，交换机以及路由器对数据只进行转发，不做复制
2. 每次只有两个实体相互通信，发送端和接收端都是唯一确定的。

2.2. 广播

1. 主机之间 一对多 的通信模式，网络对其中的每一台主机发出的信息都进行无条件复制并转发。

2. 所有主机都可以接收到广播信息（不管你是否需要）

3. 禁止广播数据穿过:路由器（只能做局域网内通信），防止广播数据影响大面积主机。

4. 只有UDP能广播。

5. 广播地址：有效网络号 + 全是1的主机号

6. 1. 192.168.8.123 —> 192.168.8.255
   2. 255.255.255.255：给所有网段中的所有主机发送广播，但是无法穿过路由器，所以只能做局域网内通信。

2.2.1 广播的发送端流程 (类似UDP客户端)

1. socket 创建套接字

2. setsockopt 设置允许广播，默认是不允许的

3. bind 非必须绑定

4. 填充接收方的地址信息结构体，给sendto函数使用，指定发给谁

5. 1. IP：填广播IP,（192.168.8.255 ）
   2. PORT：与接收方绑定的一致，

6. sendto 发送数据

示例代码:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define ERR_MSG(msg) do{\
    fprintf(stderr, "line:%d ", __LINE__);\
    perror(msg);\
}while(0)

#define SER_IP "192.168.0.255"   //广播IP ifconfig
#define SER_PORT 6666           //1024-49151

int main(int argc, const char *argv[])
{
    //创建报式套接字
    int cfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(cfd < 0)
    {
        ERR_MSG("socket");
        return -1;                                                                   
    }

    //设置允许广播
    int broad = 1;
    if(setsockopt(cfd, SOL_SOCKET, SO_BROADCAST, &broad, sizeof(broad)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;
    }
    printf("set broadcast success\n");

    //bind  非必须绑定
    //如果不绑定则由操作系统自动绑定IP和端口


    //填充接收方的地址信息结构体，给sendto函数使用
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;              //必须填AF_INET;
    sin.sin_port        = htons(SER_PORT);      //端口号的网络字节序
    sin.sin_addr.s_addr = inet_addr(SER_IP);    //广播IP地址

    struct sockaddr_in rcvaddr;     //存储数据包是从谁哪里来的
    socklen_t addrlen = sizeof(rcvaddr);

    char buf[128] = "";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        printf("请输入>>> ");
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf)-1] = 0;

        //发送数据，发送给服务器
        if(sendto(cfd, buf, sizeof(buf), 0, (struct sockaddr*)&sin, sizeof(sin)) < 0)
        {
            ERR_MSG("sendto");
            return -1;
        }
        printf("发送成功\n");
    }

    //关闭文件描述符
    close(cfd);
    return 0;
}

2.2.2 广播的接收端流程(类似UDP服务器)

1. socket 创建套接字

2. 填充接收自身的地址信息结构体，给bind函数使用

3. 1. IP ：广播IP(192.168.8.255 或者 0.0.0.0（INADDR_ANY）)

   2. 1. 0.0.0.0：将本机所有可用IP都绑定到套接字上，192.168.8.123, 127.0.0.1（本地环回），广播IP，组播IP

   3. PORT ：1024-49151

4. bind 必须绑定

5. recvfrom 接收广播数据

接收方:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define ERR_MSG(msg) do{\
    fprintf(stderr, "line:%d ", __LINE__);\
    perror(msg);\
}while(0)

#define IP "192.168.0.255"   //广播IP ifconfig
#define PORT 6666           //1024-49151

int main(int argc, const char *argv[])
{
    //创建报式套接字                                                                          
    int sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }

    //填充接收方自身的地址信息结构体
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;          //必须填AF_INET;
    sin.sin_port        = htons(PORT);      //端口号的网络字节序
    sin.sin_addr.s_addr = inet_addr(IP);    //广播IP地址

    //绑定 必须绑定
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
    {
        ERR_MSG("bind");
        return -1;
    }

    struct sockaddr_in cin;     //存储数据包是从谁哪里来的
    socklen_t addrlen = sizeof(cin);

    char buf[128] = "";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        //接收数据,必须接收数据包的发送方地址信息，给sendto使用
        res = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&cin, &addrlen);
        //res = recv(sfd, buf, sizeof(buf), 0);
        if(res < 0)
        {
            ERR_MSG("recvfrom");
            return -1;
        }
        printf("[%s : %d]: %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
    }

    //关闭文件描述符
    close(sfd);
    return 0;
}

2.3. 组播

1. 广播方式是给同一网段下的所有主机发送信息，会占用大量网络带宽，影响正常通信。
2. 主机之间一对一组的通信模式，也就是加入了同一个小组的主机可以收到此组内的所有数据。
3. 组播地址：D类：224.0.0.0-239.255.255.255

2.3.1组播的发送端流程 (类似UDP客户端)

1. socket 创建套接字
2. bind 非必须绑定
3. 填充接收方的地址信息结构体，给sendto函数使用，指定发给谁

• 1. IP：填组播IP,（224.0.0.0-239.255.255.255 ）,与接收方绑定的组播IP一致。
  2. PORT：与接收方绑定的一致，

4. sendto 发送数据

2.3.2组播的接收端流程(类似UDP服务器)

1. socket 创建套接字

2. setsockopt 加入多播组：level：IPPROTO_IP optname：IP_ADD_MEMBERSHIP optval：struct ip_mreqn*

3. 1. 注意加入的多播组IP，与下面绑定的组播IP一致

4. 填充接收自身的地址信息结构体，给bind函数使用

5. 1. IP ：组播IP( 224.0.0.0-239.255.255.255 或者 0.0.0.0 )

   2. 1. 0.0.0.0：将本机所有可用IP都绑定到套接字上，192.168.8.123, 127.0.0.1（本地环回），广播IP，组播IP

   3. PORT ：1024-49151

6. bind 必须绑定

7. recvfrom 接收广播数据

2.3.3 加入多播组

功能：设置/获取网络属性;
原型：
       #include           /* See NOTES */
       #include 

       int setsockopt(int sockfd, int level, int optname,
const void *optval, socklen_t optlen);
参数：
    int sockfd：指定要设置/获取哪个套接字的属性;
    int level：指定要控制的协议层次;
        IPPROTO_IP：IP选项;                man 7 IP
        
    int optname：指定要控制的内容，指定控制方式；
      --- IPPROTO_IP：IP选项;                man 7 IP -----
         IP_ADD_MEMBERSHIP：加入多播组

    void *optval：根据optname不同，该类型不同;
            struct ip_mreqn {
               struct in_addr imr_multiaddr; /* IP multicast group
 address */    组播IP的网络字节序，
               struct in_addr imr_address;   /* IP address of local
 interface */ 本机IP的网络字节序，ifconfig
               int            imr_ifindex;   /* interface index */     设备索引号，网卡编号
                                                                   1. 0，默认索引号
                                                                   2. ifconfig查看网卡名，例如ens33.
                                                                       ip ad，找到ens33对应的编号为2
                                                                   3. if_nametoindex("ens33")                                                                                                                                             
           };

            struct ip_mreq  {
                struct in_addr imr_multiaddr;   /* IP multicast address of group */
                struct in_addr imr_interface;   /* local IP address of interface */
            };

    socklen_t optlen/socklen_t *optlen：真实的optval指针指向的内存空间的大小;
返回值：
    成功，返回0；
    失败，返回-1，更新errno;

示例代码

1. 发送方

   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   
   #define ERR_MSG(msg) do{\
       fprintf(stderr, "line:%d ", __LINE__);\
       perror(msg);\
   }while(0)
   
   #define GRP_IP "224.1.2.3"   //224.0.0.0-239.255.255.255
   #define PORT 6666           //1024-49151
   
   int main(int argc, const char *argv[])
   {
       //创建报式套接字
       int cfd = socket(AF_INET, SOCK_DGRAM, 0); 
       if(cfd < 0)
       {   
           ERR_MSG("socket");
           return -1; 
       }   
                                                                                        
       //bind  非必须绑定
       //如果不绑定则由操作系统自动绑定IP和端口
   
   
       //填充接收放的地址信息结构体，给sendto函数使用
       struct sockaddr_in sin;
       sin.sin_family      = AF_INET;              //必须填AF_INET;
       sin.sin_port        = htons(PORT);          //端口号的网络字节序
       sin.sin_addr.s_addr = inet_addr(GRP_IP);    //IP地址
       
       char buf[128] = ""; 
       ssize_t res = 0;
       while(1)
       {   
           bzero(buf, sizeof(buf));
           printf("请输入>>> ");
           fgets(buf, sizeof(buf), stdin);
           buf[strlen(buf)-1] = 0;
   
           //发送数据，发送给服务器
           if(sendto(cfd, buf, sizeof(buf), 0, (struct sockaddr*)&sin, sizeof(sin)) < 0)
           {
               ERR_MSG("sendto");
               return -1; 
           }
           printf("发送成功\n");
   
       }   
   
       //关闭文件描述符
       close(cfd);
       return 0;
   }
   

   2. 接收方

      #include 
      #include 
      #include 
      #include 
      #include 
      #include 
      #include 
      #include 
      
      #define ERR_MSG(msg) do{\
          fprintf(stderr, "line:%d ", __LINE__);\
          perror(msg);\
      }while(0)
      
      #define IP     "192.168.0.119"   //本机IP ifconfig
      #define GRP_IP "224.1.2.3"      //组播IP 224.0.0.0 - 239.255.255.255
      
      #define PORT 6666           //1024-49151
      
      int main(int argc, const char *argv[])
      {
          //创建报式套接字
          int sfd = socket(AF_INET, SOCK_DGRAM, 0); 
          if(sfd < 0)
          {   
              ERR_MSG("socket");
              return -1; 
          }   
      
          //加入多播组                                                                        
          struct ip_mreqn mq; 
          mq.imr_multiaddr.s_addr = inet_addr(GRP_IP);    //组播IP
          mq.imr_address.s_addr   = inet_addr(IP);        //本机IP
          mq.imr_ifindex = 2;                             //设备索引号
      
          if(setsockopt(sfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mq, sizeof(mq)) < 0)
          {   
              ERR_MSG("setsockopt");
              return -1; 
          }   
          printf("加入多播组成功\n");
      
          //填充接收放的地址信息结构体
          struct sockaddr_in sin;
          sin.sin_family      = AF_INET;              //必须填AF_INET;
          sin.sin_port        = htons(PORT);          //端口号的网络字节序
          sin.sin_addr.s_addr = inet_addr(GRP_IP);    //组播IP地址，与加入的组播IP一致
          
          //绑定 必须绑定
          if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
          {   
              ERR_MSG("bind");
              return -1; 
          }   
      
          struct sockaddr_in cin;     //存储数据包是从谁哪里来的
          socklen_t addrlen = sizeof(cin);
          
          char buf[128] = ""; 
          ssize_t res = 0;
          while(1)
          {   
              bzero(buf, sizeof(buf));
              //接收数据,必须接收数据包的发送方地址信息，给sendto使用
              res = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&cin, &addrlen);
              if(res < 0)
              {
                  ERR_MSG("recvfrom");
                  return -1; 
              }
              printf("[%s : %d]: %s\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);
      
          }   
      
          //关闭文件描述符
          close(sfd);
          return 0;
      }
      

      bzero(buf, sizeof(buf));
      //接收数据,必须接收数据包的发送方地址信息，给sendto使用
      res = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&cin, &addrlen);
      if(res < 0)
      {
      ERR_MSG(“recvfrom”);
      return -1;
      }
      printf(“[%s : %d]: %s\n”, inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf);

      }   
      
      //关闭文件描述符
      close(sfd);
      return 0;
      

      }