NetworkUtilities Class Reference

#include <NetworkUtilities.h>

Collaboration diagram for NetworkUtilities:

Static Public Member Functions
static void	safeCloseDataChannel (std::shared_ptr< rtc::DataChannel > &dc)
static void	safeClosePeerConnection (std::shared_ptr< rtc::PeerConnection > &pc)
static void	safeCloseWebSocket (std::shared_ptr< rtc::WebSocket > &ws)
static std::string	runCommand (const std::string &cmd)
static std::string	httpGet (const std::wstring &host, const std::wstring &path)
static std::string	getLocalIPv4Address ()
static std::string	normalizeWsUrl (const std::string &hostOrUrl, unsigned short port)
static void	setupTLS ()
static std::string	normalizeWsUrl (const std::string &raw)
static std::string	startLocalTunnel (const std::string &subdomainBase, int port)
static void	stopLocalTunnel ()
static std::string	getLocalTunnelUrl ()

Static Private Member Functions
static void	closeHandleIf (HANDLE &h)
static void	createKillJobIfNeeded ()
static void	assignToJob (HANDLE process)
static std::string	lastErrorToString (DWORD err)

Static Private Attributes
static std::atomic< bool >	running {false}
static std::string	localTunnelUrl
static std::mutex	urlMutex
static std::condition_variable	urlCv
static HANDLE	ltProc = nullptr
static HANDLE	ltThread = nullptr
static HANDLE	ltStdoutRd = nullptr
static HANDLE	ltStdoutWr = nullptr
static HANDLE	ltStdinRd = nullptr
static HANDLE	ltStdinWr = nullptr
static HANDLE	ltJob = nullptr

Detailed Description

Definition at line 27 of file NetworkUtilities.h.

Member Function Documentation

assignToJob()

static void NetworkUtilities::assignToJob ( HANDLE process )

inlinestaticprivate

Definition at line 408 of file NetworkUtilities.h.

    {
        createKillJobIfNeeded();
        if (ltJob)
            AssignProcessToJobObject(ltJob, process);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

closeHandleIf()

static void NetworkUtilities::closeHandleIf ( HANDLE & h )

inlinestaticprivate

Definition at line 388 of file NetworkUtilities.h.

    {
        if (h)
        {
            CloseHandle(h);
            h = nullptr;
        }
    }

Here is the caller graph for this function:

createKillJobIfNeeded()

static void NetworkUtilities::createKillJobIfNeeded ( )

inlinestaticprivate

Definition at line 397 of file NetworkUtilities.h.

    {
        if (ltJob)
            return;
        ltJob = CreateJobObjectA(nullptr, nullptr);
        if (!ltJob)
            return;
        JOBOBJECT_EXTENDED_LIMIT_INFORMATION info{};
        info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
        SetInformationJobObject(ltJob, JobObjectExtendedLimitInformation, &info, sizeof(info));
    }

Here is the caller graph for this function:

getLocalIPv4Address()

static std::string NetworkUtilities::getLocalIPv4Address ( )

inlinestatic

Definition at line 158 of file NetworkUtilities.h.

    {
        WSADATA wsaData;
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        {
            throw std::runtime_error("WSAStartup failed");
        }
 
        // Create a UDP socket (does not actually send packets)
        SOCKET sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (sock == INVALID_SOCKET)
        {
            WSACleanup();
            throw std::runtime_error("socket creation failed");
        }
 
        sockaddr_in remote{};
        remote.sin_family = AF_INET;
        remote.sin_port = htons(53);                     // DNS port
        inet_pton(AF_INET, "8.8.8.8", &remote.sin_addr); // Google DNS
 
        // Connect sets the default route for this socket
        if (connect(sock, reinterpret_cast<sockaddr*>(&remote), sizeof(remote)) != 0)
        {
            closesocket(sock);
            WSACleanup();
            throw std::runtime_error("connect failed");
        }
 
        sockaddr_in local{};
        int len = sizeof(local);
        if (getsockname(sock, reinterpret_cast<sockaddr*>(&local), &len) != 0)
        {
            closesocket(sock);
            WSACleanup();
            throw std::runtime_error("getsockname failed");
        }
 
        char ipStr[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &local.sin_addr, ipStr, sizeof(ipStr));
 
        closesocket(sock);
        WSACleanup();
 
        return std::string(ipStr);
    }

Here is the caller graph for this function:

getLocalTunnelUrl()

static std::string NetworkUtilities::getLocalTunnelUrl ( )

inlinestatic

Definition at line 703 of file NetworkUtilities.h.

    {
        std::lock_guard<std::mutex> lk(urlMutex);
        return localTunnelUrl;
    }

Here is the caller graph for this function:

httpGet()

static std::string NetworkUtilities::httpGet ( const std::wstring & host, const std::wstring & path )

inlinestatic

Definition at line 98 of file NetworkUtilities.h.

    {
        std::string result;
 
        HINTERNET hSession = WinHttpOpen(L"RunicVTT/1.0",
                                         WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                                         WINHTTP_NO_PROXY_NAME,
                                         WINHTTP_NO_PROXY_BYPASS, 0);
 
        if (hSession)
        {
            HINTERNET hConnect = WinHttpConnect(hSession, host.c_str(),
                                                INTERNET_DEFAULT_HTTPS_PORT, 0);
 
            if (hConnect)
            {
                HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", path.c_str(),
                                                        NULL, WINHTTP_NO_REFERER,
                                                        WINHTTP_DEFAULT_ACCEPT_TYPES,
                                                        WINHTTP_FLAG_SECURE);
 
                if (hRequest)
                {
                    BOOL bResults = WinHttpSendRequest(hRequest,
                                                       WINHTTP_NO_ADDITIONAL_HEADERS, 0,
                                                       WINHTTP_NO_REQUEST_DATA, 0,
                                                       0, 0);
 
                    if (bResults)
                        bResults = WinHttpReceiveResponse(hRequest, NULL);
 
                    if (bResults)
                    {
                        DWORD dwSize = 0;
                        do
                        {
                            DWORD dwDownloaded = 0;
                            if (!WinHttpQueryDataAvailable(hRequest, &dwSize))
                                break;
 
                            if (!dwSize)
                                break;
 
                            std::string buffer(dwSize, 0);
                            if (!WinHttpReadData(hRequest, buffer.data(), dwSize, &dwDownloaded))
                                break;
 
                            result.append(buffer.c_str(), dwDownloaded);
 
                        } while (dwSize > 0);
                    }
                    WinHttpCloseHandle(hRequest);
                }
                WinHttpCloseHandle(hConnect);
            }
            WinHttpCloseHandle(hSession);
        }
        return result;
    }

Here is the caller graph for this function:

lastErrorToString()

static std::string NetworkUtilities::lastErrorToString ( DWORD err )

inlinestaticprivate

Definition at line 415 of file NetworkUtilities.h.

    {
        LPVOID msg = nullptr;
        DWORD n = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                 nullptr, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&msg, 0, nullptr);
        std::string s;
        if (n && msg)
        {
            s.assign((LPSTR)msg, n);
            LocalFree(msg);
        }
        return s;
    }

Here is the caller graph for this function:

normalizeWsUrl() [1/2]

static std::string NetworkUtilities::normalizeWsUrl ( const std::string & hostOrUrl, unsigned short port )

inlinestatic

Definition at line 206 of file NetworkUtilities.h.

    {
        auto starts = [](const std::string& s, const char* p)
        { return s.rfind(p, 0) == 0; };
 
        if (starts(hostOrUrl, "wss://") || starts(hostOrUrl, "ws://"))
            return hostOrUrl;
        if (starts(hostOrUrl, "https://"))
        {
            auto u = hostOrUrl;
            u.replace(0, 8, "wss://");
            return u;
        }
        if (starts(hostOrUrl, "http://"))
        {
            auto u = hostOrUrl;
            u.replace(0, 7, "ws://");
            return u;
        }
 
        // No scheme given:
        if (hostOrUrl.find(".loca.lt") != std::string::npos)
        {
            // LocalTunnel public endpoint → secure, no port
            return "wss://" + hostOrUrl;
        }
 
        // LAN / plain host → need explicit port
        return "ws://" + hostOrUrl + ":" + std::to_string(port);
    }

Here is the caller graph for this function:

normalizeWsUrl() [2/2]

static std::string NetworkUtilities::normalizeWsUrl ( const std::string & raw )

inlinestatic

Definition at line 251 of file NetworkUtilities.h.

    {
        auto starts = [&](const char* p)
        { return raw.rfind(p, 0) == 0; };
        if (starts("https://"))
            return "wss://" + raw.substr(8);
        if (starts("http://"))
            return "ws://" + raw.substr(7);
        // if already ws:// or wss:// or a bare host (leave as caller wishes)
        return raw;
    }

runCommand()

static std::string NetworkUtilities::runCommand ( const std::string & cmd )

inlinestatic

Definition at line 84 of file NetworkUtilities.h.

    {
        std::array<char, 128> buffer;
        std::string result;
        std::unique_ptr<FILE, decltype(&_pclose)> pipe(_popen(cmd.c_str(), "r"), _pclose);
        if (!pipe)
            throw std::runtime_error("popen() failed!");
        while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
        {
            result += buffer.data();
        }
        return result;
    }

safeCloseDataChannel()

static void NetworkUtilities::safeCloseDataChannel ( std::shared_ptr< rtc::DataChannel > & dc )

inlinestatic

Definition at line 31 of file NetworkUtilities.h.

                                                                        {
        if (!dc) return;
        try {
            dc->onOpen(nullptr);
            dc->onMessage(nullptr);
            dc->onBufferedAmountLow(nullptr);
            dc->onClosed(nullptr);
            dc->onError(nullptr);
            dc->close();
        } catch (const std::exception& e) {
            Logger::instance().log("main", Logger::Level::Error, std::string("[DC close] ") + e.what());
            //pushStatusToast("DataChannel close error", ImGuiToaster::Level::Error, 5.0f);
        } catch (...) {
            Logger::instance().log("main", Logger::Level::Error, "[DC close] unknown");
            //pushStatusToast("DataChannel close error (unknown)", ImGuiToaster::Level::Error, 5.0f);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

safeClosePeerConnection()

static void NetworkUtilities::safeClosePeerConnection ( std::shared_ptr< rtc::PeerConnection > & pc )

inlinestatic

Definition at line 49 of file NetworkUtilities.h.

                                                                              {
        if (!pc) return;
        try {
            pc->onStateChange(nullptr);
            pc->onGatheringStateChange(nullptr);
            pc->onLocalDescription(nullptr);
            pc->onDataChannel(nullptr);
            pc->onTrack(nullptr);
            pc->close();
        } catch (const std::exception& e) {
            Logger::instance().log("main", Logger::Level::Error, std::string("[PC close] ") + e.what());
            //pushStatusToast("PeerConnection close error", ImGuiToaster::Level::Error, 5.0f);
        } catch (...) {
            Logger::instance().log("main", Logger::Level::Error, "[PC close] unknown");
            //pushStatusToast("PeerConnection close error (unknown)", ImGuiToaster::Level::Error, 5.0f);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

safeCloseWebSocket()

static void NetworkUtilities::safeCloseWebSocket ( std::shared_ptr< rtc::WebSocket > & ws )

inlinestatic

Definition at line 67 of file NetworkUtilities.h.

                                                                    {
        if (!ws) return;
        try {
            ws->onOpen(nullptr);
            ws->onMessage(nullptr);
            ws->onClosed(nullptr);
            ws->onError(nullptr);
            ws->close();
        } catch (const std::exception& e) {
            Logger::instance().log("main", Logger::Level::Error, std::string("[WS close] ") + e.what());
            //pushStatusToast("WebSocket close error", ImGuiToaster::Level::Error, 5.0f);
        } catch (...) {
            Logger::instance().log("main", Logger::Level::Error, "[WS close] unknown");
            //pushStatusToast("WebSocket close error (unknown)", ImGuiToaster::Level::Error, 5.0f);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setupTLS()

static void NetworkUtilities::setupTLS ( )

inlinestatic

Definition at line 237 of file NetworkUtilities.h.

    {
        auto caPath = PathManager::getCertsPath() / "cacert.pem";
        auto caPathString = caPath.string();
        if (_putenv_s("SSL_CERT_FILE", caPathString.c_str()) != 0)
        {
            std::cerr << "[NetworkUtilities] Failed to set SSL_CERT_FILE\n";
        }
        else
        {
            std::cout << "[NetworkUtilities] SSL_CERT_FILE set to " << caPath << "\n";
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

startLocalTunnel()

static std::string NetworkUtilities::startLocalTunnel ( const std::string & subdomainBase, int port )

inlinestatic

Definition at line 430 of file NetworkUtilities.h.

    {
        stopLocalTunnel(); // ensure clean start
 
        // Normalize subdomain: remove dots, lowercase
        std::string subdomain = std::regex_replace(subdomainBase, std::regex("\\."), "");
        for (auto& c : subdomain)
            c = (char)std::tolower((unsigned char)c);
 
        {
            std::lock_guard<std::mutex> lk(urlMutex);
            localTunnelUrl.clear();
        }
 
        // Create stdout pipe
        SECURITY_ATTRIBUTES sa{};
        sa.nLength = sizeof(sa);
        sa.bInheritHandle = TRUE;
        if (!CreatePipe(&ltStdoutRd, &ltStdoutWr, &sa, 0))
        {
            OutputDebugStringA("[LT] CreatePipe stdout failed\n");
            return {};
        }
        SetHandleInformation(ltStdoutRd, HANDLE_FLAG_INHERIT, 0); // parent read end: not inheritable
 
        // Create stdin pipe
        if (!CreatePipe(&ltStdinRd, &ltStdinWr, &sa, 0))
        {
            OutputDebugStringA("[LT] CreatePipe stdin failed\n");
            closeHandleIf(ltStdoutWr);
            closeHandleIf(ltStdoutRd);
            return {};
        }
        SetHandleInformation(ltStdinWr, HANDLE_FLAG_INHERIT, 0); // parent write end: not inheritable
 
        // Build command: "node.exe" "lt-controller.js" --port N --subdomain X
        std::string nodePath = PathManager::getNodeExePath().string();
        std::string ctlPath = PathManager::getLocalTunnelControllerPath().string();
 
        std::ostringstream cmd;
        cmd << "\"" << nodePath << "\" \"" << ctlPath << "\""
            << " --port " << port
            << " --subdomain " << subdomain;
 
        STARTUPINFOA si{};
        PROCESS_INFORMATION pi{};
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
        si.hStdInput = ltStdinRd;
        si.hStdOutput = ltStdoutWr;
        si.hStdError = ltStdoutWr;
        si.wShowWindow = SW_HIDE;
 
        DWORD flags = CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP;
 
        std::string cmdLine = cmd.str();
        std::vector<char> mutableCmd(cmdLine.begin(), cmdLine.end());
        mutableCmd.push_back('\0');
 
        // Optionally set working dir so require('localtunnel') resolves next to lt-controller.js
        std::string workingDir = PathManager::getLocalTunnelControllerPath().parent_path().string();
 
        BOOL ok = CreateProcessA(
            /*appName*/ nullptr,
            /*cmdLine*/ mutableCmd.data(),
            nullptr, nullptr,
            /*inherit handles*/ TRUE, // child inherits ltStdoutWr, ltStdinRd
            flags,
            /*env*/ nullptr,
            /*current dir*/ workingDir.empty() ? nullptr : workingDir.c_str(),
            &si, &pi);
 
        // Parent no longer needs these ends
        closeHandleIf(ltStdoutWr);
        closeHandleIf(ltStdinRd);
 
        if (!ok)
        {
            DWORD err = GetLastError();
            std::string em = "[LT] CreateProcess failed: " + lastErrorToString(err);
            OutputDebugStringA(em.c_str());
            closeHandleIf(ltStdoutRd);
            closeHandleIf(ltStdinWr);
            return {};
        }
 
        ltProc = pi.hProcess;
        ltThread = pi.hThread;
        running.store(true, std::memory_order_relaxed);
 
        assignToJob(ltProc);
        std::thread([rd = ltStdoutRd]()
                    {
            std::string buf; buf.reserve(4096);
            constexpr DWORD CHUNK = 1024;
            char tmp[CHUNK + 1];
 
            auto trimCR = [](std::string& s) {
                if (!s.empty() && s.back() == '\r') s.pop_back(); // handle CRLF
            };
 
            auto handleJsonLine = [](const std::string& line) {
                auto findField = [&](const char* key)->std::string {
                    auto kpos = line.find(std::string("\"")+key+"\"");
                    if (kpos == std::string::npos) return {};
                    auto colon = line.find(':', kpos);
                    if (colon == std::string::npos) return {};
                    auto q1 = line.find('"', colon + 1);
                    if (q1 == std::string::npos) return {};
                    auto q2 = line.find('"', q1 + 1);
                    if (q2 == std::string::npos) return {};
                    return line.substr(q1 + 1, q2 - (q1 + 1));
                };
 
                const auto ev  = findField("event");
                const auto url = findField("url");
                const auto msg = findField("message");
 
                if (ev.empty()) {
                    Logger::instance().log("localtunnel", Logger::Level::Debug, "LT raw: " + line);
                    return;
                }
 
                if (ev == "boot") {
                    Logger::instance().log("localtunnel", Logger::Level::Debug, "LT boot: " + line);
                } else if (ev == "require_ok") {
                    Logger::instance().log("localtunnel", Logger::Level::Success, "LT require('localtunnel') OK");
                } else if (ev == "require_err") {
                    Logger::instance().log("localtunnel", Logger::Level::Error, "LT require error: " + msg);
                } else if (ev == "ready") {
                    Logger::instance().log("localtunnel", Logger::Level::Success, "LT ready: " + url);
                    {
                        std::lock_guard<std::mutex> lk(NetworkUtilities::urlMutex);
                        if (NetworkUtilities::localTunnelUrl.empty())
                            NetworkUtilities::localTunnelUrl = url;
                    }
                    NetworkUtilities::urlCv.notify_all();
                } else if (ev == "error") {
                    Logger::instance().log("localtunnel", Logger::Level::Error, "LT error: " + msg);
                } else if (ev == "closed") {
                    Logger::instance().log("localtunnel", Logger::Level::Warn, "LT closed");
                } else {
                    Logger::instance().log("localtunnel", Logger::Level::Info, "LT: " + line);
                }
            };
 
            while (NetworkUtilities::running.load(std::memory_order_relaxed)) {
                DWORD got = 0;
                BOOL ok = ReadFile(rd, tmp, CHUNK, &got, nullptr);
                if (!ok || got == 0) break;
                tmp[got] = '\0';
                buf.append(tmp, got);
 
                size_t pos = 0;
                while (true) {
                    size_t nl = buf.find('\n', pos);
                    if (nl == std::string::npos) break;
                    std::string line = buf.substr(pos, nl - pos);
                    trimCR(line);
                    pos = nl + 1;
 
                    if (!line.empty()) {
                        handleJsonLine(line);
                    }
                }
                if (pos > 0) buf.erase(0, pos);
            }
            NetworkUtilities::urlCv.notify_all(); })
            .detach();
 
        // Reader thread: read one JSON line with {"event":"ready","url":...}
        //std::thread([rd = ltStdoutRd]()
        //            {
        //    std::string buf; buf.reserve(4096);
        //    constexpr DWORD CHUNK = 1024;
        //    char tmp[CHUNK + 1];
 
        //    auto parseLine = [](const std::string& line) -> std::string {
        //        // very tiny JSON extraction: look for "event":"ready" + extract url
        //        if (line.find("\"event\":\"ready\"") == std::string::npos) return {};
        //        auto u = line.find("\"url\"");
        //        if (u == std::string::npos) return {};
        //        u = line.find('"', u + 4); // first quote after "url"
        //        if (u == std::string::npos) return {};
        //        auto v = line.find('"', u + 1);
        //        if (v == std::string::npos) return {};
        //        return line.substr(u + 1, v - (u + 1));
        //    };
 
        //    while (NetworkUtilities::running.load(std::memory_order_relaxed)) {
        //        DWORD got = 0;
        //        BOOL ok = ReadFile(rd, tmp, CHUNK, &got, nullptr);
        //        if (!ok || got == 0) break;
        //        tmp[got] = '\0';
        //        buf.append(tmp, got);
 
        //        // process complete lines
        //        size_t pos = 0;
        //        while (true) {
        //            size_t nl = buf.find('\n', pos);
        //            if (nl == std::string::npos) break;
        //            std::string line = buf.substr(pos, nl - pos);
        //            pos = nl + 1;
 
        //            if (auto url = parseLine(line); !url.empty()) {
        //                {
        //                    std::lock_guard<std::mutex> lk(NetworkUtilities::urlMutex);
        //                    if (NetworkUtilities::localTunnelUrl.empty())
        //                        NetworkUtilities::localTunnelUrl = std::move(url);
        //                }
        //                NetworkUtilities::urlCv.notify_all();
        //            }
        //        }
        //        if (pos > 0) buf.erase(0, pos);
        //    }
        //    NetworkUtilities::urlCv.notify_all(); })
        //    .detach();
 
        // Wait up to 15s for URL or process exit
        std::unique_lock<std::mutex> lk(urlMutex);
        bool have = urlCv.wait_for(lk, std::chrono::seconds(15), []
                                   { return !localTunnelUrl.empty() || !running.load(std::memory_order_relaxed); });
 
        return have ? localTunnelUrl : std::string{};
    }

Here is the call graph for this function:

Here is the caller graph for this function:

stopLocalTunnel()

static void NetworkUtilities::stopLocalTunnel ( )

inlinestatic

Definition at line 656 of file NetworkUtilities.h.

    {
        // tell reader thread to stop
        running.store(false, std::memory_order_relaxed);
 
        // try graceful: send "stop\n" if stdin is open
        if (ltStdinWr)
        {
            DWORD written = 0;
            const char* stopCmd = "stop\n";
            WriteFile(ltStdinWr, stopCmd, (DWORD)strlen(stopCmd), &written, nullptr);
        }
 
        // wait a moment for clean exit
        if (ltProc)
        {
            DWORD wait = WaitForSingleObject(ltProc, 300); // 300ms grace
            if (wait != WAIT_OBJECT_0)
            {
                // force kill now (non-blocking)
                TerminateProcess(ltProc, 0);
            }
        }
 
        // close all handles
        closeHandleIf(ltThread);
        closeHandleIf(ltProc);
        closeHandleIf(ltStdoutWr); // usually already closed
        closeHandleIf(ltStdoutRd);
        closeHandleIf(ltStdinRd); // already closed
        closeHandleIf(ltStdinWr);
 
        // close job (kills any remaining children)
        if (ltJob)
        {
            CloseHandle(ltJob);
            ltJob = nullptr;
        }
 
        // clear URL and wake any waiters
        {
            std::lock_guard<std::mutex> lk(urlMutex);
            localTunnelUrl.clear();
        }
        urlCv.notify_all();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

localTunnelUrl

std::string NetworkUtilities::localTunnelUrl

inlinestaticprivate

Definition at line 364 of file NetworkUtilities.h.

ltJob

HANDLE NetworkUtilities::ltJob = nullptr

inlinestaticprivate

Definition at line 380 of file NetworkUtilities.h.

ltProc

HANDLE NetworkUtilities::ltProc = nullptr

inlinestaticprivate

Definition at line 371 of file NetworkUtilities.h.

ltStdinRd

HANDLE NetworkUtilities::ltStdinRd = nullptr

inlinestaticprivate

Definition at line 377 of file NetworkUtilities.h.

ltStdinWr

HANDLE NetworkUtilities::ltStdinWr = nullptr

inlinestaticprivate

Definition at line 378 of file NetworkUtilities.h.

ltStdoutRd

HANDLE NetworkUtilities::ltStdoutRd = nullptr

inlinestaticprivate

Definition at line 374 of file NetworkUtilities.h.

ltStdoutWr

HANDLE NetworkUtilities::ltStdoutWr = nullptr

inlinestaticprivate

Definition at line 375 of file NetworkUtilities.h.

ltThread

HANDLE NetworkUtilities::ltThread = nullptr

inlinestaticprivate

Definition at line 372 of file NetworkUtilities.h.

running

std::atomic<bool> NetworkUtilities::running {false}

inlinestaticprivate

Definition at line 363 of file NetworkUtilities.h.

{false};

urlCv

std::condition_variable NetworkUtilities::urlCv

inlinestaticprivate

Definition at line 366 of file NetworkUtilities.h.

urlMutex

std::mutex NetworkUtilities::urlMutex

inlinestaticprivate

Definition at line 365 of file NetworkUtilities.h.

---

The documentation for this class was generated from the following file:

• include/network/NetworkUtilities.h