【lesson62】网络通信UdpSocket版

news/2024/5/18 13:17:14 标签: Linux, 网络通信, 网络协议, udp

文章目录

  • UdpSocket
  • UdpServer.hpp
    • UdpServer类
      • 成员变量解释
      • 成员函数解释
    • UdpServer的实现
    • ServerIinit的实现
      • socket
      • bind
      • htons
      • inet_addr
      • 具体实现
    • ServerStart的实现
      • recvfrom
      • sendto
      • ntohs
      • inet_ntoa
      • 具体实现
    • ~UdpServer函数实现
    • UdpServer.hpp整体完整代码
  • UdpServer.cc
  • UdpClient.cc
    • Thread.hpp
    • UdpClient.cc实现
  • Common.h
  • Log.hpp

UdpSocket

我们要用udp协议来实现网络通信。
我们要用udp协议实现两样：
UdpServer（服务器）
UdpClient（客户端）
客服端可以向服务器发送一些数据或者请求，服务器对其进行响应

UdpServer.hpp

UdpServer类

class UdpServer
{
public:
    UdpServer(uint16_t port, std::string ip = "")
        : _port(port),
          _ip(ip)
    {}

    bool ServerIinit()
    {}

    void ServerStart()
    {}

    ~UdpServer()
    {}

private:
    uint16_t _port;
    std::string _ip;
    int _sock;

    std::unordered_map<std::string, struct sockaddr_in> _users;
};

成员变量解释

uint16_t _port;
std::string _ip;
int _sock;
std::unordered_map<std::string, struct sockaddr_in> _users;

_port：服务器进程要绑定的端口号
_ip：指定连接该服务器的客户端IP，可以设为INADDR_ANY支持任意客户端连接服务器
_sock：套接字
_users：存储所有连接该服务器的端口号和sockaddr_in

成员函数解释

UdpServer(uint16_t port, std::string ip = "")
    : _port(port),
      _ip(ip)
{}

bool ServerIinit()
{}

void ServerStart()
{}

~UdpServer()
{}

UdpServer：构造函数
参数解释：
port：服务器要绑定的端口号
ip：服务器要绑定的IP地址，如果不传默认为缺省值“”，如果为缺省值我们可以设为INADDR_ANY支持任意IP绑定

ServerIinit:初始化服务器

ServerStart：启动服务器

~UdpServer:析构函数，释放一些资源

UdpServer的实现

UdpServer(uint16_t port, std::string ip = "")
    : _port(port),
      _ip(ip)
{}

ServerIinit的实现

需要用到的接口介绍

socket

在这里插入图片描述
参数解释：
domain：
在这里插入图片描述
type：
在这里插入图片描述
protocol：
在这里插入图片描述
return value：
在这里插入图片描述
在这里插入图片描述

bind

在这里插入图片描述
在这里插入图片描述
参数介绍：
socetfd：创建套接字文件的文件描述符
addr：表示struct sockaddr的地址，用于设定要绑定的ip和端口
addr_len：struct sockaddr结构体的大小

struct sockaddr {
   sa_family_t sa_family;
   char        sa_data[14];
}

sa_family 用于指定AF_***表示使用什么协议族的ip
sa_data 存放ip和端口
这里有一个问题，直接向sa_data中写入ip和端口号有点麻烦，内核提供struct sockaddr_in结构体进行写入,通过/usr/include/linux/in.h可以看到结构体原型
使用该结构体时需要包含<netinet/in.h>头文件，且sockaddr_in结构体是专门为tcp/ip协议族使用，其他协议族需要使用其对应的转换结构体,比如**“域通信协议族**” 使用的是sockaddr_un结构体

struct sockaddr_in {
	  __kernel_sa_family_t  sin_family;     /* Address family               */
	  __be16                sin_port;       /* Port number                  */
	  struct in_addr        sin_addr;       /* Internet address             */
	
	  /* Pad to size of `struct sockaddr'. 设置IP端口号这个成员暂时用不到 */
	  unsigned char         __pad[__SOCK_SIZE__ - sizeof(short int) -
	                        sizeof(unsigned short int) - sizeof(struct in_addr)];
};

/* Internet address.填补相比于struct sockaddr所缺的字节数，保障强制转换不要出错 */
struct in_addr {
        __be32  s_addr; // __be32是32位的unsigned int ，因为ipv4是无符号32位整型 
};

sockaddr_in结构体中存放的端口和ip是分开的，使用struct sockaddr_in设置后，让后将其强制转换为struct sockaddr类型，然后传递给bind函数即可

htons

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

inet_addr

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

具体实现

bool ServerIinit()
{
	//1.创建套接字
	//AF_INET 表示是网络编程
	//SOCK_DGRAM 表示使用的是udp协议
    _sock = socket(AF_INET, SOCK_DGRAM, 0);
    //如果返回值小于0，说明创建套接字失败
    if (_sock < 0)
    {
    	//打出创建的日志信息
        LogMessage(FATAL, "socket %s", strerror(errno));
        exit(2);
    }
    //打出创建的日志信息
    LogMessage(NORMAL, "udp socket success");
	
	//定义sockaddr_in 对象
    struct sockaddr_in local;
    //初始化sockaddr_in ，初始化为0
    bzero(&local, sizeof(local));
	
	//向sockaddr_in对象 local填入一些数据
	//local.sin_port server要绑定的端口号
	//local.sin_family server使用的协议家族，指明要使用什么协议
	//local.sin_addr.s_addr server要绑定的IP地址
	//htons()将端口号转化为大端
    local.sin_port = htons(_port);
    local.sin_family = AF_INET;
    
    //判断要绑定的IP地址是否为空，如果为空填入INADDR_ANY表示绑定任意IP地址
    //如果不为空填入该IP
    //inet_addr()做了两个工作
    //1.将字符串IP转化为32位整数 2.将32位整数转化为大端
    local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());

	//2.开始绑定
    int n = bind(_sock, (struct sockaddr *)&local, sizeof(local));
    //如果绑定失败n bind会返回-1
    if (n == -1)
    {
    	//打印出绑定的日志信息
        LogMessage(FATAL, "bind %s", strerror(errno));
        exit(3);
    }
    //打印出绑定的日志信息
    LogMessage(NORMAL, "udp bind success");
	
	//到最后成功打印出初始化成功的日志信息
    LogMessage(NORMAL, "init udp server done ... %s", strerror(errno));
    return true;
}

ServerStart的实现

需要用到的接口介绍

recvfrom

在这里插入图片描述
在这里插入图片描述
参数解释：
sockfd：创建套接字文件的文件描述符
buffer：输出型参数，数据缓冲区数组，会把从网络中获取到的数据放入其中
len：buffer的大小
flages：
在这里插入图片描述
src_addr:指向一个sockaddr结构体，用于存储发送方的地址信息。
addrlen:src_addr结构体的大小
return value：
在这里插入图片描述
在这里插入图片描述

sendto

在这里插入图片描述

在这里插入图片描述
参数解释：
sockfd：创建套接字文件的文件描述符
buffer：要输入数据的数组
len：输入数据的长度
dest_addr:指向一个sockaddr结构体，用于存储接受方的地址信息。
addrlen:dest_addr结构体的大小
flags:
在这里插入图片描述
return value:
在这里插入图片描述
在这里插入图片描述

ntohs

在这里插入图片描述

inet_ntoa

在这里插入图片描述
在这里插入图片描述

具体实现

void ServerStart()
{
	//数据缓冲区
    char buffer[BUFFER_SIZE];
    //客户端的IP和port的临时存放区
    char key[64];
	
	//服务器肯定是一直循环执行的
    while (true)
    {
    	//定义peer结构体，peer是输出型参数，可以获取客户端的IP和port
        struct sockaddr_in peer;
        //计算peer结构体的大小
        socklen_t len = sizeof(peer);
        //初始化peer结构体，初始化为0
        memset(&peer, 0, len);
        //recvfrom从_sock文件中获取数据
        int s = recvfrom(_sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&peer, &len);
		
		//s > 0 代表成功获取数据，我们要对该数据进行处理
        if (s > 0)
        {
            buffer[s] = '\0';
			
			//因为端口是从网络中来的，所以是大端序列
			//ntohs将大端的port转化为小端
            uint16_t src_port = ntohs(peer.sin_port);
            
            //inet_ntoa做了两个工作
            //1.将网络中获取到的32位整数IP地址转化为小端序列
            //2.将IP地址转化为字符串
            std::string src_ip = inet_ntoa(peer.sin_addr);
			
			//处理获取到的数据
            printf("[%s:%d]# %s\n", src_ip.c_str(), src_port, buffer);
            //将网络中的IP地址和端口号存入key中
            snprintf(key, sizeof(key), "%s-%u", src_ip.c_str(), src_port);
            LogMessage(NORMAL, "key: %s", key);
			
			//在_users中查找key，如果存在说明这个客户端之前有连接果不用在添加进_user中
            auto ret = _users.find(key);
            //如果不存在如果存在说明这个客户端第一次连接服务器，将其添加进_user中
            if (ret == _users.end())
            {
                LogMessage(NORMAL, "add new user : %s", key);
                _users.insert(std::make_pair(key, peer));
            }
        }
		
		//将收到的消息广播给所有主机
        for (auto &iter : _users)
        {
            std::string send_message(key);
            send_message += "# ";
            send_message += buffer;
            LogMessage(NORMAL, "push message to %s", iter.first.c_str());
            //std::cout << send_message << std::endl;
            //sendto发送数据到_sock文件中，并指明要发送主机的IP地址和端口号
            //主机的IP地址和端口号在(struct sockaddr *)&iter.second
            sendto(_sock, send_message.c_str(), send_message.size(), 0,
                   (struct sockaddr *)&iter.second, len);
        }
    }
}

~UdpServer函数实现

~UdpServer()
    {
        if (_sock >= 0)
        {
            close(_sock);
        }
    }

UdpServer.hpp整体完整代码

#include "Common.h"
#include "Log.hpp"

class UdpServer
{
public:
    UdpServer(uint16_t port, std::string ip = "")
        : _port(port),
          _ip(ip)
    {
    }

    bool ServerIinit()
    {
        _sock = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sock < 0)
        {
            LogMessage(FATAL, "socket %s", strerror(errno));
            exit(2);
        }
        LogMessage(NORMAL, "udp socket success");

        struct sockaddr_in local;
        bzero(&local, sizeof(local));

        local.sin_port = htons(_port);
        local.sin_family = AF_INET;
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());

        int n = bind(_sock, (struct sockaddr *)&local, sizeof(local));
        if (n == -1)
        {
            LogMessage(FATAL, "bind %s", strerror(errno));
            exit(3);
        }
        LogMessage(NORMAL, "udp bind success");

        LogMessage(NORMAL, "init udp server done ... %s", strerror(errno));
        return true;
    }

    void ServerStart()
    {
        char buffer[BUFFER_SIZE];
        char key[64];

        while (true)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            memset(&peer, 0, len);
            int s = recvfrom(_sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&peer, &len);

            if (s > 0)
            {
                buffer[s] = '\0';

                uint16_t src_port = ntohs(peer.sin_port);
                std::string src_ip = inet_ntoa(peer.sin_addr);

                printf("[%s:%d]# %s\n", src_ip.c_str(), src_port, buffer);
                snprintf(key, sizeof(key), "%s-%u", src_ip.c_str(), src_port);
                LogMessage(NORMAL, "key: %s", key);

                auto ret = _users.find(key);
                if (ret == _users.end())
                {
                    LogMessage(NORMAL, "add new user : %s", key);
                    _users.insert(std::make_pair(key, peer));
                }
            }

            for (auto &iter : _users)
            {
                std::string send_message(key);
                send_message += "# ";
                send_message += buffer;
                LogMessage(NORMAL, "push message to %s", iter.first.c_str());
                //std::cout << send_message << std::endl;
                sendto(_sock, send_message.c_str(), send_message.size(), 0,
                       (struct sockaddr *)&iter.second, len);
            }
        }
    }

    ~UdpServer()
    {
        if (_sock >= 0)
        {
            close(_sock);
        }
    }

private:
    uint16_t _port;
    std::string _ip;
    int _sock;

    std::unordered_map<std::string, struct sockaddr_in> _users;
};

UdpServer.cc

#include "udp_server.hpp"

static void Usage(std::string proc)
{
    std::cout << "Usage:\t\n " << proc << " port\n" << std::endl;
}

int main(int argc,char* argv[])
{
	//使用规则必须是 ./server port
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    //使用智能指针管理UdpServer
    std::unique_ptr<UdpServer> svr(new UdpServer(port));

    svr->ServerIinit();
    svr->ServerStart();

    return 0;
}

UdpClient.cc

Thread.hpp

#include "Common.h"
#include "Log.hpp"

typedef void *(*fun_t)(void *);

class ThreadData
{
public:
    std::string _name;
    void *_args;
};

class Thread
{
public:
    Thread(std::string name, fun_t routine, void *args)
    {
        _thread_data._name = name;
        _func = routine;
        _thread_data._args = args;
    }

    void Start()
    {
        pthread_create(&_tid, nullptr, _func, (void*)&_thread_data);
        //std::cout <<  _thread_data._name << " create success" << std::endl;
        LogMessage(NORMAL,"%s creadte success",_thread_data._name.c_str());
    }

    void Join()
    {
        pthread_join(_tid, nullptr);
        //std::cout <<  _thread_data._name << " join success" << std::endl;
        LogMessage(NORMAL,"%s join success",_thread_data._name.c_str());
    }

    std::string GetName()
    {
        return _thread_data._name;
    }

private:
    ThreadData _thread_data;
    pthread_t _tid;
    fun_t _func;
};

UdpClient.cc实现

#include "Common.h"
#include "Log.hpp"
#include "Thread.hpp"

std::string serverip;
uint16_t serverport = 0;

static void Usage(std::string proc)
{
    std::cout << "Usage:\t\n " << proc << " serverip serverport\n"
              << std::endl;
}

//发送数据的线程
void *udpSend(void *args)
{
    int sock = *((int *)((ThreadData *)args)->_args);

    //std::cout << sock << std::endl;

    struct sockaddr_in server;
    bzero(&server, sizeof(server));

    server.sin_port = htons(serverport);
    //std::cout << serverport << std::endl;;
    //std::cout << serverip << std::endl;
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    std::string message;
    while (true)
    {
        std::cerr << "Please Entery your message: ";
        std::getline(std::cin, message);
        if (message.c_str() == "quit")
        {
            LogMessage(NORMAL, "client quit");
            break;
        }

        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server));
    }
}

//接收数据的线程
void *udpRecv(void *args)
{
    int sock = *((int *)((ThreadData *)args)->_args);
    //std::cout << sock << std::endl;
    char buffer[BUFFER_SIZE];
    while (true)
    {
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        int s = recvfrom(sock,buffer,sizeof(buffer),0,(struct sockaddr*)&temp,&len);

        //std::cout << buffer;
        if(s > 0)
        {
            buffer[s] = '\0';
            std::cout << buffer << std::endl;
        }
    }
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        LogMessage(FATAL, "socket %s", strerror(errno));
        exit(1);
    }
    LogMessage(NORMAL, "socket %s", strerror(errno));

    serverip = argv[1];
    serverport = atoi(argv[2]);
	
	//多线程版
    std::unique_ptr<Thread> sender(new Thread("send_thread", udpSend, (void *)&sock));
    std::unique_ptr<Thread> recver(new Thread("recv_thread", udpRecv, (void *)&sock));

    sender->Start();
    recver->Start();

    sender->Join();
    recver->Join();

    // LogMessage(NORMAL, "%s%d",serverip.c_str(),serverport);
	
	//单线程版 弊端：一直卡在发送数据处，当别人发消息时，无法及时接收
    /* struct sockaddr_in server;
    bzero(&server, sizeof(server));

    server.sin_port = htons(serverport);
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    std::string message;
    char buffer[BUFFER_SIZE];
    while (true)
    {
        std::cout << "Please Entery your message: ";
        std::getline(std::cin, message);
        if (message.c_str() == "quit")
        {
            LogMessage(NORMAL, "client quit");
            break;
        }

        //std::cout << message;
        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server));

        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        int s = recvfrom(sock,buffer,sizeof(buffer),0,(struct sockaddr*)&temp,&len);

        //std::cout << buffer;
        if(s > 0)
        {
            buffer[s] = '\0';
            std::cout << buffer << std::endl;
        }
    } */
    return 0;
}

Common.h

共用的头文件

#pragma once

#include <iostream>
#include <string>
#include <unordered_map>
#include <memory>
#include <cstring>
#include <cerrno>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdarg.h>
#include <pthread.h>

#define BUFFER_SIZE 1024

Log.hpp

打印日志的函数

#pragma once
#include "Common.h"

// 日志是有日志级别的
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4

#define STANDARD_NUM 1024
#define CUSTOM_NUM 1024

const char *gLevelMap[] = {
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"};

void LogMessage(int level, const char *format, ...)
{
 #ifndef DEBUG_SHOW
    if(level== DEBUG) return;
#endif
    // 标准部分
    char standard_buffer[STANDARD_NUM];
    snprintf(standard_buffer, sizeof(standard_buffer), "[%s][%ld]", gLevelMap[level], time(nullptr));

    // 自定义部分
    char custom_buffer[CUSTOM_NUM];
    va_list args;
    va_start(args, format);
    vsnprintf(custom_buffer, sizeof(custom_buffer), format, args);
    va_end(args);

    printf("%s%s\n", standard_buffer, custom_buffer);
}

http://www.niftyadmin.cn/n/5383010.html

相关文章

瑞_23种设计模式_代理模式

瑞_23种设计模式_代理模式

文章目录 1 代理模式&#xff08;Proxy Pattern&#xff09;1.1 介绍1.2 概述1.3 代理模式的结构 2 静态代理2.1 介绍2.2 案例——静态代理2.3 代码实现 3 JDK动态代理★★★3.1 介绍3.2 代码实现3.3 解析代理类3.3.1 思考3.3.2 使用 Arthas 解析代理类3.3.3 结论 3.4 动态代理…
阅读更多...
机器学习基础（一）理解机器学习的本质

机器学习基础（一）理解机器学习的本质

导读&#xff1a;在本文中&#xff0c;将深入探索机器学习的根本原理&#xff0c;包括基本概念、分类及如何通过构建预测模型来应用这些理论。 目录 机器学习 机器学习概念 相关概念 机器学习根本&#xff1a;模型 数据的语言&#xff1a;特征与标签 训练与测试&#xf…
阅读更多...
随手写的小程序2 一个nc能控制的程序

随手写的小程序2 一个nc能控制的程序

小程序源代码 下载: https://download.csdn.net/download/nn_84/88846445?spm1001.2014.3001.5501 请下载 Qt 5.12.12 server.pro : QT gui networkCONFIG c11 console CONFIG - app_bundle# You can make your code fail to compile if it uses deprecated APIs. # In o…
阅读更多...
Linux、Ubuntu、CenterOS、RedHat、Debian、AIpine关系和区别？

Linux、Ubuntu、CenterOS、RedHat、Debian、AIpine关系和区别？

目录 1. 区别和联系 2. 安装命令 3. 其他发行版本 4.参考 1. 区别和联系 Ubuntu, Debian, RedHat, CentOS都是不同的Linux发行版。 Ubuntu 是基于Debian的一个开源GNU/Linux操作系统。它的目标是为一般用户提供一个最新同时又相当稳定&#xff0c;主要以自由软件建构而成…
阅读更多...
litemall系统默认弱口令漏洞

litemall系统默认弱口令漏洞

免责声明&#xff1a;文章来源互联网收集整理&#xff0c;请勿利用文章内的相关技术从事非法测试&#xff0c;由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;所产生的一切不良后果与文章作者无关。该…
阅读更多...
人工智能_PIP3安装使用国内镜像源_安装GIT_普通服务器CPU_安装清华开源人工智能AI大模型ChatGlm-6B_002---人工智能工作笔记0097

人工智能_PIP3安装使用国内镜像源_安装GIT_普通服务器CPU_安装清华开源人工智能AI大模型ChatGlm-6B_002---人工智能工作笔记0097

接着上一节来看,可以看到,这里 创建软连接以后 [root@localhost Python-3.10.8]# ln -s /usr/local/python3/bin/python3 /usr/bin/python3 [root@localhost Python-3.10.8]# python3 -V Python 3.10.8 [root@localhost Python-3.10.8]# pwd /usr/local/Python-3.10.8 [root@…
阅读更多...
C# 字典（Dictionary）基本操作

C# 字典（Dictionary）基本操作

一、定义一个字典&#xff1a; // 定义一个存储字符串键和整数值的字典 Dictionary<string, int> numbers new Dictionary<string, int>(); 二、添加元素&#xff1a; // 添加键值对 numbers.Add("One", 1); numbers.Add("Two", 2); 三、通…
阅读更多...
面向对象编程(三)

面向对象编程(三)

目录 1. 关键字&#xff1a;static 1.1 类属性、类方法的设计思想 1.2 static关键字 1.3 静态变量 1.3.1 语法格式 1.3.2 静态变量的特点 1.3.3 举例 1.3.4 内存解析 1.4 静态方法 1.4.1 语法格式 1.4.2 静态方法的特点 1.4.3 举例 2. 单例(Singleton)设计模式 2…
阅读更多...
最新文章

Copyright @ 2022~2023