devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

网络编程基础(四)

作者：你好赵伟 | 2024-06-01 18:13:18

赞

踩

网络编程基础(四)

目录

前言

 二、多点通信

2.1 单播

2.2 广播

2.2.1 广播得发送端实现--》类似与UDP的客户端

 2.3 组播

2.3.1 组播发送端流程--》类似于UDP的客户端流程

 2.3.2 组播的接收端流程---》类似于UDP的服务器端流程

前言

多点通信

一、套接字选项得获取和设置

  1.  int getsockopt(int sockfd, int level, int optname,void *optval, socklen_t *optlen);
  2.  int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);
  3.         功能：获取或设置套接字在不同层级上的相关属性
  4.         参数1：要获取或设置的套接字文件描述符
  5.         参数2：表示要获取或设置的层
  6.                 应用层：SOL_SOCKET
  7.                 传输层TCP：IPPROTO_TCP
  8.                 传输层UDP：IPPROTO_UDP
  9.                 网络层：IPPROTO_IP
  10.         参数3：当前层的属性名称，见下表所示
  11.         参数4：要获取或设置的属性值的起始地址
  12.         参数5：参数4的大小
  13.         返回值：成功返回0，失败返回-1并置位错误码

 

1.代码演示

  1. #include<myhead.h>
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5.     //1、创建一个套接字文件描述符
  6.     int sfd = socket(AF_INET, SOCK_STREAM, 0);
  7.     if(sfd == -1)
  8.     {
  9.         perror("socket error");
  10.         return -1;
  11.     }
  12.     
  13.     //2、获取地址快速重用属性的值
  14.     int res = -1;              //接收属性值
  15.     int reslen = sizeof(res);  //接收属性的大小
  16.     if(getsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &res, &reslen)==-1)
  17.     {
  18.         perror("getsockopt error");
  19.         return -1;
  20.     }
  21.  
  22.     //程序执行至此，就获取了默认是否能地址快速重用
  23.     printf("res = %d\n", res);          //0表示默认不能快速重用
  24.  
  25.     //3\、设置地址能够快速重用
  26.     int reuse = 1;
  27.     if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))==-1)
  28.     {
  29.         perror("setsockopt error");
  30.         return -1;
  31.     }
  32.  
  33.     //4、再重新获取一次，判断是否设置成功
  34.     res = -1;
  35.     if(getsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &res, &reslen)==-1)
  36.     {
  37.         perror("getsockopt error");
  38.         return -1;
  39.     }
  40.  
  41.     //程序执行至此，就获取了默认是否能地址快速重用
  42.     printf("res = %d\n", res);                  //1表示已经设置成功了
  43.  
  44.  
  45.     return 0;
  46. }

 二、多点通信

2.1 单播

1.主机之间存在的是一对一的通信方式，交换机以及路由器对数据只进行转发，不进行复制

2.每次只有两个实体之间进行相互通信，发送端和接收端都是唯一确定的

2.2 广播

1.广播是允许通信实体之间完成一对多的通信方式，网络对其中每一台发送数据的主机信息都进行无条件的复制后并转发给其他所有主机

2.所有主机都会收到广播消息（不管是都愿意接受）

3.广播只能由UDP通信方式来实现

4.广播消息，只能在当前网络下进行转播，不允许传过路由器

5.广播地址：网络号+255

6.官博分为发送端和接收端实现

2.2.1 广播得发送端实现--》类似与UDP的客户端

  1. 1、创建用于通信的套接字文件描述符：socket
  2. 2、设置该套接字允许发送广播消息：setsockopt     ---> SOL_SOCKET  ---> SO_BROADCAST
  3. 3、绑定IP地址和端口号（可选）
  4. 4、向广播地址发送数据：sendto
  5.     广播地址IP：网络号 + 255
  6.     端口号：与接收端保持一致
  7. 5、关闭套接字：close

代码实现：

  1. #include<myhead.h>
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5.     //1、创建用于通信的套接字文件描述符
  6.     int rfd = socket(AF_INET, SOCK_DGRAM, 0);
  7.     if(rfd == -1)
  8.     {
  9.         perror("socket error");
  10.         return -1;
  11.     }
  12.  
  13.  
  14.     //2、填充地址信息结构体：
  15.     //ip：广播地址
  16.     //port：与发送端保持一致
  17.     struct sockaddr_in rin;
  18.     rin.sin_family = AF_INET;
  19.     rin.sin_port = htons(6666);     //端口号
  20.     rin.sin_addr.s_addr = inet_addr("192.168.125.255"); //广播ip地址
  21.  
  22.     //3、绑定端口号和IP地址（必须）
  23.     if(bind(rfd, (struct sockaddr*)&rin, sizeof(rin)) == -1)
  24.     {
  25.         perror("bind error");
  26.         return -1;
  27.     }
  28.  
  29.     //4、接受发送端发来的消息：recvfrom
  30.     char rbuf[128] = "";
  31.     while(1)
  32.     {
  33.         //清空容器
  34.         bzero(rbuf, sizeof(rbuf));
  35.  
  36.         //读取数据
  37.         recv(rfd, rbuf, sizeof(rbuf), 0);
  38.  
  39.         //展示
  40.         printf("收到广播消息：%s\n", rbuf);
  41.         //判断广播是否结束
  42.  
  43.         if(strcmp(rbuf, "over") == 0)
  44.         {
  45.             break;
  46.         }
  47.     }
  48.  
  49.     //5、关闭套接字：close
  50.     close(rfd);
  51.  
  52.     return 0;
  53. }

2.2.2 广播的接收端--》类似于UDP的服务器端 

  1. 1、创建用于通信的套接字文件描述符
  2. 2、填充地址信息结构体：
  3.     ip：广播地址
  4.     port：与发送端保持一致
  5. 3、绑定端口号和IP地址（必须）
  6. 4、接受发送端发来的消息：recvfrom
  7. 5、关闭套接字：close

代码实现：

 

  1. #include<myhead.h>
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5.     //1、创建用于通信的套接字文件描述符
  6.     int rfd = socket(AF_INET, SOCK_DGRAM, 0);
  7.     if(rfd == -1)
  8.     {
  9.         perror("socket error");
  10.         return -1;
  11.     }
  12.  
  13.  
  14.     //2、填充地址信息结构体：
  15.     //ip：广播地址
  16.     //port：与发送端保持一致
  17.     struct sockaddr_in rin;
  18.     rin.sin_family = AF_INET;
  19.     rin.sin_port = htons(6666);     //端口号
  20.     rin.sin_addr.s_addr = inet_addr("192.168.125.255"); //广播ip地址
  21.  
  22.     //3、绑定端口号和IP地址（必须）
  23.     if(bind(rfd, (struct sockaddr*)&rin, sizeof(rin)) == -1)
  24.     {
  25.         perror("bind error");
  26.         return -1;
  27.     }
  28.  
  29.     //4、接受发送端发来的消息：recvfrom
  30.     char rbuf[128] = "";
  31.     while(1)
  32.     {
  33.         //清空容器
  34.         bzero(rbuf, sizeof(rbuf));
  35.  
  36.         //读取数据
  37.         recv(rfd, rbuf, sizeof(rbuf), 0);
  38.  
  39.         //展示
  40.         printf("收到广播消息：%s\n", rbuf);
  41.         //判断广播是否结束
  42.  
  43.         if(strcmp(rbuf, "over") == 0)
  44.         {
  45.             break;
  46.         }
  47.     }
  48.  
  49.     //5、关闭套接字：close
  50.     close(rfd);
  51.  
  52.     return 0;
  53. }

 2.3 组播

1.由于广播通信过程中，会占用大量的网络宽带，影响正常通信，如果通信的主机较少的话，可以引入组播

2.组播也是实现主机之间一对多的通信方式

3.要求所有接收端主机加入多播组，只有加入多播组的主机才能收到消息

4.对于发送端而言，只需向该多组播中发送消息即可，无需其他设置

5.组播也是使用UDP实现的

6.组播地址：D类网络【224.0.0.0---239.255.255.255】

7.组播也分为发送端和接收端

2.3.1 组播发送端流程--》类似于UDP的客户端流程

  1. 1、创建用于通信的套接字文件描述符：socket
  2. 2、绑定IP地址和端口号（可选）
  3. 3、向组播地址发送数据：sendto
  4.     广播地址IP：【224.0.0.0 --- 239.255.255.255】
  5.     端口号：与接收端保持一致
  6. 4、关闭套接字：close

代码实现：

 

  1. #include<myhead.h>
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5.     //1、创建用于通信的套接字文件描述符：socket
  6.     int sfd = socket(AF_INET, SOCK_DGRAM, 0);
  7.     if(sfd == -1)
  8.     {
  9.         perror("socket error");
  10.         return -1;
  11.     }
  12.  
  13.     //2、绑定IP地址和端口号（可选）
  14.     //3、向组播地址发送数据：sendto
  15.     //广播地址IP：【224.0.0.0 --- 239.255.255.255】
  16.     //端口号：与接收端保持一致
  17.     struct sockaddr_in rin;
  18.     rin.sin_family = AF_INET;
  19.     rin.sin_port = htons(5555);
  20.     rin.sin_addr.s_addr = inet_addr("224.1.2.3");
  21.  
  22.     //数据的发送
  23.    //发送数据
  24.    char wbuf[128] = "";
  25.    while(1)
  26.    {
  27.        //从终端获取数据
  28.        fgets(wbuf, sizeof(wbuf), stdin);
  29.        wbuf[strlen(wbuf)-1] = 0;
  30.  
  31.        //发送给广播消息
  32.        sendto(sfd, wbuf, strlen(wbuf), 0, (struct sockaddr*)&rin, sizeof(rin));
  33.        printf("发送成功\n");
  34.  
  35.        //判断发送的消息
  36.        if(strcmp(wbuf, "over") == 0)
  37.        {
  38.            break;
  39.        }
  40.    }
  41.  
  42.  
  43.     //5、关闭套接字：close
  44.     close(sfd);
  45.  
  46.     return 0;
  47. }

 2.3.2 组播的接收端流程---》类似于UDP的服务器端流程

  1. 1、创建用于通信的套接字文件描述符：socket
  2. 2、将该套接字加入多播组：setsockopt   --->  IPPROTO_IP    --> IP_ADD_MEMBERSHIP   
  3. 属性类型：
  4.   struct ip_mreqn {
  5.                struct in_addr imr_multiaddr; /* 组播地址 */
  6.                struct in_addr imr_address;   /* 主机ip地址 */
  7.                int            imr_ifindex;   /* 设备索引，可以通过 ip ad指令查看， 也可以填0，表示使用默认的索引*/
  8.            };
  9.  
  10. 3、填充地址信息结构体：
  11.     ip：组播地址
  12.     port：与发送端保持一致
  13. 4、绑定端口号和IP地址（必须）
  14. 5、接受发送端发来的消息：recvfrom
  15. 6、关闭套接字：close

代码实现：

  1. #include<myhead.h>
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5.     
  6.     //1、创建用于通信的套接字文件描述符：socket
  7.     int rfd = socket(AF_INET, SOCK_DGRAM, 0);
  8.     if(rfd == -1)
  9.     {
  10.         perror("socket error");
  11.         return -1;
  12.     }
  13.  
  14.     //2、将该套接字加入多播组：setsockopt   --->  IPPROTO_IP    --> IP_ADD_MEMBERSHIP 
  15.     struct ip_mreqn  imr;
  16.     imr.imr_multiaddr.s_addr = inet_addr("224.1.2.3");
  17.     imr.imr_address.s_addr = inet_addr("192.168.125.113");
  18.     imr.imr_ifindex = 2;
  19.  
  20.     //设置套接字选项，加入多播组
  21.     if(setsockopt(rfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, sizeof(imr))==-1)
  22.     {
  23.         perror("setsockopt error");
  24.         return -1;
  25.     }
  26.  
  27.     //3、填充地址信息结构体：
  28.     //ip：组播地址
  29.     //port：与发送端保持一致
  30.     struct sockaddr_in rin;
  31.     rin.sin_family = AF_INET;
  32.     rin.sin_addr.s_addr = inet_addr("224.1.2.3");
  33.     rin.sin_port = htons(5555);
  34.  
  35.     //4、绑定端口号和IP地址（必须）
  36.     if(bind(rfd, (struct sockaddr*)&rin, sizeof(rin)) == -1)
  37.     {
  38.         perror("bind error");
  39.         return -1;
  40.     }
  41.  
  42.  
  43.     //5、接受发送端发来的消息：recvfrom
  44.     char rbuf[128] = "";
  45.     while(1)
  46.     {
  47.         //清空容器
  48.         bzero(rbuf, sizeof(rbuf));
  49.  
  50.         //读取数据
  51.         recv(rfd, rbuf, sizeof(rbuf), 0);
  52.  
  53.         //展示
  54.         printf("收到广播消息：%s\n", rbuf);
  55.         //判断广播是否结束
  56.  
  57.         if(strcmp(rbuf, "over") == 0)
  58.         {
  59.             break;
  60.         }
  61.     }
  62.  
  63.     //6、关闭套接字：close
  64.     close(rfd);
  65.  
  66.  
  67.  
  68.     return 0;
  69. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/658841
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号