【Linux网络】应用层自定义协议与序列化及Socket模拟封装

已于 2025-04-24 13:52:22 修改
阅读量1.1k 收藏 41
点赞数 41
文章标签： linux 网络 tcp/ip 服务器
于 2025-04-24 13:51:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77954967/article/details/147463054
版权

📢博客主页：https://blog.csdn.net/2301_779549673
📢博客仓库：https://gitee.com/JohnKingW/linux_test/tree/master/lesson
📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
📢本文由 JohnKi 原创，首发于 CSDN🙉
📢未来很长，值得我们全力奔赴更美好的生活✨

在这里插入图片描述

在这里插入图片描述

文章目录

11111111
11111111
11111111
11111111
**** 11111111

🏳️‍🌈一、应用层

我们程序员写的一个个解决我们实际问题, 满足我们日常需求的网络程序, 都是在应用层.

1.1 再谈 “协议”

协议是一种 “约定”. socket api 的接口, 在读写数据时, 都是按 “字符串” 的方式来发送接收的. 如果我们要传输一些 “结构化的数据” 怎么办呢?

其实，协议就是双方约定好的结构化的数据！

1.2 网络版计算器

例如, 我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加数发过去, 然后由服务器进行计算, 最后再把结果返回给客户端.

约定方案一(传结构体对象):

  • 客户端发送一个形如"1+1"的字符串;
  • 这个字符串中有两个操作数, 都是整形;
  • 两个数字之间会有一个字符是运算符, 运算符只能是 + ;
  • 数字和运算符之间没有空格;
  • …

不推荐直接传结构体对象，从技术和业务角度解释？

1、技术角度

  • 1、跨平台与兼容性：

    • 结构体的大小和内存布局可能因编译器、操作系统或硬件平台的不同而有所差异。这可能导致在一个平台上发送的结构体在另一个平台上无法正确解析。

  • 2、内存对齐与填充：

    • 为了优化内存访问速度，编译器可能会对结构体成员进行对齐和填充。这会导致结构体的实际大小大于其成员大小的总和。
    • 直接传输结构体可能会因为内存对齐和填充的问题而导致数据解析错误。

  • 3、指针与动态内存：

    • 结构体中可能包含指针，这些指针指向动态分配的内存。直接传输结构体无法传递指针所指向的数据，而只能传递指针值，这可能导致数据丢失或内存泄漏。

2、业务角度

  • 1、数据安全性：
    • 直接传输结构体可能会暴露数据的内部结构和实现细节，从而增加数据被恶意攻击的风险。
  • 2、数据版本控制：
    • 随着业务的发展和变化，数据结构和格式可能需要进行调整和升级。

约定方案二(传字符串):

  • 定义结构体来表示我们需要交互的信息;
  • 发送数据时将这个结构体按照一个规则转换成字符串, 接收到数据的时候再按照相同的规则把字符串转化回结构体;
  • 这个过程叫做 “序列化” 和 “反序列化”

1.3 序列化和反序列化

在这里插入图片描述

无论我们采用方案一, 还是方案二, 还是其他的方案, 只要保证, 一端发送时构造的数据,在另一端能够正确的进行解析, 就是 ok 的. 这种约定, 就是 应用层协议

但是，为了让我们深刻理解协议，我们打算自定义实现一下协议的过程。

  • 我们采用方案 2，我们也要体现协议定制的细节
  • 我们要引入序列化和反序列化，只不过我们课堂直接采用现成的方案 – jsoncpp库
  • 我们要对 socket 进行字节流的读取处理

🏳️‍🌈二、什么是全双工

在这里插入图片描述

所以：

  • 在任何一台主机上，TCP 连接既有发送缓冲区，又有接受缓冲区，所以，在内核中，可以在发消息的同时，也可以收消息，即全双工
  • 这就是为什么一个 tcp sockfd 读写都是它的原因
  • 实际数据什么时候发，发多少，出错了怎么办，由 TCP 控制，所以 TCP 叫做传输控制协议

1、read，write，send，recv本质是拷贝函数！
2、发送数据的本质：是从发送方的发送缓冲区把数据通过协议栈和网络拷贝给接收方大的接收缓冲区！
3、tcp支持全双工通信的原因(有发送和接收缓冲区)！
4、有两个缓冲区这种模式就是生产者消费者模型！
5、为什么IO函数要阻塞？本质是在维护同步关系！

TCP协议是面向字节流的，客户端发的，不一定是全部是服务端收的，怎么保证读到的是一个完整的请求呢？

  • 分割完整的报文！

🏳️‍🌈三、Socket封装

Socket类以模板方法类的设计模式进行封装，将算法的不变部分封装在抽象基类中 ，而将可变部分延迟到子类中实现！

3.1 整体结构

  • 抽象类（Abstract Class）：

    1. 定义了多个抽象操作，这些操作在抽象类中不具体实现，由子类实现。
    2. 定义了两个模板方法，这个方法通常调用了上面提到的抽象操作。模板方法的算法骨架是固定的，但其中一些步骤的具体实现会延迟到子类中。

  • 具体子类（Concrete Class）：

    1. 实现抽象类中的抽象操作，提供具体的算法步骤实现。
    2. 可以重写父类中的模板方法，但通常情况下不需要这么做，因为模板方法已经在抽象类中定义好了算法的骨架。

3.2 Socket 基类

将套接字创建、绑定、监听等 ​通用流程​ 抽象为模板方法，如 BuildListenSocket，而将具体步骤（如 CreaterSocketOrDie）延迟到子类实现。

​角色划分​：

  • ​抽象类（Abstract Class）​​：Socket 定义了纯虚函数（步骤方法）和模板方法（流程框架）。​
  • 具体子类（Concrete Class）​​：由用户继承 Socket 并实现纯虚函数（例如 TcpSocket、UdpSocket）。
using SockPtr = std::shared_ptr<Socket>;

class Socket {

public:
    virtual void CreateSocketOrDie() = 0;                 // 创建套接字
    virtual void BindOrDie(uint16_t port) = 0;            // 绑定套接字
    virtual void ListenOrDie(int backlog = gbacklog) = 0; // 监听套接字
    virtual SockPtr Accepter(InetAddr* cli) = 0;          // 获取链接
    virtual bool Connector(const std::string& peerip,
                           uint16_t peerport) = 0; // 简历连接
    virtual int Sockfd() = 0;
    virtual void Close() = 0;
    virtual ssize_t Recv(std::string* out) = 0;      // 接收数据
    virtual ssize_t Send(const std::string& in) = 0; // 发送数据

public:
    // 创建监听套接字
    void BuildListenSocket(uint16_t port) {
        CreateSocketOrDie(); // 创建
        BindOrDie(port);     // 绑定
        ListenOrDie();       // 监听
    }

    // 创建客户端套接字
    void BuildConnectorSocket(const std::string& peerip, uint16_t peerport) {
        CreateSocketOrDie();         // 创建
        Connector(peerip, peerport); // 连接
    }
};

3.3 TcpSocket 子类

TcpSocket类 继承 Socket类，并具体实现父类的抽象操作！

3.3.1 基本结构

TcpSocket 子类就是具体实现父类的抽象操作，所以所有 TCP 可能会用到的父类方法都要具体实现

class TcpSocket : public Socket {
public:
    TcpSocket() {}
    TcpSocket(int sockfd) {}

    // 创建套接字
    void CreateSocketOrDie() {}
    // 绑定套接字
    void BindOrDie(uint16_t port) {}
    // 监听套接字
    void ListenOrDie(int backlog = gbacklog) {}
    // 获取链接
    SockPtr Accepter(InetAddr* cli) {}
    // 建立连接
    bool Connector(const std::string& peerip, uint16_t peerport) {}
    // 获取套接字描述符
    int Sockfd() {}
    // 关闭套接字
    void Close() {}

    ~TcpSocket() {}

private:
    int _sockfd;
};

3.3.2 构造、析构函数

  • 构造函数 可以实现两个，一个无参构造，一个有参构造(传参sockfd)，用于初始化成员变量
  • 析构函数 可以不做处理，后面关闭套接字自己调用关闭函数即可！
TcpSocket() {}
TcpSocket(int sockfd) : _sockfd(sockfd) {}
~TcpSocket() {}

3.3.3 创建套接字

使用库函数 socket 按照格式创建套接字

// 创建套接字
void CreateSocketOrDie() override {
    _sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (_sockfd < 0) {
        LOG(LogLevel::ERROR) << "create socket error";
        exit(SOCKET_ERR);
    }
    LOG(LogLevel::DEBUG) << "sockfd create success : " << _sockfd;
}

3.3.4 绑定套接字

这部分用于服务端，所以需要先构建服务端的网络字节序地址，然后绑定套接字和网络字节序地址

// 绑定套接字
            void BindOrDie(uint16_t port) override{
                // sockaddr_in 的头文件是 #include <netinet/in.h>
                struct sockaddr_in local;
                memset(&local, 0, sizeof(local));
                local.sin_family = AF_INET;
                local.sin_port = htons(port);
                local.sin_addr.s_addr = htonl(INADDR_ANY);
                
                int n = ::bind(_sockfd, CONV(&local), sizeof(local));
                if(n < 0){
                    LOG(LogLevel::ERROR) << "bind socket error";
                    exit(BIND_ERR);
                }
                LOG(LogLevel::DEBUG) << "bind success";
            }

3.3.5 监听套接字

在绑定好网络字节序地址后，我们需要形成老板模式，设置最大连接数量，然后不断监听

// 监听套接字
void ListenOrDie(int backlog = gbacklog) override {
    int n = ::listen(_sockfd, backlog);
    if (n < 0) {
        LOG(LogLevel::ERROR) << "listen socket error";
        exit(LISTEN_ERR);
    }
    LOG(LogLevel::DEBUG) << "listen success";
}

3.3.6 获取连接

在为监听套接字设置好最大连接长度后，我们不断使用 accept 监听这个套接字，将获取到的客户端ip和端口号等信息 与 我们的服务端的连接 整合起来，形成一个整体套接字，实现面向对象连接

// 获取链接
SockPtr Accepter(InetAddr* cli) override {
    struct sockaddr_in client;
    socklen_t clientlen = sizeof(client);
    // accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
    // 返回一个新的套接字，该套接字与调用进程间接地建立了连接。
    int sockfd = ::accept(_sockfd, CONV(&client), &clientlen);
    if (sockfd < 0) {
        LOG(LogLevel::ERROR) << "accept socket error";
        return nullptr;
    }
    *cli = InetAddr(client);
    LOG(LogLevel::DEBUG) << "get a new connection from "
                         << cli->AddrStr().c_str() << ", sockfd : " << sockfd;

    return std::make_shared<TcpSocket>(sockfd);
}

3.3.7 建立连接

当客户端想要连接上服务端的时候，我们需要先为服务端创建一个网络字节序地址，再与客户端的套接字连接起来

// 建立连接
bool Connector(const std::string& serverip, uint16_t serverport) override {
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;         // IPv4协议
    server.sin_port = htons(serverport); // 端口号
    // 这句话表示将字符串形式的IP地址转换为网络字节序的IP地址
    // inet_pton函数的作用是将点分十进制的IP地址转换为网络字节序的IP地址
    // 这里的AF_INET表示IPv4协议
    // 这里的serverip.c_str()表示IP地址的字符串形式
    // &server.sin_addr表示将IP地址存储到sin_addr成员变量中
    ::inet_pton(AF_INET, serverip.c_str(), &server.sin_addr); // IP地址

    int n = ::connect(_sockfd, CONV(&server), sizeof(server));
    if (n < 0) {
        LOG(LogLevel::ERROR) << "connect socket error";
        return false;
    }
    LOG(LogLevel::DEBUG) << "connect success";
    return true;
}

3.3.8 其他方法

还有一些其他的方法，难度不大，就不一一介绍了

// 获取套接字描述符
int Sockfd() override { return _sockfd; }

// 关闭套接字
void Close() override {
    if (_sockfd >= 0)
        ::close(_sockfd);
}

// 接收数据
ssize_t Recv(std::string* out) override {
    char inbuffer[4096];
    ssize_t n = ::recv(_sockfd, inbuffer, sizeof(inbuffer) - 1, 0);
    if (n > 0) {
        inbuffer[n] = 0;
        *out = inbuffer;
    }
    return n;
}

// 发送数据
ssize_t Send(const std::string& in) override {
    return ::send(_sockfd, in.c_str(), in.size(), 0);
}

3.3.10 整体代码

#pragma once 

#include <iostream>
#include <cstring>
#include <Socket.h>
#include <memory>

#include <netinet/in.h>

#include "InetAddr.hpp"
#include "Log.hpp"
#include "Common.hpp"

using namespace LogModule;

const int gbacklog = 8;


// common.hpp
// #define Die(code)   \
//     do              \
//     {               \
//         exit(code); \
//     } while (0)

// #define CONV(v) (struct sockaddr *)(v)

// enum 
// {
//     USAGE_ERR = 1,
//     SOCKET_ERR,
//     BIND_ERR,
//     LISTEN_ERR,
//     CONNECTION_ERR
// };

namespace SocketModule{
    using SockPtr = std::shared_ptr<Socket>;

    class Socket{
    
        public:
            virtual void CreateSocketOrDie() = 0;                                       // 创建套接字
            virtual void BindOrDie(uint16_t port) = 0;                                  // 绑定套接字
            virtual void ListenOrDie(int backlog = gbacklog) = 0;                       // 监听套接字
            virtual SockPtr Accepter(InetAddr* cli) = 0;                                // 获取链接
            virtual bool Connector(const std::string& serverip, uint16_t serverport) = 0;   // 简历连接
            virtual int Sockfd() = 0;
            virtual void Close() = 0;
            virtual ssize_t Recv(std::string* out) = 0;                                  // 接收数据
            virtual ssize_t Send(const std::string& in) = 0;                             // 发送数据 
    
        public:
            // 创建监听套接字
            void BuildListenSocket(uint16_t port){
                CreateSocketOrDie();        // 创建
                BindOrDie(port);            // 绑定
                ListenOrDie();              // 监听
            }
    
            // 创建客户端套接字
            void BuildConnectorSocket(const std::string& serverip, uint16_t serverport){
                CreateSocketOrDie();        // 创建
                Connector(serverip, serverport); // 连接
            }
    };



    class TcpSocket : public Socket{
        public:
            TcpSocket(){}
            TcpSocket(int sockfd) : _sockfd(sockfd){ }

            // 创建套接字
            void CreateSocketOrDie() override{
                _sockfd = socket(AF_INET, SOCK_STREAM, 0);
                if(_sockfd < 0){
                    LOG(LogLevel::ERROR) << "create socket error";
                    exit(SOCKET_ERR);
                }
                LOG(LogLevel::DEBUG) << "sockfd create success : " << _sockfd;
            }
            // 绑定套接字
            void BindOrDie(uint16_t port) override{
                // sockaddr_in 的头文件是 #include <netinet/in.h>
                struct sockaddr_in local;
                memset(&local, 0, sizeof(local));
                local.sin_family = AF_INET;
                local.sin_port = htons(port);
                local.sin_addr.s_addr = htonl(INADDR_ANY);
                
                int n = ::bind(_sockfd, CONV(&local), sizeof(local));
                if(n < 0){
                    LOG(LogLevel::ERROR) << "bind socket error";
                    exit(BIND_ERR);
                }
                LOG(LogLevel::DEBUG) << "bind success";
            }                                  
            // 监听套接字
            void ListenOrDie(int backlog = gbacklog) override{
                int n = ::listen(_sockfd, backlog);
                if(n < 0){
                    LOG(LogLevel::ERROR) << "listen socket error";
                    exit(LISTEN_ERR);
                }
                LOG(LogLevel::DEBUG) << "listen success";
            }
            // 获取链接
            SockPtr Accepter(InetAddr* cli) override{
                struct sockaddr_in client;
                socklen_t clientlen = sizeof(client);
                // accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
                // 返回一个新的套接字，该套接字与调用进程间接地建立了连接。
                int sockfd = ::accept(_sockfd, CONV(&client), &clientlen);
                if(sockfd < 0){
                    LOG(LogLevel::ERROR) << "accept socket error";
                    return nullptr;
                }
                *cli = InetAddr(client);
                LOG(LogLevel::DEBUG) << "get a new connection from " << cli->AddrStr().c_str() << ", sockfd : " << sockfd;

                return std::make_shared<TcpSocket>(sockfd);
            }
            // 建立连接
            bool Connector(const std::string& serverip, uint16_t serverport) override{
                struct sockaddr_in server;
                memset(&server, 0, sizeof(server));
                server.sin_family = AF_INET;    // IPv4协议
                server.sin_port = htons(serverport); // 端口号
                // 这句话表示将字符串形式的IP地址转换为网络字节序的IP地址
                // inet_pton函数的作用是将点分十进制的IP地址转换为网络字节序的IP地址
                // 这里的AF_INET表示IPv4协议
                // 这里的serverip.c_str()表示IP地址的字符串形式
                // &server.sin_addr表示将IP地址存储到sin_addr成员变量中
                ::inet_pton(AF_INET, serverip.c_str(), &server.sin_addr);   // IP地址

                int n = ::connect(_sockfd, CONV(&server), sizeof(server));
                if(n < 0){
                    LOG(LogLevel::ERROR) << "connect socket error" ;
                    return false;
                }
                LOG(LogLevel::DEBUG) << "connect success";
                return true;
            }
            
            // 获取套接字描述符
            int Sockfd() override{ return _sockfd; }
            // 关闭套接字
            void Close() override{ if(_sockfd >= 0) ::close(_sockfd); }
            // 接收数据
            ssize_t Recv(std::string* out) override{
                char inbuffer[4096];
                ssize_t n = ::recv(_sockfd, inbuffer, sizeof(inbuffer) - 1, 0);
                if(n > 0){
                    inbuffer[n] = 0;
                    *out = inbuffer;
                }
                return n;
            }           
            // 发送数据                        
            ssize_t Send(const std::string& in) override{
                return ::send(_sockfd, in.c_str(), in.size(), 0);
            }

            ~TcpSocket(){}
        private:
            int _sockfd;
    };
}

👥总结

本篇博文对 【Linux网络】应用层自定义协议与序列化及Socket模拟封装 做了一个较为详细的介绍，不知道对你有没有帮助呢

觉得博主写得还不错的三连支持下吧！会继续努力的~

JhonKI
关注
【Linux】应用层自定义协议与序列化
加油，考上985的研究生
09-04 1582
在应用层中，我们解释了序列化和反序列化的操作，接下来，我们需要将请求和响应进行封装。根据我们自定义协议来进行序列化。下面，我们就以一个有关计算器的请求和响应的数据结构，
【Linux第十课-计算机网络】网络基础、网络套接字、应用层自定义协议与序列化
m0_60803455的博客
12-27 808
TCP建立链接的read、write、send、recv、sendto、recvfrom实际上是拷贝函数tcp发送数据的本质：把自己的发送缓冲区拷贝到接收方的接收缓冲区。通信的本质是拷贝本质是因为cs双方有一对发送和接收缓冲区。
【Linux网络】应用层自定义协议与序列化
qinjh_的博客
04-21 2860
💬 hello!各位铁子们大家好哇。今日更新了Linux网络应用层自定义协议与序列化的内容。
【Linux网络】自定义应用层协议 (序列化)
EterNity_TiMe_的计算机学习之路
11-21 2524
应用层协议，作为网络通信架构中的最高层，直接与用户应用交互，负责数据的格式化和传输控制。通过自定义应用层协议，开发者可以实现特定业务需求，提高数据传输效率，增强系统的安全性和可扩展性。
【Linux】深入理解网络编程：应用层自定义协议、序列化、TCP粘包问题与Socket封装
hanwangyyds的博客
12-12 3578
深入理解网络编程：应用层协议、序列化、TCP粘包问题与Socket封装
应用层自定义协议与序列化
cp
12-15 1192
介绍序列化和反序列化、通过 自定义协议、采用Json 实现序列化和反序列化 实现网络版本的计算器
【计算机网络】应用层自定义协议
YoungMLet的博客
02-26 2824
认识应用层自定义协议，序列化和反序列化，基于定制自定义协议和序列化反序列化实现网络版的计算器！最后认识使用 JSON 进行序列化和反序列化！
【计网】自定义协议与序列化(一) —— Socket封装于服务器端改写
欢迎来到阿熊的blog~~
11-26 1262
文章目录：Tcp协议Socket编程    应用层简介    序列化和反序列化       重新理解read/write/recv/send及tcp的全双工       Socket封装       服务器端改写  我们程序员写的一个个解决我们实际问题，满足我们日常需求的网络程序, 都是在应用层。  不论是Udp Socket编程还是Tcp Socket编程，所传的数据都是字符串类型的的数据，但是如果我们想要传输结构化的数据呢？什么是结构化的数据？其实在我们第一次说计算机网络时就已经提到过，结构化的数据就是
【网络】应用层协议（自定义协议）（序列和反序列化）
m0_70088010的博客
07-27 980
自定义协议和序列反序列化
【在Linux世界中追寻伟大的One Piece】应用层自定义协议|序列化
weixin_74809706的博客
10-18 1904
应用层是OSI模型或TCP/IP模型中的最高层，它直接为用户的应用程序提供网络服务。提供用户与计算机网络交互的界面，允许用户访问网络资源、发送和接收数据、运行应用程序等。允许用户在端系统上进行文档编辑、数据存储和处理等操作。通过网络接口与计算机网络进行通信，发送和接收数据，与其他端系统或网络设备进行交互。如客户/服务器模型(C/S模型)和对等网络模型(P2P模型)，这些模型定义了应用程序之间通信和服务提供的方式。
【Linux】：自定义协议（应用层）
Yikefore的博客
03-19 945
自定义协议的实现（手写序列反序列化以及协议定制），使用jsoncpp进行序列反序列化
自定义协议（应用层协议）——网络版计算机基于TCP传输协议
qq2127189274的博客
07-25 1166
自定义一个网络协议，实现数据的序列化+封包和解包+反序列化，
基于tcp实现自定义应用层协议
C_Rio的博客
05-26 1178
在自定义协议时必须让客户端与服务器都能够看到同一份协议字段，这样才能在接收数据的时候按照规定的格式进行准确无误的接收。对于序列化的字段格式采用空格作为分隔符。而反序列化的时候就可以通过空格分隔符将数据提取出来。// 模拟定协议// 添加报头数据和解报头mes = ret;// 先判断收到的数据是否完整// 指向第一个换行符// 指向第二个换行符// 解包后的数据// 去掉被读走的数据public:"
Linux--应用层自定义协议与序列化（例子：网络计算器）
2301_76618602的博客
08-12 1147
tcp服务器（Tcpserver）处理请求，会做IO，那么就调用IO服务（Service），IO服务处理做序列化和反序列化，还要处理业务，这时就会调用业务处理服务（NetCal网络计算器）。整体而言，这段代码展示了如何在C++中使用JSON进行简单的序列化和反序列化操作，以及如何设计一个简单的文本基通信协议来传输结构化数据。通信协议的设计是基于文本的，使用特定的格式来传输数据，包括长度字段和实际的JSON字符串。类，它负责处理客户端的连接请求，并对接收到的数据进行处理后再发送回客户端。
Linux软硬链接和动静态库(20)
tan180°的博客
04-25 1098
我有款非常喜欢玩的游戏，叫做《饥荒》，现在我下载了这一款游戏，但我不会跑到游戏所在目录中双击 .exe 打开游戏，大多数人都会通过桌面的快捷方式直接打开文件，而这个快捷方式实际就是对 .exe 的 软链接 文件；当你在游戏中加载地图、道具等资源时，这些数据是存在 .exe 文件中的吗？答案是当然不是，这些资源文件都以 库 的方式与 .exe 位于同一目录中，通常为动态库，在 Windows 中后缀为 dll，那么这些神奇的辅助文件是如何产生的？其本质又是如何？本篇将带你一起揭晓。
Linux 服务管理两种方式service和systemctl
最新发布
lza20001103的博客
04-29 600
Linux 服务管理两种方式service和systemctl
Linux常用指令
ya3288426755的博客
04-23 1835
最近在进行操作系统的实验，涉及到Linux系统的使用，下面总结一些常用指令，涵盖文件管理、系统信息、进程管理、用户与权限、网络工具、文本处理、压缩与归档、系统维护等核心功能。：将前一个命令的输出作为后一个命令的输入。：将命令输出保存到文件。
io_uring概述：现代 Linux 异步 IO 的新范式
2401_84703565的博客
04-26 753
io_uring 是由 Jens Axboe 主导开发的异步 I/O 框架，它设计的核心是：用户态与内核共享两个环形队列（SQ & CQ）来提交和获取 I/O 请求，从而避免频繁的系统调用，提高性能。其工作机制如下：SQ（Submission Queue）：用户将 I/O 请求写入 SQ（实际上是 struct io_uring_sqe）。CQ（Completion Queue）：内核完成请求后，将结果写入 CQ（struct io_uring_cqe）。
一篇速成Linux 设置位 S（SetUID）
DreamCollector的博客
04-25 3768
SetUID 是让“普通用户临时拥有管理员权限”的关键机制，强大但危险，务必在可控范围内使用。
自定义网络协议与C语言编程实现
1. **协议设计**：设计网络协议时需要考虑网络层、传输层和应用层协议的设计，同时要确保协议的简洁性和可扩展性。 2. **协议实现**：实现协议时通常会通过定义数据结构、编码函数和解码函数等方式。 3. **协议...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值