devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux/C++:基于TCP协议实现网络版本计算器（自定义应用层协议）_linuxc++ tcpserver

作者：空白诗007 | 2024-08-14 05:30:49

赞

踩

linuxc++ tcpserver

目录

Sock.hpp

TcpServer.hpp

Protocol.hpp

CalServer.cc

CalClient.cc

分析

因为，TCP面向字节流，所以TCP有粘包问题，故我们需要应用层协议来区分每一个数据包。防止读取到半个，一个半数据包的情况。

Sock.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <unistd.h>
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include "log.hpp"
  12.  
  13. // 对于一些TCP相关调用的封装
  14. class Sock
  15. {
  16. private:
  17.     const static int gback_log = 20;
  18. public:
  19.     int Socket()
  20.     {
  21.         // 1. 创建套接字，成功返回对应套接字，失败直接进程exit
  22.         int listen_sock = socket(AF_INET, SOCK_STREAM, 0); // 网络套接字, 面向字节流（tcp）
  23.         if (listen_sock < 0)
  24.         {
  25.             logMessage(FATAL, "create listen socket error, %d:%s", errno, strerror(errno));
  26.             exit(2);
  27.         }
  28.         logMessage(NORMAL, "create listen socket success: %d", listen_sock); // 1111Log
  29.         return listen_sock;
  30.     }
  31.     void Bind(int sock, uint16_t port, std::string ip = "0.0.0.0")
  32.     {
  33.         // 2. bind，注意云服务器不能绑定公网IP，不允许。
  34.         // 成功bind则成功bind，失败进程exit(bind不在循环语句内，故失败直接进程退出。)
  35.         struct sockaddr_in local;
  36.         memset(&local, 0, sizeof local);
  37.         local.sin_family = AF_INET;
  38.         local.sin_port = htons(port);
  39.         local.sin_addr.s_addr = inet_addr(ip.c_str());
  40.         if (bind(sock, (struct sockaddr *)&local, sizeof local) < 0)
  41.         {
  42.             logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
  43.             exit(3);
  44.         }
  45.     }
  46.     void Listen(int sock)
  47.     {
  48.         // 3. listen监听: 因为TCP是面向连接的，在我们正式通信之前，需要先建立连接
  49.         // listen: 将套接字状态设置为监听状态。服务器要一直处于等待状态，这样客户端才能随时随地发起连接。
  50.         // 成功则成功，失败则exit
  51.         if (listen(sock, gback_log) < 0) // gback_log后面讲，全连接队列的长度。我猜测就是这个服务器同一时刻允许连接的客户端的数量最大值？也不太对呀，这么少么？
  52.         {
  53.             logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
  54.             exit(4);
  55.         }
  56.         logMessage(NORMAL, "listen success");
  57.     }
  58.     // 一般经验
  59.     // const std::string &: 输入型参数
  60.     // std::string *: 输出型参数
  61.     // std::string &: 输入输出型参数
  62.     int Accept(int sock, uint16_t *port, std::string *ip)
  63.     {
  64.         // accept失败进程不退出，返回-1
  65.         // 成功则返回对应的通信套接字
  66.         struct sockaddr_in client;
  67.         socklen_t len = sizeof client;
  68.         // 其实accept是获取已经建立好的TCP连接。建立好的连接在一个内核队列中存放，最大数量的第二个参数+1
  69.         int service_sock = accept(sock, (struct sockaddr *)&client, &len); // 返回一个用于与客户端进行网络IO的套接字，不同于listen_sock
  70.         // On success, these system calls return a nonnegative integer that is a descriptor for the accepted socket.  On error, -1 is returned, and errno is set appropriately.
  71.         if (service_sock < 0)
  72.         {
  73.             logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
  74.             return -1;  // accept失败不直接exit，而是返回-1。因为在循环语句内部。
  75.         }
  76.         if (port)
  77.             *port = ntohs(client.sin_port);
  78.         if (ip)
  79.             *ip = inet_ntoa(client.sin_addr);
  80.         logMessage(NORMAL, "link(accept) success, service socket: %d | %s:%d", service_sock,
  81.                    (*ip).c_str(), *port);
  82.         return service_sock;
  83.     }
  84.     int Connect(int sock, const std::string &ip, const uint16_t &port)
  85.     {
  86.         // 惯例写一下：失败返回-1，成功则客户端与服务端连接成功，返回0
  87.         struct sockaddr_in server;
  88.         memset(&server, 0, sizeof server);
  89.         server.sin_family = AF_INET;
  90.         server.sin_addr.s_addr = inet_addr(ip.c_str());
  91.         server.sin_port = htons(port);
  92.         if (connect(sock, (struct sockaddr *)&server, sizeof server) < 0)
  93.         {
  94.             return -1;
  95.         }
  96.         return 0;
  97.     }
  98. public:
  99.     Sock() = default;
  100.     ~Sock() = default;
  101. };

TcpServer.hpp

  1. #ifndef _TCP_SERVER_HPP_
  2. #define _TCP_SERVER_HPP_
  3.  
  4. #include "Sock.hpp"
  5. #include <vector>
  6. #include <functional>
  7.  
  8. // 说实话，这个TcpServer类实现的非常棒，真的很棒，网络和服务进行了解耦。
  9. // 使用者直接BindServer, 然后start即可
  10. namespace ns_tcpserver
  11. {
  12.     using func_t = std::function<void(int socket)>; // 服务器提供的服务方法类型void(int)，可变
  13.  
  14.     class TcpServer;
  15.     class ThreadData
  16.     {
  17.     public:
  18.         ThreadData(int sock, TcpServer *server)
  19.             : _sock(sock), _server(server)
  20.         {}
  21.         ~ThreadData() {}
  22.     public:
  23.         int _sock;
  24.         TcpServer *_server; // 因为静态成员函数呀
  25.     };
  26.  
  27.     class TcpServer
  28.     {
  29.         // 不关心bind的ip和port，因为用不到啊，保留一个listen_sock用于accept就够了。
  30.     private:
  31.         int _listen_sock;
  32.         Sock _sock;
  33.         std::vector<func_t> _funcs; // 服务器提供的服务
  34.     private:
  35.         static void *threadRoutine(void *args)
  36.         {
  37.             pthread_detach(pthread_self());    // 线程分离（避免类似于僵尸进程状态）
  38.             ThreadData *td = (ThreadData *)args;
  39.             td->_server->excute(td->_sock); // 提供服务
  40.             close(td->_sock);   // 保证四次挥手正常结束
  41.             delete td;
  42.             return nullptr;
  43.         }
  44.     public:
  45.         TcpServer(const uint16_t &port, const std::string &ip = "0.0.0.0")
  46.         {
  47.             // 创建监听套接字，bind，listen
  48.             _listen_sock = _sock.Socket();
  49.             _sock.Bind(_listen_sock, port, ip);
  50.             _sock.Listen(_listen_sock);
  51.         }
  52.         void start()
  53.         {
  54.             for (;;)
  55.             {
  56.                 // 开始accept，然后执行任务
  57.                 std::string ip;
  58.                 uint16_t port;     // 这两个东西，也并没有传给线程。
  59.                 int sock = _sock.Accept(_listen_sock, &port, &ip); // 后面是输出型参数
  60.                 if (sock == -1)
  61.                     continue; // 本次accept失败，循环再次accept。目前来看几乎不会
  62.  
  63.                 // 连接客户端成功，ip port已有。但是这里没用...
  64.                 pthread_t tid;
  65.                 ThreadData *td = new ThreadData(sock, this);
  66.                 pthread_create(&tid, nullptr, threadRoutine, (void *)td); // 新线程去提供service，主线程继续accept
  67.             }
  68.         }
  69.         void bindService(func_t service)   // 暴露出去的接口，用于设置该服务器的服务方法
  70.         {
  71.             _funcs.push_back(service);
  72.         }
  73.         void excute(int sock)
  74.         {
  75.             for (auto &func : _funcs)
  76.             {
  77.                 func(sock);
  78.             }
  79.         }
  80.         ~TcpServer()
  81.         {
  82.             if (_listen_sock >= 0)
  83.                 close(_listen_sock);
  84.         }
  85.     };
  86. }
  87. #endif

Protocol.hpp

  1. #ifndef _PROTOCOL_HPP_
  2. #define _PROTOCOL_HPP_
  3.  
  4. #include <iostream>
  5. #include <string>
  6. #include <cstring>
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <arpa/inet.h>
  10. #include <netinet/in.h>
  11. #include <jsoncpp/json/json.h>
  12.  
  13. // important and new
  14. namespace ns_protocol
  15. {
  16.  
  17. // #define MYSELF 1 // 自己实现序列化反序列化还是使用json库
  18.  
  19. #define SPACE " "
  20. #define SPACE_LENGTH strlen(SPACE)
  21. #define SEP "\r\n"
  22. #define SEP_LENGTH strlen(SEP)
  23.  
  24.     // 请求和回复，都需要序列化和反序列化的成员函数
  25.     // 序列化和反序列化双方都不同。但是添加报头和去报头是相同的，"Length\r\nxxxxx\r\n";
  26.     // 客户端生成请求，序列化之后发送给服务端
  27.     class Request
  28.     {
  29.     public:
  30.         Request() = default;
  31.         Request(int x, int y, char op)
  32.             : _x(x), _y(y), _op(op)
  33.         {
  34.         }
  35.         ~Request() {}
  36.  
  37.     public:
  38.         int _x;
  39.         int _y;
  40.         char _op;
  41.  
  42.     public:
  43.         std::string serialize()
  44.         {
  45.             // 序列化为"_x _op _y"  （注意，序列化和添加报头是分开的，反序列化和去掉报头是分开的
  46. #ifdef MYSELF
  47.             std::string s = std::to_string(_x);
  48.             s += SPACE;
  49.             s += _op;
  50.             s += SPACE;
  51.             s += std::to_string(_y);
  52.             return s;
  53. #else
  54.             Json::Value root;
  55.             root["x"] = _x;
  56.             root["y"] = _y;
  57.             root["op"] = _op;
  58.             Json::FastWriter writer;
  59.             return writer.write(root);
  60. #endif
  61.         }
  62.         bool deserialize(const std::string &s)
  63.         {
  64. #ifdef MYSELF
  65.             // "_x _op _y"
  66.             std::size_t left = s.find(SPACE);
  67.             if (left == std::string::npos)
  68.                 return false;
  69.             std::size_t right = s.rfind(SPACE);
  70.             if (right == left)
  71.                 return false;
  72.             _x = atoi(s.substr(0, left).c_str());
  73.             _op = s[left + SPACE_LENGTH];
  74.             _y = atoi(s.substr(right + SPACE_LENGTH).c_str());
  75. #else
  76.             Json::Value root;
  77.             Json::Reader reader;
  78.             reader.parse(s, root);
  79.             _x = root["x"].asInt();
  80.             _y = root["y"].asInt();
  81.             _op = root["op"].asInt();
  82. #endif
  83.             return true;
  84.         }
  85.     };
  86.     // 服务端收到请求，反序列化，业务处理生成response，序列化后发送给客户端
  87.     class Response
  88.     {
  89.     public:
  90.         Response(int result = 0, int code = 0)
  91.             : _result(result), _code(code)
  92.         {
  93.         }
  94.         ~Response() {}
  95.  
  96.     public:
  97.         std::string serialize()
  98.         {
  99.             // 序列化为"_code _result"  （注意，序列化和添加报头是分开的，反序列化和去掉报头是分开的
  100. #ifdef MYSELF
  101.             std::string s = std::to_string(_code);
  102.             s += SPACE;
  103.             s += std::to_string(_result);
  104.             return s;
  105. #else
  106.             Json::Value root;
  107.             root["code"] = _code;
  108.             root["result"] = _result;
  109.             Json::FastWriter writer;
  110.             return writer.write(root);
  111. #endif
  112.         }
  113.         bool deserialize(const std::string &s)
  114.         {
  115. #ifdef MYSELF
  116.             // "_code _result"
  117.             std::size_t pos = s.find(SPACE);
  118.             if (pos == std::string::npos)
  119.                 return false;
  120.             _code = atoi(s.substr(0, pos).c_str());
  121.             _result = atoi(s.substr(pos + SPACE_LENGTH).c_str());
  122. #else
  123.             Json::Value root;
  124.             Json::Reader reader;
  125.             reader.parse(s, root);
  126.             _result = root["result"].asInt();
  127.             _code = root["code"].asInt();
  128. #endif
  129.             return true;
  130.         }
  131.     public:
  132.         int _result;
  133.         int _code; // 状态码, 防止除零，模零，和其他错误（比如非法运算符运算符）。code == 0时，result有效。
  134.     };
  135.     // 进行去报头，报文完整则去报头，并返回有效载荷，不完整则代表失败返回空字符串。
  136.     std::string deCode(std::string &s) // 输入型输出型参数
  137.     {
  138.         // "Length\r\nx op y\r\n"   成功返回有效载荷，失败返回空串
  139.         std::size_t left = s.find(SEP);
  140.         if (left == std::string::npos)
  141.             return "";
  142.         std::size_t right = s.rfind(SEP);
  143.         if (right == left)
  144.             return "";
  145.         int length = atoi(s.substr(0, left).c_str());
  146.         if (length > s.size() - left - 2 * SEP_LENGTH)
  147.             return ""; // 有效载荷长度不足，不是一个完整报文，其实经过上面两次的if判断已经够了可能。
  148.         // 是一个完整报文，进行提取
  149.         std::string ret;
  150.         s.erase(0, left + SEP_LENGTH);
  151.         ret = s.substr(0, length);
  152.         s.erase(0, length + SEP_LENGTH);
  153.         return ret;
  154.     }
  155.     std::string enCode(const std::string &s)
  156.     {
  157.         // "Length\r\n1+1\r\n"
  158.         std::string retStr = std::to_string(s.size());
  159.         retStr += SEP;
  160.         retStr += s;
  161.         retStr += SEP;
  162.         return retStr;
  163.     }
  164.     // 我真的很想用引用，但是好像传统规则是输出型参数用指针...
  165.     // 其实这个Recv就是一个单纯的读数据的函数，将接收缓冲区数据读到应用层缓冲区中，也就是*s中。存储的是对端发来的应用层报文。
  166.     bool Recv(int sock, std::string *s)
  167.     {
  168.         // 仅仅读取数据到*s中
  169.         char buff[1024];
  170.         ssize_t sz = recv(sock, buff, sizeof buff, 0);
  171.         if (sz > 0)
  172.         {
  173.             buff[sz] = '\0';
  174.             *s += buff;    
  175.             return true;
  176.         }
  177.         else if (sz == 0)
  178.         {
  179.             std::cout << "peer quit" << std::endl;
  180.             return false;
  181.         }
  182.         else
  183.         {
  184.             std::cout << "recv error" << std::endl;
  185.             return false;
  186.         }
  187.     }
  188.     bool Send(int sock, const std::string &s)
  189.     {
  190.         ssize_t sz = send(sock, s.c_str(), s.size(), 0);
  191.         if (sz > 0)
  192.         {
  193.             return true;
  194.         }
  195.         else
  196.         {
  197.             std::cout << "send error!" << std::endl;
  198.             return false;
  199.         }
  200.     }
  201. }
  202.  
  203. #endif

CalServer.cc

  1. #include "TcpServer.hpp"
  2. #include "Protocol.hpp"
  3. #include <memory>
  4.  
  5. using namespace ns_tcpserver;
  6. using namespace ns_protocol;
  7.  
  8. Response calculatorHelp(const Request &req)
  9. {
  10.     // "1+1"???
  11.     Response resp;
  12.     int x = req._x;
  13.     int y = req._y;
  14.     switch (req._op)
  15.     {
  16.     case '+':
  17.         resp._result = x + y;
  18.         break;
  19.     case '-':
  20.         resp._result = x - y;
  21.         break;
  22.     case '*':
  23.         resp._result = x * y;
  24.         break;
  25.     case '/':
  26.         if (y == 0)
  27.             resp._code = 1;
  28.         else
  29.             resp._result = x / y;
  30.         break;
  31.     case '%':
  32.         if (y == 0)
  33.             resp._code = 2;
  34.         else
  35.             resp._result = x % y;
  36.         break;
  37.     default:
  38.         resp._code = 3;
  39.         break;
  40.     }
  41.     return resp;
  42. }
  43.  
  44. void calculator(int sock)
  45. {
  46.     std::string s;
  47.     for (;;)
  48.     {
  49.         if (Recv(sock, &s) <= 0) // 输出型参数
  50.             break;  // 大概率对端退出，则服务结束。一般不会读取失败recv error
  51.         std::string package = deCode(s);
  52.         if (package.empty())
  53.             continue; // 不是一个完整报文，继续读取（因为TCP面向字节流！！！）
  54.         // 读取到一个完整报文，且已经去了应用层报头，有效载荷在package中。如"1 + 2"
  55.         Request req;
  56.         req.deserialize(package);
  57.         Response resp = calculatorHelp(req);
  58.         std::string backStr = resp.serialize();
  59.         backStr = enCode(backStr);
  60.         if (!Send(sock, backStr)) // 发送失败就退出
  61.             break;
  62.     }
  63. }
  64.  
  65. // ./cal_server port
  66. int main(int argc, char **argv)
  67. {
  68.     // std::cout << "test remake" << std::endl;  // success
  69.     if (argc != 2)
  70.     {
  71.         std::cout << "\nUsage: " << argv[0] << " port\n"
  72.                   << std::endl;
  73.         exit(1);
  74.     }
  75.     std::unique_ptr<TcpServer> server(new TcpServer(atoi(argv[1])));
  76.     server->bindService(calculator); // 给服务器设置服务方法，将网络服务和业务逻辑进行解耦
  77.     server->start();                 // 服务器开始进行accept，连接一个client之后就提供上方bind的服务
  78.     return 0;
  79. }

CalClient.cc

  1. #include "Protocol.hpp"
  2. #include "Sock.hpp"
  3. #include <memory>
  4.  
  5. using namespace ns_protocol;
  6.  
  7. // ./client serverIp serverPort
  8. int main(int argc, char **argv)
  9. {
  10.     if (argc != 3)
  11.     {
  12.         std::cout << "\nUsage: " << argv[0] << " serverIp serverPort\n"
  13.                   << std::endl;
  14.         exit(1);
  15.     }
  16.     Sock sock;
  17.     int sockfd = sock.Socket();
  18.     // 客户端不需要显式bind, 老生常谈了。
  19.     if (sock.Connect(sockfd, argv[1], atoi(argv[2])) == -1)
  20.     {
  21.         std::cout << "connect error" << std::endl;
  22.         exit(3);
  23.     }
  24.     std::string backStr;  // 
  25.     bool quit = false;
  26.     while (!quit)
  27.     {
  28.         Request req;
  29.         std::cout << "Please enter# ";
  30.         std::cin >> req._x >> req._op >> req._y;
  31.         std::string reqStr = req.serialize();
  32.         reqStr = enCode(reqStr); // 添加应用层报头，此处添加报头（制定协议）是为了解决TCP粘包问题，因为TCP是面向字节流的。
  33.         if (!Send(sockfd, reqStr))
  34.             break;
  35.         while (true)
  36.         {
  37.             if (!Recv(sockfd, &backStr))
  38.             {
  39.                 quit = true;
  40.                 break;
  41.             }
  42.             std::string package = deCode(backStr);
  43.             if(package.empty())
  44.                 continue;    // 这次不是一个完整的应用层报文，继续读取
  45.             // 读取到一个完整的应用层报文，且已经去报头，获取有效载荷成功，在package中。（这个有效载荷是server发来的，计算结果）
  46.             Response resp;
  47.             resp.deserialize(package);
  48.             switch (resp._code)
  49.             {
  50.             case 1:
  51.                 std::cout << "除零错误" << std::endl;
  52.                 break;
  53.             case 2:
  54.                 std::cout << "模零错误" << std::endl;
  55.                 break;
  56.             case 3:
  57.                 std::cout << "其他错误" << std::endl;
  58.                 break;
  59.             default:
  60.                 std::cout << req._x << " " << req._op << " " << req._y << " = " << resp._result << std::endl;
  61.                 break;
  62.             }
  63.             break;  // 退出防止TCP粘包问题的循环。
  64.         }
  65.         // 进行下一次获取用户输入，进行计算。
  66.     }
  67.     close(sockfd);
  68.     return 0;
  69. }

分析

可以分为两个模块：网络通信模块，应用层模块（包括应用层协议，以及应用层计算器逻辑）。

网络模块中，Sock.hpp就是一个简单的对于系统调用的封装，TcpServer.hpp的设计很优雅，内部有一个std::vector<func_t> _funcs;即这个server提供的服务。对外提供一个BindServer的方法，可以指定这个服务器提供的服务。Start，为服务器开始方法，先accept获取与客户端建立好的连接，然后创建新线程给客户端提供服务，服务就是BindServer绑定的方法，类型为void(int)。

应用层协议：一个Request，一个Response。分别是客户端的请求（x,y,运算符）和服务端的响应（计算结果）。这两个类，都有序列化和反序列化的方法，便于网络传输。还有一个Encode添加报头和Decode去报头的方法，这个其实就是应用层协议的报头，大体格式为 Length\r\nxxxx\r\n。目的就是解决TCP面向字节流所引起的粘包问题。
Recv内部就是一个recv调用，将读取的网络数据添加到一个输出型参数string*指向string的结尾。因为TCP粘包问题，所以可能读取的不是一个完整报文（半个？），故，在Decode方法内部，也就是去报头时，会检测此时是否有至少一个完整应用层报文。若有，则去报头，获取有效载荷。若没有则返回一个空串。上层可以通过判断是否为空串。判断是否读到了一个完整应用层报文，若没有，则再次Recv，直到读到一个完整应用层报文为止。所以，server和client在读取网络数据并去报头时，都是在while循环内部进行的。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/978221
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号