【网络】协议定制+序列化/反序列化
为什么要序列化？
如果光看定义很难理解序列化的意义，那么我们可以从另一个角度来推导出什么是序列化, 那么究竟序列化的目的是什么？
其实序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。
因为我们单方面的只把对象转成字节数组还不行，因为没有规则的字节数组我们是没办法把对象的本来面目还原回来的，所以我们必须在把对象转成字节数组的时候就制定一种规则（序列化），那么我们从IO流里面读出数据的时候再以这种规则把对象还原回来（反序列化）。
如果我们要把一栋房子从一个地方运输到另一个地方去，序列化就是我把房子拆成一个个的砖块放到车子里，然后留下一张房子原来结构的图纸，反序列化就是我们把房子运输到了目的地以后，根据图纸把一块块砖头还原成房子原来面目的过程。
是需要进行“跨平台存储”和”网络传输”的数据，都需要进行序列化。本质上存储和网络传输 都需要经过 把一个对象状态保存成一种跨平台识别的字节格式，然后其他的平台才可以通过字节信息解析还原对象信息。
序列化只是一种拆装组装对象的规则，那么这种规则肯定也可能有多种多样，比如现在常见的序列化方式有：
JDK（不支持跨语言）、JSON、XML、Hessian、Kryo（不支持跨语言）、Thrift、Protostuff、FST（不支持跨语言）
在进行网络传输之前，我们要将数据转换成字符串的形式，以字节流的方式发送信息。双方在通信时如果发送端一直发送数据，但是接收端并没有及时的接收数据，那这一对的数据就会被堆积下来。等接收端能开始接收数据时该如何保证报文和报文的边界的呢？保证读到的时一个报文而不是半个或者1.5个报文的呢？
常见的解决方法：
1. 定 长： 即可以规定一个报文的大小为1024字节，读取时严格的按照定下的长度读取
2.特殊符号：在报文的结束端加上特殊符号“ + ” " - "等特殊符号以此区分不同的报文
3.自描述方式：规定报文的头四个字节存储的是报文的有效长度，未来在读取报文的时候首先读取这头四个字节，根据这四个字节存储的长度然后截取这个报文。
协议的实现
接下来将采用序列化和反序列化+自描述的方式实现一款简易版网络计算器。网络计算器在发起请求的过程中的格式为：a运算符b ，我们首先创建一个对象将两个运算的数和一个运算符存储起来，因为tcp是面向字节流的所以在网络通信前，首先需要将这个对象转换为字符串的形式，以字节流的方式发送数据到服务端。上文所讲为了方便服务端读取报文，所以这里采用的是自描述的方式发送数据，即在报文的有效载荷前加上一个存储报文有效长度的报头，报头再与报文之间用特殊的字符隔开，未来再服务端进行读取时就找这个特殊的分隔符，根据分隔符确定报头的位置，然后根据报头中存储的有效的长度就可以完整的读取到一条客户端的请求。
客户端发起请求就是serialize+enLength（序列化+自描述），服务端在接收到这个报文后首先去掉报头得到正文，将正文反序列化得到一个包含正文元素的对象（请求对象），此时再创建一个要返回结果的对象（响应对象），将这请求对象和相应对象传入到计算函数中，计算函数将计算的结果和计算的退出码保存到相应对象中，再将相应对象序列化+添加报头组成一个大的“字符串”通过网络发送到客户端，客户端接收后先去报头再反序列化构建出一个对象，这个对象中就保存着计算的结果和计算的退出码。
客户端从网络接收到数据后先去报头得到正文，反序列化得到对象，对象中所存储的值就有这次运算的退出码和运算结果。
协议的定制中包括：1分隔符的种类2.添加报头3.去报头3.数据从缓冲区的接收4.请求对象的序列化和反序列化 5.相应对象的序列化和反序列化6.运行结果的退出码
代码如下：
#pragma once
#include
#include
#include
#include
#include
#include
#define SEP " "
#define SEP_LEN strlen(SEP) // 不敢使用sizeof()
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP) // 不敢使用sizeof()
enum
{
OK = 0,
DIV_ZERO,
MOD_ZERO,
OP_ERROR
};
// "x op y" -> "content_len"\r\n"x op y"\r\n
// "exitcode result" -> "content_len"\r\n"exitcode result"\r\n
std::string enLength(const std::string &text)
{
std::string send_string = std::to_string(text.size());
send_string += LINE_SEP;
send_string += text;
send_string += LINE_SEP;
return send_string;
}
// "content_len"\r\n"exitcode result"\r\n
bool deLength(const std::string &package, std::string *text)
{
auto pos = package.find(LINE_SEP);
if (pos == std::string::npos)
return false;
std::string text_len_string = package.substr(0, pos);
int text_len = std::stoi(text_len_string);
*text = package.substr(pos + LINE_SEP_LEN, text_len);
return true;
}
// 没有人规定我们网络通信的时候，只能有一种协议！！
// 我们怎么让系统知道我们用的是哪一种协议呢？？
// "content_len"\r\n"协议编号"\r\n"x op y"\r\n
class Request
{
public:
Request() : x(0), y(0), op(0)
{
}
Request(int x_, int y_, char op_) : x(x_), y(y_), op(op_)
{
}
// 1. 自己写
// 2. 用现成的
bool serialize(std::string *out)
{
#ifdef MYSELF
*out = "";
// 结构化 -> "x op y";
std::string x_string = std::to_string(x);
std::string y_string = std::to_string(y);
*out = x_string;
*out += SEP;
*out += op;
*out += SEP;
*out += y_string;
#else
Json::Value root;
root["first"] = x;
root["second"] = y;
root["oper"] = op;
Json::FastWriter writer;
// Json::StyledWriter writer;
*out = writer.write(root);
#endif
return true;
}
// "x op yyyy";
bool deserialize(const std::string &in)
{
#ifdef MYSELF
// "x op y" -> 结构化
auto left = in.find(SEP);
auto right = in.rfind(SEP);
if (left == std::string::npos || right == std::string::npos)
return false;
if (left == right)
return false;
if (right - (left + SEP_LEN) != 1)
return false;
std::string x_string = in.substr(0, left); // [0, 2) [start, end) , start, end - start
std::string y_string = in.substr(right + SEP_LEN);
if (x_string.empty())
return false;
if (y_string.empty())
return false;
x = std::stoi(x_string);
y = std::stoi(y_string);
op = in[left + SEP_LEN];
#else
Json::Value root;
Json::Reader reader;
reader.parse(in, root);
x = root["first"].asInt();
y = root["second"].asInt();
op = root["oper"].asInt();
#endif
return true;
}
public:
// "x op y"
int x;
int y;
char op;
};
class Response
{
public:
Response() : exitcode(0), result(0)
{
}
Response(int exitcode_, int result_) : exitcode(exitcode_), result(result_)
{
}
bool serialize(std::string *out)
{
#ifdef MYSELF
*out = "";
std::string ec_string = std::to_string(exitcode);
std::string res_string = std::to_string(result);
*out = ec_string;
*out += SEP;
*out += res_string;
#else
Json::Value root;
root["exitcode"] = exitcode;
root["result"] = result;
Json::FastWriter writer;
*out = writer.write(root);
#endif
return true;
}
bool deserialize(const std::string &in)
{
#ifdef MYSELF
// "exitcode result"
auto mid = in.find(SEP);
if (mid == std::string::npos)
return false;
std::string ec_string = in.substr(0, mid);
std::string res_string = in.substr(mid + SEP_LEN);
if (ec_string.empty() || res_string.empty())
return false;
exitcode = std::stoi(ec_string);
result = std::stoi(res_string);
#else
Json::Value root;
Json::Reader reader;
reader.parse(in, root);
exitcode = root["exitcode"].asInt();
result = root["result"].asInt();
#endif
return true;
}
public:
int exitcode; // 0：计算成功，!0表示计算失败，具体是多少，定好标准
int result; // 计算结果
};
// "content_len"\r\n"x op y"\r\n"content_len"\r\n"x op y"\r\n"content_len"\r\n"x op
bool recvPackage(int sock, std::string &inbuffer, std::string *text)
{
char buffer[1024];
while (true)
{
ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (n > 0)
{
buffer[n] = 0;
inbuffer += buffer;
// 分析处理
auto pos = inbuffer.find(LINE_SEP);
if (pos == std::string::npos)
continue;
std::string text_len_string = inbuffer.substr(0, pos);
int text_len = std::stoi(text_len_string);
int total_len = text_len_string.size() + 2 * LINE_SEP_LEN + text_len;
// text_len_string + "\r\n" + text + "\r\n" <= inbuffer.size();
std::cout << "处理前#inbuffer: \n" << inbuffer << std::endl;
if (inbuffer.size() < total_len)
{
std::cout << "你输入的消息，没有严格遵守我们的协议，正在等待后续的内容, continue" << std::endl;
continue;
}
// 至少有一个完整的报文
*text = inbuffer.substr(0, total_len);
inbuffer.erase(0, total_len);
std::cout << "处理后#inbuffer:\n " << inbuffer << std::endl;
break;
}
else
return false;
}
return true;
} 服务端将字符串通过去报头和反序列化的操作就将客户端的请求构建出来一个请求对象，服务端再创建一个响应对象，这两个对象在计算函数的内部将计算的结果和计算的退出码一起存储到响应对象中，至此完成了计算任务，计算函数如下：
bool cal(const Request &req, Response &resp)
{
resp.exitcode = OK;
resp.result = OK;
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.exitcode = DIV_ZERO;
else
resp.result = req.x / req.y;
}
break;
case '%':
{
if (req.y == 0)
resp.exitcode = MOD_ZERO;
else
resp.result = req.x % req.y;
}
break;
default:
resp.exitcode = OP_ERROR;
break;
}
return true;
}客户端启动后，就会弹出让用户输入计算的式子，这个式子是从键盘接收的，首先将接收的式子存到一个零时缓冲区内，方便我们对输入的式子切割并完成对请求对象的构建，调用切割的函数如下：
Request ParseLine(const std::string &line)
{
int status = 0;
int i = 0;
int cnt = line.size();
std::string left, right;
char op;
while (i < cnt)
{
switch (status)
{
case 0:
{
if(!isdigit(line[i]))
{
op = line[i];
status = 1;
}
else left.push_back(line[i++]);
}
break;
case 1:
i++;
status = 2;
break;
case 2:
right.push_back(line[i++]);
break;
}
}
std::cout << std::stoi(left)<<" " << std::stoi(right) << " " << op << std::endl;
return Request(std::stoi(left), std::stoi(right), op);
}这是一个名为ParseLine的C++函数，它接受一个名为line的std::string参数，并返回一个Request对象。ParseLine函数首先初始化一些变量，包括status、i、cnt、left、right和op。status跟踪正在读取字符串的哪个部分，i跟踪正在读取的字符的索引，cnt是输入字符串的大小，left和right分别保存左操作数和右操作数，op保存运算符。接下来，ParseLine使用while循环遍历输入字符串中的每个字符。在while循环内，有一个switch语句，根据当前状态处理不同情况。在第0种情况下，函数使用isdigit()检查索引i处的当前字符是否为数字。如果它不是数字，则将op设置为当前字符，将状态更新为1，并继续到下一个字符。否则，它将当前字符附加到left字符串中并增加i。在第1种情况下，它增加i并将状态更改为2。在第2种情况下，它将当前字符附加到right字符串中并增加i。while循环结束后，函数使用std::cout打印left、right和op的值，并使用解析后的left、right和op值构造一个Request对象并返回它。这样就完成了请求对象的构建。
对于序列化和反序列化这个操作的过程可以自己完成，也可以使用Json协议，使用别人定制好的成熟的方法，关于Json第三方库的安装，可以使用命令下载Json:
sudo yum install -y jsoncpp-deve
至于要使用自己的方法还是Json协议，这里可以使用条件编译的方式，将两者方法都写进代码中
代码在上方的协议文件中有体现。
数据前面的字符串就是为反序列化建立的索引，先说序列化：Value是Json中的一个万能对象，用它可以序列化不同格式的数据，创建Value对象root，root[“x”, _x]就是在root中插入了一个键值对，把所有的数插入到root后，创建FastWrite对象，以root为参数调用其write方法，用string类型对象str接收write的返回值，str中保存的就是{“op”:43,“x”:1,“y”:1}这样的字符串，是将数据序列化后的结果。
至于Json的反序列化：我们创建Reader类型对象rd与Value类型对象root，调用rd的parse方法，将root和序列化后的字符串str作为parse的参数，parse方法会将反序列化后的结果写入root，此时我们就能根据当时创建root对象时，为数据建立的索引来还原数据，比如root[“x”].asInt()，将root中以"x"为key的value值以int的格式返回，这样我们就能将数据还原到我们的结构体中
关于条件编译，我们可以在makefile文件中，以命令行的方式，在编译源文件时创建宏，具体是-D 宏的名字
实验结果演示
全部代码：
calClient.cc:
#include "calClient.hpp"
#include
using namespace std;
static void Usage(string proc)
{
cout << "\nUsage:\n\t" << proc << " serverip serverport\n\n";
}
// ./tcpclient serverip serverport
int main(int argc, char *argv[])
{
if (argc != 3)
{
Usage(argv[0]);
exit(1);
}
string serverip = argv[1];
uint16_t serverport = atoi(argv[2]);
unique_ptr tcli(new CalClient(serverip, serverport));
tcli->initClient();
tcli->start();
return 0;
} calClient.hpp:
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include "protocol.hpp"
#define NUM 1024
class CalClient
{
public:
CalClient(const std::string &serverip, const uint16_t &serverport)
: _sock(-1), _serverip(serverip), _serverport(serverport)
{
}
void initClient()
{
_sock = socket(AF_INET, SOCK_STREAM, 0);
if (_sock < 0)
{
std::cerr << "socket create error" << std::endl;
exit(2);
}
}
void start()
{
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(_serverport);
server.sin_addr.s_addr = inet_addr(_serverip.c_str());
if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
{
std::cerr << "socket connect error" << std::endl;
}
else
{
std::string line;
std::string inbuffer;
while (true)
{
std::cout << "mycal>>> ";
std::getline(std::cin, line);
Request req = ParseLine(line);
std::string content;
req.serialize(&content);
std::string send_string = enLength(content);
send(_sock, send_string.c_str(), send_string.size(), 0);
std::string package, text;
if (!recvPackage(_sock, inbuffer, &package))
continue;
if (!deLength(package, &text))
continue;
Response resp;
resp.deserialize(text);
std::cout << "exitCode: " << resp.exitcode << std::endl;
std::cout << "result: " << resp.result << std::endl;
}
}
}
Request ParseLine(const std::string &line)
{
int status = 0;
int i = 0;
int cnt = line.size();
std::string left, right;
char op;
while (i < cnt)
{
switch (status)
{
case 0:
{
if(!isdigit(line[i]))
{
op = line[i];
status = 1;
}
else left.push_back(line[i++]);
}
break;
case 1:
i++;
status = 2;
break;
case 2:
right.push_back(line[i++]);
break;
}
}
std::cout << std::stoi(left)<<" " << std::stoi(right) << " " << op << std::endl;
return Request(std::stoi(left), std::stoi(right), op);
}
~CalClient()
{
if (_sock >= 0)
close(_sock);
}
private:
int _sock;
std::string _serverip;
uint16_t _serverport;
}; calServer.cc:
#include "calServer.hpp"
#include
using namespace server;
using namespace std;
static void Usage(string proc)
{
cout << "\nUsage:\n\t" << proc << " local_port\n\n";
}
bool cal(const Request &req, Response &resp)
{
resp.exitcode = OK;
resp.result = OK;
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.exitcode = DIV_ZERO;
else
resp.result = req.x / req.y;
}
break;
case '%':
{
if (req.y == 0)
resp.exitcode = MOD_ZERO;
else
resp.result = req.x % req.y;
}
break;
default:
resp.exitcode = OP_ERROR;
break;
}
return true;
}
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(USAGE_ERR);
}
uint16_t port = atoi(argv[1]);
unique_ptr tsvr(new CalServer(port));
tsvr->initServer();
tsvr->start(cal);
return 0;
} calServer.hpp:
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "log.hpp"
#include "protocol.hpp"
namespace server
{
enum
{
USAGE_ERR = 1,
SOCKET_ERR,
BIND_ERR,
LISTEN_ERR
};
static const uint16_t gport = 8080;
static const int gbacklog = 5;
typedef std::function func_t;
void handlerEntery(int sock, func_t func)
{
std::string inbuffer;
while (true)
{
std::string req_text, req_str;
if (!recvPackage(sock, inbuffer, &req_text))
return;
std::cout << "带报头的请求：\n" << req_text << std::endl;
if (!deLength(req_text, &req_str))
return;
std::cout << "去掉报头的正文：\n" << req_str << std::endl;
Request req;
if (!req.deserialize(req_str))
return;
Response resp;
func(req, resp);
std::string resp_str;
resp.serialize(&resp_str);
std::cout << "计算完成, 序列化响应: " << resp_str << std::endl;
std::string send_string = enLength(resp_str);
std::cout << "构建完成完整的响应\n" << send_string << std::endl;
send(sock, send_string.c_str(), send_string.size(), 0);
}
}
class CalServer
{
public:
CalServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
{
}
void initServer()
{
_listensock = socket(AF_INET, SOCK_STREAM, 0);
if (_listensock < 0)
{
logMessage(FATAL, "create socket error");
exit(SOCKET_ERR);
}
logMessage(NORMAL, "create socket success: %d", _listensock);
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(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
{
logMessage(FATAL, "bind socket error");
exit(BIND_ERR);
}
logMessage(NORMAL, "bind socket success");
if (listen(_listensock, gbacklog) < 0)
{
logMessage(FATAL, "listen socket error");
exit(LISTEN_ERR);
}
logMessage(NORMAL, "listen socket success");
}
void start(func_t func)
{
for (;;)
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
if (sock < 0)
{
logMessage(ERROR, "accept error, next");
continue;
}
logMessage(NORMAL, "accept a new link success, get new sock: %d", sock); // ?
// version 2 多进程版(2)
pid_t id = fork();
if (id == 0) // child
{
close(_listensock);
// if(fork()>0) exit(0);
// serviceIO(sock);
handlerEntery(sock, func);
close(sock);
exit(0);
}
close(sock);
// father
pid_t ret = waitpid(id, nullptr, 0);
if (ret > 0)
{
logMessage(NORMAL, "wait child success"); // ?
}
}
}
~CalServer() {}
private:
int _listensock;
uint16_t _port;
};
} 日志：
#pragma once
#include
#include
#include
#include
#include
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4
const char * to_levelstr(int level)
{
switch(level)
{
case DEBUG : return "DEBUG";
case NORMAL: return "NORMAL";
case WARNING: return "WARNING";
case ERROR: return "ERROR";
case FATAL: return "FATAL";
default : return nullptr;
}
}
void logMessage(int level, const char *format, ...)
{
#define NUM 1024
char logprefix[NUM];
snprintf(logprefix, sizeof(logprefix), "[%s][%ld][pid: %d]",
to_levelstr(level), (long int)time(nullptr), getpid());
char logcontent[NUM];
va_list arg;
va_start(arg, format);
vsnprintf(logcontent, sizeof(logcontent), format, arg);
std::cout << logprefix << logcontent << std::endl;
} protocol.hpp:
#pragma once
#include
#include
#include
#include
#include
#include
#define SEP " "
#define SEP_LEN strlen(SEP) // 不敢使用sizeof()
#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP) // 不敢使用sizeof()
enum
{
OK = 0,
DIV_ZERO,
MOD_ZERO,
OP_ERROR
};
// "x op y" -> "content_len"\r\n"x op y"\r\n
// "exitcode result" -> "content_len"\r\n"exitcode result"\r\n
std::string enLength(const std::string &text)
{
std::string send_string = std::to_string(text.size());
send_string += LINE_SEP;
send_string += text;
send_string += LINE_SEP;
return send_string;
}
// "content_len"\r\n"exitcode result"\r\n
bool deLength(const std::string &package, std::string *text)
{
auto pos = package.find(LINE_SEP);
if (pos == std::string::npos)
return false;
std::string text_len_string = package.substr(0, pos);
int text_len = std::stoi(text_len_string);
*text = package.substr(pos + LINE_SEP_LEN, text_len);
return true;
}
// 没有人规定我们网络通信的时候，只能有一种协议！！
// 我们怎么让系统知道我们用的是哪一种协议呢？？
// "content_len"\r\n"协议编号"\r\n"x op y"\r\n
class Request
{
public:
Request() : x(0), y(0), op(0)
{
}
Request(int x_, int y_, char op_) : x(x_), y(y_), op(op_)
{
}
// 1. 自己写
// 2. 用现成的
bool serialize(std::string *out)
{
#ifdef MYSELF
*out = "";
// 结构化 -> "x op y";
std::string x_string = std::to_string(x);
std::string y_string = std::to_string(y);
*out = x_string;
*out += SEP;
*out += op;
*out += SEP;
*out += y_string;
#else
Json::Value root;
root["first"] = x;
root["second"] = y;
root["oper"] = op;
Json::FastWriter writer;
// Json::StyledWriter writer;
*out = writer.write(root);
#endif
return true;
}
// "x op yyyy";
bool deserialize(const std::string &in)
{
#ifdef MYSELF
// "x op y" -> 结构化
auto left = in.find(SEP);
auto right = in.rfind(SEP);
if (left == std::string::npos || right == std::string::npos)
return false;
if (left == right)
return false;
if (right - (left + SEP_LEN) != 1)
return false;
std::string x_string = in.substr(0, left); // [0, 2) [start, end) , start, end - start
std::string y_string = in.substr(right + SEP_LEN);
if (x_string.empty())
return false;
if (y_string.empty())
return false;
x = std::stoi(x_string);
y = std::stoi(y_string);
op = in[left + SEP_LEN];
#else
Json::Value root;
Json::Reader reader;
reader.parse(in, root);
x = root["first"].asInt();
y = root["second"].asInt();
op = root["oper"].asInt();
#endif
return true;
}
public:
// "x op y"
int x;
int y;
char op;
};
class Response
{
public:
Response() : exitcode(0), result(0)
{
}
Response(int exitcode_, int result_) : exitcode(exitcode_), result(result_)
{
}
bool serialize(std::string *out)
{
#ifdef MYSELF
*out = "";
std::string ec_string = std::to_string(exitcode);
std::string res_string = std::to_string(result);
*out = ec_string;
*out += SEP;
*out += res_string;
#else
Json::Value root;
root["exitcode"] = exitcode;
root["result"] = result;
Json::FastWriter writer;
*out = writer.write(root);
#endif
return true;
}
bool deserialize(const std::string &in)
{
#ifdef MYSELF
// "exitcode result"
auto mid = in.find(SEP);
if (mid == std::string::npos)
return false;
std::string ec_string = in.substr(0, mid);
std::string res_string = in.substr(mid + SEP_LEN);
if (ec_string.empty() || res_string.empty())
return false;
exitcode = std::stoi(ec_string);
result = std::stoi(res_string);
#else
Json::Value root;
Json::Reader reader;
reader.parse(in, root);
exitcode = root["exitcode"].asInt();
result = root["result"].asInt();
#endif
return true;
}
public:
int exitcode; // 0：计算成功，!0表示计算失败，具体是多少，定好标准
int result; // 计算结果
};
// "content_len"\r\n"x op y"\r\n"content_len"\r\n"x op y"\r\n"content_len"\r\n"x op
bool recvPackage(int sock, std::string &inbuffer, std::string *text)
{
char buffer[1024];
while (true)
{
ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (n > 0)
{
buffer[n] = 0;
inbuffer += buffer;
// 分析处理
auto pos = inbuffer.find(LINE_SEP);
if (pos == std::string::npos)
continue;
std::string text_len_string = inbuffer.substr(0, pos);
int text_len = std::stoi(text_len_string);
int total_len = text_len_string.size() + 2 * LINE_SEP_LEN + text_len;
// text_len_string + "\r\n" + text + "\r\n" <= inbuffer.size();
std::cout << "处理前#inbuffer: \n" << inbuffer << std::endl;
if (inbuffer.size() < total_len)
{
std::cout << "你输入的消息，没有严格遵守我们的协议，正在等待后续的内容, continue" << std::endl;
continue;
}
// 至少有一个完整的报文
*text = inbuffer.substr(0, total_len);
inbuffer.erase(0, total_len);
std::cout << "处理后#inbuffer:\n " << inbuffer << std::endl;
break;
}
else
return false;
}
return true;
} makefile:
cc=g++
LD=-DMYSELF
.PHONY:all
all:calserver calclient
calclient:calClient.cc
$(cc) -o $@ $^ -std=c++11 -ljsoncpp ${LD}
calserver:calServer.cc
$(cc) -o $@ $^ -std=c++11 -ljsoncpp ${LD}
.PHONY:clean
clean:
rm -f calclient calserver