std::string body, headers;

long http_code = 0; // NOLINT(runtime/int)

// No RAII wrapper: curl_easy_init/curl_easy_cleanup are synchronous C API

// calls that never throw, CURLOPT_NOSIGNAL avoids signal-based

// interruption, and every path below falls through to the unconditional

// curl_easy_cleanup(curl) at the end of this test-only helper.

CURL *curl = curl_easy_init();

curl_easy_setopt(curl, CURLOPT_URL, url);

curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc);

curl_easy_setopt(curl, CURLOPT_WRITEDATA, &body);

curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, writefunc);

curl_easy_setopt(curl, CURLOPT_HEADERDATA, &headers);

curl_easy_setopt(curl, CURLOPT_TIMEOUT, 150L);

curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 150L);

curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);

curl_easy_perform(curl);

curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);

curl_easy_cleanup(curl);

return {http_code, headers};

const char* url,

const char* auth_hdr,

std::string* body_out) {

long http_code = 0; // NOLINT(runtime/int)

// No RAII wrapper: curl_easy_init/curl_easy_cleanup are synchronous C API

// calls that never throw, CURLOPT_NOSIGNAL avoids signal-based

// interruption, and every path below falls through to the unconditional

// curl_easy_cleanup(curl) at the end of this test-only helper.

CURL *curl = curl_easy_init();

struct curl_slist *hdrs = nullptr;

hdrs = curl_slist_append(hdrs, auth_hdr);

curl_easy_setopt(curl, CURLOPT_URL, url);

curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);

curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hdrs);

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc);

curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_out);

curl_easy_setopt(curl, CURLOPT_TIMEOUT, 150L);

curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 150L);

curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);

curl_easy_perform(curl);

curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);

curl_easy_cleanup(curl);

curl_slist_free_all(hdrs);

return http_code;

public:

http_response render_get(const http_request& req) {

if (req.get_user() != "myuser" || req.get_pass() != "mypass") {

return http_response::unauthorized("Basic", "examplerealm", "FAIL");

}

return http_response::string(std::string(req.get_user()) + " " + std::string(req.get_pass()));

}

public:

http_response render_get(const http_request& req) {

using httpserver::http::http_utils;

using httpserver::digest_challenge;

digest_challenge fail_ch{.realm = "examplerealm", .response_body = "FAIL"};

if (req.get_digested_user() == "") {

return http_response::unauthorized(fail_ch);

}

auto result = req.check_digest_auth("examplerealm", "mypass", 300,

0, http_utils::digest_algorithm::MD5);

if (result == http_utils::digest_auth_result::NONCE_STALE) {

auto stale_ch = fail_ch;

stale_ch.signal_stale = true;

return http_response::unauthorized(stale_ch);

}

if (result != http_utils::digest_auth_result::OK) {

return http_response::unauthorized(fail_ch);

}

return http_response::string("SUCCESS");

}

public:

using http_utils = httpserver::http::http_utils;

digest_ha1_resource(http_utils::digest_algorithm algo,

const unsigned char* ha1,

std::size_t ha1_size)

: algo_(algo), ha1_(ha1), ha1_size_(ha1_size) {}

http_response render_get(const http_request& req) {

using httpserver::digest_challenge;

if (req.get_digested_user() == "") {

return http_response::unauthorized(

digest_challenge{.realm = "examplerealm",

.algorithm = algo_,

.response_body = "FAIL"});

}

auto result = req.check_digest_auth_digest("examplerealm", ha1_,

ha1_size_, 300, 0, algo_);

if (result == http_utils::digest_auth_result::NONCE_STALE) {

return http_response::unauthorized(

digest_challenge{.realm = "examplerealm",

.algorithm = algo_,

.signal_stale = true,

.response_body = "FAIL"});

} else if (result != http_utils::digest_auth_result::OK) {

return http_response::unauthorized(

digest_challenge{.realm = "examplerealm",

.algorithm = algo_,

.response_body = "FAIL"});

}

return http_response::string("SUCCESS");

}

private:

http_utils::digest_algorithm algo_;

const unsigned char* ha1_;

std::size_t ha1_size_;

public:

http_response render_get(const http_request& req) {

using httpserver::http::http_utils;

using httpserver::digest_challenge;

// First call: populates the cache from MHD (or returns empty if no

// Authorization header has been sent yet).

std::string user1 = std::string(req.get_digested_user());

if (user1.empty()) {

// No digest auth provided -- emit the initial RFC 7616 §3.3

// challenge so a client can compute a response.

return http_response::unauthorized(

digest_challenge{.realm = "testrealm",

.response_body = "FAIL"});

}

// Validate the round-2 credentials. NOT_AUTHORIZED here means the

// response token didn't verify against the configured password.

auto result = req.check_digest_auth("testrealm", "testpass", 300,

0, http_utils::digest_algorithm::MD5);

if (result != http_utils::digest_auth_result::OK) {

return http_response::unauthorized(

digest_challenge{.realm = "testrealm",

.response_body = "FAIL"});

}

// Second call: must hit the cache (lines 293-295 in http_request.cpp).

std::string user2 = std::string(req.get_digested_user());

if (user1 != user2) {

return http_response::string("CACHE_MISMATCH").with_status(500);

}

return http_response::string("USER:" + user1);

}

public:

http_response render_get(const http_request&) {

return http_response::string("SUCCESS");

}

if (req.get_user() != "admin" || req.get_pass() != "secret") {

return http_response::unauthorized("Basic", "testrealm", "Unauthorized");

}

return std::nullopt; // Allow request

public:

http_response render_get(const http_request&) {

return http_response::string("ADMIN_SECRET");

}

public:

http_response render_get(const http_request&) {

return http_response::string("PUBLIC_OK");

}