14.广播，组播，本地套接字，心跳包 C++/Linux-2022-10-28

4. 广播

• 只适用于局域网
• 过程
  • 服务器
    • 创建套接字 – socket
    • fd绑定服务器IP和PORT
    • 初始化客户端的IP和PORT
      • struct sockaddr_in cli;
      • cli.sin_family = AF_INET;
      • cli.port = htos(9898);
      • inet_pton(AF_INET, "xxx.xxx.xxx.125", &cli.adr);
    • 发送数据
      • sendto(fd, buf, len, 0)
  • code

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

int main(int argc, const char* argv[])
{
    // 创建套接字
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(fd == -1)
    {
        perror("socket error");
        exit(1);
    }

    // 绑定server的iP和端口
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family  = AF_INET;
    serv.sin_port = htons(8787);    // server端口
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    int ret = bind(fd, (struct sockaddr*)&serv, sizeof(serv));
    if(ret == -1)
    {
        perror("bind error");
        exit(1);
    }

    // 初始化客户端地址信息
    struct sockaddr_in client;
    memset(&client, 0, sizeof(client));
    client.sin_family = AF_INET;
    client.sin_port = htons(6767);  // 客户端要绑定的端口
    // 使用广播地址给客户端发数据
    inet_pton(AF_INET, "192.168.123.255", &client.sin_addr.s_addr);

    // 给服务器开放广播权限
    int flag = 1;
    setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &flag, sizeof(flag));

    // 通信
    while(1)
    {
        // 一直给客户端发数据
        static int num = 0;
        char buf[1024] = {0};
        sprintf(buf, "hello, udp == %d\n", num++);
        int ret = sendto(fd, buf, strlen(buf)+1, 0, (struct sockaddr*)&client, sizeof(client));
        if(ret == -1)
        {
            perror("sendto error");
            break;
        }
        
        printf("server == send buf: %s\n", buf);

        sleep(1);
    }
    
    close(fd);

    return 0;
}

• 客户端

  • 创建套接字

  • 显示绑定IP和PORT

    • bind

  • 接受数据 - server数据

    • recvfrom();

  • code

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

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

    // 绑定iP和端口
    struct sockaddr_in client;
    memset(&client, 0, sizeof(client));
    client.sin_family = AF_INET;
    client.sin_port = htons(6767);  
    inet_pton(AF_INET, "0.0.0.0", &client.sin_addr.s_addr);
    int ret  = bind(fd, (struct sockaddr*)&client, sizeof(client));
    if(ret == -1)
    {
        perror("bind error");
        exit(1);
    }

    // 接收数据
    while(1)
    {
        char buf[1024] = {0};
        int len = recvfrom(fd, buf, sizeof(buf), 0, NULL, NULL);
        if(len == -1)
        {
            perror("recvfrom error");
            break;
        }
        
        printf("client == recv buf: %s\n", buf);
    }

    close(fd);
    
    return 0;
}

5.组播

跟广播类似，需要使用组播地址

• 组播地址
  • 224.0.0.0~224.0.0.255
    • 预留的组播地址（永久组地址），地址224.0.0.0保留不做分配，其他地址供路由协议使用。
  • 224.0.1.0~224.0.1.255
    • 公用组播地址，可以用于Internet，使用需要申请
  • 224.0.2.0~238.255.255.255
    • 用户可用的组播地址，全网范围有效
  • 239.0.0.0~239.255.255.255
    • 本地管理组播地址，仅在特定的本地范围有效
• code-server

//头文件
#include 
// 使用组播地址给客户端发数据
    inet_pton(AF_INET, "239.0.0.10", &client.sin_addr.s_addr);

    // 给服务器开放组播权限
    struct ip_mreqn flag;
    // init flag
    inet_pton(AF_INET, "239.0.0.10", &flag.imr_multiaddr.s_addr);   // 组播地址
    inet_pton(AF_INET, "0.0.0.0", &flag.imr_address.s_addr);    // 本地IP
    flag.imr_ifindex = if_nametoindex("ens33");
    setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, &flag, sizeof(flag));

• code-client

  #include 
  // 加入到组播地址
    struct ip_mreqn fl;
    inet_pton(AF_INET, "239.0.0.10", &fl.imr_multiaddr.s_addr);
    inet_pton(AF_INET, "0.0.0.0", &fl.imr_address.s_addr);
    fl.imr_ifindex = if_nametoindex("ens33");
    setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &fl, sizeof(fl));

6.本地套接字

• 文件格式：
  • 管道：p
  • 套接字：s
    • 伪文件
• 头文件
  • sys/un.h
• 服务器端
  • 创建套接字
    • int lfd = socket(AF_LOACAL, SOCK_STREAM, 0);
  • 绑定
    • struct sockaddr_un serv;
    • serv.sun_family = AF_LOCAL;
    • strcpy(ser.sun_path."server.socket"); –后缀.socket为了区分
    • bind(lfd, (struct sockaddr*)&serv, len);
  • 设置监听
    • listen()
  • 等待连接请求
    • struct sockaddr_un client;
    • int len = sizeof(client);
    • int cfd = accept(lfd, &client, &len);
  • 通信
    • send()
    • recv()
  • 断开连接
    • close(cfd);
  • code

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

int main(int argc, const char* argv[])
{
    int lfd = socket(AF_LOCAL, SOCK_STREAM, 0);
    if(lfd == -1)
    {
        perror("socket error");
        exit(1);
    }

    // 如果套接字文件存在, 删除套接字文件
    unlink("server.sock");

    // 绑定
    struct sockaddr_un serv;
    serv.sun_family = AF_LOCAL;
    strcpy(serv.sun_path, "server.sock");
    int ret = bind(lfd, (struct sockaddr*)&serv, sizeof(serv));
    if(ret == -1)
    {
        perror("bind error");
        exit(1);
    }
     
    // 监听
    ret = listen(lfd, 36);
    if(ret == -1)
    {
        perror("listen error");
        exit(1);
    }

    // 等待接收连接请求
    struct sockaddr_un client;
    socklen_t len = sizeof(client);
    int cfd = accept(lfd, (struct sockaddr*)&client, &len);
    if(cfd == -1)
    {
        perror("accept error");
        exit(1);
    }
    printf("======client bind file: %s\n", client.sun_path);
     
    // 通信
    while(1)
    {
        char buf[1024] = {0};
        int recvlen = recv(cfd, buf, sizeof(buf), 0);
        if(recvlen == -1)
        {
            perror("recv error");
            exit(1);
        }
        else if(recvlen == 0)
        {
            printf("clietn disconnect ....\n");
            close(cfd);
            break;
        }
        else
        {
            printf("recv buf: %s\n", buf);
            send(cfd, buf, recvlen, 0);
        }
    }
    close(cfd);
    close(lfd);
    
    return 0;
}

• 客户端
  • 创建套接字
    • int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
  • 绑定一个套接字文件
    • struct sockaddr_un client;
    • client.sun_family = AF_LOCAL;
    • strcpy(client.sun_path, "client.socket");
    • bind(fd, (struct sockaddr*)&client, len);
  • 连接服务器
    • struct sockaddr_un serv;
    • ser.sun_family = AF_LOCAL;
    • strcpy(serv.sun_path,"server.socket");
    • connect(fd, &serv,sizeof(server));
  • 通信
    • recv
    • send
  • 关闭
    • close();
  • code

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

int main(int argc, const char* argv[])
{
    int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
    if(fd == -1)
    {
        perror("socket error");
        exit(1);
    }

    unlink("client.sock");

    // ================================
    // 给客户端绑定一个套接字文件
    struct sockaddr_un client;
    client.sun_family = AF_LOCAL;
    strcpy(client.sun_path, "client.sock");
    int ret = bind(fd, (struct sockaddr*)&client, sizeof(client));
    if(ret == -1)
    {
        perror("bind error");
        exit(1);
    }

    // 初始化server信息
    struct sockaddr_un serv;
    serv.sun_family = AF_LOCAL;
    strcpy(serv.sun_path, "server.sock");

    // 连接服务器
    connect(fd, (struct sockaddr*)&serv, sizeof(serv));

    // 通信
    while(1)
    {
        char buf[1024] = {0};
        fgets(buf, sizeof(buf), stdin);
        send(fd, buf, strlen(buf)+1, 0);

        // 接收数据
        recv(fd, buf, sizeof(buf), 0);
        printf("recv buf: %s\n", buf);
    }

    close(fd);

    return 0;
}

7.心跳包

• 心跳包
  • 判断客户端和服务器端是否处于连接状态
    • 心跳机制
      • 不会携带大量的数据
      • 每个一定时间服务器—客户端/客户端----服务器发送一个数据包
    • 心跳包看成一个协议
      • 应用层协议
    • 判断网络是否断开
      • 又多个连续的心跳包没收到/没有回复
      • 关闭通信的套接字
    • 重连
      • 重新初始套接字
      • 继续发送心跳包
  • 乒乓包
    • 比心跳包携带的数据多一些
    • 除了知道连接是否存在，还能获取一些信息