asio2 Documentation

You can inject logic before and after HTTP request processing by passing an object that implements before and after methods to the bind function.

• before(http::web_request& req, http::web_response& rep): Called before the handler. Return true to continue, false to abort.
• after(std::shared_ptr<asio2::http_session>& session_ptr, http::web_request& req, http::web_response& rep): Called after the handler.

Note: Some hooks may accept std::shared_ptr<asio2::http_session> while others do not, depending on the specific binding context.

struct aop_log
{
    bool before(http::web_request& req, http::web_response& rep)
    {
        printf("before %s\n", req.method_string().data());
        return true;
    }
    bool after(std::shared_ptr<asio2::http_session>& session_ptr, http::web_request& req, http::web_response& rep)
    {
        printf("after\n");
        return true;
    }
};

// Usage in bind
server.bind<http::verb::get>("/api/user/*", [](http::web_request& req, http::web_response& rep) {
    rep.fill_text("data");
}, aop_log{});

The asio2::http_client and asio2::https_client provide several ways to interact with web services:

1. Direct Download: download(url, filename) saves a file directly to disk.
2. Streaming Download: Use download(ssl_context, url, body_callback) to process chunks of data manually (e.g., writing to a file stream).
3. Execute Request: execute(url) or execute(host, port, request) performs a synchronous request and returns a response.
4. URL Utilities:
   • http::url_to_path(url)
   • http::url_to_query(url)
   • http::url_encode(string)
   • http::url_decode(string)

// Download file directly
asio2::https_client::download("https://example.com/file.exe", "file.exe");

// Execute request and get response
auto rep = asio2::http_client::execute("http://www.baidu.com/get_user?name=abc");
if (asio2::get_last_error()) {
    std::cout << asio2::last_error_msg() << std::endl;
} else {
    std::cout << rep << std::endl;
}

The asio2::rpc_server allows you to bind global functions, member functions, or lambdas to be called remotely.

Server Initialization: asio2::rpc_server server(init_recv_buffer_size, max_recv_buffer_size, thread_count);

• max_recv_buffer_size is used to prevent malicious packets; if a packet exceeds this, the client is automatically disconnected.

Binding Methods:

• Global functions: server.bind("name", func);
• Member functions (by reference): server.bind("name", &Class::method, instance);
• Member functions (by pointer): server.bind("name", &Class::method, &instance);
• Lambdas: server.bind("name", [](args...) { ... });

Function Signature for Session Access: If a function needs to know which client called it, the first parameter should be std::shared_ptr<asio2::rpc_session>& session_ptr.

int add(std::shared_ptr<asio2::rpc_session>& session_ptr, int a, int b)
{
	return a + b;
}

asio2::rpc_server server(
	512,  // initialize recv buffer size
	1024, // max recv buffer size
	4     // thread count
);

server.bind("add", add);
server.start("0.0.0.0", 8080);

To cross-compile OpenSSL for Arm (e.g., for Raspberry Pi 4), follow these steps to set up the GNU Arm Toolchain and configure the build.

1. Toolchain Setup

1. Download the arm gcc compiler (specifically gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz) from the Arm Developer website.
   • Note: Avoid packages containing none-linux as they are intended for kernels, not applications. Ensure the package supports -pthread.
2. Extract the toolchain to a directory (e.g., /usr/local/gcc-arm-...).
3. Add the toolchain bin directory to your PATH in /etc/profile: export PATH=$PATH:/usr/local/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin
4. Verify installation with arm-linux-gnueabihf-gcc -v.

2. OpenSSL Cross-Compilation

1. Navigate to the OpenSSL source directory.
2. Run the configuration command with the CROSS_COMPILE and CC flags. Use --api=0.9.8 to maintain compatibility with older, deprecated APIs.
3. Run make and make install.

Troubleshooting:

• If you encounter -m64 errors, edit the Makefile and remove all -m64 flags.
• When including OpenSSL headers in your C/C++ code, add #define OPENSSL_API_COMPAT 0x00908000L before the includes to ensure compatibility.

3. Compiling and Linking your Application

Once OpenSSL is cross-compiled, use the arm-specific compiler to build your project, linking against the static libraries (libssl.a and libcrypto.a).

# Configure OpenSSL for Arm
./config no-asm no-shared --api=0.9.8 --prefix=/opt/openssl --openssldir=/usr/local/ssl CROSS_COMPILE=arm-linux-gnueabihf- CC=gcc

# Build and Install
make
make install

# Example: Compiling a C++ application
arm-linux-gnueabihf-g++ -c -x c++ main.cpp -I /usr/local/include -I /opt/openssl/include -g2 -gdwarf-2 -o main.o -Wall -Wswitch -W"no-deprecated-declarations" -W"empty-body" -Wconversion -W"return-type" -W"parentheses" -W"no-format" -W"uninitialized" -W"unreachable-code" -W"unused-function" -W"unused-value" -W"unused-variable" -O3 -fno-strict-aliasing -fno-omit-frame-pointer -fthreadsafe-statics -fexceptions -frtti -std=c++17

# Example: Linking the application
arm-linux-gnueabihf-g++ -o main.out -Wl,--no-undefined -Wl,-L/opt/openssl/lib -Wl,-z,relro -Wl,-z,now -Wl,-z,noexecstack -pthread -lrt -ldl -Wl,-rpath=. main.o -lstdc++fs -l:libssl.a -l:libcrypto.a

Use asio2::http_server to create a web server. You can bind lifecycle callbacks for connection events and define route handlers using bind. Route handlers can be matched by path and HTTP verb (e.g., GET, POST).

Key lifecycle callbacks:

• bind_recv: Triggered when a request is received.
• bind_connect: Triggered when a client connects.
• bind_disconnect: Triggered when a client leaves.
• bind_start: Triggered when the server starts.
• bind_stop: Triggered when the server stops.
• bind_not_found: Triggered when a requested path does not match any route.

Route handlers can also accept AOP (Aspect Oriented Programming) objects to intercept requests/responses.

asio2::http_server server;

server.bind_recv([&](http::request& req, http::response& rep) {
    std::cout << req.path() << std::endl;
});

server.bind<http::verb::get>("/index.*", [](http::request& req, http::response& rep) {
    rep.fill_file("../index.html");
    rep.chunked(true);
});

server.start(host, port);

To create a TCP server, instantiate asio2::tcp_server and bind callbacks for receiving data, connection events, and disconnections. Use start() to begin listening.

Key callbacks:

• bind_recv: Triggered when data is received. Provides a std::shared_ptr<asio2::tcp_session> and the received data as a std::string_view.
• bind_connect: Triggered when a client connects. Allows configuring session properties like no_delay(true) or starting session-specific timers.
• bind_disconnect: Triggered when a client disconnects.

start() supports various packet framing (splitting) strategies:

• Single character: server.start("0.0.0.0", "8080", '\n')
• String delimiter: server.start("0.0.0.0", "8080", "\r\n")
• Fixed size: server.start("0.0.0.0", "8080", asio::transfer_exactly(100))
• Datagram mode (guaranteed whole packets): server.start("0.0.0.0", "8080", asio2::use_dgram)

asio2::tcp_server server;
server.bind_recv([&](std::shared_ptr<asio2::tcp_session> & session_ptr, std::string_view s)
{
	printf("recv : %zu %.*s\n", s.size(), (int)s.size(), s.data());
	session_ptr->async_send(s);
}).bind_connect([&](auto & session_ptr)
{
	session_ptr->no_delay(true);
    // session_ptr->start_timer(1, std::chrono::seconds(1), []() {});
}).bind_disconnect([&](auto & session_ptr)
{
	printf("client leave : %s %u %s %u\n",
		session_ptr->remote_address().c_str(), session_ptr->remote_port(),
		asio2::last_error_msg().c_str());
});
server.start("0.0.0.0", "8080");