C++网络库

#include <assert.h>
#include <curl/curl.h>
#include <iostream>

using namespace std;

// 回调函数的原型
// 回调会被多次调用，每次调用都会传递一块数据;ptr指向传递的数据，该数据的大小为nmemb；size始终为1
// size * nmemb 是缓冲区的大小
// ptr 是缓冲区的地址
// userdata 是用户自定义的数据
size_t write_callback(char*, size_t, size_t, void*);

int main() {
    auto curl = curl_easy_init(); // 创建CURL句柄
    assert(curl);

    curl_easy_setopt(curl, CURLOPT_URL, "http://nginx.org"); // 设置请求URI
    // 避免代理设置为长连接 Proxy-Connection:close或者不使用代理
    curl_easy_setopt(curl, CURLOPT_PROXY, "");
    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);

    // 没有设置回调函数时，内部的默认回调，把得到的 HTTP 响应数据输出到标准流
    // c++11, 无捕获的 lambda 表达式可以显式转换成一个函数指针=>C使用
    curl_easy_setopt(
        curl, CURLOPT_WRITEFUNCTION, // 设置回调函数
        (decltype(&write_callback))  // decltype获取函数指针类型，显式转换
            [](char* ptr, size_t size, size_t nmemb, void* userdata) {
                cout << "size = " << size << "*" << nmemb << "=" << size * nmemb << endl; // 简单的处理
                return size * nmemb;                                                      // 返回接收的字节数
            });

    auto res = curl_easy_perform(curl); // 发送数据
    if (res != CURLE_OK) {              // 检查是否执行成功
        cout << curl_easy_strerror(res) << endl;
    }
    curl_easy_cleanup(curl); // 清理句柄相关的资源
    return 0;
}

#include <cpr/cpr.h>
#include <iostream>
#include <string>

int main(int argc, char** argv) {
    cpr::Response r = cpr::Get(cpr::Url{"https://api.github.com/repos/whoshuu/cpr/contributors"},
                               cpr::Authentication{"user", "pass", cpr::AuthMode::BASIC},
                               cpr::Parameters{{"anon", "true"}, {"key", "value"}});
    std::cout << "Status code: " << r.status_code << '\n';
    std::cout << "Header:\n";
    for (const std::pair<const std::basic_string<char>, std::basic_string<char>>& kv : r.header) {
        std::cout << '\t' << kv.first << ':' << kv.second << '\n';
    }
    std::cout << "Text: " << r.text << '\n';
    return 0;
}

#include "zmq.hpp"

#include <iostream>
#include <memory>
#include <string>
#include <thread>

using namespace std;

int main() {
    const auto thread_num = 1;               // 并发线程数z
    zmq::context_t context(thread_num);      // ZMQ环境变量
    auto make_sock = [&](auto mode) {        // 定义一个lambda表达式
        return zmq::socket_t(context, mode); // 创建ZMQ套接字
    };

    const auto addr = "ipc:///tmp/shm/zmq.sock"s; // 通信地址

    auto receiver = [=]() {              //  lambda表达式接收数据
        auto sock = make_sock(ZMQ_PULL); // 创建ZMQ套接字，拉数据

        sock.bind(addr);                  // 绑定套接字
        assert(sock.handle() != nullptr); // 断言套接字有效

        auto buf = make_unique<char[]>(1024);     // 创建一个1024字节的缓冲区
        zmq::mutable_buffer msg(buf.get(), 1024); // 创建ZMQ消息
        sock.recv(msg, zmq::recv_flags::none);    // 接收数据
        cout << (char*)msg.data() << endl;
    };

    auto sender = [=]() {                // lambda表达式发送数据
        auto sock = make_sock(ZMQ_PUSH); // 创建ZMQ套接字，推数据

        sock.connect(addr); // 连接到对端
        assert(sock.handle() != nullptr);

        string s = "hello zmq";
        sock.send(zmq::const_buffer{s.data(), s.length()}); // 发送消息
    };

    thread t1(sender);
    thread t2(receiver);

    t1.join();
    t2.join();
}

#include <iostream>
#include <thread>
#include "sockpp/tcp_acceptor.h"
#include "sockpp/version.h"

using namespace std;
// The thread function. 
void run_echo(sockpp::tcp_socket sock)
{
	ssize_t n;
	char buf[512];
	
	while ((n = sock.read(buf, sizeof(buf))) > 0)
		sock.write_n(buf, n);
	cout << "Connection closed from " << sock.peer_address() << endl;
}

int main(int argc, char* argv[])
{
	cout << "Sample TCP echo server for 'sockpp' "
		<< sockpp::SOCKPP_VERSION << '\n' << endl;

	in_port_t port = (argc > 1) ? atoi(argv[1]) : 12345;

	sockpp::socket_initializer sockInit;
	sockpp::tcp_acceptor acc(port);

	if (!acc) {
		cerr << "Error creating the acceptor: " << acc.last_error_str() << endl;
		return 1;
	}
	cout << "Awaiting connections on port " << port << "..." << endl;

	while (true) {
		sockpp::inet_address peer;

		// Accept a new client connection
		sockpp::tcp_socket sock = acc.accept(&peer);
		cout << "Received a connection request from " << peer << endl;

		if (!sock) {
			cerr << "Error accepting incoming connection: " 
				<< acc.last_error_str() << endl;
		}
		else {
			// Create a thread and transfer the new stream to it.
			thread thr(run_echo, std::move(sock));
			thr.detach();
		}
	}
	return 0;
}

#include <iostream>
#include <string>
#include "sockpp/tcp_connector.h"
#include "sockpp/version.h"

using namespace std;
using namespace std::chrono;

int main(int argc, char* argv[])
{
	cout << "Sample TCP echo client for 'sockpp' "
		<< sockpp::SOCKPP_VERSION << '\n' << endl;

	string host = (argc > 1) ? argv[1] : "localhost";
	in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;

	sockpp::socket_initializer sockInit;
	sockpp::tcp_connector conn({host, port});
	if (!conn) {
		cerr << "Error connecting to server at "
			<< sockpp::inet_address(host, port)
			<< "\n\t" << conn.last_error_str() << endl;
		return 1;
	}

	cout << "Created a connection from " << conn.address() << endl;

	// Set a timeout for the responses
	if (!conn.read_timeout(seconds(5))) {
	    cerr << "Error setting timeout on TCP stream: "
	            << conn.last_error_str() << endl;
	}

	string s, sret;
	while (getline(cin, s) && !s.empty()) {
		if (conn.write(s) != ssize_t(s.length())) {
			cerr << "Error writing to the TCP stream: "
				<< conn.last_error_str() << endl;
			break;
		}

		sret.resize(s.length());
		ssize_t n = conn.read_n(&sret[0], s.length());

		if (n != ssize_t(s.length())) {
			cerr << "Error reading from TCP stream: "
				<< conn.last_error_str() << endl;
			break;
		}
		cout << sret << endl;
	}
	return (!conn) ? 1 : 0;
}