• C++套接字库sockpp介绍

          sockpp是一个开源、简单、现代的C++套接字库，地址为：https://github.com/fpagliughi/sockpp，最新发布版本为0.8.1，license为BSD-3-Clause。目前支持Linux、Windows、Mac上的IPv4、IPv6和Unix域套接字。其它*nix和POSIX系统只需很少的修改或无需修改即可工作。
          1.套接字基类包装(wrap)系统套接字句柄，并维持其生命周期。当C++对象超出范围时，它会关闭底层套接字句柄。套接字对象通常是可移动的，但不可复制。可以使用 std::move()将套接字从一个作用域(或线程)传输到另一个作用域。
          2.库中的所有代码都位于sockpp C++命名空间内。
          3.TCP和其它"流"网络应用程序通常设置为服务器或客户端。接受器用于创建TCP/流服务器。它绑定一个地址并侦听已知端口以接受传入连接。 当连接被接受时，会创建一个新的流式套接字。该新套接字可以直接处理或移动到线程(或线程池)进行处理。
          相反，要创建TCP客户端，需要创建连接器对象并将其连接到已知地址(通常是主机和套接字)的服务器。连接后，套接字是一种流式套接字，可以直接用于读写。
          对于IPv4，sockpp::tcp_acceptor和sockpp::tcp_connector类分别用于创建服务器和客户端。它们使用sockpp::inet_address类来指定由32位主机地址和16位端口号组成的端点地址。
          sockpp::tcp_acceptor通常位于一个循环中接受新连接，并将它们传递给另一个进程、线程或线程池以与客户端交互。
          TCP客户端稍微简单一些，创建一个sockpp::tcp_connector对象并连接，然后可以直接读写数据。
          4.每个套接字类的默认构造函数不执行任何操作，只是将底层句柄设置为INVALID_SOCKET。它们不创建套接字对象。
          5.套接字对象不是线程安全的。想要有多个线程从套接字读取或写入套接字的应用程序应该使用某种形式的序列化，例如std::mutex来保护访问。套接字可以安全地从一个线程移动到(moved)另一个线程。这是服务器的一种常见模式，它使用一个线程接受传入连接，然后将新套接字传递给另一个线程或线程池进行处理。
          由于套接字无法复制，唯一的选择是将套接字移动到这样的函数。这是一种常见的模式，尤其是在客户端应用程序中，让一个线程从套接字读取数据，另一个线程向套接字写入数据。在这种情况下，底层套接字句柄可以被认为是线程安全的(一个读线程和一个写线程)。但即使在这种情况下，sockpp::socket对象仍然不是线程安全的，特别是由于缓存的错误值(cached error value)。写入线程可能会看到读取线程上发生的错误，反之亦然。
          这种情况的解决方案是使用socket::clone()方法来复制套接字。这将使用系统的dup()函数或类似的函数创建另一个带有套接字句柄的重复副本的套接字。这样做的另一个好处是套接字的每个副本都可以保持独立的生命周期。在两个对象超出范围之前，底层套接字不会关闭。

          在Windows和Linux上编译的sockpp的shell脚本如下：

    1. #! /bin/bash
    2.  
    3. if [ $# != 2 ]; then
    4.     echo "Error: requires two parameters: 1: windows or linux; 2: release or debug"
    5.     echo "For example: $0 windows debug"
    6.     exit -1
    7. fi
    8.  
    9. if [ $1 != "windows"  ] && [ $1 != "linux" ]; then
    10.     echo "Error: the first parameter can only be windows or linux"
    11.     exit -1
    12. fi
    13.  
    14. if [ $2 != "debug" ] && [ $2 != "release" ]; then
    15.     echo "Error: the second parameter can only be debug or release"
    16.     exit -1
    17. fi
    18.  
    19. if [ $1 == "windows" ] && [ $2 == "debug" ]; then
    20.     cmake \
    21.         -G"Visual Studio 17 2022" -A x64 \
    22.         -DCMAKE_BUILD_TYPE=Debug \
    23.         -DCMAKE_CONFIGURATION_TYPES=Debug \
    24.         -DSOCKPP_BUILD_SHARED=OFF \
    25.         -DSOCKPP_BUILD_STATIC=ON \
    26.         -DSOCKPP_BUILD_EXAMPLES=ON \
    27.         -DCMAKE_INSTALL_PREFIX=install/debug \
    28.         -Bbuild \
    29.         .
    30.     
    31.     cmake --build build/ --target install --config debug
    32. fi
    33.  
    34. if [ $1 == "windows" ] && [ $2 == "release" ]; then
    35.     cmake \
    36.         -G"Visual Studio 17 2022" -A x64 \
    37.         -DCMAKE_BUILD_TYPE=Release \
    38.         -DCMAKE_CONFIGURATION_TYPES=Release \
    39.         -DSOCKPP_BUILD_SHARED=OFF \
    40.         -DSOCKPP_BUILD_STATIC=ON \
    41.         -DSOCKPP_BUILD_EXAMPLES=ON \
    42.         -DCMAKE_INSTALL_PREFIX=install/release \
    43.         -Bbuild \
    44.         .
    45.  
    46.     cmake --build build/ --target install --config release
    47. fi
    48.  
    49. if [ $1 == "linux" ] && [ $2 == "debug" ]; then
    50.     cmake \
    51.         -DCMAKE_BUILD_TYPE=Debug \
    52.         -DSOCKPP_BUILD_SHARED=OFF \
    53.         -DSOCKPP_BUILD_STATIC=ON \
    54.         -DSOCKPP_BUILD_EXAMPLES=ON \
    55.         -DCMAKE_INSTALL_PREFIX=install/debug \
    56.         -Bbuild \
    57.         .
    58.     
    59.     cmake --build build/ --target install --config debug
    60. fi
    61.  
    62. if [ $1 == "linux" ] && [ $2 == "release" ]; then
    63.     cmake \
    64.         -DCMAKE_BUILD_TYPE=Release \
    65.         -DSOCKPP_BUILD_SHARED=OFF \
    66.         -DSOCKPP_BUILD_STATIC=ON \
    67.         -DSOCKPP_BUILD_EXAMPLES=ON \
    68.         -DCMAKE_INSTALL_PREFIX=install/release \
    69.         -Bbuild \
    70.         .
    71.  
    72.     cmake --build build/ --target install --config release
    73. fi
    74.  
    75. rc=$?
    76. if [[ ${rc} != 0 ]]; then
    77.     echo "Error: please check: ${rc}"
    78. 	exit ${rc}
    79. fi

          以下为IPv4的测试代码：

          1.客户端测试代码如下：

    1. int test_sockpp_client()
    2. {
    3.     sockpp::initialize();
    4.  
    5.     sockpp::tcp_connector conn({host, port});
    6. 	if (!conn) {
    7. 		std::cerr << "Error: connecting to server at: "
    8. 			<< sockpp::inet_address(host, port)
    9. 			<< ", message: " << conn.last_error_str() << std::endl;
    10. 		return -1;
    11. 	}
    12.  
    13.     std::cout << "created a connection from: " << conn.address() << std::endl;
    14. 	std::cout << "created a connection to " << conn.peer_address() << std::endl;
    15.  
    16.     // set a timeout for the responses
    17.     if (!conn.read_timeout(std::chrono::seconds(5))) {
    18.         std::cerr << "Error: setting timeout on TCP stream: " << conn.last_error_str() << std::endl;
    19.     }
    20.  
    21.     const std::vector addr{"csdn", "github", "gitlab"};
    22.     std::unique_ptr<unsigned char[]> buf(new unsigned char[len]);
    23.     int index{0};
    24.  
    25. 	std::atomic<bool> quit{ false };
    26. 	std::thread th([&quit] {
    27. 		std::this_thread::sleep_for(std::chrono::seconds(20));
    28. 		quit = true;
    29. 	});
    30.  
    31. 	while (true) {
    32. 		if (quit) break;
    33.  
    34.         auto ret = conn.write(addr[index]);
    35.         if (ret != addr[index].size()) {
    36.             std::cerr << "Error: writing to the TCP stream: " << conn.last_error_str() << std::endl;
    37.             break;
    38.         }
    39.  
    40. 		memset(buf.get(), 0, len);
    41.         ret = conn.read(buf.get(), len);
    42.         if (ret == -1) {
    43.             std::cerr << "Error: reading from TCP stream: " << conn.last_error_str() << std::endl;
    44.             break;
    45.         }
    46.  
    47.         std::cout << addr[index] << ": " << buf.get() << std::endl;
    48.  
    49.         if (++index == addr.size()) index = 0;
    50. 		std::this_thread::sleep_for(std::chrono::seconds(1));
    51. 	}
    52.  
    53. 	th.join();
    54.     return 0;
    55. }

          2.服务器端测试代码如下：

    1. int test_sockpp_server()
    2. {
    3.     sockpp::initialize();
    4.  
    5.     sockpp::tcp_acceptor acc(port);
    6. 	if (!acc) {
    7. 		std::cerr << "Error: creating the acceptor: " << acc.last_error_str() << std::endl;
    8. 		return -1;
    9. 	}
    10.  
    11. 	while (true) {
    12. 		sockpp::inet_address peer;
    13. 		// accept a new client connection
    14. 		sockpp::tcp_socket sock = acc.accept(&peer);
    15. 		std::cout << "received a connection request from: " << peer << std::endl;
    16. 		if (!sock) {
    17. 			std::cerr << "Error: accepting incoming connection: " << acc.last_error_str() << std::endl;
    18. 		}
    19. 		else {
    20. 			// create a thread and transfer the new stream to it
    21. 			std::thread th2(run_echo, std::move(sock));
    22. 			th2.detach();
    23. 		}
    24. 	}
    25.  
    26.     return 0;
    27. }

          3.辅助code如下所示：

    1. namespace {
    2.  
    3. constexpr char* host{"127.0.0.1"};
    4. constexpr in_port_t port{ 8888 };
    5. constexpr int len {64};
    6.  
    7. void run_echo(sockpp::tcp_socket sock)
    8. {
    9. 	std::cout << "thread id: " << std::this_thread::get_id() << std::endl;
    10.  
    11. 	std::map addr;
    12. 	addr["csdn"] = "https://blog.csdn.net/fengbingchun";
    13. 	addr["github"] = "https://github.com/fengbingchun";
    14.  
    15. 	std::unique_ptr<unsigned char[]> buf(new unsigned char[len]);
    16.  
    17. 	while (true) {
    18. 		memset(buf.get(), 0, len);
    19. 		auto ret = sock.read(buf.get(), len);
    20. 		if (ret == -1) {
    21. 			std::cerr << "Error: reading from TCP stream: " << sock.last_error_str() << std::endl;
    22.             break;
    23. 		}
    24.  
    25. 		auto it = addr.find(std::string((char*)buf.get()));
    26. 		if (it != addr.end()) {
    27. 			sock.write(it->second);
    28. 		}
    29. 		else
    30. 			sock.write("unkonwn");
    31. 	}
    32. }
    33.  
    34. } // namespace

          Windows上执行结果如下所示：模拟1个服务器端，3个客户端

          Linux上执行结果如下图所示：模拟1个服务器端，3个客户端

          GitHub：https://github.com/fengbingchun/OpenSSL_Test

  • 相关阅读:
    sox音频处理和ffmpeg评测
    【图像分类】2022-MPViT CVPR
    Python爬虫技巧：使用代理IP和User-Agent应对反爬虫机制
    第二十五篇 组件通信 - 间接
    60行自己动手写LockSupport是什么体验？
    浅谈本地缓存的几种方案选型
    悲观锁与乐观锁介绍，优缺点
    Java中使用Hutool的ExecutorBuilder实现自定义线程池
    SpringBoot简介
    想去银行测试？那这套题目你必须要会
  • 原文地址：https://blog.csdn.net/fengbingchun/article/details/134359922