<legend>Social Auth with Mastodon (not yet supported)</legend>

	<legend>Social Auth with Mastodon</legend>

    let token = match Uuid::parse_str(&token.into_inner()) {

    let token = match Uuid::parse_str(&token.into_inner().replace("=", "")) {

    pub cache_mastodon_state: Mutex<TtlCache<String, String>>,

    pub cache_mastodon_state: Mutex<TtlCache<String, (String, String)>>,

use rand::{rng, RngExt};
use sha2::{Digest, Sha256};

use base64::Engine;

    code_verifier: &str,

            "client_id={}&client_secret={}&redirect_uri={}&grant_type=authorization_code&code={}&scopes=read:accounts",

            "client_id={}&client_secret={}&redirect_uri={}&grant_type=authorization_code&code={}&scopes=read:accounts&code_verifier={}",

            pct_str::PctString::encode(code.chars(), pct_str::UriReserved::Any).as_str()

            pct_str::PctString::encode(code.chars(), pct_str::UriReserved::Any).as_str(),
            code_verifier

    let mut random_bytes = [0u8; 32];
    rng().fill(&mut random_bytes);
    let code_verifier = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(random_bytes);
    let mut hasher = Sha256::new();
    hasher.update(code_verifier.as_bytes());
    let code_challenge = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(hasher.finalize());

    let location = format!("https://{}/oauth/authorize?client_id={}&scope=read:accounts&redirect_uri={}&response_type=code&state={}", 

    let location = format!("https://{}/oauth/authorize?client_id={}&scope=read:accounts&redirect_uri={}&response_type=code&state={}&code_challenge_method=S256&code_challenge={}", 

        state);

        state,
        code_challenge);

            domain,

            (domain, code_verifier),

    if cached_data.is_none_or(|x| x != domain) {
        log::warn!("Unknown state for mastodon redirect: {}", state);
        return HttpResponse::BadRequest().body("Incorrect");
    }

    let code_verifier = match cached_data {
        None => {
            log::warn!("Unknown state for mastodon redirect: {}", state);
            return HttpResponse::BadRequest().body("Incorrect");
        }
        Some((cached_domain, code_verifier)) => {
            if cached_domain != domain {
                log::warn!(
                    "Unknown domain and state for mastodon redirect: {} domain {} != {}",
                    state,
                    domain,
                    cached_domain
                );
                return HttpResponse::BadRequest().body("Incorrect");
            } else {
                code_verifier
            }
        }
    };

            &code_verifier,

[dependencies.rand]
version = "0.10"
features = ["thread_rng"]

 "rand 0.10.1",