boostorg/beast

Features

• Asynchronous Network Frameworks - Provides a foundational asynchronous networking framework for composing non-blocking I/O operations and layered stream stacks.
• WebSocket Servers - Provides a high-performance server implementation for managing persistent, bidirectional communication channels with multiple clients.
• HTTP Server Implementations - Provides core logic for listening on network ports and handling high-performance HTTP request-response cycles.
• Asynchronous Network Buffers - Uses dynamic and sequence-based buffer concepts to handle incremental data parsing.
• Asynchronous Networking - Implements networking architectures that decouple transmission and reception to maximize concurrency using an asynchronous model.
• WebSocket Control Frame Handling - Manages low-level WebSocket protocol signals including ping, pong, and close messages.
• WebSocket Ping/Pong Keepalives - Monitors connection liveness by exchanging WebSocket ping, pong, and close frames.
• Connection Lifecycle Management - Manages the full lifecycle of network connections, from initiating outgoing requests to accepting incoming traffic.
• Websocket Connection Managers - Manages the lifecycle and state of persistent WebSocket connections using both synchronous and asynchronous interfaces.
• Client Handshake Initiations - Provides the mechanism for clients to send upgrade requests and validate server responses to establish WebSocket connections.
• HTTP/2 and WebSocket Servers - Serves both HTTP and WebSocket traffic on a single port to support multiple web standards.
• WebSocket Protocol Upgrades - Implements the core protocol logic required to upgrade HTTP connections and maintain bidirectional data transfer.
• C++ HTTP Server Libraries - Implements a low-level C++ library for building HTTP and WebSocket clients and servers using the Boost.Asio model.
• HTTP Header Serialization - Serializes HTTP headers, versions, and status identifiers into buffer sequences for efficient network transmission.
• HTTP Implementations - Provides low-level libraries for parsing, serializing, and managing HTTP/1.1 protocol traffic.
• HTTP Message Parsers - Parses raw wire format data from a network stream into structured HTTP message objects.
• Incremental Byte-Limited Parsing - Implements incremental HTTP data parsing with custom byte limits to ensure memory safety.
• Multi-Stage Message Parsing - Supports multi-stage parsing to retrieve HTTP headers before processing large message bodies.
• HTTP Message Serialization - Implements serialization of HTTP message objects into octet buffers for transmission over network streams.
• Layered Stream Composition - Nests multiple stream wrappers into a stack to combine capabilities like SSL and WebSockets over TCP.
• Message Serialization Protocols - Serializes wire-format messages to a stream using both synchronous and asynchronous I/O operations.
• Network Data Streaming - Implements the architectural mechanism for piping data chunks through network sockets as ordered byte sequences.
• I/O Buffering - Handles contiguous memory regions and buffer sequences to perform efficient scatter-gather I/O.
• WebSocket Message Exchanges - Enables the bidirectional transmission of text and binary frames over a persistent connection.
• WebSocket Clients - Provides a complete implementation for establishing and managing persistent bidirectional WebSocket connections.
• WebSocket Connection Management - Creates stateful streams that manage the WebSocket protocol over layered network transports.
• WebSocket Implementations - Provides a low-level implementation of the WebSocket protocol, including handshakes, control frames, and compression.
• WebSocket Message Readers - Reads incoming text and binary data from WebSocket connections as complete messages or incremental pieces.
• WebSocket Message Writers - Transmits text and binary data to a WebSocket connection as complete messages or fragmented frames.
• Asynchronous I/O Libraries - Implements non-blocking I/O operations that utilize completion handlers to notify the application upon finishing.
• Dynamic Network Buffer Management - Creates resizable buffer implementations that support owning ranges and contiguous memory.
• Secure Network Communication - Integrates SSL and TLS layers into network streams to provide encrypted data transmission.
• TLS Traffic Encryption - Integrates with TLS implementations to encrypt and decrypt network traffic across communication channels.
• Asynchronous Concurrency Scaling - Utilizes a consistent asynchronous model to efficiently handle thousands of concurrent network connections.
• Asynchronous WebSocket Operations - Executes WebSocket read, write, ping, and close operations using completion handlers or coroutines.
• Buffer Interface Standardization - Standardizes the interface for sequences of memory buffers to facilitate efficient transfer.
• Standardized HTTP Message Interfaces - Models HTTP requests and responses using configurable containers for headers and body content.
• Buffer Sequences - Provides standard interfaces for constant and mutable buffer sequences to enable efficient scatter-gather I/O.
• HTTP Request Handling - Provides utilities for parsing, routing, and managing incoming HTTP requests and their associated data payloads.
• HTTP Header Manipulators - Provides comprehensive utilities for constructing and modifying HTTP request and response headers.
• Body Storage Strategies - Allows flexible selection of storage strategies for message bodies, including strings, files, and memory buffers.
• Incremental Message Serialization - Implements incremental serialization to transmit HTTP headers before the message body is fully processed.
• HTTP Client Implementations - Provides custom logic for executing asynchronous network requests and parsing responses from remote servers.
• HTTP Request and Response Handlers - Provides a comprehensive toolset for processing raw HTTP request streams and managing response headers and bodies.
• Incremental Body Processing - Processes HTTP message bodies progressively using fixed-size buffers to minimize memory overhead.
• Full-Duplex Frame Protocols - Provides low-level primitives for framed, full-duplex communication over a single network connection.
• Message Parsing - Extracts headers and status codes from raw HTTP messages to manage connection state and payload sizes.
• Buffer Serialization Interfaces - Provides interfaces to wrap raw memory regions for serializing structured data types into buffers.
• Incremental Serialization - Produces a series of octet buffers from a message to regulate network flow and minimize memory spikes.
• Streamed Message Body Interfaces - Streams parsed body octets into dynamic buffers, custom containers, or files.
• Deferred Storage Strategies - Determines the message body type after parsing headers to optimize the chosen storage strategy.
• Asynchronous Task Composition - Combines multiple intermediate asynchronous actions into a single initiating function.
• Asynchronous Future APIs - Transforms asynchronous return types to support futures, fibers, or custom completion tokens.
• Bandwidth Management - Controls the speed of network read and write operations using configurable bandwidth policies.
• Chunked Transfer Encoding - Implements decoding of HTTP chunked transfer encoding for incremental delivery of response bodies.
• Chunked Transfer Controls - Enables manual control over the emission and reception of individual HTTP chunks and trailers.
• WebSocket Control Frame Notifications - Triggers registered callbacks whenever a WebSocket protocol control frame is received during a read operation.
• TLS Handshake Detection - Identifies the presence of TLS client hello messages within buffer sequences to detect encrypted connections.
• Timeout Managements - Prevents stale connections by enforcing time limits on asynchronous WebSocket operations.
• WebSocket Connection Modifications - Allows interception and modification of the URL and headers during the WebSocket connection upgrade phase.
• Connection Closures - Implements synchronous and asynchronous shutdown of the transport stream to close WebSocket connections.
• Customizable HTTP Parsers - Provides a customizable HTTP parser allowing users to define their own strategies for handling parsed elements.
• WebSocket Frame Compression - Supports network bandwidth reduction using the permessage-deflate extension for WebSocket frame compression.
• Buffered WebSocket Handshake Handling - Processes WebSocket upgrade requests using data already read into a buffer.
• Automatic HTTP Protocol Selectors - Provides low-level protocol primitives and selectors for building interoperable HTTP networking clients and servers.
• HTTP Response Body Limits - Provides configurable byte thresholds for incoming response bodies to protect against oversized payloads.
• Persistent Full-Duplex Connections - Manages reliable, ordered bidirectional byte-stream communication using synchronous and asynchronous I/O.
• Request Data Transmission - Implements capabilities for sending berbagai data types and body formats to remote servers over HTTP.
• HTTP Pipelining - Implements techniques for sending multiple HTTP requests over a single TCP connection without waiting for responses.
• Write Buffering - Implements internal memory queues to store outgoing network data until the socket is ready for transmission.
• Message Fragmentations - Prevents control frames from being blocked by splitting large outgoing messages into smaller frames.
• Transport Abstractions - Uses standard read and write stream interfaces to support custom transport layers through a unified abstraction.
• Completion Handler Optimizations - Implements non-type-erased callbacks at the call site to optimize compiler performance and memory allocation.
• Stream Timeout Management - Provides the ability to set time limits on synchronous and asynchronous operations to prevent connections from hanging.
• Synchronous Blocking I/O - Provides blocking read and write operations on streams that return results immediately.
• Lazy Buffer Transformations - Transforms buffer sequences using lazy evaluation to modify data without new allocations.
• Header-Body Structural Separation - Decouples the serialization and parsing of protocol headers from the payload to optimize storage decisions.
• Client Certificate Authentication - Verifies client certificates and private keys during the handshake to secure network access.
• SSL Private Key Management - Supports loading SSL private keys from files or memory with integrated password protection.
• SSL/TLS Connection Termination - Exchanges close notify messages to securely signal the termination of an encrypted stream.
• WebSocket Security - Wraps WebSocket streams in an SSL/TLS layer to provide encrypted bidirectional communication.
• Asynchronous Event Handlers - Executes non-type-erased completion handlers at the call site to optimize compiler performance.
• Async Operation Timeouts - Enforces maximum execution durations for asynchronous network operations, automatically closing connections upon timeout.
• Incremental Parsers - Processes HTTP wire format data in stages to retrieve headers before processing large payloads.
• Transfer Rate Throttling - Implements flow control by managing the byte-per-second transfer rate of send and receive streams.
• Template-Based Protocol Modeling - Provides low-level primitives for HTTP and WebSocket logic that adapt to different synchronous or asynchronous stream types.
• Response Body Buffering Control - Provides mechanisms to stream response bodies incrementally using caller-provided buffers to avoid full in-memory buffering.
• Staged Serialization - Separates serialization into stages to ensure headers are fully emitted before the message body is sent.
• Body Streaming - Retrieves data buffers incrementally during serialization to handle message bodies that exceed available memory limits.
• Policy-Based Body Handling - Uses user-defined types and algorithms to determine how message payloads are stored or streamed.
• File-Based Request Bodies - Allows HTTP message bodies to be read from or written directly to the local filesystem.
• Subprotocol Negotiation - Implements the process of negotiating and selecting supported application subprotocols during the WebSocket handshake.
• DevOps & Infrastructure - HTTP and WebSocket built on Asio
• Networking - HTTP and WebSocket library based on Asio.
• Networking Libraries - HTTP and WebSocket implementation built on Asio.
• Web and Networking - HTTP and WebSocket implementation built on Boost.Asio.

Star history