bearer_auth.hpp

Go to the documentation of this file.

/*
 * RESTinio
 */

 
#pragma once
 
#include <restinio/helpers/http_field_parsers/authorization.hpp>
 
#include <restinio/http_headers.hpp>
#include <restinio/request_handler.hpp>
#include <restinio/expected.hpp>
 
#include <iostream>
 
namespace restinio
{
 
namespace http_field_parsers
{
 
namespace bearer_auth
{
 
//
// params_t
//
struct params_t
{

    std::string token;
};
 
//
// extraction_error_t
//
enum class extraction_error_t
{
    no_auth_http_field,

    illegal_http_field_value,

    not_bearer_auth_scheme,

    invalid_bearer_auth_param,
};

[[nodiscard]]
inline string_view_t
to_string_view( extraction_error_t what ) noexcept
{
    string_view_t result{ "<unknown>" };
 
    switch( what )
    {
    case extraction_error_t::no_auth_http_field:
        result = string_view_t{ "no_auth_http_field" };
    break;
    
    case extraction_error_t::illegal_http_field_value:
        result = string_view_t{ "illegal_http_field_value" };
    break;
 
    case extraction_error_t::not_bearer_auth_scheme:
        result = string_view_t{ "not_bearer_auth_scheme" };
    break;
 
    case extraction_error_t::invalid_bearer_auth_param:
        result = string_view_t{ "invalid_bearer_auth_param" };
    break;
    }
 
    return result;
}
 
//
// try_extract_params
//
[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
try_extract_params(
    const authorization_value_t & http_field )
{
    const auto * b64token = std::get_if<authorization_value_t::token68_t>(
            &http_field.auth_param );
    if( !b64token )
        return make_unexpected( extraction_error_t::invalid_bearer_auth_param );
 
    return params_t{ b64token->value };
}

[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
try_extract_params(
    authorization_value_t && http_field )
{
    auto * b64token = std::get_if<authorization_value_t::token68_t>(
            &http_field.auth_param );
    if( !b64token )
        return make_unexpected( extraction_error_t::invalid_bearer_auth_param );
 
    return params_t{ std::move(b64token->value) };
}
 
namespace impl
{
 
[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
perform_extraction_attempt(
    const std::optional< string_view_t > opt_field_value )
{
    if( !opt_field_value )
        return make_unexpected( extraction_error_t::no_auth_http_field );
 
    auto field_value_parse_result = authorization_value_t::try_parse(
            *opt_field_value );
    if( !field_value_parse_result )
        return make_unexpected( extraction_error_t::illegal_http_field_value );
 
    auto & parsed_value = *field_value_parse_result;
    if( "bearer" != parsed_value.auth_scheme )
        return make_unexpected( extraction_error_t::not_bearer_auth_scheme );
 
    return try_extract_params( std::move(parsed_value) );
}
 
} /* namespace impl */
 
//
// try_extract_params
//
[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
try_extract_params(
    const http_header_fields_t & fields,
    string_view_t auth_field_name )
{
    return impl::perform_extraction_attempt(
            fields.opt_value_of( auth_field_name ) );
}

template< typename Extra_Data >
[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
try_extract_params(
    const generic_request_t< Extra_Data > & req,
    string_view_t auth_field_name )
{
    return try_extract_params( req.header(), auth_field_name );
}

[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
try_extract_params(
    const http_header_fields_t & fields,
    http_field_t auth_field_id )
{
    return impl::perform_extraction_attempt(
            fields.opt_value_of( auth_field_id ) );
}

template< typename Extra_Data >
[[nodiscard]]
inline expected_t< params_t, extraction_error_t >
try_extract_params(
    const generic_request_t< Extra_Data > & req,
    http_field_t auth_field_id )
{
    return try_extract_params( req.header(), auth_field_id );
}
 
} /* namespace bearer_auth */
 
} /* namespace http_field_parsers */
 
} /* namespace restinio */