/*
     This file is part of libhttpserver
     Copyright (C) 2011-2019 Sebastiano Merlino

     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.

     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.

     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
     USA
*/

// http_request public-API forwarders for the auth/credentials surface:
// get_user / get_pass / get_digested_user, check_digest_auth /
// check_digest_auth_digest, and the high-level TLS / client-certificate
// accessors. The declarations live in httpserver/http_request.hpp.

#include "httpserver/http_request.hpp"

#include <stdint.h>

#include <microhttpd.h>  // NOLINT(build/include_order)

#include <string>
#include <string_view>

#include "httpserver/detail/http_request_impl.hpp"
#include "httpserver/http_utils.hpp"

namespace httpserver {

std::string_view http_request::get_user() const {
#ifdef HAVE_BAUTH
    // Use user_pass_fetched instead of !username.empty() as the cache
    // guard: an empty username string after a successful MHD call is a
    // valid result (no auth header), but would cause a redundant re-fetch
    // on every subsequent get_user() call without the boolean.
    if (!impl_->user_pass_fetched) {
        impl_->fetch_user_pass();
        // fetch_user_pass() sets the flag only on the live path; set it
        // here so the test-request (null connection_) path caches too.
        impl_->user_pass_fetched = true;
    }
    return impl_->username;
#else
    // BAUTH disabled at build time -> empty view (documented sentinel).
    return std::string_view{};
#endif
}

std::string_view http_request::get_pass() const {
#ifdef HAVE_BAUTH
    // Mirror the get_user() boolean guard.
    if (!impl_->user_pass_fetched) {
        impl_->fetch_user_pass();
        impl_->user_pass_fetched = true;
    }
    return impl_->password;
#else
    // BAUTH disabled at build time -> empty view (documented sentinel).
    return std::string_view{};
#endif
}

std::string_view http_request::get_digested_user() const {
#ifdef HAVE_DAUTH
    // Fast-path: cached value (non-empty) or test-request (null connection,
    // digested_user holds whatever create_test_request().digested_user() set).
    // The two conditions are ORed so the null-connection check is not
    // repeated below.
    if (!impl_->digested_user.empty() || impl_->connection_ == nullptr) {
        return impl_->digested_user;
    }

    struct MHD_DigestAuthUsernameInfo* info = MHD_digest_auth_get_username3(impl_->connection_);

    impl_->digested_user = EMPTY;
    if (info != nullptr) {
        if (info->username != nullptr) {
            impl_->digested_user.assign(info->username, info->username_len);
        }
        MHD_free(info);
    }

    return impl_->digested_user;
#else
    // DAUTH disabled at build time -> empty view (documented sentinel).
    return std::string_view{};
#endif
}

http::http_utils::digest_auth_result http_request::check_digest_auth(
    const std::string& realm,
    const std::string& password,
    unsigned int nonce_timeout,
    uint32_t max_nc,
    http::http_utils::digest_algorithm algo) const {
#ifdef HAVE_DAUTH
    // CWE-476 guard: test-request path sets connection_ to nullptr.
    // Passing nullptr to MHD_digest_auth_check3 is undefined behaviour;
    // return the same WRONG_HEADER sentinel used on the HAVE_DAUTH-off
    // path and by get_digested_user() when connection_ is null.
    if (impl_->connection_ == nullptr) {
        return http::http_utils::digest_auth_result::WRONG_HEADER;
    }

    std::string_view digested_user = get_digested_user();

    enum MHD_DigestAuthResult result = MHD_digest_auth_check3(
        impl_->connection_,
        realm.c_str(),
        digested_user.data(),
        password.c_str(),
        nonce_timeout,
        max_nc,
        MHD_DIGEST_AUTH_MULT_QOP_ANY_NON_INT,
        static_cast<MHD_DigestAuthMultiAlgo3>(algo));

    return static_cast<http::http_utils::digest_auth_result>(result);
#else
    // DAUTH disabled at build time -> the call is documented
    // to "return a sentinel result". WRONG_HEADER
    // is the most explicit "this request was never authenticated"
    // terminal value of the digest_auth_result enum.
    (void)realm;
    (void)password;
    (void)nonce_timeout;
    (void)max_nc;
    (void)algo;
    return http::http_utils::digest_auth_result::WRONG_HEADER;
#endif
}

http::http_utils::digest_auth_result http_request::check_digest_auth_digest(
    const std::string& realm,
    const void* userdigest,
    size_t userdigest_size,
    unsigned int nonce_timeout,
    uint32_t max_nc,
    http::http_utils::digest_algorithm algo) const {
#ifdef HAVE_DAUTH
    // CWE-476 guard: same null-connection guard as check_digest_auth.
    if (impl_->connection_ == nullptr) {
        return http::http_utils::digest_auth_result::WRONG_HEADER;
    }

    std::string_view digested_user = get_digested_user();

    enum MHD_DigestAuthResult result = MHD_digest_auth_check_digest3(
        impl_->connection_,
        realm.c_str(),
        digested_user.data(),
        userdigest,
        userdigest_size,
        nonce_timeout,
        max_nc,
        MHD_DIGEST_AUTH_MULT_QOP_ANY_NON_INT,
        static_cast<MHD_DigestAuthMultiAlgo3>(algo));

    return static_cast<http::http_utils::digest_auth_result>(result);
#else
    (void)realm;
    (void)userdigest;
    (void)userdigest_size;
    (void)nonce_timeout;
    (void)max_nc;
    (void)algo;
    return http::http_utils::digest_auth_result::WRONG_HEADER;
#endif
}

// ----------------------------------------------------------------------
// High-level GnuTLS accessors. Public surface is unconditional
// (same symbols visible whether HAVE_GNUTLS is on or off at build time);
// only the body of each method dispatches on HAVE_GNUTLS. Sentinel
// returns when GnuTLS is disabled match the architecture spec §7:
// empty for the four string_view accessors, false for the three
// predicates, -1 for the two time accessors.
//
// Three of the five `noexcept` accessors (is_client_cert_verified and
// the two time accessors) wrap populate_all_cert_fields() in try/catch
// so a hypothetical std::bad_alloc from the cache-fill path doesn't
// violate the noexcept commitment; on throw they return the documented
// sentinel. The other two (has_tls_session / has_client_certificate)
// never call populate_all_cert_fields() -- they query the session
// directly through non-allocating impl methods, so no try/catch is
// needed. The four string_view accessors deliberately omit `noexcept`
// so the allocator failure mode is observable.
// ----------------------------------------------------------------------
bool http_request::has_tls_session() const noexcept {
#ifdef HAVE_GNUTLS
    return impl_->has_tls_session();
#else
    return false;
#endif
}

bool http_request::has_client_certificate() const noexcept {
#ifdef HAVE_GNUTLS
    return impl_->has_client_certificate();
#else
    return false;
#endif
}

std::string_view http_request::get_client_cert_dn() const {
#ifdef HAVE_GNUTLS
    impl_->populate_all_cert_fields();
    return std::string_view(impl_->client_cert_dn.data(),
                            impl_->client_cert_dn.size());
#else
    return std::string_view{};
#endif
}

std::string_view http_request::get_client_cert_issuer_dn() const {
#ifdef HAVE_GNUTLS
    impl_->populate_all_cert_fields();
    return std::string_view(impl_->client_cert_issuer_dn.data(),
                            impl_->client_cert_issuer_dn.size());
#else
    return std::string_view{};
#endif
}

std::string_view http_request::get_client_cert_cn() const {
#ifdef HAVE_GNUTLS
    impl_->populate_all_cert_fields();
    return std::string_view(impl_->client_cert_cn.data(),
                            impl_->client_cert_cn.size());
#else
    return std::string_view{};
#endif
}

std::string_view http_request::get_client_cert_fingerprint_sha256() const {
#ifdef HAVE_GNUTLS
    impl_->populate_all_cert_fields();
    return std::string_view(impl_->client_cert_fingerprint_sha256.data(),
                            impl_->client_cert_fingerprint_sha256.size());
#else
    return std::string_view{};
#endif
}

bool http_request::is_client_cert_verified() const noexcept {
#ifdef HAVE_GNUTLS
    try {
        impl_->populate_all_cert_fields();
        return impl_->client_cert_verified;
    } catch (...) {
        return false;
    }
#else
    return false;
#endif
}

std::int64_t http_request::get_client_cert_not_before() const noexcept {
#ifdef HAVE_GNUTLS
    try {
        impl_->populate_all_cert_fields();
        return impl_->client_cert_not_before;
    } catch (...) {
        return -1;
    }
#else
    return -1;
#endif
}

std::int64_t http_request::get_client_cert_not_after() const noexcept {
#ifdef HAVE_GNUTLS
    try {
        impl_->populate_all_cert_fields();
        return impl_->client_cert_not_after;
    } catch (...) {
        return -1;
    }
#else
    return -1;
#endif
}

}  // namespace httpserver