DNS Resolver (cpp, written by Codex)

Codex wrote this cpp project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: DNS Resolver

Write a program that performs DNS lookups for domain names, supporting multiple record types, reverse lookups, DNS-over-HTTPS, and batch resolution with response time measurements.

FUNCTIONAL REQUIREMENTS:
- Accept a domain name as a command-line argument
- Support querying multiple DNS record types via --type flag: A, AAAA, MX, NS, TXT, CNAME, SOA, PTR, SRV (default: A)
- Support querying all common record types at once via --all flag
- Support reverse DNS lookups (IP to hostname) via --reverse flag
- Allow specifying a custom DNS server via --server flag (default: system DNS resolver)
- Support DNS-over-HTTPS (DoH) via --doh flag using configurable DoH providers
- Measure and display query response time in milliseconds for each lookup
- Support batch resolution of multiple domains from a file via --file flag (one domain per line)
- Display TTL (Time To Live) values for each record
- Support recursive trace mode via --trace flag: show the full resolution path from root servers to authoritative servers
- Print results to console in a structured format showing: domain, record type, value, TTL, response time, and nameserver used
- Save results as JSON with --output flag (default: dns_results.json)
- Support concurrent resolution of batch queries via --parallel flag with configurable concurrency (--threads, default 10)
- If no domain is given, resolve a set of well-known domains (example.com, google.com, github.com, cloudflare.com) across multiple record types and display a formatted comparison table
- Handle errors: NXDOMAIN (non-existent domain), SERVFAIL, timeout, invalid domain names, and unreachable DNS servers

Create a complete C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.22)
project(dns_resolver_cpp VERSION 1.0.0 LANGUAGES C CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

include(FetchContent)

FetchContent_Declare(
  nlohmann_json
  URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
)
FetchContent_MakeAvailable(nlohmann_json)

FetchContent_Declare(
  curl
  URL https://github.com/curl/curl/releases/download/curl-8_10_1/curl-8.10.1.tar.xz
)
set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
set(BUILD_CURL_EXE OFF CACHE BOOL "" FORCE)
set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(curl)

add_executable(dns_resolver src/main.cpp)
target_link_libraries(dns_resolver PRIVATE nlohmann_json::nlohmann_json CURL::libcurl)

# DNS Resolver (C++)

Performs DNS queries with multi-type support, reverse lookups, optional DoH, batch file input, response timing, optional trace output, concurrent batch execution, and JSON reporting.

## Requirements

- Ubuntu 22.04
- G++ 12+
- CMake 3.22+

## Dependencies (Pinned)

- nlohmann/json `3.11.3`
- cURL `8.10.1`

## Build

```bash
cmake -S . -B build
cmake --build build -j
```

## Run

```bash
./build/dns_resolver example.com
./build/dns_resolver example.com --type A,AAAA,MX,TXT
./build/dns_resolver --all example.com
./build/dns_resolver 8.8.8.8 --reverse
./build/dns_resolver example.com --doh cloudflare --type A,AAAA
./build/dns_resolver --file domains.txt --parallel --threads 20 --type A
./build/dns_resolver example.com --trace --output dns_results.json
./build/dns_resolver
```

## Notes

- Supported types: `A, AAAA, MX, NS, TXT, CNAME, SOA, PTR, SRV`.
- For non-`A/AAAA/PTR` system mode, implementation falls back to DoH query path.
- If no domain is provided, resolver queries: `example.com`, `google.com`, `github.com`, `cloudflare.com`.

#include <arpa/inet.h>
#include <curl/curl.h>
#include <netdb.h>

#include <nlohmann/json.hpp>

#include <algorithm>
#include <atomic>
#include <chrono>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

namespace fs = std::filesystem;
using json = nlohmann::json;

struct CliOptions {
    std::map<std::string, std::string> kv;
    std::vector<std::string> positional;
};

const std::vector<std::string> DEFAULT_DOMAINS = {"example.com", "google.com", "github.com", "cloudflare.com"};
const std::vector<std::string> COMMON_TYPES = {"A", "AAAA", "MX", "NS", "TXT", "CNAME", "SOA", "PTR", "SRV"};
const std::map<std::string, std::string> DOH = {
    {"google", "https://dns.google/resolve"},
    {"cloudflare", "https://cloudflare-dns.com/dns-query"},
    {"quad9", "https://dns.quad9.net:5053/dns-query"}
};

CliOptions parseArgs(int argc, char** argv) {
    CliOptions out;
    for (int i = 1; i < argc; ++i) {
        std::string t = argv[i];
        if (t.rfind("--", 0) == 0) {
            std::string k = t.substr(2);
            std::string v = "true";
            if (i + 1 < argc) {
                std::string n = argv[i + 1];
                if (n.rfind("--", 0) != 0) {
                    v = n;
                    ++i;
                }
            }
            out.kv[k] = v;
        } else out.positional.push_back(t);
    }
    return out;
}

std::vector<std::string> parseTypes(const CliOptions& opts) {
    if (opts.kv.count("all")) return COMMON_TYPES;
    std::string raw = opts.kv.count("type") ? opts.kv.at("type") : "A";
    std::vector<std::string> out;
    std::stringstream ss(raw);
    std::string part;
    while (std::getline(ss, part, ',')) {
        for (char& c : part) c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
        if (!part.empty()) out.push_back(part);
    }
    return out;
}

std::vector<std::string> parseDomains(const CliOptions& opts) {
    std::set<std::string> out;
    if (!opts.positional.empty()) out.insert(opts.positional.front());
    if (opts.kv.count("file")) {
        std::ifstream in(fs::absolute(opts.kv.at("file")));
        std::string line;
        while (std::getline(in, line)) {
            while (!line.empty() && std::isspace(static_cast<unsigned char>(line.back()))) line.pop_back();
            size_t st = 0;
            while (st < line.size() && std::isspace(static_cast<unsigned char>(line[st]))) st++;
            if (st < line.size()) out.insert(line.substr(st));
        }
    }
    if (out.empty()) out.insert(DEFAULT_DOMAINS.begin(), DEFAULT_DOMAINS.end());
    return std::vector<std::string>(out.begin(), out.end());
}

std::string ptrFromIp(const std::string& ip) {
    if (ip.find(':') != std::string::npos) {
        std::string hex;
        for (char c : ip) if (c != ':') hex.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
        while (hex.size() < 32) hex = "0" + hex;
        std::string rev;
        for (auto it = hex.rbegin(); it != hex.rend(); ++it) {
            if (!rev.empty()) rev.push_back('.');
            rev.push_back(*it);
        }
        return rev + ".ip6.arpa";
    }
    std::stringstream ss(ip);
    std::string a, b, c, d;
    std::getline(ss, a, '.'); std::getline(ss, b, '.'); std::getline(ss, c, '.'); std::getline(ss, d, '.');
    return d + "." + c + "." + b + "." + a + ".in-addr.arpa";
}

size_t curlWrite(char* ptr, size_t size, size_t nmemb, void* userdata) {
    auto* out = static_cast<std::string*>(userdata);
    out->append(ptr, size * nmemb);
    return size * nmemb;
}

std::vector<json> queryDoH(const std::string& provider, const std::string& domain, const std::string& type) {
    std::string base = DOH.count(provider) ? DOH.at(provider) : provider;
    std::string url = base + "?name=" + curl_easy_escape(nullptr, domain.c_str(), static_cast<int>(domain.size())) + "&type=" + type;
    auto started = std::chrono::steady_clock::now();
    CURL* curl = curl_easy_init();
    if (!curl) throw std::runtime_error("curl init failed");
    std::string body;
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlWrite);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &body);
    struct curl_slist* headers = nullptr;
    headers = curl_slist_append(headers, "accept: application/dns-json");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    CURLcode rc = curl_easy_perform(curl);
    long code = 0;
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - started).count();

    if (rc != CURLE_OK || code >= 400) {
        return {json{{"domain", domain}, {"type", type}, {"value", ""}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", "doh:" + provider}, {"error", rc == CURLE_OK ? ("HTTP " + std::to_string(code)) : curl_easy_strerror(rc)}}};
    }
    json j = json::parse(body, nullptr, false);
    if (j.is_discarded()) {
        return {json{{"domain", domain}, {"type", type}, {"value", ""}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", "doh:" + provider}, {"error", "Invalid JSON"}}};
    }
    if (j.value("Status", 0) != 0) {
        return {json{{"domain", domain}, {"type", type}, {"value", ""}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", "doh:" + provider}, {"error", "DoH status " + std::to_string(j.value("Status", 0))}}};
    }
    if (!j.contains("Answer") || !j["Answer"].is_array() || j["Answer"].empty()) {
        return {json{{"domain", domain}, {"type", type}, {"value", ""}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", "doh:" + provider}, {"error", "NoAnswer"}}};
    }
    std::vector<json> out;
    for (const auto& a : j["Answer"]) {
        out.push_back(json{
            {"domain", domain},
            {"type", type},
            {"value", a.value("data", "")},
            {"ttl", a.contains("TTL") ? a["TTL"] : json(nullptr)},
            {"response_ms", std::round(ms * 100) / 100.0},
            {"nameserver", "doh:" + provider},
            {"error", ""}
        });
    }
    return out;
}

std::vector<json> querySystem(const std::string& domain, const std::string& type, bool reverseMode, const std::string& nameserver) {
    auto started = std::chrono::steady_clock::now();
    try {
        std::vector<json> out;
        if (reverseMode) {
            sockaddr_in sa{};
            sa.sin_family = AF_INET;
            if (inet_pton(AF_INET, domain.c_str(), &sa.sin_addr) != 1) throw std::runtime_error("Invalid IP");
            char host[NI_MAXHOST];
            int rc = getnameinfo(reinterpret_cast<sockaddr*>(&sa), sizeof(sa), host, sizeof(host), nullptr, 0, 0);
            double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - started).count();
            if (rc != 0) throw std::runtime_error(gai_strerror(rc));
            out.push_back({{"domain", domain}, {"type", "PTR"}, {"value", std::string(host)}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", nameserver}, {"error", ""}});
            return out;
        }
        if (type == "A" || type == "AAAA") {
            addrinfo hints{};
            hints.ai_family = (type == "A") ? AF_INET : AF_INET6;
            hints.ai_socktype = SOCK_STREAM;
            addrinfo* res = nullptr;
            int rc = getaddrinfo(domain.c_str(), nullptr, &hints, &res);
            double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - started).count();
            if (rc != 0) throw std::runtime_error(gai_strerror(rc));
            std::set<std::string> vals;
            for (addrinfo* p = res; p; p = p->ai_next) {
                char ip[INET6_ADDRSTRLEN];
                void* addr = (p->ai_family == AF_INET)
                    ? static_cast<void*>(&reinterpret_cast<sockaddr_in*>(p->ai_addr)->sin_addr)
                    : static_cast<void*>(&reinterpret_cast<sockaddr_in6*>(p->ai_addr)->sin6_addr);
                inet_ntop(p->ai_family, addr, ip, sizeof(ip));
                vals.insert(ip);
            }
            freeaddrinfo(res);
            for (const auto& v : vals) out.push_back({{"domain", domain}, {"type", type}, {"value", v}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", nameserver}, {"error", ""}});
            if (out.empty()) out.push_back({{"domain", domain}, {"type", type}, {"value", ""}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", nameserver}, {"error", "NoAnswer"}});
            return out;
        }
        // fallback to DoH for richer record types
        return queryDoH("google", domain, type);
    } catch (const std::exception& ex) {
        double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - started).count();
        return {json{{"domain", domain}, {"type", type}, {"value", ""}, {"ttl", nullptr}, {"response_ms", std::round(ms * 100) / 100.0}, {"nameserver", nameserver}, {"error", ex.what()}}};
    }
}

std::vector<json> traceDomain(const std::string& domain, const std::string& dohProvider) {
    std::stringstream ss(domain);
    std::string label;
    std::vector<std::string> labels;
    while (std::getline(ss, label, '.')) labels.push_back(label);
    std::vector<json> steps;
    for (size_t i = 0; i < labels.size(); ++i) {
        std::string zone;
        for (size_t j = i; j < labels.size(); ++j) {
            if (!zone.empty()) zone += ".";
            zone += labels[j];
        }
        auto ans = queryDoH(dohProvider, zone, "NS");
        std::vector<std::string> ns;
        std::string err;
        for (const auto& r : ans) {
            if (r["error"].get<std::string>().empty()) ns.push_back(r["value"].get<std::string>());
            else err = r["error"].get<std::string>();
        }
        if (!ns.empty()) steps.push_back({{"zone", zone}, {"ns", ns}});
        else steps.push_back({{"zone", zone}, {"error", err.empty() ? "No NS answer" : err}});
    }
    return steps;
}

void printRows(const std::vector<json>& rows) {
    std::cout << "Domain | Type | Value | TTL | Response(ms) | Nameserver | Error\n";
    std::cout << "------ | ---- | ----- | --- | ------------ | ---------- | -----\n";
    for (const auto& r : rows) {
        std::cout << r.value("domain", "") << " | " << r.value("type", "") << " | " << r.value("value", "") << " | ";
        if (r["ttl"].is_null()) std::cout << "";
        else std::cout << r["ttl"];
        std::cout << " | " << r.value("response_ms", 0.0) << " | " << r.value("nameserver", "") << " | " << r.value("error", "") << "\n";
    }
}

int main(int argc, char** argv) {
    try {
        CliOptions opts = parseArgs(argc, argv);
        std::vector<std::string> types = parseTypes(opts);
        std::vector<std::string> domains = parseDomains(opts);
        bool reverseMode = opts.kv.count("reverse") > 0;
        bool parallel = opts.kv.count("parallel") > 0;
        int threads = std::max(1, std::stoi(opts.kv.count("threads") ? opts.kv.at("threads") : "10"));
        std::string nameserver = opts.kv.count("server") ? opts.kv.at("server") : "system";

        struct Task { std::string input; std::string queryName; std::string type; };
        std::vector<Task> tasks;
        for (const auto& d : domains) {
            std::string qname = (reverseMode && opts.kv.count("doh")) ? ptrFromIp(d) : d;
            std::vector<std::string> qtypes = (reverseMode && !opts.kv.count("doh")) ? std::vector<std::string>{"PTR"} : types;
            for (const auto& t : qtypes) tasks.push_back({d, qname, t});
        }

        if (curl_global_init(CURL_GLOBAL_DEFAULT) != 0) throw std::runtime_error("curl init failed");
        std::vector<json> rows;
        std::mutex rowsMutex;
        std::mutex outMutex;

        auto runTask = [&](const Task& t) {
            std::vector<json> recs = opts.kv.count("doh")
                ? queryDoH(opts.kv.at("doh"), t.queryName, t.type)
                : querySystem(t.queryName, t.type, reverseMode && t.type == "PTR", nameserver);
            for (auto& r : recs) {
                r["domain"] = t.input;
                {
                    std::lock_guard<std::mutex> lk(rowsMutex);
                    rows.push_back(r);
                }
                std::lock_guard<std::mutex> lk(outMutex);
                std::cout << t.input << " " << t.type << " -> "
                          << (r.value("value", "").empty() ? r.value("error", "") : r.value("value", "")) << "\n";
            }
        };

        if (parallel && tasks.size() > 1) {
            std::atomic<size_t> next{0};
            std::vector<std::thread> pool;
            auto worker = [&]() {
                while (true) {
                    size_t i = next.fetch_add(1);
                    if (i >= tasks.size()) break;
                    runTask(tasks[i]);
                }
            };
            for (int i = 0; i < threads; ++i) pool.emplace_back(worker);
            for (auto& t : pool) t.join();
        } else {
            for (const auto& t : tasks) runTask(t);
        }

        std::sort(rows.begin(), rows.end(), [](const json& a, const json& b) {
            return std::tie(a["domain"], a["type"], a["value"]) < std::tie(b["domain"], b["type"], b["value"]);
        });
        printRows(rows);

        json traces = nullptr;
        if (opts.kv.count("trace")) {
            std::string provider = opts.kv.count("doh") ? opts.kv.at("doh") : "google";
            traces = json::object();
            std::cout << "\nTrace:\n";
            for (const auto& d : domains) {
                auto steps = traceDomain(d, provider);
                traces[d] = steps;
                std::cout << "- " << d << "\n";
                for (const auto& s : steps) {
                    if (s.contains("ns")) {
                        std::cout << "  " << s["zone"] << ": ";
                        bool first = true;
                        for (const auto& n : s["ns"]) {
                            if (!first) std::cout << ", ";
                            std::cout << n.get<std::string>();
                            first = false;
                        }
                        std::cout << "\n";
                    } else std::cout << "  " << s["zone"] << ": " << s["error"] << "\n";
                }
            }
        }

        auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
        std::tm tm = *gmtime(&now);
        char iso[32];
        std::strftime(iso, sizeof(iso), "%Y-%m-%dT%H:%M:%SZ", &tm);

        json payload = {
            {"generated_at", std::string(iso)},
            {"options", opts.kv},
            {"results", rows}
        };
        if (!traces.is_null()) payload["traces"] = traces;
        fs::path out = fs::absolute(opts.kv.count("output") ? opts.kv.at("output") : "dns_results.json");
        fs::create_directories(out.parent_path());
        std::ofstream ofs(out);
        ofs << payload.dump(2) << "\n";
        std::cout << "\nSaved: " << out << "\n";
        curl_global_cleanup();
        return 0;
    } catch (const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << "\n";
        return 1;
    }
}