当前位置： 首页 > article >正文

计算机网络（五） —— 自定义协议简单网络程序

article 2024/11/15 21:47:17

目录

一，关于“协议”

1.1 结构化数据

1.2 序列化和反序列化

二，网络版计算器实现准备

2.1 套用旧头文件

2.2 封装sock API

三，自定义协议

3.1 关于自定义协议

3.2  实现序列化和反序列化

3.3 测试

三，服务器实现

3.1 逻辑梳理

3.2 各头文件实现

四，客户端实现

一，关于“协议”

1.1 结构化数据

两个主机通过网络和协议进行通信时，发送的数据有两种形式：

  • 如果传输的数据直接就是一个字符串，那么把这个字符串发出去，对方也能得到这个字符串
  • 如果需要传输的是一个struct结构体，那么不能将结构体数据一个个发送到网络中

比如我要实现一个网络版的计算器，那么客户端给服务器发送的数据，就要包含左操作数，运算符和右操作数，那么这就不仅仅是一个字符串了，而是一组数据

所以客户端不能把这些数据一个个发送过去，需要把这些数据“打个包”，统一发到网络中，此时服务器就能获取到一个完整的数据请求，“打包”方式有两种：

方案一：将结构化的数据结合成一个大的字符串

  • 比如我要发送“1+1”，用户输入的是“整型”，“字符”，“整型”
  • 我们先用to_string函数把整型转为字符串，然后用strcat或者C++/string的 "+="运算符重载将这三个字符拼接成一个长字符串，然后就可以直接发送
  • 最后服务器收到了长字符串，再以相同的方式进行拆分，用stoi函数将字符串转整型，就可以提取这些结构化的数据

方案二：定制结构化数据，实现序列化和反序列化 

  • 客户端可以定制一个结构体，将需要交互的信息放到结构体种
  • 客户端发送前，将结构体的数据进行序列化，服务器收到数据后进行反序列化，此时服务器就能得到客户端发送过来的结构体，下面我们来详细讲讲序列化和反序列化

1.2 序列化和反序列化

  •  序列化是将对象的状态信息转换为可以存储或传输的形式（字节序列）的过程
  • 反序列化就是把序列化的字节序列恢复为对象的过程

OSI七层模型中表示层的作用，就是“实现数据格式和网络标准数据格式的转换”。前者数据格式就是指数据再应用层上的格式，后者就是指序列化之后可以进行网络传输的数据格式 

  •  序列化的目的，是为了方便网络数据的发送和接收，序列化后数据就全变成了二进制数据，此时底层在进行数据传输时看到的统一都是二进制序列
  • 我发的是二进制数据，所以对方收到的也是二进制数据，所以需要进行反序列化，将二进制数据转化为上层能够识别的比如字符串，整型数据

二，网络版计算器实现准备

前置博客：计算机网络（三） —— 简单Udp网络程序-CSDN博客

计算机网络（四） —— 简单Tcp网络程序-CSDN博客

下面我们来全程手搓一个网络版计算器服务，并且我们自己实现一个自定义协议，主要是为了感受一下协议的实现，后面我们就不会再自定义协议了，直接用现成的

2.1 套用旧头文件

源代码下载：计算机网络/自定义协议——网络版计算器 · 小堃学编程/Linux学习 - 码云 - 开源中国 (gitee.com)

网络版计算器我们要用到的头文件有以下几个：

 

 我们先把前面写的头文件套用一下：

makefile：

.PHONY:all
all:servercal clientcal

Flag=#-DMySelf=1
Lib=-ljsoncpp #这个是后面使用json头文件时要用的

servercal:ServerCal.cc
	g++ -o $@ $^ -std=c++11 $(Lib) $(Flag)
clientcal:ClientCal.cc
	g++ -o $@ $^ -std=c++11 -g $(Lib) $(Flag)


.PHONY:clean
clean:
	rm -f clientcal servercal

Log.hpp：

#pragma once

#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define SIZE 1024

#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4

#define Screen 1
#define Onefile 2
#define Classfile 3

#define LogFile "log.txt"

class Log
{
public:
    Log()
    {
        printMethod = Screen;
        path = "./log/";
    }
    void Enable(int method)
    {
        printMethod = method;
    }
    std::string levelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "None";
        }
    }

    void printLog(int level, const std::string &logtxt)
    {
        switch (printMethod)
        {
        case Screen:
            std::cout << logtxt << std::endl;
            break;
        case Onefile:
            printOneFile(LogFile, logtxt);
            break;
        case Classfile:
            printClassFile(level, logtxt);
            break;
        default:
            break;
        }
    }
    void printOneFile(const std::string &logname, const std::string &logtxt)
    {
        std::string _logname = path + logname;
        int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666); // "log.txt"
        if (fd < 0)
            return;
        write(fd, logtxt.c_str(), logtxt.size());
        close(fd);
    }
    void printClassFile(int level, const std::string &logtxt)
    {
        std::string filename = LogFile;
        filename += ".";
        filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"
        printOneFile(filename, logtxt);
    }

    ~Log()
    {
    }
    void operator()(int level, const char *format, ...)
    {
        time_t t = time(nullptr);
        struct tm *ctime = localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),
                 ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
                 ctime->tm_hour, ctime->tm_min, ctime->tm_sec);

        va_list s;
        va_start(s, format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);

        // 格式：默认部分+自定义部分
        char logtxt[SIZE * 2];
        snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);

        // printf("%s", logtxt); // 暂时打印
        printLog(level, logtxt);
    }

private:
    int printMethod;
    std::string path;
};

Log log;

Deamon.hpp：

#pragma once

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

const std::string nullfile = "/dev/null";

void Daemon(const std::string &cwd = "")
{
    // 1. 忽略其他异常信号
    signal(SIGCLD, SIG_IGN);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGSTOP, SIG_IGN);

    // 2. 将自己变成独立的会话
    if (fork() > 0)
        exit(0);
    setsid();

    // 3. 更改当前调用进程的工作目录
    if (!cwd.empty())
        chdir(cwd.c_str());

    // 4. 标准输入，标准输出，标准错误重定向至/dev/null
    int fd = open(nullfile.c_str(), O_RDWR);
    if (fd > 0)
    {
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);
    }
}

2.2 封装sock API

在Udp和Tcp服务器编写时，可以发现在使用sock API以及填装sockaddr结构体时，步骤都非常相似，所以我们可以把这些相似的步骤都封装起来，下面是Socket.hpp的代码：

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "Log.hpp"

#include <cstring>

enum

{
    SocketErr = 2,
    BindErr,
    ListenErr,
};

const int backlog = 10;

class Sock
{
public:
    Sock()
    {
    }
    ~Sock()
    {
    }

public:
    void Socket() // 创建套接字
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            log(Fatal, "socket error, %s: %d", strerror(errno), errno);
            exit(SocketErr);
        }
    }
    void Bind(uint16_t port) // 绑定套接字
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY;

        if (bind(_sockfd, (struct sockaddr *)&local, sizeof(local)) < 0) // 如果小于0就绑定失败
        {
            log(Fatal, "bind error, %s: %d", strerror(errno), errno);
            exit(BindErr);
        }
    }

    void Listen() // 监听套接字
    {
        if (listen(_sockfd, backlog) < 0) // 如果小于0就代表监听失败
        {
            log(Fatal, "listen error, %s: %d", strerror(errno), errno);
            exit(ListenErr);
        }
    }

    int Accept(std::string *clientip, uint16_t *clientport) // 获取连接，参数做输出型参数
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int newfd = accept(_sockfd, (struct sockaddr *)(&peer), &len);
        if (newfd < 0) // 获取失败
        {
            log(Warning, "accept error, %s: %d", strerror(errno), errno);
            return -1;
        }
        char ipstr[64];
        inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr)); // 把网络字节序列转化为字符串保存在ipstr数组里供用户读取
        *clientip = ipstr;
        *clientport = ntohs(peer.sin_port);

        return newfd;
    }

    bool Connect(const std::string &ip, const uint16_t port)
    {
        struct sockaddr_in peer;
        memset(&peer, 0, sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &(peer.sin_addr));

        int n = connect(_sockfd, (struct sockaddr *)&peer, sizeof(peer));
        if (n == -1)
        {
            std::cerr << "connect to " << ip << ":" << port << "error" << std::endl;
            return false;
        }
        return true;
    }

    void Close()
    {
        close(_sockfd);
    }

    int Fd()
    {
        return _sockfd;
    }

private:
    int _sockfd;
};

三，自定义协议

3.1 关于自定义协议

在之前的文章中介绍过，任何的网络协议，都要提供两种功能，下面是博客的截图：计算机网络（一） —— 网络基础入门_计算机网络基础教程-CSDN博客

网络版计算器，用户会在命令行输入三个字符："1"，"+"，"1"，然后我们可以拼接成一个长字符串："1 + 1"，数字与运算符通过一个空格隔开，

但是，如果客户端连续发了两个字符串，那么最终服务器收到的报文就是“1 + 12 + 1”，可以发现，两个字符串粘在了一起，所以我们的自定义协议，不仅仅要提供将报文和有效载荷分离的能力，也要提供将报文与报文分开的能力，有下面两种方法：

  • 方案一，用特殊字符隔开报文与报文 --> "1 + 1" \n "2 + 2"
  • 方案二，在报文前面加上报文的长度，也就是报头 --> "9"\n"100 + 200"\n，这样就为一个完整的报文（其实只要有长度就可以了，这里增加\n是为了可读性，也是为了方便后面打印）

所以下面来梳理一下我们自定义协议的序列化和反序列化全流程：

3.2  实现序列化和反序列化

这个部分就是具体实现Protocol.hpp头文件了，这个文件具体包含下面几个内容：

  1. "100"，"+"，"200" --> "100 + 200"
  2. "100 + 200" --> "9"\n"100 + 200"
  3.  "9"\n"100 + 200" --> "100 + 200"
  4. "100 + 200" --> "100"，"+"，"200"

该文件包含两个类，一个类是请求类，是客户端发给服务器用到的类；另一个类是响应类，是服务器处理完后，返回给客户端的类；此外还包括两个方法，分别是封装报头和将报头和有效载荷分离

Request类：

#pragma once
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>

#define MySelf 0 // 去掉注释就是用我们自己的序列化和反序列化，加上注释就是用json库提供的

const std::string blank_space = " "; // 分隔符
const std::string protocol_sep = "\n";

class Request // 计算的请求
{
public:
    Request(int data1, int data2, char oper)
        : x(data1), y(data2), op(oper)
    {
    }
    Request()
    {
    }
    ~Request()
    {
    }

public:
    bool Serialize(std::string *out) // 序列化
    {
#ifdef MySelf
        // 1，构建报文的有效载荷
        //  需要把结构化的数据转化为字符串 struct --> string, "x op y"
        std::string s = std::to_string(x);
        s += blank_space;
        s += op;
        s += blank_space;
        s += std::to_string(y);
        // 走到这里的时候就是字符串 "x op y"
        // 但是在传输的时候可能发过来的不是完整的一个报文："10 + 20"，而是只有半个报文："10 + "
        // 解决方案一：用特殊字符隔开报文与报文 --> "10 + 20" \n "20 + 40"
        // 解决方案二：再在报文前面加一个字符串的长度也就是报头，例如s.size()
        // 结合起来就是"9"\n"100 + 200"\n，为一个完整的报文，其实只要有长度就可以了，这里增加\n是为了可读性，也是为了方便后面

        // 2，封装报头
        *out = s;
        return true;
#else
        Json::Value root;
        root["x"] = x;
        root["y"] = y;
        root["op"] = op;
        Json::FastWriter w;
        *out = w.write(root);
        return true;

#endif
    }
    bool DeSerialize(const std::string &in) // 反序列化  "9"\n"10 + 20"
    {
#ifdef MySelf
        std::size_t left = in.find(blank_space); // 找空格的左边，"10 + 20"，也就是找10的右边位置
        if (left == std::string::npos)           // 没找到空格，说明当前解析错误
        {
            return false;
        }
        std::string part_x = in.substr(0, left); // 截取第一个数字，也就是10

        std::size_t right = in.rfind(blank_space); // 逆向再次找空格，"10 + 20"，找20左边的位置
        if (right == std::string::npos)            // 没找到空格，说明当前解析错误
        {
            return false;
        }
        std::string part_y = in.substr(right + 1); // 截取后面的数字，也就是20，+1是因为找到的是空格的右边，+1跳过空格才是数字
        if (left + 2 != right)
            return false;  // 数字中间还有运算符，所以left+2就应该是right的左边那个空格的左边位置，如果不是那么就是解析错误
        op = in[left + 1]; // 拿到运算符
        // op = in[right - 1]; //一样的

        x = std::stoi(part_x); // 拿到数字
        y = std::stoi(part_y);

        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);

        x = root["x"].asInt();
        y = root["y"].asInt();
        op = root["op"].asInt();
        return true;
#endif
    }
    void DebugPrint()
    {
        std::cout << "新请求构建完成:  " << x << " " << op << " " << y << "=?" << std::endl;
    }

public:
    int x;
    int y;
    char op; // 运算符
};

class Response // 计算的应答
{
public:
    Response(int res, int c)
        : result(res), code(c)
    {
    }
    Response()
    {
    }
    ~Response()
    {
    }

public:
    bool Serialize(std::string *out) // 序列化
    {
#ifdef MySelf
        // 1，构建报文的有效载荷
        //"len"\n"result code"
        std::string s = std::to_string(result);
        s += blank_space;
        s += std::to_string(code);

        *out = s;
        return true;
#else
        Json::Value root;
        root["result"] = result;
        root["code"] = code;
        // Json::FastWriter w;
        Json::StyledWriter w;
        *out = w.write(root);
        return true;
#endif
    }
    bool DeSerialize(const std::string &in) // 反序列化
    {
#ifdef MySelf
        // 对服务器发过来的结果报文做解析: "result code"
        std::size_t pos = in.find(blank_space); // 找空格的左边
        if (pos == std::string::npos)           // 没找到空格，说明当前解析错误
        {
            return false;
        }
        std::string part_left = in.substr(0, pos);   // 截取第一个数字，也就是result
        std::string part_right = in.substr(pos + 1); // 截取后面第二个数字，也就是code

        result = std::stoi(part_left);
        code = std::stoi(part_right);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);
        result = root["result"].asInt();
        code = root["code"].asInt();
        return true;
#endif
    }

    void DebugPrint()
    {
        std::cout << "结果响应完成, result: " << result << ", code: " << code << std::endl;
    }

public:
    int result; // x op y
    int code;   // 错误码，为0时结果正确，为其它数时对应的数表示对应的原因
};

 Response类：

class Response // 计算的应答
{
public:
    Response(int res, int c)
        : result(res), code(c)
    {
    }
    Response()
    {
    }
    ~Response()
    {
    }

public:
    bool Serialize(std::string *out) // 序列化
    {
#ifdef MySelf
        // 1，构建报文的有效载荷
        //"len"\n"result code"
        std::string s = std::to_string(result);
        s += blank_space;
        s += std::to_string(code);

        *out = s;
        return true;
#else
        Json::Value root;
        root["result"] = result;
        root["code"] = code;
        // Json::FastWriter w;
        Json::StyledWriter w;
        *out = w.write(root);
        return true;
#endif
    }
    bool DeSerialize(const std::string &in) // 反序列化
    {
#ifdef MySelf
        // 对服务器发过来的结果报文做解析: "result code"
        std::size_t pos = in.find(blank_space); // 找空格的左边
        if (pos == std::string::npos)           // 没找到空格，说明当前解析错误
        {
            return false;
        }
        std::string part_left = in.substr(0, pos);   // 截取第一个数字，也就是result
        std::string part_right = in.substr(pos + 1); // 截取后面第二个数字，也就是code

        result = std::stoi(part_left);
        code = std::stoi(part_right);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);
        result = root["result"].asInt();
        code = root["code"].asInt();
        return true;
#endif
    }

    void DebugPrint()
    {
        std::cout << "结果响应完成, result: " << result << ", code: " << code << std::endl;
    }

public:
    int result; // x op y
    int code;   // 错误码，为0时结果正确，为其它数时对应的数表示对应的原因
};

 添加和去掉报头函数：

std::string Encode(const std::string &content) // 添加报头
{
    std::string packge = std::to_string(content.size()); // 加报头
    packge += protocol_sep;                              // 加\n
    packge += content;                                   // 加正文
    packge += protocol_sep;                              // 再加\n

    return packge;
}

bool Decode(std::string &package, std::string *content) // 解析并去掉报头 "9"\n"10 + 20"\n -->"10 + 20"  俗称解包，但是只是去掉了报头，没有做报文的具体解析
{
    std::size_t pos = package.find(protocol_sep); // 找到\n的左边
    if (pos == std::string::npos)
        return false;                             // 解析失败
    std::string len_str = package.substr(0, pos); // 从开始截到我找到的\n处，把前面的9给截出来
    std::size_t len = std::stoi(len_str);         // 把截出来的报头转化为size_t，也就是把字符串9转化成数字9

    // packge的长度 = 报头长度len_str + 有效载荷长度content_str + 两个\n 2
    std::size_t total_len = len_str.size() + len + 2;
    // ①找到了第一个\n说明一定有长度，如果没找到\n就说明连报头都没有
    // ②有了长度报头，你也还得保证后面的内容也是完整的，如果不完整也就是长度不一样，那我也就不玩了
    if (package.size() < total_len)
        return false;

    // 走到这一步说明我们能保证报文是完整的，开始拿有效载荷
    *content = package.substr(pos + 1, len); // pos现在是第一个\n左边的位置，+1后面的就是正文内容，正文内容长度为len

    // 移除一个报文，该功能需要和网络相结合
    package.erase(0, total_len);

    return true;
}

3.3 测试

我们可以在ServerCal.cc文件里测试上面我们的序列化和反序列化操作

先测试Request：

ServerCal.cc：

#include "Log.hpp"
#include "Socket.hpp"
#include "TcpServer.hpp"
#include "Protocol.hpp"
#include "ServerCal.hpp"
#include "Deamon.hpp"

int main()
{
    // Request测试--------------------
     Request req(10, 20, '+');
     std::string s;
     req.Serialize(&s);
     std::cout << "有效载荷为: " << s << std::endl;
     s = Encode(s);
     std::cout << "报文为：" << s;

    std::string content;
    bool r = Decode(s, &content); //分离报头和有效载荷
    std::cout << "分离报头后的有效载荷为: "<< content << std::endl;
    Request temp;

    temp.DeSerialize(content); //解析有效载荷
    std::cout<< "有效载荷分离后, x为: " << temp.x << " 运算符为:\"" << temp.op << "\"  y为: " << temp.y << std::endl;

    return 0;
}

然后是Response的测试： 

ServerCal.cc：

#include "Log.hpp"
#include "Socket.hpp"
#include "TcpServer.hpp"
#include "Protocol.hpp"
#include "ServerCal.hpp"
#include "Deamon.hpp"

int main()
{
    // Response测试--------------------
    Response resp(10, 20);
    std::string s;
    resp.Serialize(&s);
    std::cout << "有效载荷为: " << s << std::endl;
    std::string package = Encode(s); //分离报头和有效载荷
    std::cout << "报文为: " << package;
    s = "";
    bool r = Decode(package, &s);
    std::cout << "分离报头后的有效载荷为: " << s << std::endl;

    Response temp;
    temp.DeSerialize(s); // 解析有效载荷
    std::cout << "解析有效载荷: " << std::endl;
    std::cout << "结果为: " << temp.result << std::endl;
    std::cout << "错误码为: " << temp.code << std::endl;

    return 0;
}

三，服务器实现

3.1 逻辑梳理

服务器涉及两个个头文件和一个源文件，有点绕，下面先梳理一下：

有三个文件：

  • 首先，TcpServer.hpp是服务器主函数，ServerCal.cc包含服务器初始化和启动的main函数，ServerCal.hpp是进行计算器运算的头文件
  • 首先构建服务器对象，并在构造函数里将ServerCal.cc里面的运算函数带进去，然后是初始化服务器，执行创建套接字等操作，然后启动服务器
  • 当服务器收到客户端发来的报文后，直接将报文传给运算函数，由运算函数做去掉报头，解析有效载荷等过程，并执行运算，最后把运算结果再次构建成响应报文，以返回值形式返回给服务器运行函数
  • 然后服务器再把响应报文发给客户端，完成一次计算请求处理

3.2 各头文件实现

Server.hpp实现：

#pragma once
#include <iostream>
#include <string>
#include "Protocol.hpp"

enum
{
    Div_Zero = 1,
    Mod_Zero,
    Other_Oper
};

class ServerCal
{
public:
    ServerCal()
    {
    }

    ~ServerCal()
    {
    }
    Response CalculatorHelper(const Request &req)
    {
        Response resp(0, 0);
        switch (req.op)
        {
        case '+':
            resp.result = req.x + req.y;
            break;
        case '-':
            resp.result = req.x - req.y;
            break;
        case '*':
            resp.result = req.x * req.y;
            break;
        case '/':
        {
            if (req.y == 0)
            {
                resp.code = Div_Zero;
            }
            else
            {
                resp.result = req.x / req.y;
            }
        }
        break;
        case '%':
        {
            if (req.y == 0)
            {
                resp.code = Mod_Zero;
            }
            else
            {
                resp.result = req.x % req.y;
            }
        }
        break;
        default:
            resp.code = Other_Oper;
            break;
        }

        return resp;
    }

    std::string Calculator(std::string &package)
    {
        std::string content;
        if (!Decode(package, &content)) // 分离报头和有效载荷："len"\n"10 + 20"\n
            return "";
        // 走到这里就是完整的报文
        Request req;
        if (!req.DeSerialize(content)) // 反序列化，解析有效载荷 "10 + 20" --> x=10 op="+" y=20
            return "";

        content = "";
        Response resp = CalculatorHelper(req); // 执行计算逻辑
        resp.Serialize(&content);              // 序列化计算结果的有效载荷 result=10, code=0
        content = Encode(content);             // 将有效载荷和报头封装成响应报文 "len"\n"30 0"

        return content;
    }
};

TcpServer.hpp实现：

#pragma once
#include "Log.hpp"
#include "Socket.hpp"
#include <signal.h>
#include <string>
#include <functional>

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

class TcpServer
{
public:
    TcpServer(uint16_t port, func_t callback)
        : _port(port), _callback(callback)
    {
    }

    bool InitServer()
    {
        // 创建，绑定，监听套接字
        _listensockfd.Socket();
        _listensockfd.Bind(_port);
        _listensockfd.Listen();
        log(Info, "Init server... done");
        return true;
    }

    void Start()
    {
        signal(SIGCHLD, SIG_IGN); // 忽略
        signal(SIGPIPE, SIG_IGN);
        while (true)
        {
            std::string clientip;
            uint16_t clientport;
            int sockfd = _listensockfd.Accept(&clientip, &clientport);

            if (sockfd < 0)
                continue;
            log(Info, "accept a new link, sockfd: %d, clientip: %s, clientport: %d", sockfd, clientip.c_str(), clientport);

            // 走到了这里就是成功获取发起连接方IP与port，后面就是开始提供服务
            if (fork() == 0)
            {
                _listensockfd.Close();
                // 进行数据运算服务
                std::string inbuffer_stream;
                while (true)
                {
                    char buffer[1280];
                    ssize_t n = read(sockfd, buffer, sizeof(buffer));
                    if (n > 0)
                    {
                        buffer[n] = 0;
                        inbuffer_stream += buffer; // 这里用+=

                        log(Debug, "debug:\n%s", inbuffer_stream.c_str());
                        while (true)
                        {
                            std::string info = _callback(inbuffer_stream);
                            // if (info.size() == 0) //ServerCal.hpp，解析报文失败的话会返回空串
                            if (info.empty()) // 空的话代表inbuffstream解析时出问题，表示不遵守协议，发不合法的报文给我，我直接丢掉不玩了
                                break;        // 不能用continue

                            log(Debug, "debug, response:\n%s", info.c_str());
                            log(Debug, "debug:\n%s", inbuffer_stream.c_str());
                            write(sockfd, info.c_str(), info.size());
                        }
                    }
                    else if (n == 0) // 读取出错
                        break;
                    else // 读取出错
                        break;
                }
                exit(0);
            }
            close(sockfd);
        }
    }

    ~TcpServer()
    {
    }

private:
    uint16_t _port;
    Sock _listensockfd;
    func_t _callback;
};

ServerCal.cc实现：

#include "Log.hpp"
#include "Socket.hpp"
#include "TcpServer.hpp"
#include "Protocol.hpp"
#include "ServerCal.hpp"
#include "Deamon.hpp"

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

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(0);
    }
    uint16_t port = std::stoi(argv[1]);
    ServerCal cal;
    TcpServer *tsvp = new TcpServer(port, std::bind(&ServerCal::Calculator, &cal, std::placeholders::_1));
    tsvp->InitServer();
    //Daemon();
    //daemon(0, 0);
    tsvp->Start();

    // Request测试--------------------
    // Request req(10, 20, '+');
    // std::string s;
    // req.Serialize(&s);
    // std::cout << "有效载荷为: " << s << std::endl;
    // s = Encode(s);
    // std::cout << "报文为：" << s;

    // std::string content;
    // bool r = Decode(s, &content); //分离报头和有效载荷
    // std::cout << "分离报头后的有效载荷为: "<< content << std::endl;
    // Request temp;

    // temp.DeSerialize(content); //解析有效载荷
    // std::cout<< "有效载荷分离后, x为: " << temp.x << " 运算符为:\"" << temp.op << "\"  y为: " << temp.y << std::endl;

    // Response测试--------------------
    // Response resp(10, 20);
    // std::string s;
    // resp.Serialize(&s);
    // std::cout << "有效载荷为: " << s << std::endl;
    // std::string package = Encode(s); //分离报头和有效载荷
    // std::cout << "报文为: " << package;
    // s = "";
    // bool r = Decode(package, &s);
    // std::cout << "分离报头后的有效载荷为: " << s << std::endl;

    // Response temp;
    // temp.DeSerialize(s); // 解析有效载荷
    // std::cout << "解析有效载荷: " << std::endl;
    // std::cout << "结果为: " << temp.result << std::endl;
    // std::cout << "错误码为: " << temp.code << std::endl;

    return 0;
}

四，客户端实现

客户端的话，为了方便发送计算请求，会采用随机数的方式获取运算数和运算符，如下代码：

#include <iostream>
#include <string>
#include <ctime>
#include <cassert>
#include <unistd.h>
#include "Socket.hpp"
#include "Protocol.hpp"

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

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]); //获取IP和端口

    Sock sockfd;
    sockfd.Socket();
    if (!sockfd.Connect(serverip, serverport))
        return 1;

    srand(time(nullptr) ^ getpid()); // 种随机数种子
    int cnt = 1;
    const std::string opers = "+-*/%-=&^";

    std::string inbuffer_stream;
    while (cnt <= 5)
    {
        std::cout << "===============第" << cnt << "次测试....., " << "===============" << std::endl;
        int x = rand() % 100 + 1;
        usleep(1234);
        int y = rand() % 100;
        usleep(4321);
        char oper = opers[rand() % opers.size()];
        Request req(x, y, oper);
        req.DebugPrint();

        // 下面是根据协议发送给对方
        std::string package;
        req.Serialize(&package);                    // 序列化
        package = Encode(package);                  // 形成报文
        int fd = sockfd.Fd();                       // 获取套接字
        write(fd, package.c_str(), package.size()); // 将请求从客户端往服务端写过去

        // 下面是读取服务器发来的结果并解析
        char buffer[128];
        ssize_t n = read(sockfd.Fd(), buffer, sizeof(buffer)); // 读取服务器发回来的结果，但是这里也无法保证能读取到一个完整的报文
        if (n > 0)                                             // 读成功了
        {
            buffer[n] = 0;
            inbuffer_stream += buffer; // "len"\n"result code"\n
            std::cout << inbuffer_stream << std::endl;
            std::string content;
            bool r = Decode(inbuffer_stream, &content); // 去掉报头"result code"\n
            assert(r);                                  // r为真说明报头成功去掉
            Response resp;
            r = resp.DeSerialize(content); // 对有效荷载进行反序列化
            assert(r);

            resp.DebugPrint(); // 打印结果
        }
        std::cout << "=================================================" << std::endl;
        sleep(1);
        cnt++;
    }

    sockfd.Close();
    return 0;
}

 效果演示：


http://www.kler.cn/a/302592.html

相关文章：

  • 服务jar包增加高斯数据库驱动jar包
  • 【视觉SLAM】1-概述
  • 网络技术-网桥模式
  • 从0学习React（11）
  • ABAP开发学习——ST05 ABAP SQL跟踪工具
  • 开源模型应用落地-qwen模型小试-Qwen2.5-7B-Instruct-tool usage入门-集成心知天气（二）
  • 数据结构 栈 队列
  • Java 8新特性：Lambda表达式的魅力
  • 一支烟花版的《汉语新解》，欢迎来玩儿！
  • 面试常见八股
  • Spring Boot 部署（jar包）
  • FPGA 学习仿真硬件设计
  • 再次进阶 舞台王者 第八季完美童模全球赛形象大使【于洪森】赛场秀场超燃合集！
  • Vue3:实现重置密码和校验功能
  • Anaconda安装
  • DB-GPT部署和试用
  • 使用MATLAB进行动力学分析与可视化
  • C++ 音频
  • Android MediaProjection录屏权限处理
  • VIT论文阅读
  • 工业相机飞拍的原理及工作原理
  • Python(TensorFlow和PyTorch)两种显微镜成像重建算法模型(显微镜学)
  • 简单计算机网络概念
  • Salting technique
  • flink中startNewChain() 的详解
  • Qt-QWidget的font属性(18)