【linux】网络基础（2）——udp协议

文章目录

• 引言
• udp协议的特点
• udp的头部结构
• UDP的工作原理
• 简单的UDP网络程序
• • 套接字的认识
  • udp服务端代码
  • udp客户端代码
  • 服务端运行

引言

用户数据报协议（User Datagram Protocol, UDP）是一种无连接的传输层协议。它是因特网协议家族的一部分，定义在RFC 768中。UDP提供了一种简单且高效的数据传输方式，适用于需要快速传输、低延迟和不需要可靠传输保证的应用场景。

udp协议的特点

特点	解释
无连接	UDP是一种无连接协议。在传输数据之前，发送方和接收方不需要建立连接。每个数据报（Datagram）都是独立传输的，彼此之间没有关系。这种方式减少了传输前的握手时间，从而提高了传输速度。
不可靠传输	UDP不保证数据的可靠传输。数据报在传输过程中可能会丢失、重复或乱序到达。应用程序需要自己处理这些情况，例如通过超时重传或错误检测和恢复机制。
数据报传输	UDP以数据报的形式传输数据。每个数据报包含一个完整的消息，大小限制在65,535字节以内。由于每个数据报都是独立的，接收方需要根据数据报头的信息来判断数据的顺序和完整性。
轻量级	UDP头部只有8个字节，包含源端口、目标端口、长度和校验和字段。相比之下，TCP头部有20个字节。较小的头部开销使得UDP在传输效率上更具优势。

udp的头部结构

报头名称	功能
16位源端口号	发送方的端口号
16位目的端口	接收方的端口号
16位DUP长度	UDP头部和数据部分的总长度
16位校验和	用于错误检测，覆盖整个数据报，包括头部和数据部分（如果数据效验不匹配，则数据包会被丢弃，并且不会重传）

**关于报头与数据的分离：**因为报头的大小是固定的八个字节，在进行信息处理时，用UDP的长度减去固定长度八个字节，可以得出数据的具体大小

UDP的工作原理

数据报的生成与传输
1、生成数据报：应用程序将数据封装成数据报，包括UDP头部和数据部分。
2、发送数据报：UDP协议将数据报传递给网络层，网络层负责根据IP地址将数据报传输到目标主机。
3、接收数据报：目标主机的UDP协议接收数据报并将其传递给对应的应用程序。

简单的UDP网络程序

套接字的认识

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);
// 绑定端口号 (TCP/UDP, 服务器) 
int bind(int socket, const struct sockaddr *address,
 socklen_t address_len);
// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);
// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,
 socklen_t* address_len);
// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,
 socklen_t addrlen)

udp服务端代码

#include "Inet_Addr.hpp"
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"


const static uint16_t defaultport = 8888;
const static int defaultfd = -1;
const static int defaultsize = 1024;

class Udpserver
{
public:
    Udpserver(uint port = defaultport)
        : _port(port),
          _sockfd(defaultfd)
    {
    }
    void Init()
    {
       // 套接字创建
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            lg.LogMessage(Fatal, "socket errr, %d : %s \n", errno, strerror(errno));
            exit(1);
        }
            lg.LogMessage(Info, "socket success,sockfd: %d\n", _sockfd);
        // 套接字的设置
        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; // 0

        // 套接字绑定内核

        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n != 0)
        {
            lg.LogMessage(Fatal, "bind erro.......", errno, strerror(errno));
            exit(1);
        }
            lg.LogMessage(Info, "bind success");
    }
    void Start()
    {
        char buffer[defaultsize];
        for (;;)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int n = recvfrom(_sockfd, &buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
            if (n > 0)
            {
                InetAddr addr(peer);
                buffer[n] = 0;
                std::cout << "[" << addr.PrintDebug() << "]# " << buffer << std::endl;
                sendto(_sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&peer, len);
            }
        }
    }
    ~Udpserver()
    {
    }
private:
    uint16_t _port;
    int _sockfd;
};

udp客户端代码

#include <iostream>
#include <cerrno>
#include <cstring>
#include <string>
#include <fstream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;
void Usage()
{
    std::cout << "客户端连接服务参数错误" << std::endl;
}
int main(int argc,char* argv[])
{
    if (argc != 3)
    {
        Usage();
        return 1;
    }
    std::string server_ip = argv[1];
    uint16_t server_port = std::stoi(argv[2]);
    
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if(sock < 0)
    {
        std::cout << "sock erro..." << std::endl;
        exit(1);
    }
    else
    std::cout << "sock succcess..." << std::endl;

    struct sockaddr_in server;
    memset(&server,0,sizeof(server));
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());;
    server.sin_family = AF_INET;

    while(true)
    {
        std::string inbuffer;
        std::cout<<"please enter# " << std::endl;
        std::getline(std::cin,inbuffer);
        ssize_t n = sendto(sock,inbuffer.c_str(),sizeof(inbuffer)-1,0,(struct sockaddr*)&server,sizeof(server));
        if(n > 0)
        {
            char buffer[1024];
            struct sockaddr_in temp;
            socklen_t len = sizeof(temp);
            ssize_t m = recvfrom(sock,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&temp,&len);
            if(m > 0)
            {
                buffer[m] = 0;
                cout << "server say#: " << buffer << endl;
            }
            else break;
        }
        else
        break;
    }
    close(sock);
    return 0;
}

服务端运行

#include "UdpServer.hpp"
#include <memory>
#include "Inet_Addr.hpp"
void Usage()
{
    std::cout << "服务器启动参数设置错误" << std::endl;
}
int main(int argc, char *argv[])
{
    if((argc != 2))
    {
        Usage();
        return 0;
    }

    uint16_t port = std::stoi(argv[1]);
    std::unique_ptr<Udpserver> usv = std::make_unique<Udpserver>(port);
    usv->Init();
    usv->Start();
}