Networking

#include <coroio/dns/resolver.hpp>
#include <coroio/all.hpp>
using namespace NNet;

TFuture<void> lookup(TDefaultPoller& poller) {
    TResolver resolver(poller);                              // reads /etc/resolv.conf

    auto addrs = co_await resolver.Resolve("example.com");  // A record
    auto v6    = co_await resolver.Resolve("example.com", EDNSType::AAAA);

    // THostPort: literal IPs bypass DNS; hostnames go through TResolver
    TAddress addr = co_await THostPort("example.com", 443).Resolve(resolver);

    co_return;
}

TFuture<void> bulkResolve(TDefaultPoller& poller) {
    TResolver resolver(poller);
    std::vector<std::string> names = {"a.example.com", "b.example.com", "c.example.com"};

    // All queries are sent concurrently; results arrive in any order
    std::vector<TFuture<std::vector<TAddress>>> futures;
    for (auto& name : names)
        futures.push_back(resolver.Resolve(name));

    auto results = co_await All(std::move(futures));
    co_return;
}

#include <coroio/http/httpd.hpp>
using namespace NNet;

struct TMyRouter : public IRouter {
    TFuture<void> HandleRequest(TRequest& req, TResponse& resp) override {
        if (req.Method() == "GET" && req.Uri().Path() == "/hello") {
            resp.SetStatus(200);
            resp.SetHeader("Content-Type", "text/plain");
            co_await resp.WriteBodyFull("Hello, World!\n");
        } else if (req.Method() == "POST" && req.Uri().Path() == "/echo") {
            auto body = co_await req.ReadBodyFull();
            resp.SetStatus(200);
            resp.SetHeader("Content-Type", "application/octet-stream");
            co_await resp.WriteBodyFull(body);
        } else {
            resp.SetStatus(404);
            co_await resp.WriteBodyFull("Not found\n");
        }
        co_return;
    }
};

int main() {
    TLoop<TDefaultPoller> loop;
    TMyRouter router;

    using TSocket = TDefaultPoller::TSocket;
    TSocket sock(loop.Poller(), AF_INET6);
    sock.Bind(TAddress{"::", 8080});
    sock.Listen();

    TWebServer<TSocket> server(std::move(sock), router);
    server.Start();
    loop.Loop();
}

TFuture<void> HandleRequest(TRequest& req, TResponse& resp) override {
    resp.SetStatus(200);
    resp.SetHeader("Content-Type", "text/event-stream");
    co_await resp.SendHeaders();                  // headers only, no Content-Length

    for (int i = 0; i < 10; ++i) {
        std::string chunk = "data: " + std::to_string(i) + "\n\n";
        co_await resp.WriteBodyChunk(chunk.data(), chunk.size());
    }
    co_return;
}

#include <coroio/ws/ws.hpp>
#include <coroio/dns/resolver.hpp>
using namespace NNet;

TFuture<void> wsClient(TDefaultPoller& poller) {
    TResolver resolver(poller);
    TAddress addr = co_await THostPort("ws.kraken.com", 443).Resolve(resolver);

    TDefaultPoller::TSocket tcp(poller, addr.Domain());

    // wss:// — wrap with TLS
    TSslContext ctx = TSslContext::Client();
    TSslSocket ssl(std::move(tcp), ctx);
    ssl.SslSetTlsExtHostName("ws.kraken.com");    // SNI, must be before Connect
    co_await ssl.Connect(addr);

    TWebSocket ws(ssl);
    co_await ws.Connect("ws.kraken.com", "/v2");   // HTTP Upgrade

    // Subscribe to BTC/USD ticker
    co_await ws.SendText(
        R"({"method":"subscribe","params":{"channel":"ticker","symbol":["BTC/USD"]}})");

    while (true) {
        auto msg = co_await ws.ReceiveText();      // string_view, valid until next call
        std::cout << msg << "\n";
    }
    co_return;
}

#include <coroio/ssl.hpp>
using namespace NNet;

// ── Client ───────────────────────────────────────────────────────────────────
TSslContext ctx = TSslContext::Client();
TSslSocket ssl(std::move(tcpSocket), ctx);
ssl.SslSetTlsExtHostName("example.com");   // SNI — before Connect
co_await ssl.Connect(addr);

ssize_t n = co_await ssl.ReadSome(buf, sizeof buf);
co_await ssl.WriteSome(buf, n);

// ── Server (PEM files) ───────────────────────────────────────────────────────
TSslContext ctx = TSslContext::Server("server.crt", "server.key");

// ── Server (in-memory PEM) ───────────────────────────────────────────────────
TSslContext ctx = TSslContext::ServerFromMem(certPemPtr, keyPemPtr);

// In the accept loop:
auto raw = co_await listener.Accept();
TSslSocket<decltype(raw)> ssl(std::move(raw), ctx);
co_await ssl.AcceptHandshake();
// ssl is now ready for ReadSome / WriteSome

#include <coroio/pipe/pipe.hpp>
using namespace NNet;

TFuture<void> compress(TDefaultPoller& poller) {
    TPipe pipe(poller, {"gzip", "-c"});          // spawn gzip

    std::string input = "hello world\n";
    co_await pipe.WriteSome(input.data(), input.size());
    pipe.CloseWrite();                            // send EOF to child's stdin

    char buf[4096]; ssize_t n;
    while ((n = co_await pipe.ReadSome(buf, sizeof buf)) > 0)
        std::cout.write(buf, n);                  // compressed bytes

    int exit_code = co_await pipe.Wait();
    std::cout << "gzip exited: " << exit_code << "\n";
    co_return;
}