libhv

libhv provides high-level C++ classes for various networking protocols and services. Available classes include:

• Core: EventLoop, Channel
• TCP: TcpServer, TcpClient
• UDP: UdpServer, UdpClient
• HTTP: HttpServer, HttpClient
• WebSocket: WebSocketServer, WebSocketClient
• Redis: RedisClient

libhv provides a wide range of low-level base utilities for system interaction, memory management, and string manipulation. Key headers include:

• hplatform.h: OS and architecture detection (e.g., OS_WIN, OS_UNIX, ARCH_X64).
• hdef.h: Common macros and helper functions (e.g., MAX, MIN, SAFE_FREE, IS_ALPHA).
• hbase.h: Memory management (hv_malloc, hv_calloc) and string utilities (hv_strcontains, hv_strstartswith, hv_mkdir_p).
• hstring.h: High-level string operations (split, replace, trim, to_string).
• htime.h: Time and date management (gettick_ms, datetime_now, cron_next_timeout).
• hthread.h & hmutex.h: Threading and synchronization primitives (hthread_create, hmutex_lock, hv::MutexLock, hv::RWLock).

libhv provides a set of C-style APIs for core networking and system tasks. Key modules include:

• hloop: Event loop management.
• hdns: Asynchronous DNS resolution.
• hbase: Basic utility functions.
• hlog: Logging capabilities.

The evpp module consists of the following header-only components for network programming:

• Buffer.h: Buffer management class.
• Channel.h: Channel class, encapsulates hio_t.
• Event.h: Event class, encapsulates hevent_t and htimer_t.
• EventLoop.h: Event loop class, encapsulates hloop_t.
• EventLoopThread.h: Event loop thread class, combines EventLoop and thread.
• EventLoopThreadPool.h: Event loop thread pool class, combines EventLoop and ThreadPool.
• TcpClient.h: TCP client class.
• TcpServer.h: TCP server class.
• UdpClient.h: UDP client class.
• UdpServer.h: UDP server class.

Redis support is disabled by default. To enable it, use the --with-redis flag during configuration or -DWITH_REDIS=ON when using CMake. The Redis C++ module is located in the redis/ directory.

### Using Makefile
```shell
./configure --with-redis
make

Using CMake

cmake -S . -B build -DWITH_EVPP=ON -DWITH_REDIS=ON -DBUILD_UNITTEST=ON
cmake --build build --target redis_protocol_test redis_async_client_test redis_client_test redis_batch_test redis_subscriber_test

The hdns module provides a native, non-blocking DNS resolver that runs entirely within the hloop event loop. Unlike the standard blocking getaddrinfo(), hdns uses non-blocking UDP to construct and parse DNS packets, ensuring that network latency or DNS unavailability does not stall the event loop. It supports IPv4 (A), IPv6 (AAAA), and both, and automatically handles system nameservers (e.g., /etc/resolv.conf on Unix) or falls back to 8.8.8.8.

#include "hloop.h"
#include "hdns.h"
#include "hsocket.h"

static void on_resolved(hdns_t* query, const hdns_result_t* result, void* userdata) {
    if (result->status == HDNS_STATUS_OK) {
        // Process result->addrs
    }
}

// Inside your loop logic:
hdns_resolve(loop, "example.com", on_resolved, userdata);

To create a WebSocket server, inherit from or use the WebSocketServer class (which extends HttpServer) and register a WebSocketService object. The WebSocketService struct allows you to define callbacks for connection lifecycle events and message handling.

Key components of WebSocketService:

• onopen: Callback triggered when a WebSocket connection is opened. Receives the WebSocketChannelPtr and the initial HttpRequestPtr.
• onmessage: Callback triggered when a message is received. Receives the WebSocketChannelPtr and the message content as a std::string.
• onclose: Callback triggered when a connection is closed. Receives the WebSocketChannelPtr.
• ping_interval: An integer setting the heartbeat interval.