cppnet

English version is here

• 一个轻量级 C++ 网络框架, cppweb 2.0 升级版
• 避免了之前 cppweb 单个头文件的臃肿的问题, 并且使用更加友善的使用方式

Author

• chenxuan

仓库地址

• github
• gitee

官网

• chenxuanweb.top/cppnet/index.html

Docs

• cppnet 在线文档地址

优势

1. 使用简单,入侵性小,全平台支持, 不要求强行安装到系统的include目录中, 推荐直接作为一个submodule 引用或者直接使用静态库
2. 使用现代的C++构建, 使用方式和函数和 Go 的 gin 框架类似 , 学习和入门成本小, 可适合作为初学者进行源码学习
3. 轻量化框架, 非常小, 源码不到5000行, 避免了大型网络框架的臃肿

Quick Start

• 需要编译器支持 C++17

使用 Release 包

1. 下载 release 库(Releases · chenxuan520/cppnet) , 并且解压(地点可以随意, 可以放到系统的 include 也可以不放 下文假设是解压到当前目录), 需要编译器支持C++17
   • 这里如果是需要ssl (需要安装 openssl ),就下载 ssl 的版本, 否则下载默认即可
2. 编写代码, 这一步可以根据需要编写代码, 下面是两个简单的demo , 分别是 没有ssl 和有ssl的两个demo, 具体的函数介绍可以参考文档内容

#include "./cppnet/include/cppnet/http/server/http_server.hpp"
#include "./cppnet/include/cppnet/utils/const.hpp"
#include <iostream>

using namespace cppnet;

int main() {
  HttpServer server;
  auto rc = server.Init({"127.0.0.1", 8080});
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  return 0;
}

// ssl 版本

#include "./cppnet/include/cppnet/http/server/http_server.hpp"
#include "./cppnet/include/cppnet/utils/const.hpp"
#include <iostream>
#include <memory>

using namespace cppnet;

int main() {
  HttpServer server;
  std::shared_ptr<SSLContext> ssl_ctx = std::make_shared<SSLContext>();
  auto rc = ssl_ctx->InitSvrFile("./ssl/cacert.pem", "./ssl/privkey.pem");
  if (rc != kSuccess) {
    std::cout << "init ssl context wrong " << ssl_ctx->err_msg() << std::endl;
    return rc;
  }
  rc = server.InitSSL({"127.0.0.1", 8080}, ssl_ctx);
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  return 0;
}

3. 编写编译文件

   1. 如果是使用 CMake 编译, 需要在CMakeLists 添加如下内容 , 实际上就是加上了链接库

   # 是否使用ssl都需要添加
   link_directories(./cppnet/lib)
   link_libraries(-lcppnet)
   
   # **如果使用的是 ssl版本并且需要使用ssl的功能,才需要添加下面的**
   add_definitions(-DCPPNET_OPENSSL)
   link_libraries(-lssl -lcrypto)
   

   2. 如果是使用 Makefile 编译, 需要在编译选项中添加 -L./cppnet/lib 和 -lcppnet, 下面是一个 Makefile 编译 demo, 当然如果是ssl的编译也是同理添加 lib 库 和 添加 CPPNET_OPENSSL 宏

   all: libserver-makefile
   
   libserver-makefile:
   	g++ -O2 -Wall -std=c++17 ./main.cpp -o libserver-makefile -lcppnet -L./cppnet/lib
   	# ssl 版本的是
   	g++ -O2 -Wall -std=c++17 ./main.cpp -o libserver-makefile -DCPPNET_OPENSSL -lcppnet -lssl -lcrypto -L./cppnet/lib
   

4. 执行编译, 获得编译的文件就成功了

从源码编译

1. 使用 git clone https://github.com/chenxuan520/cppnet --recurse-submodules 拉取源代码
   1. 默认是编译出 ssh版本的, 如果需要无ssl版本的需要手动修改cmake文件
2. 运行 cd src;./build.sh 生成的静态库在lib中
   • 需要 cmake
   • 需要编译器支持 C++17

性能测试

• 使用 github action的ubuntu-latest进行自动化测试, 机器配置参考
  • 4核 16G 内存 14G 硬盘
• 根据每次 commit 的代码自动运行更新测试结果, 参考 bench 文件夹下脚本, 图片中也会有 hash 值
• 使用 vegeta 进行压力测试, 分别测试在不同QPS下
  • 平均响应时间
  • p99 响应时间
  • 正确率
  • 等待时间
• 使用 cppnet 框架 和 go gin 框架进行对比, 使用两者实现同样的功能

More Demo

• 更多demo参考 demo 文件夹和 test 文件夹

创建TcpServer

  Address addr{"127.0.0.1", 8080};
  TcpServer server{addr};

  // init server
  auto rc = server.Init();
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }

  // init event function
  auto event_func = [&](TcpServer::Event event, TcpServer &server, Socket fd) {
    if (event == TcpServer::kEventAccept) {
      // accept
      std::cout << "accept " << fd.fd() << std::endl;

    } else if (event == TcpServer::kEventRead) {
      // read
      string buf;
      auto ser_rc = fd.Read(buf, msg.size());
      std::cout << "read " << buf << std::endl;

    } else if (event == TcpServer::kEventLeave) {
      // leave
      std::cout << "leave " << fd.fd() << std::endl;
    } else {
      // error event
      std::cout << "dismiss " << fd.fd() << std::endl;
    }
  };
  // register event function
  server.Register(event_func);

socket连接服务器

  Socket sock;
  auto rc = sock.Init();
  if (rc != kSuccess) {
    std::cout << "init socket wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  rc = sock.Connect(addr);
  if (rc != kSuccess) {
    std::cout << "connect wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  // write
  string msg = "hello world";
  rc = sock.Write(msg);
  if (rc != kSuccess) {
    std::cout << "write wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  // read
  string buf;
  rc = sock.Read(buf, msg.size());
  if (rc <= 0) {
    std::cout << "read wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  std::cout << "read " << buf << std::endl;
  // close
  rc = sock.Close();
  if (rc != kSuccess) {
    std::cout << "close wrong " << sock.err_msg() << std::endl;
    return rc;
  }

创建httpserver

  HttpServer server;
  auto rc = server.Init({"127.0.0.1", 8080});
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }

创建httpsserver ssl

  HttpServer server;
  std::shared_ptr<SSLContext> ssl_ctx = std::make_shared<SSLContext>();
  auto rc = ssl_ctx->InitSvrFile("./ssl/cacert.pem", "./ssl/privkey.pem");
  if (rc != kSuccess) {
    std::cout << "init ssl context wrong " << ssl_ctx->err_msg() << std::endl;
    return rc;
  }
  rc = server.InitSSL({"127.0.0.1", 8080}, ssl_ctx);
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }

创建httpclient

  HttpClient client;
  Address addr;
  addr.InitWithDomain("www.androidftp.top", 80);
  auto rc = client.Init(addr);
  // 如果是https 443 端口 ssl
  // auto rc = client.InitSSL(addr);
  if (rc != kSuccess) {
    std::cout << "init client wrong " << client.err_msg() << std::endl;
    return rc;
  }
  HttpReq req;
  req.GET("/");
  HttpResp resp;
  rc = client.Send(req, resp);
  if (rc != kSuccess) {
    std::cout << "send request wrong " << client.err_msg() << std::endl;
    return rc;
  }
  std::string resp_str;
  rc = resp.Build(resp_str);
  if (rc != kSuccess) {
    std::cout << "build response wrong " << resp.err_msg() << std::endl;
    return rc;
  }

定时触发器server

• 使用 AddSoc 监听timesocket, 等待触发即可

  TcpServer server{addr};
  auto rc = server.Init();
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }

  TimerSocket timerfd(0, 1e5);
  if (rc != kSuccess) {
    std::cout << "init timerfd wrong " << timerfd.err_msg() << std::endl;
    return rc;
  }
  rc = server.AddSoc(timerfd);

源码结构

• 仓库结构如下
  • cppnet 放置所以的源码以及编译文件
  • lib 放置生成的静态库以及静态库构建的 CMakeLists 文件
  • test 是测试用例
  • third_party 是第三方仓库, 目前只依赖 cpptest 用于test 文件夹的单元测试
  • build.sh 生成 lib 静态库以及 单元测试的二进制文件
  • docs 是接口文档
  • demo 是参考的事例
  • bench 是性能测试

.
├── LICENSE
├── README.en.md
├── README.md
├── bench
│   ├── build.sh
│   └── init.sh
├── demo
│   ├── asset
│   ├── build.sh
│   ├── mnist
│   ├── pack
│   ├── simple-http-server
│   ├── use-lib-server
│   ├── use-lib-server-ssl
│   ├── util
│   └── web-server
├── docs
│   ├── cppnet
│   └── update.sh
└── src
    ├── CMakeLists.txt
    ├── build.sh
    ├── cppnet
    ├── lib
    ├── release.sh
    ├── test
    ├── third_party
    └── win_release.sh

• 源码主要放置在 src/cppnet

cppnet
├── http
│   ├── client
│   │   ├── http_client.cpp
│   │   └── http_client.hpp
│   ├── header
│   │   ├── http_header.cpp
│   │   └── http_header.hpp
│   ├── req
│   │   ├── http_req.cpp
│   │   ├── http_req.hpp
│   │   ├── method
│   │   │   ├── http_method.cpp
│   │   │   └── http_method.hpp
│   │   └── route
│   │       ├── http_route.cpp
│   │       └── http_route.hpp
│   ├── resp
│   │   ├── http_resp.cpp
│   │   ├── http_resp.hpp
│   │   └── status_code
│   │       ├── http_status_code.cpp
│   │       └── http_status_code.hpp
│   ├── server
│   │   ├── filter
│   │   │   ├── http_filter.hpp
│   │   │   ├── http_host_filter.hpp
│   │   │   └── http_method_filter.hpp
│   │   ├── http_server.cpp
│   │   └── http_server.hpp
│   └── version
│       ├── http_version.cpp
│       └── http_version.hpp
├── log
│   ├── file_logger.cpp
│   ├── file_logger.hpp
│   ├── logger.hpp
│   ├── multi_logger.cpp
│   ├── multi_logger.hpp
│   └── std_logger.hpp
├── server
│   ├── io_multiplexing
│   │   ├── epoll.cpp
│   │   ├── epoll.hpp
│   │   ├── io_multiplexing_base.hpp
│   │   ├── io_multiplexing_factory.cpp
│   │   ├── io_multiplexing_factory.hpp
│   │   ├── kqueue.cpp
│   │   ├── kqueue.hpp
│   │   ├── select.cpp
│   │   └── select.hpp
│   ├── tcp_server.cpp
│   └── tcp_server.hpp
├── socket
│   ├── address.cpp
│   ├── address.hpp
│   ├── socket.cpp
│   └── socket.hpp
├── ssl
│   ├── ssl_context.cpp
│   ├── ssl_context.hpp
│   ├── ssl_socket.cpp
│   └── ssl_socket.hpp
├── timer
│   ├── timer.cpp
│   └── timer.hpp
└── utils
    ├── const.hpp
    ├── file.cpp
    ├── file.hpp
    ├── host.cpp
    ├── host.hpp
    ├── string.cpp
    ├── string.hpp
    ├── threadpool.cpp
    ├── threadpool.hpp
    ├── trie.cpp
    ├── trie.hpp
    ├── version.cpp
    └── version.hpp

19 directories, 61 files

类关系图

TODO

• 补充完整 readme
• 支持设置LT和ET模式下的事件触发方式
• 支持设置连接的超时时间
• 补全select
• 支持UDP协议(添加测试)
• 支持Http协议(彻底迁移 cppweb -> cppnet)
• 支持 cicd 生成 lib 包
• 添加 release pkg的demo 和cmakelist
• httpclient 完成
• httpserver test
• 添加更多log
• route 宽泛匹配
• post 参数设置
• 触发模式控制修改
• 抽象出epoll层
• 支持SSL
• accept 改造
• 完善多线程
• 添加压力测试
• 提升trie

cppnet

• A lightweight C++ network framework, an upgraded version of cppweb 2.0
• Avoids the bloatiness of the previous cppweb single header file, and uses a more friendly way of using

Author

• chenxuan

Repository Address

• github
• gitee

Official Website

• chenxuanweb.top/cppnet/index.html

Docs

• cppnet online docs

Advantages

1. Easy to use, low invasiveness, full platform support, does not require forcible installation into the system's include directory, recommended to be directly referenced as a submodule or used directly with static libraries
2. Built with modern C++, similar in usage and functions to Go's gin framework, small learning and entry cost, suitable for beginners to learn source code
3. Lightweight framework, very small, with less than 5000 lines of source code, avoiding the bloat of large network frameworks

Quick Start

Using the Release Package

1. Download the release library (Releases · chenxuan520/cppnet), and extract it (you can choose any location, you can put it in the system's include directory or not. In the following, it is assumed that the extraction is to the current directory). A C++17-compatible compiler is required.
   • If you need SSL (you need to install OpenSSL), download the SSL version. The default option is fine.
2. Write code. You can write code according to your needs. The following are two simple demos, one without SSL and the other with SSL. For specific function descriptions, you can refer to the documentation.

#include "./cppnet/include/cppnet/http/server/http_server.hpp"
#include "./cppnet/include/cppnet/utils/const.hpp"
#include <iostream>

using namespace cppnet;

int main() {
  HttpServer server;
  auto rc = server.Init({"127.0.0.1", 8080});
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  return 0;
}

// ssl 版本

#include "./cppnet/include/cppnet/http/server/http_server.hpp"
#include "./cppnet/include/cppnet/utils/const.hpp"
#include <iostream>
#include <memory>

using namespace cppnet;

int main() {
  HttpServer server;
  std::shared_ptr<SSLContext> ssl_ctx = std::make_shared<SSLContext>();
  auto rc = ssl_ctx->InitSvrFile("./ssl/cacert.pem", "./ssl/privkey.pem");
  if (rc != kSuccess) {
    std::cout << "init ssl context wrong " << ssl_ctx->err_msg() << std::endl;
    return rc;
  }
  rc = server.InitSSL({"127.0.0.1", 8080}, ssl_ctx);
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  return 0;
}

3. Compiling the build file

   1. If you are using CMake to compile, you need to add the following content to the CMakeLists.txt file. In fact, you just add the link library

   # Whether to use SSL or not, you need to add this
   link_directories(./cppnet/lib)
   link_libraries(-lcppnet)
   
   # **If you are using the SSL version and need to use the SSL function, you need to add the following**
   add_definitions(-DCPPNET_OPENSSL)
   link_libraries(-lssl -lcrypto)
   

   2. If you are using Makefile to compile, you need to add -L./cppnet/lib and -lcppnet to the compilation options. Here is a Makefile compilation demo. Of course, if it is an SSL compilation, you also need to add the lib library and add the CPPNET_OPENSSL macro.

   all: libserver-makefile
   
   libserver-makefile:
       g++ -O2 -Wall -std=c++17./main.cpp -o libserver-makefile -lcppnet -L./cppnet/lib
       # SSL version
       g++ -O2 -Wall -std=c++17./main.cpp -o libserver-makefile -DCPPNET_OPENSSL -lcppnet -lssl -lcrypto -L./cppnet/lib
   

4. Execute the compilation to obtain the compiled file successfully.

Compiling from source

1. Use git clone https://github.com/chenxuan520/cppnet --recurse-submodules to pull the source code
   1. By default, the ssh version is compiled. If you need an ssl-free version, you need to modify the cmake file manually
2. Run cd src;./build.sh to generate the static library in lib
   • Requires cmake
   • Requires a compiler that supports C++17

Performance Testing

• Automated testing is performed using ubuntu-latest from github action, with machine configuration refer to
  • 4 cores, 16GB of memory, and 14GB of hard disk
• Automatically run updated test results based on each commit's code, referring to the scripts in the bench folder, and the hash value will also be in the picture.
• Use vegeta for stress testing, testing at different QPS respectively
  • Average response time
  • p99 response time
  • Accuracy
  • Wait time
• Compare cppnet framework and go gin framework, and implement the same function with both

More Demo

• More demo references can be found in the "demo" folder and the "test" folder.

Create a TcpServer

  Address addr{"127.0.0.1", 8080};
  TcpServer server{addr};

  // init server
  auto rc = server.Init();
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }

  // init event function
  auto event_func = [&](TcpServer::Event event, TcpServer &server, Socket fd) {
    if (event == TcpServer::kEventAccept) {
      // accept
      std::cout << "accept " << fd.fd() << std::endl;

    } else if (event == TcpServer::kEventRead) {
      // read
      string buf;
      auto ser_rc = fd.Read(buf, msg.size());
      std::cout << "read " << buf << std::endl;

    } else if (event == TcpServer::kEventLeave) {
      // leave
      std::cout << "leave " << fd.fd() << std::endl;
    } else {
      // error event
      std::cout << "dismiss " << fd.fd() << std::endl;
    }
  };
  // register event function
  server.Register(event_func);

Connect to the server using socket

  Socket sock;
  auto rc = sock.Init();
  if (rc != kSuccess) {
    std::cout << "init socket wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  rc = sock.Connect(addr);
  if (rc != kSuccess) {
    std::cout << "connect wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  // write
  string msg = "hello world";
  rc = sock.Write(msg);
  if (rc != kSuccess) {
    std::cout << "write wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  // read
  string buf;
  rc = sock.Read(buf, msg.size());
  if (rc <= 0) {
    std::cout << "read wrong " << sock.err_msg() << std::endl;
    return rc;
  }
  std::cout << "read " << buf << std::endl;
  // close
  rc = sock.Close();
  if (rc != kSuccess) {
    std::cout << "close wrong " << sock.err_msg() << std::endl;
    return rc;
  }

Create HttpServer

  HttpServer server;
  auto rc = server.Init({"127.0.0.1", 8080});
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }

Create HttpsServer ssl

  HttpServer server;
  std::shared_ptr<SSLContext> ssl_ctx = std::make_shared<SSLContext>();
  auto rc = ssl_ctx->InitSvrFile("./ssl/cacert.pem", "./ssl/privkey.pem");
  if (rc != kSuccess) {
    std::cout << "init ssl context wrong " << ssl_ctx->err_msg() << std::endl;
    return rc;
  }
  rc = server.InitSSL({"127.0.0.1", 8080}, ssl_ctx);
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }
  server.set_logger(std::make_shared<StdLogger>());
  server.GET("/", [](HttpContext &ctx) {
    ctx.resp().Success(HttpHeader::ContentType::kTextHtml,
                       "<h1>Hello, World!</h1>");
  });
  rc = server.Run();
  if (rc != kSuccess) {
    std::cout << "run server wrong " << server.err_msg() << std::endl;
    return rc;
  }

Create HttpClient

  HttpClient client;
  Address addr;
  addr.InitWithDomain("www.androidftp.top", 80);
  auto rc = client.Init(addr);
  // If it is the https 443 port ssl
  // auto rc = client.InitSSL(addr);
  if (rc != kSuccess) {
    std::cout << "init client wrong " << client.err_msg() << std::endl;
    return rc;
  }
  HttpReq req;
  req.GET("/");
  HttpResp resp;
  rc = client.Send(req, resp);
  if (rc != kSuccess) {
    std::cout << "send request wrong " << client.err_msg() << std::endl;
    return rc;
  }
  std::string resp_str;
  rc = resp.Build(resp_str);
  if (rc != kSuccess) {
    std::cout << "build response wrong " << resp.err_msg() << std::endl;
    return rc;
  }

Timer trigger server

• To use AddSoc to listen for the timesocket and wait for a trigger.

  TcpServer server{addr};
  auto rc = server.Init();
  if (rc != kSuccess) {
    std::cout << "init server wrong " << server.err_msg() << std::endl;
    return rc;
  }

  TimerSocket timerfd(0, 1e5);
  if (rc != kSuccess) {
    std::cout << "init timerfd wrong " << timerfd.err_msg() << std::endl;
    return rc;
  }
  rc = server.AddSoc(timerfd);

Source code structure

• The repository structure is as follows
  • cppnet stores all source code and build files
  • lib stores the generated static library and the CMakeLists file for static library construction
  • test is the test case
  • third_party is a third-party repository, currently only depends on cpptest for unit testing in the test folder
  • build.sh generates the lib static library and the unit test binary file
  • docs is the interface documentation
  • demo is the reference example
  • bench is the benchmark

.
├── LICENSE
├── README.en.md
├── README.md
├── bench
│   ├── build.sh
│   └── init.sh
├── demo
│   ├── asset
│   ├── build.sh
│   ├── mnist
│   ├── pack
│   ├── simple-http-server
│   ├── use-lib-server
│   ├── use-lib-server-ssl
│   ├── util
│   └── web-server
├── docs
│   ├── cppnet
│   └── update.sh
└── src
    ├── CMakeLists.txt
    ├── build.sh
    ├── cppnet
    ├── lib
    ├── release.sh
    ├── test
    ├── third_party
    └── win_release.sh

• The source code is mainly placed in src/cppnet.

cppnet
├── http
│   ├── client
│   │   ├── http_client.cpp
│   │   └── http_client.hpp
│   ├── header
│   │   ├── http_header.cpp
│   │   └── http_header.hpp
│   ├── req
│   │   ├── http_req.cpp
│   │   ├── http_req.hpp
│   │   ├── method
│   │   │   ├── http_method.cpp
│   │   │   └── http_method.hpp
│   │   └── route
│   │       ├── http_route.cpp
│   │       └── http_route.hpp
│   ├── resp
│   │   ├── http_resp.cpp
│   │   ├── http_resp.hpp
│   │   └── status_code
│   │       ├── http_status_code.cpp
│   │       └── http_status_code.hpp
│   ├── server
│   │   ├── filter
│   │   │   ├── http_filter.hpp
│   │   │   ├── http_host_filter.hpp
│   │   │   └── http_method_filter.hpp
│   │   ├── http_server.cpp
│   │   └── http_server.hpp
│   └── version
│       ├── http_version.cpp
│       └── http_version.hpp
├── log
│   ├── file_logger.cpp
│   ├── file_logger.hpp
│   ├── logger.hpp
│   ├── multi_logger.cpp
│   ├── multi_logger.hpp
│   └── std_logger.hpp
├── server
│   ├── io_multiplexing
│   │   ├── epoll.cpp
│   │   ├── epoll.hpp
│   │   ├── io_multiplexing_base.hpp
│   │   ├── io_multiplexing_factory.cpp
│   │   ├── io_multiplexing_factory.hpp
│   │   ├── kqueue.cpp
│   │   ├── kqueue.hpp
│   │   ├── select.cpp
│   │   └── select.hpp
│   ├── tcp_server.cpp
│   └── tcp_server.hpp
├── socket
│   ├── address.cpp
│   ├── address.hpp
│   ├── socket.cpp
│   └── socket.hpp
├── ssl
│   ├── ssl_context.cpp
│   ├── ssl_context.hpp
│   ├── ssl_socket.cpp
│   └── ssl_socket.hpp
├── timer
│   ├── timer.cpp
│   └── timer.hpp
└── utils
    ├── const.hpp
    ├── file.cpp
    ├── file.hpp
    ├── host.cpp
    ├── host.hpp
    ├── string.cpp
    ├── string.hpp
    ├── threadpool.cpp
    ├── threadpool.hpp
    ├── trie.cpp
    ├── trie.hpp
    ├── version.cpp
    └── version.hpp

19 directories, 61 files

Class Diagram

cppnet::HttpClient

HttpClient()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpClient 对象。

~HttpClient()

• 参数：无
• 返回值：无
• 作用：HttpClient 类的析构函数，用于关闭客户端连接。

int Init(Address &addr)

• 参数：
  • addr：服务器地址对象。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化客户端，连接到指定的服务器地址。

int Send(HttpReq &req, HttpResp &resp)

• 参数：
  • req：Http 请求对象的引用。
  • resp：Http 响应对象的引用。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：发送 Http 请求并接收 Http 响应。

void Close()

• 参数：无
• 返回值：无
• 作用：关闭客户端连接。

int InitSSL(Address &addr)

• 参数：
  • addr：服务器地址对象。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 SSL 客户端，连接到指定的服务器地址。

Socket &socket()

• 参数：无
• 返回值：Socket &，套接字对象的引用。
• 作用：获取客户端的套接字对象。

std::string err_msg()

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

cppnet::HttpHeader

ContentType

• 这是一个枚举类，定义了多种HTTP头部的内容类型，包括常见的文本类型（如 kTextPlain、kTextHtml等）、应用类型（如 kApplicationJson、kApplicationOctetStream等）、图像类型（如 kImagePng、kImageJpeg等），还有 kCustom 用于自定义类型以及 kUnknown 表示未知类型。

static ContentType ConvertToContentType(const std::string &content_type)

• 参数：
  • content_type：字符串类型的内容类型表示。
• 返回值：ContentType类型，对应的内容类型枚举值。
• 作用：将给定的字符串形式的内容类型转换为枚举值。

static ContentType ConvertFileType(const std::string &file_type)

• 参数：
  • file_type：字符串类型的文件类型表示。
• 返回值：ContentType类型，对应的内容类型枚举值。
• 作用：将给定的字符串形式的文件类型转换为内容类型枚举值。

static std::string ConvertToStr(const ContentType &content_type, const std::string &file_type = "")

• 参数：
  • content_type：ContentType类型的内容类型枚举值。
  • file_type：可选的字符串类型的文件类型表示，默认为空字符串。
• 返回值：std::string类型，对应的内容类型字符串表示，可能会结合文件类型进行转换。
• 作用：将给定的内容类型枚举值转换为字符串表示，会根据文件类型做进一步处理。

static void SetCustomContentType(const std::string &file_type, const std::string &content_type)

• 参数：
  • file_type：字符串类型的文件类型。
  • content_type：字符串类型的自定义内容类型。
• 返回值：无
• 作用：设置自定义的内容类型，将文件类型与对应的自定义内容类型进行关联。

HttpHeader()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpHeader 对象。

int Parse(const std::string &origin_header)

• 参数：
  • origin_header：原始的HTTP头部字符串。
• 返回值：int类型，0表示成功，-1表示无效的头部。
• 作用：解析给定的原始HTTP头部。

void Add(const std::string &key, const std::string &value)

• 参数：
  • key：头部键。
  • value：头部值。
• 返回值：无
• 作用：向HTTP头部添加一个键值对。

std::string Get(const std::string &key) const

• 参数：
  • key：头部键。
• 返回值：std::string类型，头部值。
• 作用：根据头部键获取头部值。

std::string ToString() const

• 参数：无
• 返回值：std::string类型，HTTP头部的字符串表示。
• 作用：将HTTP头部转换为字符串。

std::string &operator[](const std::string &key)

• 参数：
  • key：头部键。
• 返回值：std::string&类型，头部值的引用。
• 作用：通过头部键获取头部值的引用。

inline std::string err_msg()

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

void Clear()

• 参数：无
• 返回值：无
• 作用：清空HTTP头部。

int GetContentLength() const

• 参数：无
• 返回值：int类型，内容长度。
• 作用：获取HTTP头部中的内容长度。

void SetContentLength(int content_length)

• 参数：
  • content_length：内容长度。
• 返回值：无
• 作用：设置HTTP头部中的内容长度。

ContentType GetContentType() const

• 参数：无
• 返回值：ContentType类型，内容类型枚举值。
• 作用：获取HTTP头部中的内容类型。

void SetContentType(ContentType content_type)

• 参数：
  • content_type：内容类型枚举值。
• 返回值：无
• 作用：设置HTTP头部中的内容类型为枚举值形式。

void SetContentType(const std::string &content_type)

• 参数：
  • content_type：字符串形式的内容类型。
• 返回值：无
• 作用：设置HTTP头部中的内容类型为字符串形式。

std::string GetHost() const

• 参数：无
• 返回值：std::string类型，主机名。
• 作用：获取HTTP头部中的主机名。

void SetHost(const std::string &host)

• 参数：
  • host：主机名。
• 返回值：无
• 作用：设置HTTP头部中的主机名。

void SetLongConnection(bool is_long_connect = true)

• 参数：
  • is_long_connect：布尔类型，指示是否为长连接，默认为true。
• 返回值：无
• 作用：设置HTTP头部中的连接类型为长连接或短连接。

std::string GetCookieVal(const std::string &key) const

• 参数：
  • key：Cookie的键。
• 返回值：std::string类型，Cookie的值。
• 作用：根据Cookie的键获取其值。

void SetCookie(const Cookie &cookie)

• 参数：
  • cookie：Cookie结构体，包含Cookie的各种属性。
• 返回值：无
• 作用：设置HTTP头部中的Cookie。

private static std::unordered_map<std::string, std::string> custom_content_type_

• 这是一个静态的无序映射，用于存储自定义的文件类型与对应的内容类型的关联关系，以便在处理自定义内容类型时使用。

cppnet::HttpMethod

• 这是一个枚举类，定义了各种 HTTP 方法，包括 GET、POST、PUT、DELETE 等常见方法以及一个表示未知方法的 UNKNOWN。

cppnet::HttpMethodUtil

static std::string ConvertToStr(const HttpMethod &method)

• 参数：
  • method：HttpMethod类型的 HTTP 方法枚举值。
• 返回值：std::string类型，对应的 HTTP 方法字符串表示。
• 作用：将给定的 HTTP 方法枚举值转换为字符串表示。

static HttpMethod ConvertToMethod(const std::string &method)

• 参数：
  • method：字符串类型的 HTTP 方法表示。
• 返回值：HttpMethod类型，对应的 HTTP 方法枚举值。
• 作用：将给定的字符串形式的 HTTP 方法转换为枚举值。

cppnet::HttpReq

HttpReq()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpReq 对象。

int Parse(const std::string &origin_req)

• 参数：
  • origin_req：原始的 HTTP 请求字符串。
• 返回值：int类型，0 表示成功，-1 表示无效的 HTTP 请求。
• 作用：解析给定的原始 HTTP 请求。

int Build(std::string &req_str)

• 参数：
  • req_str：用于存储构建后的 HTTP 请求字符串的引用。
• 返回值：int类型，0 表示成功，-1 表示无效的 HTTP 请求。
• 作用：构建 HTTP 请求并存储为字符串。

void Clear()

• 参数：无
• 返回值：无
• 作用：清空 HTTP 请求的内容。

void GET(const std::string &url, const KVMappings &params = KVMappings(), const KVMappings &extra_header = KVMappings())

• 参数：
  • url：请求的 URL。
  • params：键值对映射，表示请求参数，默认为空映射。
  • extra_header：键值对映射，表示额外的请求头部，默认为空映射。
• 返回值：无
• 作用：构建一个 GET 请求。

void POST(const std::string &url, const std::string &body, const KVMappings &extra_header = KVMappings())

• 参数：
  • url：请求的 URL。
  • body：请求体内容。
  • extra_header：键值对映射，表示额外的请求头部，默认为空映射。
• 返回值：无
• 作用：构建一个带有请求体的 POST 请求。

void POST(const std::string &url, const KVMappings & params, const KVMappings &extra_header = KVMappings())

• KVMappings含义 KVMappings = std::unordered_map<std::string, std::string>
• 参数：
  • url：请求的 URL。
  • params：键值对映射，表示请求参数。
  • extra_header：键值对映射，表示额外的请求头部，默认为空映射。
• 返回值：无
• 作用：构建一个带有请求参数的 POST 请求。

HttpHeader &header()

• 参数：无
• 返回值：HttpHeader &，HTTP 请求头部对象的引用。
• 作用：获取 HTTP 请求的头部对象。

HttpRoute &route()

• 参数：无
• 返回值：HttpRoute &，HTTP 请求路由对象的引用。
• 作用：获取 HTTP 请求的路由对象。

HttpMethod &method()

• 参数：无
• 返回值：HttpMethod &，HTTP 请求方法对象的引用。
• 作用：获取 HTTP 请求的方法对象。

HttpVersion &version()

• 参数：无
• 返回值：HttpVersion &，HTTP 请求版本对象的引用。
• 作用：获取 HTTP 请求的版本对象。

std::string &body()

• 参数：无
• 返回值：std::string &，HTTP 请求体的引用。
• 作用：获取 HTTP 请求体。

std::string err_msg()

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

cppnet::HttpRoute

HttpRoute()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpRoute 对象。

int Parse(const std::string &origin_path)

• 参数：
  • origin_path：原始路径字符串。
• 返回值：int类型，可能表示解析是否成功，具体含义需结合实际情况判断。
• 作用：解析给定的原始路径。

void AddParam(const std::string &key, const std::string &value)

• 参数：
  • key：参数键。
  • value：参数值。
• 返回值：无
• 作用：向路由中添加参数。

std::string GetParam(const std::string &key) const

• 参数：
  • key：参数键。
• 返回值：std::string类型，参数值。
• 作用：根据参数键获取参数值。

inline void SetPath(const std::string &path)

• 参数：
  • path：路径字符串。
• 返回值：无
• 作用：设置路由的路径。

inline std::string GetPath() const

• 参数：无
• 返回值：std::string类型，路径字符串。
• 作用：获取路由的路径。

std::string ToString() const

• 参数：无
• 返回值：std::string类型，路由的字符串表示。
• 作用：将路由转换为字符串。

inline std::string &operator[](const std::string &key)

• 参数：
  • key：参数键。
• 返回值：std::string&类型，参数值的引用。
• 作用：通过参数键获取参数值的引用。

inline std::string err_msg()

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

void Clear()

• 参数：无
• 返回值：无
• 作用：清空路由。

cppnet::HttpResp

HttpResp()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpResp 对象。

int Parse(const std::string &origin_resp)

• 参数：
  • origin_resp：原始的 HTTP 响应字符串。
• 返回值：int类型，可能表示解析是否成功，具体含义需结合实际情况判断。
• 作用：解析给定的原始 HTTP 响应。

HttpVersion &version()

• 参数：无
• 返回值：HttpVersion &，HTTP 版本对象的引用。
• 作用：获取 HTTP 响应的版本对象。

HttpHeader &header()

• 参数：无
• 返回值：HttpHeader &，HTTP 头部对象的引用。
• 作用：获取 HTTP 响应的头部对象。

std::string &body()

• 参数：无
• 返回值：std::string &，HTTP 响应体的引用。
• 作用：获取 HTTP 响应体。

HttpStatusCode &status_code()

• 参数：无
• 返回值：HttpStatusCode &，HTTP 状态码对象的引用。
• 作用：获取 HTTP 响应的状态码对象。

int Build(std::string &resp_str)

• 参数：
  • resp_str：用于存储构建后的 HTTP 响应字符串的引用。
• 返回值：int类型，可能表示构建是否成功，具体含义需结合实际情况判断。
• 作用：将 HTTP 响应构建为字符串。

void Clear()

• 参数：无
• 返回值：无
• 作用：清空 HTTP 响应的内容。

void NotFound()

• 参数：无
• 返回值：无
• 作用：设置 HTTP 响应为未找到的状态。

void Redirect(const std::string &location, bool forever = false)

• 参数：
  • location：重定向的目标位置。
  • forever：布尔类型，指示是否是永久重定向。
• 返回值：无
• 作用：设置 HTTP 响应为重定向状态。

void SuccessWithBinary(const std::string &body)

• 参数：
  • body：二进制形式的成功响应体内容。
• 返回值：无
• 作用：设置 HTTP 响应为成功状态，并带有二进制响应体。

void SuccessWithJson(const std::string &body)

• 参数：
  • body：JSON 格式的成功响应体内容。
• 返回值：无
• 作用：设置 HTTP 响应为成功状态，并带有 JSON 格式的响应体。

void Success(HttpHeader::ContentType content_type, const std::string &body = "")

• 参数：
  • content_type：HTTP 头部的内容类型。
  • body：成功响应体内容，默认为空字符串。
• 返回值：无
• 作用：设置 HTTP 响应为成功状态，并指定内容类型和响应体。

void Success()

• 参数：
  • 无
• 返回值：无
• 作用：设置 HTTP 响应为成功状态。

void BadRequest(const std::string &body = "")

• 参数：
  • body：错误请求的响应体内容，默认为空字符串。
• 返回值：无
• 作用：设置 HTTP 响应为错误请求状态，并带有响应体。

void InternalServerError(const std::string &body = "")

• 参数：
  • body：内部服务器错误的响应体内容，默认为空字符串。
• 返回值：无
• 作用：设置 HTTP 响应为内部服务器错误状态，并带有响应体。

void Json(HttpStatusCode status_code, const std::string &body)

• 参数：
  • status_code：HTTP 状态码。
  • body：JSON 格式的响应体内容。
• 返回值：无
• 作用：设置 HTTP 响应为带有特定状态码和 JSON 格式响应体的状态。

void Text(HttpStatusCode status_code, const std::string &body)

• 参数：
  • status_code：HTTP 状态码。
  • body：文本格式的响应体内容。
• 返回值：无
• 作用：设置 HTTP 响应为带有特定状态码和文本格式响应体的状态。

std::string err_msg()

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。 在 HttpResp 类中添加一个方法，用于设置 HTTP 响应的内容类型 如何在 HttpResp 类中处理错误情况？ 提供一个使用 HttpResp 类的示例代码

cppnet::HttpStatusCode

• 这是一个枚举类，定义了各种 HTTP 状态码，包括常见的如 OK（200）、BAD_REQUEST（400）、INTERNAL_SERVER_ERROR（500）等以及一个表示未知状态的 UNKNOWN（-1）。

cppnet::HttpStatusCodeUtil

static std::string ConvertToStr(const HttpStatusCode &code)

• 参数：
  • code：HttpStatusCode类型的 HTTP 状态码。
• 返回值：std::string类型，对应的 HTTP 状态码字符串。
• 作用：将给定的 HTTP 状态码转换为字符串表示。

static HttpStatusCode ConvertToCode(const std::string &code)

• 参数：
  • code：字符串类型的 HTTP 状态码表示。
• 返回值：HttpStatusCode类型，对应的 HTTP 状态码枚举值。
• 作用：将给定的字符串形式的 HTTP 状态码转换为枚举值。

static HttpStatusCode ConvertToCode(int code)

• 参数：
  • code：整数类型的 HTTP 状态码。
• 返回值：HttpStatusCode类型，对应的 HTTP 状态码枚举值。
• 作用：将给定的整数形式的 HTTP 状态码转换为枚举值。

cppnet::HttpFilter

• 这是一个抽象基类，用于定义 HTTP 过滤器的接口。
• 目前实现的过滤器包括：htto_host_filter,http_method_filter
  • http_host_filter：用于检查 HTTP 请求的 Host 头部是否匹配指定的主机名。
  • http_method_filter：用于检查 HTTP 请求的方法是否匹配指定的方法。

HttpFilter()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpFilter 对象。

~HttpFilter()

• 参数：无
• 返回值：无
• 作用：HttpFilter 类的虚析构函数。

bool IsMatchFilter(HttpReq &req)

• 参数：
  • req：Http 请求对象的引用。
• 返回值：bool类型，true 表示匹配过滤器，false 表示不匹配过滤器。
• 作用：检查给定的 Http 请求是否匹配该过滤器。

cppnet::HttpContext

HttpContext(HttpReq &req, HttpResp &resp, std::shared_ptr<Socket> &soc)

• 参数：
  • req：Http 请求对象的引用。
  • resp：Http 响应对象的引用。
  • soc：指向套接字的智能指针的引用。
• 返回值：无
• 作用：构造一个 HttpContext 对象，用于存储 Http 请求、响应和套接字信息。

Next()

• 参数：无
• 返回值：无
• 作用：设置继续执行的标志，在中间件中使用。

Abort()

• 参数：无
• 返回值：无
• 作用：设置停止执行的标志，在中间件中使用。

is_continue()

• 参数：无
• 返回值：bool类型，表示是否继续执行。
• 作用：获取当前的执行状态标志。

T Get(const std::string &key)

• 参数：
  • key：字符串类型，用于查找内联数据的键。
• 返回值：模板类型T的值，如果类型转换失败则返回默认值。
• 作用：根据给定的键获取内联数据。

void Set(const std::string &key, const T &value)

• 参数：
  • key：字符串类型，内联数据的键。
  • value：模板类型T的值，要设置的内联数据。
• 返回值：无
• 作用：设置内联数据。

req()

• 参数：无
• 返回值：HttpReq &，Http 请求对象的引用。
• 作用：获取 Http 请求对象。

resp()

• 参数：无
• 返回值：HttpResp &，Http 响应对象的引用。
• 作用：获取 Http 响应对象。

soc()

• 参数：无
• 返回值：Socket &，套接字对象的引用。
• 作用：获取套接字对象。

cppnet::HttpGroup

int GET(const std::string &path, HttpCallback callback, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • path：字符串类型，请求路径。
  • callback：函数指针类型，请求回调函数。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册 GET 请求的处理函数和过滤器。

int GET(const std::string &path, std::initializer_list<HttpCallback> callbacks, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • path：字符串类型，请求路径。
  • callbacks：初始化列表类型，包含多个请求回调函数。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册多个 GET 请求的处理函数和过滤器。

int POST(const std::string &path, HttpCallback callback, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • path：字符串类型，请求路径。
  • callback：函数指针类型，请求回调函数。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册 POST 请求的处理函数和过滤器。

int POST(const std::string &path, std::initializer_list<HttpCallback> callbacks, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • path：字符串类型，请求路径。
  • callbacks：初始化列表类型，包含多个请求回调函数。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册多个 POST 请求的处理函数和过滤器。

int RegisterHandler(const std::string &path, HttpCallback callback, const std::vector<std::shared_ptr<HttpFilter>> &filters = {}, bool is_exact_match = true)

• 参数：
  • path：字符串类型，请求路径。
  • callback：函数指针类型，请求回调函数。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
  • is_exact_match：布尔类型，是否精确匹配路径。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册通用请求的处理函数和过滤器，并指定匹配方式。

int RegisterHandler(const std::string &path, std::initializer_list<HttpCallback> callbacks, const std::vector<std::shared_ptr<HttpFilter>> &filters = {}, bool is_exact_match = true)

• 参数：
  • path：字符串类型，请求路径。
  • callbacks：初始化列表类型，包含多个请求回调函数。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
  • is_exact_match：布尔类型，是否精确匹配路径。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册多个通用请求的处理函数和过滤器，并指定匹配方式。

int Use(HttpCallback callback, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • callback：函数指针类型，中间件回调函数。
  • filters：包含HttpFilter智能指针的向量，中间件过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：注册中间件。

int StaticDir(const std::string &path, const std::string &dir_path, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • path：字符串类型，请求路径。
  • dir_path：字符串类型，静态目录路径。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：添加静态目录。

int StaticFile(const std::string &path, const std::string &file_path, const std::vector<std::shared_ptr<HttpFilter>> &filters = {})

• 参数：
  • path：字符串类型，请求路径。
  • file_path：字符串类型，静态文件路径。
  • filters：包含HttpFilter智能指针的向量，请求过滤器。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：添加静态文件。

HttpGroup Group(const std::string &route)

• 参数：
  • route：字符串类型，子路由路径。
• 返回值：HttpGroup类型，新的 HttpGroup 对象。
• 作用：创建一个新的 HttpGroup 对象，用于分组路由。

std::string err_msg()

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

std::shared_ptr<Logger> logger()

• 参数：无
• 返回值：指向日志对象的智能指针。
• 作用：获取日志对象。

void set_logger(std::shared_ptr<Logger> logger)

• 参数：
  • logger：指向日志对象的智能指针。
• 返回值：无
• 作用：设置日志对象。

cppnet::HttpServer

• 主要使用类,构建http 服务器

HttpServer()

• 参数：无
• 返回值：无
• 作用：构造一个 HttpServer 对象，继承自 HttpGroup。

int Init(const Address &addr)

• 参数：
  • addr：地址对象。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 Http 服务器。

int Run()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：运行 Http 服务器。

void Stop()

• 参数：无
• 返回值：无
• 作用：停止 Http 服务器。

TcpServer &server()

• 参数：无
• 返回值：TcpServer &，Tcp 服务器对象的引用。
• 作用：获取 Tcp 服务器对象。

void SetReadTimeout(unsigned timeout_sec, unsigned timeout_usec)

• 参数：
  • timeout_sec：秒数。
  • timeout_usec：微秒数。
• 返回值：无
• 作用：设置读取超时时间。

void SetWriteTimeout(unsigned timeout_sec, unsigned timeout_usec)

• 参数：
  • timeout_sec：秒数。
  • timeout_usec：微秒数。
• 返回值：无
• 作用：设置写入超时时间。

int InitSSL(const Address &addr, std::shared_ptr<SSLContext> ssl_context)

• 参数：
  • addr：地址对象。
  • ssl_context：指向 SSL 上下文的智能指针。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 HTTPS 服务器。
• 注意: 这个部分只有在 开启ssl才可用

cppnet::HttpVersion

• 这是一个枚举类，定义了不同的 HTTP 版本，包括 HTTP_1_0、HTTP_1_1、HTTP_2_0以及表示未知版本的 UNKNOWN。

cppnet::HttpVersionUtil

static std::string ConvertToStr(const HttpVersion &version)

• 参数：
  • version：HttpVersion类型的 HTTP 版本枚举值。
• 返回值：std::string类型，对应的 HTTP 版本字符串表示。
• 作用：将给定的 HTTP 版本枚举值转换为字符串表示。

static HttpVersion ConvertToVersion(const std::string &version)

• 参数：
  • version：字符串类型的 HTTP 版本表示。
• 返回值：HttpVersion类型，对应的 HTTP 版本枚举值。
• 作用：将给定的字符串形式的 HTTP 版本转换为枚举值。

cppnet::Logger

Level

• 这是一个枚举类，定义了不同的日志级别，包括 DEBUG、INFO、WARN、ERROR 和 FATAL。

Logger()

• 参数：无
• 返回值：无
• 作用：构造一个 Logger 对象。

virtual void Debug(const std::string &msg)

• 参数：
  • msg：要记录的调试信息字符串。
• 返回值：无
• 作用：记录调试级别的日志信息，默认实现为空。

virtual void Info(const std::string &msg)

• 参数：
  • msg：要记录的信息字符串。
• 返回值：无
• 作用：记录信息级别的日志信息，默认实现为空。

virtual void Warn(const std::string &msg)

• 参数：
  • msg：要记录的警告信息字符串。
• 返回值：无
• 作用：记录警告级别的日志信息，默认实现为空。

virtual void Error(const std::string &msg)

• 参数：
  • msg：要记录的错误信息字符串。
• 返回值：无
• 作用：记录错误级别的日志信息，默认实现为空。

virtual void Fatal(const std::string &msg)

• 参数：
  • msg：要记录的致命错误信息字符串。
• 返回值：无
• 作用：记录致命错误级别的日志信息，默认实现为空。

void set_level(Level level)

• 参数：
  • level：日志级别枚举值。
• 返回值：无
• 作用：设置日志记录的级别

子类

StdLogger

• 信息打印到标准输入输出

FileLogger

• 信息打印到文件中, 通过 Init 函数制定文件位置
• 经过测试性能约为每秒 150万 条日志,测试基准为ubuntu 4核16G SSD

MultiLogger

• 做个logger 作为init, 同时打听到多个logger中

cppnet::IOMultiplexingType

• 这是一个枚举类，定义了不同的 I/O 多路复用类型，包括 kEpoll（适用于 Linux）、kSelect（适用于 Windows）和 kQueue（适用于 Mac Unix）。

cppnet::IOMultiplexingBase

IOEvent

• 这是一个枚举类，定义了不同的 I/O 事件类型，包括 kIOEventRead（可读事件）、kIOEventLeave（离开事件）和 kIOEventError（错误事件）。

TriggerType

• 这是一个枚举类，定义了不同的触发类型，包括 kEdgeTrigger（边缘触发）和 kLevelTrigger（水平触发）。

virtual int Init()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 I/O 多路复用对象。

virtual int MonitorSoc(const Socket &fd)

• 参数：
  • fd：要监视的套接字文件描述符。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：将套接字添加到监视列表中。

virtual int RemoveSoc(const Socket &fd)

• 参数：
  • fd：要移除监视的套接字文件描述符。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：从监视列表中移除套接字。

virtual int Loop(NotifyCallBack callback)

• 参数：
  • callback：当事件发生时的回调函数。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：进入事件循环，等待并处理事件。

virtual void Close()

• 参数：无
• 返回值：无
• 作用：关闭 I/O 多路复用对象。

virtual void Stop()

• 参数：无
• 返回值：无
• 作用：停止事件循环。

inline std::string err_msg() const

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

inline void set_max_event_num(int num)

• 参数：
  • num：最大事件数量。
• 返回值：无
• 作用：设置最大事件数量。

inline void set_wait_timeout(int timeout)

• 参数：
  • timeout：等待超时时间。
• 返回值：无
• 作用：设置等待超时时间。

inline void set_trigger_type(TriggerType type)

• 参数：
  • type：触发类型枚举值。
• 返回值：无
• 作用：设置触发类型。

cppnet::TcpServer

Event

• 这是一个枚举类，定义了不同的事件类型，包括 kEventAccept（接受连接事件）、kEventRead（读取事件）、kEventLeave（离开事件）和 kEventError（错误事件）。

Mode

• 这是一个枚举类，定义了服务器的运行模式，包括 kIOMultiplexing（I/O 多路复用模式）、kMultiThread（多线程模式）和 kMixed（混合模式）。

TcpServer()

• 参数：无
• 返回值：无
• 作用：构造一个默认的 TcpServer 对象。

TcpServer(const std::string &ip, uint16_t port)

• 参数：
  • ip：服务器的 IP 地址字符串。
  • port：服务器的端口号。
• 返回值：无
• 作用：构造一个指定 IP 地址和端口号的 TcpServer 对象。

TcpServer(Address &addr)

• 参数：
  • addr：服务器的地址对象。
• 返回值：无
• 作用：构造一个使用给定地址对象的 TcpServer 对象。

virtual ~TcpServer()

• 参数：无
• 返回值：无
• 作用：TcpServer 类的析构函数。

int Init()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 TCP 服务器，包括创建文件描述符、绑定地址、设置非阻塞等操作。

void Stop()

• 参数：无
• 返回值：无
• 作用：停止 TCP 服务器，关闭文件描述符等资源。

void Clean()

• 参数：无
• 返回值：无
• 作用：清理所有资源。

void Register(EventCallBack cb)

• 参数：
  • cb：事件回调函数。
• 返回值：无
• 作用：注册事件回调函数，当特定事件发生时调用。

int EventLoop()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：进入事件循环，等待并处理各种事件。

int RemoveSoc(const Socket &fd)

• 参数：
  • fd：要移除的套接字文件描述符。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：从事件监听中移除指定的套接字，但不关闭它。

int AddSoc(const Socket &fd)

• 参数：
  • fd：要添加的套接字文件描述符。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：将指定的套接字添加到事件监听中。

int WakeUp()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：唤醒服务器，在停止后可选地用于退出。

inline void set_mode(Mode mode)

• 参数：
  • mode：服务器的运行模式枚举值。
• 返回值：无
• 作用：设置服务器的运行模式。

inline void set_max_connect_queue(int max_connect_queue)

• 参数：
  • max_connect_queue：最大连接队列长度。
• 返回值：无
• 作用：设置服务器的最大连接队列长度。

inline void set_addr(const Address &addr)

• 参数：
  • addr：服务器的地址对象。
• 返回值：无
• 作用：设置服务器的地址。

inline Mode mode() const

• 参数：无
• 返回值：Mode类型，服务器的运行模式枚举值。
• 作用：获取服务器的运行模式。

inline Address addr() const

• 参数：无
• 返回值：Address类型，服务器的地址对象。
• 作用：获取服务器的地址。

inline std::string err_msg() const

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

inline std::shared_ptr<IOMultiplexingBase> io_multiplexing()

• 参数：无
• 返回值：指向 IOMultiplexingBase 的智能指针，I/O 多路复用对象。
• 作用：获取服务器的 I/O 多路复用对象。

inline std::shared_ptr<ThreadPool> thread_pool()

• 参数：无
• 返回值：指向 ThreadPool 的智能指针，线程池对象。
• 作用：获取服务器的线程池对象。

Socket CreateSocket()

• 参数：无
• 返回值：Socket类型，创建的套接字文件描述符。
• 作用：创建服务器套接字。

int InitMode()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：根据服务器的运行模式进行初始化。

void HandleAccept()

• 参数：无
• 返回值：无
• 作用：处理接受连接事件。

void HandleRead(int fd)

• 参数：
  • fd：套接字文件描述符。
• 返回值：无
• 作用：处理读取事件。

void HandleLeave(int fd)

• 参数：
  • fd：套接字文件描述符。
• 返回值：无
• 作用：处理离开事件。

void HandleError(int fd)

• 参数：
  • fd：套接字文件描述符。
• 返回值：无
• 作用：处理错误事件。

cppnet::Address

Address()

• 参数：无
• 返回值：无
• 作用：构造一个默认的 Address 对象。

Address(const std::string &ip, uint16_t port)

• 参数：
  • ip：IP 地址字符串。
  • port：端口号。
• 返回值：无
• 作用：构造一个指定 IP 地址和端口号的 Address 对象。

int Init(const std::string &ip, uint16_t port)

• 参数：
  • ip：IP 地址字符串。
  • port：端口号。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：使用给定的 IP 地址和端口号初始化 Address 对象。

int InitWithDomain(const std::string &domain, uint16_t port)

• 参数：
  • domain：域名字符串。
  • port：端口号。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：使用给定的域名和端口号初始化 Address 对象。

void GetIPAndPort(std::string &ip, uint16_t &port) const

• 参数：
  • ip：用于存储 IP 地址的字符串引用。
  • port：用于存储端口号的变量引用。
• 返回值：无
• 作用：从 Address 对象中获取 IP 地址和端口号。

std::string ToString() const

• 参数：无
• 返回值：std::string类型，地址的字符串表示。
• 作用：将 Address 对象转换为字符串表示。

sockaddr_in *GetAddr()

• 参数：无
• 返回值：指向sockaddr_in结构体的指针。
• 作用：获取底层的sockaddr_in结构体指针。

sockaddr *GetSockAddr()

• 参数：无
• 返回值：指向sockaddr结构体的指针。
• 作用：获取底层的sockaddr结构体指针。

static socklen_t *GetAddrLen()

• 参数：无
• 返回值：指向socklen_t类型的指针。
• 作用：获取地址长度的指针，可能用于某些系统调用。

static int GetPeerAddr(int fd, Address &addr)

• 参数：
  • fd：套接字文件描述符。
  • addr：用于存储对等方地址的 Address 对象引用。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：获取指定套接字的对等方地址，并存储在addr中。

cppnet::Socket

Status

• 这是一个枚举类，定义了套接字的不同状态，包括 kUninit（未初始化）、kInit（已初始化）和 kClosed（已关闭）。

Socket()

• 参数：无
• 返回值：无
• 作用：构造一个默认的 Socket 对象。

Socket(int fd)

• 参数：
  • fd：套接字文件描述符。
• 返回值：无
• 作用：构造一个使用给定文件描述符的 Socket 对象。

int Init()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化套接字。

int InitUdp()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 UDP 套接字。

int Connect(Address &addr)

• 参数：
  • addr：服务器地址对象。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：尝试连接到服务器。

int Bind(Address &addr)

• 参数：
  • addr：服务器地址对象。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：绑定套接字到指定地址。

Socket Accept(Address &addr)

• 参数：
  • addr：服务器地址对象。
• 返回值：Socket类型，新接受的套接字对象。
• 作用：接受连接并返回新的套接字对象。

int Listen(int max_connect_queue)

• 参数：
  • max_connect_queue：最大连接队列长度。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：监听套接字上的连接请求。

int Close()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：关闭套接字。

int Read(std::string &buf, size_t len, bool complete = false)

• 参数：
  • buf：用于存储读取数据的字符串引用。
  • len：要读取的字节长度。
  • complete：如果为真，则必须读取 len 个字节的数据。
• 返回值：int类型，实际读取的字节长度。
• 作用：从套接字读取数据到字符串中。

int Read(void *buf, size_t len, bool complete = false)

• 参数：
  • buf：用于存储读取数据的缓冲区指针。
  • len：要读取的字节长度。
  • complete：如果为真，则必须读取 len 个字节的数据。
• 返回值：int类型，实际读取的字节长度。
• 作用：从套接字读取数据到缓冲区中。

int ReadUntil(std::string &buf, const std::string &delim)

• 参数：
  • buf：用于存储读取数据的字符串引用。
  • delim：分隔符字符串。
• 返回值：int类型，实际读取的字节长度。
• 作用：从套接字读取数据直到遇到分隔符（包括分隔符）。

int ReadPeek(std::string &buf, size_t len)

• 参数：
  • buf：用于存储读取数据的字符串引用。
  • len：要读取的字节长度。
• 返回值：int类型，实际读取的字节长度。
• 作用：从套接字读取数据但不从套接字中移除数据。

int ReadUdp(std::string &buf, size_t len, Address &addr)

• 参数：
  • buf：用于存储读取数据的字符串引用。
  • len：要读取的字节长度。
  • addr：用于存储 UDP 来源地址的对象引用。
• 返回值：int类型，实际读取的字节长度。
• 作用：从 UDP 套接字读取数据并获取来源地址。

int ReadUdp(void *buf, size_t len, Address &addr)

• 参数：
  • buf：用于存储读取数据的缓冲区指针。
  • len：要读取的字节长度。
  • addr：用于存储 UDP 来源地址的对象引用。
• 返回值：int类型，实际读取的字节长度。
• 作用：从 UDP 套接字读取数据并获取来源地址。

int Write(const std::string &buf)

• 参数：
  • buf：要写入的数据字符串。
• 返回值：int类型，实际写入的字节长度。
• 作用：将字符串数据写入套接字。

int Write(const void *buf, size_t len)

• 参数：
  • buf：要写入的数据缓冲区指针。
  • len：要写入的字节长度。
• 返回值：int类型，实际写入的字节长度。
• 作用：将缓冲区中的数据写入套接字。

int WriteUdp(const std::string &buf, Address &addr)

• 参数：
  • buf：要写入的数据字符串。
  • addr：UDP 目标地址对象。
• 返回值：int类型，实际写入的字节长度。
• 作用：将字符串数据写入 UDP 套接字并指定目标地址。

int WriteUdp(const void *buf, size_t len, Address &addr)

• 参数：
  • buf：要写入的数据缓冲区指针。
  • len：要写入的字节长度。
  • addr：UDP 目标地址对象。
• 返回值：int类型，实际写入的字节长度。
• 作用：将缓冲区中的数据写入 UDP 套接字并指定目标地址。

int SetNoBlock() const

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：设置套接字为非阻塞模式。

int SetBlock() const

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：设置套接字为阻塞模式。

int SetReuseAddr() const

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：设置套接字可重用地址。

int SetReadTimeout(int timeout_sec, int timeout_usec) const

• 参数：
  • timeout_sec：超时时间的秒数。
  • timeout_usec：超时时间的微秒数。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：设置套接字的读取超时时间。

int SetWriteTimeout(int timeout_sec, int timeout_usec) const

• 参数：
  • timeout_sec：超时时间的秒数。
  • timeout_usec：超时时间的微秒数。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：设置套接字的写入超时时间。

int SetSockOpt(int level, int optname, const void *optval, size_t optlen) const

• 参数：
  • level：套接字选项级别。
  • optname：套接字选项名称。
  • optval：套接字选项值的指针。
  • optlen：套接字选项值的长度。
• 返回值：int类型，0 表示成功，其他表示失败。
• 作用：设置套接字选项。

int GetAddr(Address &addr) const

• 参数：
  • addr：用于存储套接字地址的对象引用。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：获取套接字的地址并存储在给定的地址对象中。

Address GetAddr() const

• 参数：无
• 返回值：Address类型，套接字的地址对象。
• 作用：获取套接字的地址对象。

static inline std::string err_msg()

• 参数：无
• 返回值：std::string类型，系统错误消息。
• 作用：获取系统错误消息字符串。

static inline int err_no()

• 参数：无
• 返回值：int类型，系统错误编号。
• 作用：获取系统错误编号。

inline int fd() const

• 参数：无
• 返回值：int类型，套接字文件描述符。
• 作用：获取套接字的文件描述符。

inline Status status() const

• 参数：无
• 返回值：Status类型，套接字的状态枚举值。
• 作用：获取套接字的状态。

bool operator==(const Socket &rhs) const

• 参数：
  • rhs：另一个套接字对象。
• 返回值：bool类型，判断两个套接字是否相等。
• 作用：比较两个套接字对象是否相等。

protected inline int IORead(void *buf, size_t len, int flags = 0)

• 参数：
  • buf：用于存储读取数据的缓冲区指针。
  • len：要读取的字节长度。
  • flags：读取标志，默认为 0。
• 返回值：int类型，实际读取的字节长度。
• 作用：内部使用的读取函数，默认使用 ::recv 进行读取。

protected inline int IOWrite(const void *buf, size_t len, int flags = 0)

• 参数：
  • buf：要写入的数据缓冲区指针。
  • len：要写入的字节长度。
  • flags：写入标志，默认为 0。
• 返回值：int类型，实际写入的字节长度。
• 作用：内部使用的写入函数，默认使用 ::send 进行写入。

cppnet::SSLContext

SSLContext()

• 参数：无
• 返回值：无
• 作用：构造一个默认的 SSLContext 对象。

~SSLContext()

• 参数：无
• 返回值：无
• 作用：SSLContext 类的析构函数。

int Init(SSL_CTX *ctx)

• 参数：
  • ctx：OpenSSL 的 SSL 上下文指针。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 SSL 上下文。

int InitCli()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：初始化 SSL 客户端上下文。

int InitSvr(const std::string &cert_data, const std::string &key_data, const std::string &password = "")

• 参数：
  • cert_data：证书数据。
  • key_data：密钥数据。
  • password：密码，默认为空字符串。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：使用证书数据和密钥数据初始化 SSL 服务器上下文。

int InitSvrFile(const std::string &cert_path, const std::string &key_path, const std::string &password = "")

• 参数：
  • cert_path：证书文件路径。
  • key_path：密钥文件路径。
  • password：密码，默认为空字符串。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：使用证书文件路径和密钥文件路径初始化 SSL 服务器上下文。

std::shared_ptr<SSLSocket> CreateSSLSocket(const Socket &soc)

• 参数：
  • soc：普通套接字对象。
• 返回值：指向 SSLSocket 的智能指针。
• 作用：根据给定的普通套接字创建一个 SSL 套接字。

std::shared_ptr<SSLSocket> CreateSSLSocket()

• 参数：无
• 返回值：指向 SSLSocket 的智能指针。
• 作用：创建一个新的 SSL 套接字。

std::shared_ptr<SSLSocket> AcceptSSL(const Socket &soc)

• 参数：
  • soc：普通套接字对象。
• 返回值：指向 SSLSocket 的智能指针。
• 作用：接受一个连接并创建一个 SSL 套接字。

int Close()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：关闭 SSL 上下文。

const std::string &err_msg() const

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

cppnet::SSLSocket

SSLSocket(SSL *ssl, const Socket &soc)

• 参数：
  • ssl：OpenSSL 的 SSL 指针。
  • soc：普通套接字对象。
• 返回值：无
• 作用：构造一个 SSLSocket 对象，关联给定的 SSL 指针和套接字。

int Connect(Address &addr) override

• 参数：
  • addr：服务器地址对象。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：重写父类的连接方法，实现通过 SSL 连接服务器。

int Close() override

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：重写父类的关闭方法，关闭 SSL 和套接字。

int CloseSSL()

• 参数：无
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：关闭 SSL。

inline std::string err_msg() const

• 参数：无
• 返回值：std::string类型，错误消息。
• 作用：获取错误消息。

protected inline int IORead(void *buf, size_t len, int flag = 0) override

• 参数：
  • buf：用于存储读取数据的缓冲区指针。
  • len：要读取的字节长度。
  • flag：读取标志，默认为 0。
• 返回值：int类型，实际读取的字节长度。
• 作用：重写父类的读取方法，使用 SSL 进行读取。

protected inline int IOWrite(const void *buf, size_t len, int flag = 0) override

• 参数：
  • buf：要写入的数据缓冲区指针。
  • len：要写入的字节长度。
  • flag：写入标志，默认为 0。
• 返回值：int类型，实际写入的字节长度。
• 作用：重写父类的写入方法，使用 SSL 进行写入。

cppnet::File

static int Read(const std::string &path, std::string &data)

• 参数：
  • path：文件路径字符串。
  • data：用于存储读取到的文件数据的字符串引用。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：读取指定文件的内容并存储到 data 中。

static int Write(const std::string &path, const std::string &data)

• 参数：
  • path：文件路径字符串。
  • data：要写入文件的内容字符串。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：将 data 的内容写入指定文件。

static bool Exist(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：bool类型，文件存在返回 true，不存在返回 false。
• 作用：检查指定文件是否存在。注意：如果是目录则返回 false。

static std::string Suffix(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：std::string类型，文件后缀名（不包括点）。
• 作用：获取指定文件的后缀名。

static int Create(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：创建指定文件，如果路径中的目录不存在则自动创建。

static int Remove(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：删除指定文件。

static int Append(const std::string &path, const std::string &data)

• 参数：
  • path：文件路径字符串。
  • data：要追加到文件的内容字符串。
• 返回值：int类型，0 表示成功，-1 表示失败。
• 作用：将 data 的内容追加到指定文件末尾。

static bool CanWrite(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：bool类型，文件可写返回 true，不可写返回 false。
• 作用：检查指定文件是否具有写入权限。

static int LineCount(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：int类型，文件的行数。如果文件不存在则返回 0。
• 作用：获取指定文件的行数。

static bool IsDir(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：bool类型，是目录返回 true，不是目录返回 false。
• 作用：判断指定路径是否是一个目录。

static bool IsFile(const std::string &path)

• 参数：
  • path：文件路径字符串。
• 返回值：bool类型，是文件返回 true，不是文件返回 false。
• 作用：判断指定路径是否是一个文件。

cppnet::Host

static std::string GetLocalIP()

• 参数：无
• 返回值：std::string类型，本地 IP 地址。
• 作用：获取本地的 IP 地址。

static std::string GetLocalName()

• 参数：无
• 返回值：std::string类型，本地主机名。
• 作用：获取本地的主机名。

cppnet::StringUtil

static void Split(const std::string &origin_str, const std::string &delimiter, std::vector<std::string> &arr, bool keep_delimiter = false)

• 参数：
  • origin_str：原始字符串。
  • delimiter：分隔符。
  • arr：用于存储分割结果的字符串向量引用。
  • keep_delimiter：是否保留分隔符，默认为 false。
• 返回值：无
• 作用：将原始字符串按照给定的分隔符进行分割，并将结果存储在 arr 中。如果 keep_delimiter 为 true，则分割结果中会保留分隔符。

static std::string UrlDecode(const std::string &url)

• 参数：
  • url：要进行 URL 解码的字符串。
• 返回值：std::string类型，解码后的字符串。
• 作用：对给定的 URL 进行解码操作。

static std::string UrlEncode(const std::string &url)

• 参数：
  • url：要进行 URL 编码的字符串。
• 返回值：std::string类型，编码后的字符串。
• 作用：对给定的字符串进行 URL 编码操作。

static bool WildCardMatch(const std::string &pattern, const std::string &source);

• 参数：
  • pattern：通配符模式。
  • source：要匹配的字符串。
• 返回值：bool类型，匹配结果。
• 作用：使用通配符模式匹配给定的字符串。

cppnet::Version

static std::string GetStr()

• 参数：无
• 返回值：std::string类型，cppnet的版本号。
• 作用：获取cppnet库的版本号字符串。

static std::string GetDate()

• 参数：无
• 返回值：std::string类型，cppnet版本的发布日期，格式为“yyyy-mm-dd”。
• 作用：获取cppnet库版本的发布日期字符串，该日期为版本最后一次更新的时间。