Endpoints

The endpoint class represents a network endpoint: an IP address (IPv4 or IPv6) combined with a port number. Endpoints are used for connecting sockets and binding acceptors.

Code snippets assume:

#include <boost/corosio/endpoint.hpp>
#include <boost/corosio/ipv4_address.hpp>
#include <boost/corosio/ipv6_address.hpp>

namespace corosio = boost::corosio;

Overview

An endpoint combines an address and port:

// IPv4 endpoint
corosio::endpoint ep4(corosio::ipv4_address::loopback(), 8080);

// IPv6 endpoint
corosio::endpoint ep6(corosio::ipv6_address::loopback(), 8080);

// Port only (binds to all interfaces)
corosio::endpoint bind_ep(8080);

Construction

From IPv4 Address and Port

auto addr = corosio::ipv4_address::loopback();  // 127.0.0.1
corosio::endpoint ep(addr, 8080);

From IPv6 Address and Port

auto addr = corosio::ipv6_address::loopback();  // ::1
corosio::endpoint ep(addr, 8080);

From Port Only

corosio::endpoint ep(8080);  // IPv4 any address (0.0.0.0)

This binds to all network interfaces, useful for servers.

Default Construction

corosio::endpoint ep;  // IPv4 any address, port 0

Querying Address Type

if (ep.is_v4())
    std::cout << "IPv4 address\n";

if (ep.is_v6())
    std::cout << "IPv6 address\n";

Accessing Components

Port Number

std::uint16_t port = ep.port();  // Host byte order

IPv4 Address

if (ep.is_v4())
{
    corosio::ipv4_address addr = ep.v4_address();
    std::cout << addr.to_string() << "\n";
}

IPv6 Address

if (ep.is_v6())
{
    corosio::ipv6_address addr = ep.v6_address();
    std::cout << addr.to_string() << "\n";
}

Common Address Constants

Loopback

// IPv4 loopback: 127.0.0.1
auto v4_loop = corosio::ipv4_address::loopback();

// IPv6 loopback: ::1
auto v6_loop = corosio::ipv6_address::loopback();

Any Address

// IPv4 any: 0.0.0.0 (all interfaces)
auto v4_any = corosio::ipv4_address::any();

// IPv6 any: :: (all interfaces)
auto v6_any = corosio::ipv6_address::any();

Broadcast

// IPv4 broadcast: 255.255.255.255
auto v4_bcast = corosio::ipv4_address::broadcast();

Parsing Addresses

Parse addresses from strings. Parsing reports failure through an std::error_code out-parameter:

// IPv4
corosio::ipv4_address addr;
if (auto ec = corosio::parse_ipv4_address("192.168.1.1", addr); !ec)
{
    corosio::endpoint ep(addr, 8080);
}

// IPv6
corosio::ipv6_address addr6;
if (auto ec = corosio::parse_ipv6_address("2001:db8::1", addr6); !ec)
{
    corosio::endpoint ep(addr6, 8080);
}

You can also parse a full address:port string directly into an endpoint using parse_endpoint(), or the endpoint constructor that accepts a std::string_view:

corosio::endpoint ep;
if (auto ec = corosio::parse_endpoint("192.168.1.1:8080", ep); !ec)
{
    // Use ep...
}

Comparison

Endpoints support equality comparison:

corosio::endpoint ep1(corosio::ipv4_address::loopback(), 8080);
corosio::endpoint ep2(corosio::ipv4_address::loopback(), 8080);
corosio::endpoint ep3(corosio::ipv4_address::loopback(), 9090);

assert(ep1 == ep2);  // Same address and port
assert(ep1 != ep3);  // Different port

Usage with Sockets

Connecting

corosio::tcp_socket s(ioc);
s.open();

corosio::endpoint target(
    corosio::ipv4_address::loopback(), 8080);

auto [ec] = co_await s.connect(target);

Accepting

// Convenience constructor: open + SO_REUSEADDR + bind + listen
corosio::tcp_acceptor acc(ioc, corosio::endpoint(8080));  // bind to all interfaces

From Resolver Results

The resolver returns endpoints:

corosio::resolver r(ioc);
auto [ec, results] = co_await r.resolve("www.example.com", "80");

for (auto const& entry : results)
{
    corosio::endpoint ep = entry.get_endpoint();
    // Try connecting to ep...
}

Resolver entries implicitly convert to endpoints:

for (corosio::endpoint ep : results)
{
    auto [ec] = co_await s.connect(ep);
    if (!ec)
        break;
}

Internal Representation

The endpoint stores:

  • IPv4 address (always present, may be default)

  • IPv6 address (always present, may be default)

  • Port number (16-bit, host byte order)

  • Address type flag (is_v4)

Both address types are stored to avoid needing a union or variant. The is_v4 flag indicates which address is active.

Thread Safety

Endpoints are value types with no shared state. They are safe to copy and use from any thread.

Next Steps

Edit this Page