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

广播,组播,本地套接字,心跳包

      • 4. 广播
      • 5.组播
      • 6.本地套接字
      • 7.心跳包

4. 广播

  • 只适用于局域网
  • 过程
    • 服务器
      • 创建套接字 – socket
      • fd绑定服务器IPPORT
      • 初始化客户端的IPPORT
        • 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;
}
  • 客户端

    • 创建套接字

    • 显示绑定IPPORT

      • 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.心跳包

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

你可能感兴趣的:(C/C++Linux学习记录,c++,linux)