Linux网络——UDP的运用

Tlzns2024-12-25 9:13

Linux网络------UDP的运用

文章目录

一、引入

在上一篇Linux网络------网络套接字中我们简述了TCP/UDP协议

其实网络通信的本质就是进程间通信，而进程间通信无非就是读和写（IO）

这篇文章我们借助UDP实现服务端（server）和客户端（client）进行通信

将所学理论运用到实践中

二、服务端实现

由于服务端是面向广大用户的，如果我们将IP地址写死，那么服务器将只能从我们写的哪个IP地址中接收信息

所以启动服务器是不需要IP地址的，它默认接收所以IP地址发来的信息

cpp 复制代码 
//static const std::string default_ip = "0.0.0.0";
static const uint16_t default_port = 8888;

2.1 创建socket套接字

调用系统接口socket函数，帮助我们创建套接字，本质是把文件和网卡关联起来

参数介绍：

domain：一个域，标识了这个套接字的通信类型（网络或者本地）

只用关注上面三个类，第一个与第二个AF_UNIX/AF_LOCAL表示本地通信，而AF_INET表示网络通信
type：套接字提供服务的类型

我们用UDP实现，所以使用SOCK_DGRAM
protocol：想使用的协议，默认为0即可，因为前面的两个参数决定了，就已经决定了是TCP还是UDP协议了

返回值：

成功则返回打开的文件描述符（指向网卡文件，其实就是文件描述符），失败返回-1

创建套接字的本质其实就是创建了一个文件描述符，并返回该文件描述符的值
只是该文件描述符是用于对应服务的网路数据传输

cpp 复制代码 
	_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (_sockfd < 0)
	{
 		lg.LogMessgae(Fatal, "socket error, sockfd : %d\n", _sockfd);
    	exit(1);
	}

	lg.LogMessgae(Info, "socket success, sockfd : %d\n", _sockfd);

2.2 指定网络接口并bind

参数介绍：

socket：创建套接字的返回值
address：通用结构体（上一章Linux网络------网络套接字有详细介绍）
address_len：传入结构体的长度

我们要先定义一个sockaddr_in结构体，将结构体内对应的字段填充好，再将结构体作为参数传递

java 复制代码 
struct sockaddr_in {
    short int sin_family;           // 地址族，一般为AF_INET或PF_INET
    unsigned short int sin_port;    // 端口号，网络字节序
    struct in_addr sin_addr;        // IP地址
    unsigned char sin_zero[8];      // 用于填充，使sizeof(sockaddr_in)等于16
};

创建结构体后要先清空数据（初始化），我们可以用memset，也可以用系统接口：

java 复制代码 
#include <strings.h>

void bzero(void *s, size_t n);

填充端口号的时候要注意端口号是两个字节的数据，涉及到大小端问题
在计算机中的普遍规定：在网络中传输的数据都是大端的

所以为了统一，无论我们机器是大端还是小端，在调用接口的时候，都将IP与端口号从主机序列转化为网路序列

端口号的接口

java 复制代码 
#include <arpa/inet.h>
// 主机序列转网络序列
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
// 网络序列转主机序列
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

IP的接口

对于IP，其实有两步：首先将字符串转换为整型，再解决大小端问题

系统给了直接能解决这两个问题的接口

java 复制代码 
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int inet_aton(const char *cp, struct in_addr *inp);

in_addr_t inet_addr(const char *cp);// 点分十进制字符串

in_addr_t inet_network(const char *cp);

char *inet_ntoa(struct in_addr in);

struct in_addr inet_makeaddr(int net, int host);

in_addr_t inet_lnaof(struct in_addr in);

in_addr_t inet_netof(struct in_addr in);

这里的inet_addr就是把一个点分十进制的字符串转化成整数再进行大小端处理

我们在启动服务器的时候只需要传入端口号即可，IP默认为INADDR_ANY
即默认接收所有的IP

代码：

cpp 复制代码 
        // 2. 指定网络接口

        // 初始化结构体
        struct sockaddr_in local;
        bzero(&local, sizeof(local)); // memset

        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;

        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n != 0)
        {
            lg.LogMessgae(Fatal, "bind error\n");
            exit(2);
        }

2.3 接收数据并处理

服务端要获取到用户端发送过来的数据

参数说明：

sockfd：从哪个套接字读
buf：数据放入的缓冲区
len：缓冲区长度
flags：读取方式， 0代表阻塞式读取
src_addr和addrlen：输出型参数，返回对应的消息内容是从哪一个客户端发出的。第一个是自己定义的结构体，第二个是结构体长度

cpp 复制代码 
    void Start()
    {
        char buffer[1024];
        for (;;)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);

            if (n > 0)
            {
                InetAddr addr(peer);
                buffer[n] = 0;
                std::cout << "client[" << addr.PrintDebug() << "]# " << buffer << std::endl;

                std::string task = _BackMessage(buffer);
                sendto(_sockfd, task.c_str(), task.size(), 0, (struct sockaddr *)&peer, len);
            }
        }
    }

现在我们想要知道是谁发送过来的消息，信息都被保存到了peer结构体中，我们知道IP信息在peer.sin_addr.s_addr中

这是一个网络序列，要转成主机序列，其次为了方便观察，要把它转换成点分十进制

而这两个操作系统给了一个接口能够解决：

java 复制代码 
char *inet_ntoa(struct in_addr in);

同样获取端口号的时候也要由网络序列转成主机序列：

java 复制代码 
uint16_t ntohs(uint16_t netshort);

这里我对struct sockaddr_in进行了封装

单独写了一个类InetAddr用来专门读取struct sockaddr_in内的ip和端口号

cpp 复制代码 
#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>

class InetAddr
{
    public:
    InetAddr(struct sockaddr_in &addr)
    :_addr(addr)
    {
        _ip = inet_ntoa(addr.sin_addr);
        _port = ntohs(addr.sin_port);
    }

    std::string Ip()
    {
        return _ip;
    }

    uint16_t Port()
    {
        return _port;
    }

    sockaddr_in Addr()
    {
        return _addr;
    }

    std::string PrintDebug()
    {
        std::string info = _ip;
        info += ":";
        info += std::to_string(_port);  // "127.0.0.1:4444"
        return info;
    }
    
    ~InetAddr(){}

    private:
    std::string _ip;
    uint16_t _port;
    struct sockaddr_in _addr;
};

2.4 整体代码

java 复制代码 
#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include "nocopy.hpp"
#include "Log.hpp"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cerrno>
#include <strings.h>
#include <string.h>
#include "InetAddr.hpp"
#include "stdlib.h"
#include <functional>

//static const std::string default_ip = "0.0.0.0";
static const uint16_t default_port = 8888;
static const int default_fd = -1;
static const int default_size = 1024;

using func_t = function<std::string(std::string)>;


class UdpServer : public nocopy
{
public:
    UdpServer(func_t BackMessage,const uint16_t port = default_port)
        : _port(port), _sockfd(default_fd),_BackMessage(BackMessage)
    {
    }

    void Init()
    { // 1. 创建socket
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            lg.LogMessgae(Fatal, "socket error, sockfd : %d\n", _sockfd);
            exit(1);
        }

        lg.LogMessgae(Info, "socket success, sockfd : %d\n", _sockfd);
        // 2. 指定网络接口

        // 初始化结构体
        struct sockaddr_in local;
        bzero(&local, sizeof(local)); // memset

        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;

        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n != 0)
        {
            lg.LogMessgae(Fatal, "bind error\n");
            exit(2);
        }
    }


    ~UdpServer()
    {
    }

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

    func_t _BackMessage;
};

2.5 IP的绑定的细节

如果我们将IP绑定为127.0.0.1，这个IP地址叫做本地环回地址

它的作用就是用来做服务器代码测试的

意思就是如果我们绑定的IP是127.0.0.1的话，在应用层发送的消息不会进入物理层，也就不会发送出去

当我们运行起来后想要查看网络情况就可以用指令netstat

后边也可以附带参数：

-a：显示所有连线中的Socket；

-e：显示网络其他相关信息；

-i：显示网络界面信息表单；

-l：显示监控中的服务器的Socket；

-n：直接使用ip地址(数字)，而不通过域名服务器；

-p：显示正在使用Socket的程序识别码和程序名称；

-t：显示TCP传输协议的连线状况；

-u：显示UDP传输协议的连线状况；

三、用户端实现

要发送数据给服务器，就得知道服务器的IP和端口号

这里的IP就必须指明，用来表示我是连接哪台服务器上的哪个进程

java 复制代码 
uint16_t _serverport;
std::string _serverip;
int _sockfd;

这里的IP和port指的是要发送给谁，也就是需要服务器的IP和端口号

创建套接字就跟前面的一样：

java 复制代码 
    //1. 创建socket
    int _sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(_sockfd < 0)
    {
        lg.LogMessgae(Fatal, "socket error, sockfd : %d\n", _sockfd);
        exit(1);

    }
    lg.LogMessgae(Info, "socket success, sockfd : %d\n", _sockfd);

3.1 创建套接字

cpp 复制代码 
  	//1. 创建socket
    int _sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(_sockfd < 0)
    {
        lg.LogMessgae(Fatal, "socket error, sockfd : %d\n", _sockfd);
        exit(1);

    }
    lg.LogMessgae(Info, "socket success, sockfd : %d\n", _sockfd);

3.2 指定网络接口

cpp 复制代码 
    //2. 指定网络接口
    struct sockaddr_in send;
    memset(&send,0,sizeof(send));
    send.sin_family = AF_INET;
    send.sin_port = htons(stoi(argv[2]));
    send.sin_addr.s_addr = inet_addr(argv[1]);

3.3 发生数据并接收

这里的参数和上面的recvfrom差不多，而这里的结构体内部我们要自己填充目的IP和目的端口号

也就是服务器的IP和端口号

cpp 复制代码 
 	//3. 发送消息
    while(true)
    {
        std::string buffer;
        std::cout<<"Please Enter# ";
        getline(std::cin,buffer);
        //cout<<buffer<<endl;
        ssize_t n = sendto(_sockfd,buffer.c_str(),buffer.size(),0,(struct sockaddr*)&send,sizeof(send));
        if(n == -1)
        {
            cout<<"error"<<endl;
        }
        if(n > 0)
        {
            char rec[1024];
            //没用，但有必要
            struct sockaddr_in tmp;
            socklen_t len = sizeof(tmp);

            ssize_t m = recvfrom(_sockfd, rec, sizeof(rec) - 1, 0, (struct sockaddr *)&tmp, &len);
            
            if(m>0)
            {
                rec[m] = 0;
                InetAddr addr(tmp);
                std::cout<<"server["<<addr.PrintDebug()<<"]# "<<rec<<std::endl;
            }
            else
            {
                break;
            }


        }
        else
        {
            break;
        }
    }

3.4 绑定问题

首先bind的作用是允许应用程序指定一个端口号用于监听传入的数据报或数据流

对于服务端：

需要绑定一个公开的端口号，允许大家访问，如果是随机的，其他人不知道，也就访问不了，所以服务端需要绑定

对于客户端：

客户端在给服务器发信息的同时，服务器也可能给客户端发信息，所以客户端为了监听服务器有没有给自己回信息也需要bind一个端口号用于监听，但客户端不需要显式的bind，因为客户端的端口号不会被所有人访问，别人不需要知道，所以OS自动帮我们bind一个随机的端口号，另外也是为了防止端口号重复，避免破坏唯一性

那么为什么前面服务端必须显示的绑定port呢？

因为服务器的端口号是众所周知的，不能改变，如果变了就找不到服务器了

而客户端只需要有就可以，只用标识唯一性即可

举个例子：

我们手机上有很多的app，而每个服务端是一家公司写的，但是客户端却是多个公司写的

如果我们绑定了特定的端口，万一两个公司都用了同一个端口号呢？这样就直接冲突了

OS会自动填充主机IP和随机生成端口号进行绑定（在发送数据的时候自动绑定）
所以创建客户端我们只用创建套接字即可

四、代码

UdpServer

cpp 复制代码 
#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include "nocopy.hpp"
#include "Log.hpp"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cerrno>
#include <strings.h>
#include <string.h>
#include "InetAddr.hpp"
#include "stdlib.h"
#include <functional>

//static const std::string default_ip = "0.0.0.0";
static const uint16_t default_port = 8888;
static const int default_fd = -1;
static const int default_size = 1024;

using func_t = function<std::string(std::string)>;


class UdpServer : public nocopy
{
public:
    UdpServer(func_t BackMessage,const uint16_t port = default_port)
        : _port(port), _sockfd(default_fd),_BackMessage(BackMessage)
    {
    }

    void Init()
    { // 1. 创建socket
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            lg.LogMessgae(Fatal, "socket error, sockfd : %d\n", _sockfd);
            exit(1);
        }

        lg.LogMessgae(Info, "socket success, sockfd : %d\n", _sockfd);
        // 2. 指定网络接口

        // 初始化结构体
        struct sockaddr_in local;
        bzero(&local, sizeof(local)); // memset

        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;

        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n != 0)
        {
            lg.LogMessgae(Fatal, "bind error\n");
            exit(2);
        }
    }

    void Start()
    {
        char buffer[1024];
        for (;;)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);

            if (n > 0)
            {
                InetAddr addr(peer);
                buffer[n] = 0;
                std::cout << "client[" << addr.PrintDebug() << "]# " << buffer << std::endl;

                std::string task = _BackMessage(buffer);
                sendto(_sockfd, task.c_str(), task.size(), 0, (struct sockaddr *)&peer, len);
            }
        }
    }

    ~UdpServer()
    {
    }

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

    func_t _BackMessage;
};



#include "UdpServer.hpp"
#include <memory>

void Usage(const std::string s)
{
    std::cout << "Usagr: " << s << " local_port" << std::endl;
}

std::string BackMessage(const string s)
{
    return "Back Message# " + s;
}



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

    std::unique_ptr<UdpServer> usver(new UdpServer(BackMessage,std::stoi(argv[1])));

    usver->Init();
    usver->Start();
    return 0;
}

UdpClient

cpp 复制代码 
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
#include <memory.h>
#include "InetAddr.hpp"
#include <cstdio>
#include <string>
void usage(std::string s)
{
    std::cout<<"Usagr: "<<s<<" server_ip server_port"<<std::endl;
}

int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 0;
    }

    //1. 创建socket
    int _sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(_sockfd < 0)
    {
        lg.LogMessgae(Fatal, "socket error, sockfd : %d\n", _sockfd);
        exit(1);

    }
    lg.LogMessgae(Info, "socket success, sockfd : %d\n", _sockfd);

    //2. 指定网络接口
    struct sockaddr_in send;
    memset(&send,0,sizeof(send));
    send.sin_family = AF_INET;
    send.sin_port = htons(stoi(argv[2]));
    send.sin_addr.s_addr = inet_addr(argv[1]);

    //3. 发送消息
    while(true)
    {
        std::string buffer;
        std::cout<<"Please Enter# ";
        getline(std::cin,buffer);
        //cout<<buffer<<endl;
        ssize_t n = sendto(_sockfd,buffer.c_str(),buffer.size(),0,(struct sockaddr*)&send,sizeof(send));
        if(n == -1)
        {
            cout<<"error"<<endl;
        }
        if(n > 0)
        {
            char rec[1024];
            //没用，但有必要
            struct sockaddr_in tmp;
            socklen_t len = sizeof(tmp);

            ssize_t m = recvfrom(_sockfd, rec, sizeof(rec) - 1, 0, (struct sockaddr *)&tmp, &len);
            
            if(m>0)
            {
                rec[m] = 0;
                InetAddr addr(tmp);
                std::cout<<"server["<<addr.PrintDebug()<<"]# "<<rec<<std::endl;
            }
            else
            {
                break;
            }


        }
        else
        {
            break;
        }
    }


    return 0;
}

运行图：

五、UDP实现网络聊天室（简易版）

篇幅有限，只放gitee链接：UDP实现网络聊天室（简易版）

相关推荐
乔巴不是狸猫15 分钟前
第11周作业
linux
Bessssss1 小时前
centos权限大集合，覆盖多种权限类型，解惑权限后有“. + t s”问题！
linux·运维·centos
silver6872 小时前
Linux 下的 GPT 和 MBR 分区表详解
linux
R-sz3 小时前
14: curl#6 - “Could not resolve host: mirrorlist.centos.org； 未知的错误“
linux·python·centos
code_abc3 小时前
Shell 脚本编程基础：变量
linux
星如雨落3 小时前
Linux shell脚本对常见图片格式批量转换为PDF文件
linux·shell
冰红茶兑滴水3 小时前
云备份项目--工具类编写
linux·c++
董健正3 小时前
centos制作离线安装包
linux·运维·centos
猫猫的小茶馆3 小时前
【数据结构】数据结构整体大纲
linux·数据结构·算法·ubuntu·嵌入式软件
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明0719个Web前端交互式3D JavaScript框架和库08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO