Enum ParError 

pub enum ParError {
    MissingParameter(&'static str),
    UnsupportedResponseType,
    UnsupportedResponseMode(String),
    RedirectUriNotRegistered(String),
    UnsupportedCodeChallengeMethod(String),
    MalformedCodeChallenge,
    TooLong {
        field: &'static str,
        max: usize,
    },
    BadScope(ScopeParseError),
    ClientId(ClientIdError),
    ClientMetadata(ClientMetadataError),
    ClientAuthentication(ClientAuthError),
    DpopKeyMismatch,
    ClientRefused,
    TooManyPending(DecisionRefused),
}

Why a pushed request could not be accepted.

Variants

MissingParameter(&'static str)

A required OAuth parameter was absent.

UnsupportedResponseType

response_type named something other than code.

UnsupportedResponseMode(String)

response_mode named a mode this server does not answer in.

RedirectUriNotRegistered(String)

redirect_uri is not one the client’s own metadata declares.

UnsupportedCodeChallengeMethod(String)

code_challenge_method named something other than S256.

MalformedCodeChallenge

code_challenge is not 43 base64url characters, which every S256 challenge is.

TooLong

A parameter is longer than any value a client sends for it; see MAX_STATE_BYTES and MAX_LOGIN_HINT_BYTES.

Fields

field: &'static str

The parameter.

max: usize

Its bound, in bytes.

BadScope(ScopeParseError)

scope did not parse as the atproto scope grammar.

ClientId(ClientIdError)

client_id is not in the one spelling a policy matches; see didbot_policy::ClientId.

ClientMetadata(ClientMetadataError)

The client’s metadata document could not be fetched or validated.

One sentence for every way that can happen, naming nothing the fetch found. client_id is a URL this unauthenticated caller chose, so a message that distinguished “nothing answered” from “it redirected” from “the body was too large” would answer questions about this deployment’s own network for whoever asked them — see didbot_http::REFUSED_BLOCKS for the addresses that are refused before the fetch. The cause this variant carries is written to the journal instead; see crate::refusal.

ClientAuthentication(ClientAuthError)

The client did not authenticate the way its metadata says it does; see crate::oauth::client_auth.

DpopKeyMismatch

dpop_jkt names a key other than the one the push’s DPoP proof was signed with (RFC 9449 §10.1).

ClientRefused

plan/policy.md’s gate refuses every grant this client_id could ever ask for here — a denyClient rule, or any rule shaped the same way — independent of which account login_hint names. didbot_policy::Subject::Grant carries no account field at all (see didbot_pds::policy::grant_subject), so this judgment is a fact about the client and the requested scope alone; checking it before login_hint is even resolved changes nothing it could answer.

Refused here, before a decision record exists, and the same way for every login_hint alike — a real account, an account this gate would otherwise grant, or one nobody has ever heard of, since the judgment is made before any of them is looked at. That is what keeps this refusal from being a second account-enumeration oracle beside the one push_authorization_request’s own doc closes: it fires on client_id and requested scope alone, so no login_hint value can change which way it comes out. A grant this deployment would make still gets the ordinary opaque-decision-record treatment (plan/oauth.md’s “a pushed request is a decision record”) — only a client this gate refuses unconditionally skips minting one, because there is nothing an account could approve.

TooManyPending(DecisionRefused)

This server already holds as many undecided records as it will at once — server load, not a fact about any account, so it is safe to answer identically to every caller. Only ever built from DecisionRefused::TooMany: an account’s own bound overflowing is answered as a plain success instead, never as this — see push_authorization_request’s own doc for why.

Trait Implementations

impl Clone for ParError

fn clone(&self) -> ParError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ParError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for ParError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ClientAuthError> for ParError

fn from(source: ClientAuthError) -> Self

Converts to this type from the input type.

impl From<ClientIdError> for ParError

fn from(source: ClientIdError) -> Self

Converts to this type from the input type.

impl From<ClientMetadataError> for ParError

fn from(source: ClientMetadataError) -> Self

Converts to this type from the input type.

impl From<DecisionRefused> for ParError

fn from(source: DecisionRefused) -> Self

Converts to this type from the input type.

impl From<ScopeParseError> for ParError

fn from(source: ScopeParseError) -> Self

Converts to this type from the input type.

impl PartialEq for ParError

fn eq(&self, other: &ParError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ParError

impl StructuralPartialEq for ParError