web::http::tls::un Namespace Reference

Classes
class	EventSource

Typedefs
using	Client = web::http::client::Client< net::un::stream::tls::SocketClient >
using	Server = web::http::server::Server< net::un::stream::tls::SocketServer >

Functions
std::shared_ptr< web::http::client::tools::EventSource >	EventSource (const std::string &scheme, const net::un::SocketAddress &socketAddress, const std::string &path)
std::shared_ptr< web::http::client::tools::EventSource >	EventSource (const std::string &socketPath, const std::string &path)
std::shared_ptr< web::http::client::tools::EventSource >	EventSource (const std::string &url)

Typedef Documentation

Client

using web::http::tls::un::Client = typedef web::http::client::Client<net::un::stream::tls::SocketClient>

Definition at line 54 of file Client.h.

Server

using web::http::tls::un::Server = typedef web::http::server::Server<net::un::stream::tls::SocketServer>

Definition at line 55 of file Server.h.

Function Documentation

EventSource() [1/3]

std::shared_ptr< web::http::client::tools::EventSource > web::http::tls::un::EventSource ( const std::string &  scheme, const net::un::SocketAddress &  socketAddress, const std::string &  path  )

inline

Definition at line 72 of file EventSource.h.

                                                                                                         {
        std::shared_ptr<class EventSource> eventSource = std::make_shared<class EventSource>();
        eventSource->init(scheme, socketAddress, path);
 
        return eventSource;
    }

References web::http::client::tools::EventSourceT< Client >::init().

Referenced by EventSource(), and EventSource().

Here is the call graph for this function:

Here is the caller graph for this function:

EventSource() [2/3]

std::shared_ptr< web::http::client::tools::EventSource > web::http::tls::un::EventSource ( const std::string &  socketPath, const std::string &  path  )

inline

Definition at line 79 of file EventSource.h.

                                                                                                                        {
        return EventSource("http", net::un::SocketAddress(socketPath), path);
    }

References EventSource(), and net::un::SocketAddress::SocketAddress().

Here is the call graph for this function:

EventSource() [3/3]

std::shared_ptr< web::http::client::tools::EventSource > web::http::tls::un::EventSource ( const std::string &  url )

inline

Definition at line 83 of file EventSource.h.

                                                                                          {
        std::shared_ptr<web::http::client::tools::EventSource> eventSource;
 
        // One-liner regex: scheme + token (no '/' inside token) + optional /path + optional ?query + optional #fragment
        static const std::regex re(R"(^(?:un://)([^/?#]+)(/[^?#]*)?(\?[^#]*)?(?:#.*)?$)", std::regex::ECMAScript | std::regex::icase);
 
        auto pct_decode = [](std::string_view s) -> std::string {
            std::string out;
            out.reserve(s.size());
            for (size_t i = 0; i < s.size(); ++i) {
                if (s[i] == '%' && i + 2 < s.size()) {
                    auto hex = [](char c) -> int {
                        if (c >= '0' && c <= '9') {
                            return c - '0';
                        }
                        c |= 0x20;
                        if (c >= 'a' && c <= 'f') {
                            return 10 + (c - 'a');
                        }
                        return -1;
                    };
                    const int h = hex(s[i + 1]);
                    const int l = hex(s[i + 2]);
                    if (h >= 0 && l >= 0) {
                        out.push_back(static_cast<char>((h << 4) | l));
                        i += 2;
                        continue;
                    }
                }
                out.push_back(s[i]);
            }
            return out;
        };
 
        std::smatch match;
        if (std::regex_match(url, match, re)) {
            // Factory for Unix Domain Sockets (un://)
            // URL form: un://<pct-encoded-sockpath>[/http-path][?query][#fragment]
            //   [1] sockToken -> percent-encoded abs path ("/...") or abstract name ("@name")
            //   [2] path      -> optional HTTP path (defaults to "/")
            //   [3] query     -> optional
 
            const std::string sockToken = match[1].str();
            std::string socketPath = pct_decode(sockToken); // may start with '/' or '@'
 
            if ((!socketPath.empty() && (socketPath.front() == '/' || socketPath.front() == '@'))) {
                const std::string scheme = "un"; // fixed
                const std::string httpPath = match[2].matched ? match[2].str() : "/";
                const std::string query = match[3].matched ? match[3].str() : "";
 
                eventSource = EventSource(scheme, net::un::SocketAddress(socketPath), httpPath + query);
            } else {
                LOG(ERROR) << "UNIX socket must decode to absolute ('/..') or abstract ('@name'): " << sockToken;
            }
        } else {
            LOG(ERROR) << "EventSource unix-domain url not accepted: " << url;
        }
 
        return eventSource;
    }

References EventSource(), and net::un::SocketAddress::SocketAddress().

Here is the call graph for this function: