Linux 传输层UDP

仍有未知等待探索

已于 2024-10-05 20:18:41 修改

阅读量969

点赞数 16

分类专栏： Linux 文章标签： linux udp 运维

于 2024-10-05 20:09:45 首次发布

本文链接：https://blog.csdn.net/qq_73435980/article/details/142718366

版权

Linux 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、再谈端口号

在传输层和网络层协议中，源IP、目的IP、源端口、目的端口、协议号，用来标识一个通信。

查看知名端口号和网站的强关联信息？

cat /etc/services

一个进程是否可以bind多个端口号？

可以。

一个端口号是否可以被多个进程bind？

不可以。

理解进程和端口的关系？

进程存储在一个hash表中，而进程的key值就是端口号。所以一个端口号只能被一个进程bind，保证了key值的唯一性。

二、UDP协议

协议格式

16位源端口号：

表示发送方端口号，占用2个字节。在要求对方回信时选用，不要求时可使用全0。

16位目的端口号：

表示接收方端口号，占用2个字节。在终点交付报文时必须使用。

16位UDP长度：

表示UDP数据报文的长度，包括头部和数据部分，占用2个字节。其最小值是8（仅有首部），最大值为65535字节（包括报文在内的用户数据报的总长度）。由于UDP报头长度固定为8字节，因此实际UDP报文的数据长度最大为65527字节。

16位UDP校验和：

用于检测UDP数据报在传输过程中是否有错误，占用2个字节。如果出错则将报文丢弃。— UDP不保证数据的可靠性。

UDP数据字段：

UDP数据字段占用0个或多个字节，是实际传输的数据部分。

如何将报头和有效载荷进行分离（封装）？

因为UDP协议格式的前8个字节都是固定的，所以只需要将前8个字节进行分离，这样就能得到报文的有效载荷。

如何将有效载荷进行分用？

从前8个字节中，找到目的端口，即可将找到需要启动的PCB进程，然后只需要将有效载荷交给该进程即可。

UDP的特点

无连接。
不可靠。没有确认机制，没有重传机制。
面向数据报。— 发送多少次，就必须接收多次；发送多少字节，就必须一次性接收多少字节。

面向数据报：

应用层交给 UDP 多长的报文, UDP 原样发送, 既不会拆分, 也不会合并;
例如：UDP 传输 100 个字节的数据：如果发送端调用一次 sendto, 发送 100 个字节, 那么接收端也必须调用对应的
次 recvfrom, 接收 100 个字节；而不能循环调用 10 次 recvfrom, 每次接收 10 个字。

UDP的缓冲区

UDP 没有真正意义上的发送缓冲区. 调用 sendto 会直接交给内核, 由内核将数据传给网络层协议进行后续的传输动作;
UDP 具有接收缓冲区. 但是这个接收缓冲区不能保证收到的 UDP 报的顺序和发送 UDP 报的顺序一致; 如果缓冲区满了, 再到达的 UDP 数据就会被丢弃;
UDP 的 socket 既能读, 也能写, 这个概念叫做全双工。

UDP的注意事项

Udp协议首部中有一个16位的最大长度，也就是说一个Udp能传输的数据报最大长度是64K（包含Udp首部）。

如果需要传输的数据超过64K，则需要在应用层手动分包，并在接收端手动拼接。

UDP深刻理解

UDP报头：

报头就是结构体变量。
struct udphdr hdr= {...}

UDP报文：

os内可能同时存在大量的报文，一部分正在被向上交付，另一部分正在被向下交付。

所以os要对报文进行各种管理！先描述再组织。

对报文的修改就是对struct sk_buff双向链表的增删查改。
/********************************************
struct sk_buff中，
char *head指向的是数据包的起始位置
char *data指向的是数据包中有效数据的位置

每一个sk_buff都会有一个缓冲区，初始时head不会像常规一样直接指向最开始，而是会指向中间。
********************************************/

三、编写代码

UDP.hpp

// 负责服务端UDP的操作
#pragma once 
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

enum ErrorCode
{
    SUCCESS,
    FAIL
};
class UDP
{
public:
    UDP(int port)
        :m_ip("0")
        ,m_port(port)
    {}
    void Init()
    {
        // 创建套接字
        m_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (m_sockfd < 0)
        {
            std::cout << "创建套接字失败" << std::endl;
            exit(FAIL);
        }
        std::cout << "创建套接字成功" << std::endl;
        // 绑定套接字
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(m_port);
        addr.sin_addr.s_addr = inet_addr(m_ip.c_str());
        int n = bind(m_sockfd, (struct sockaddr *)&addr, sizeof(addr));
        if (n < 0)
        {
            std::cout << "绑定套接字失败" << std::endl;
            exit(FAIL);
        }
        std::cout << "绑定套接字成功" << std::endl;
    }
    void Start()
    {
        while (true)
        {
            // 接收消息
            char buffer[1024];
            sockaddr_in recv_addr;
            socklen_t len = sizeof(recv_addr);
            ssize_t n = recvfrom(m_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&recv_addr, &len);
            if (n > 0)
            {
                buffer[n] = 0;
                std::cout << "接收成功: " << buffer << std::endl;
            }
            else if (n == 0)
            {
                std::cout << "recvfrom 被关闭" << std::endl;
                exit(SUCCESS);
            }
            else 
            {
                std::cout << "接收异常" << std::endl;
                exit(FAIL);
            }
            // 发送消息
            std::string echo = "Echo #";
            echo += buffer;
            ssize_t m = sendto(m_sockfd, echo.c_str(), echo.size(), 0, (struct sockaddr *)&recv_addr, len);
            if (m < 0)
            {
                std::cout << "发送异常" << std::endl;
                exit(FAIL);
            }
            std::cout << "发送成功" << std::endl;
        }
    }
    ~UDP()
    {}
private:
    std::string m_ip;
    int m_port;
    int m_sockfd;
};

client.cc

#include <iostream>
#include <memory>
#include "UDP.hpp"

// ./client 127.0.0.1 8080
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        std::cout << "指令错误" << std::endl;
        exit(FAIL);
    }

    std::string ip = argv[1];
    int port = std::stoi(argv[2]);

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        std::cout << "创建套接字失败" << std::endl;
        exit(FAIL);
    }
    std::cout << "创建套接字成功" << std::endl;

    // 读写
    while (true)
    {
        // 发送消息
        std::cout << "Enter #";
        std::string enter;
        std::getline(std::cin, enter);
        sockaddr_in send_addr;
        send_addr.sin_family = AF_INET;
        send_addr.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &send_addr.sin_addr);
        socklen_t len = sizeof(send_addr);
        ssize_t n = sendto(sockfd, enter.c_str(), enter.size(), 0, (struct sockaddr *)&send_addr, len);
        if (n < 0)
        {
            std::cout << "发送异常" << std::endl;
            exit(FAIL);
        }
        std::cout << "发送成功" << std::endl;
        // 接收消息
        char buffer[1024];
        sockaddr_in addr;
        socklen_t length;
        ssize_t m = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&addr, &length);
        if (m > 0)
        {
            buffer[n] = 0;
            std::cout << "接收成功: " << buffer << std::endl;
        }
        else if (m == 0)
        {
            std::cout << "recvfrom 被关闭" << std::endl;
            exit(SUCCESS);
        }
        else
        {
            std::cout << "接收异常" << std::endl;
            exit(FAIL);
        }
    }
    return 0;
}

Server.cc

#include <iostream>
#include <memory>
#include "UDP.hpp"

// ./server 8080
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cout << "指令错误" << std::endl;
        exit(FAIL);
    }
    // 对服务端套接字进行处理
    int port = std::stoi(argv[1]);
    std::unique_ptr<UDP> up = std::make_unique<UDP>(port);
    up->Init();
    up->Start();

    return 0;
}