Enum der::ErrorKind

#[non_exhaustive]
pub enum ErrorKind {
    DateTime,
    Failed,
    Incomplete {
        expected_len: Length,
        actual_len: Length,
    },
    Length {
        tag: Tag,
    },
    Noncanonical {
        tag: Tag,
    },
    OidMalformed,
    OidUnknown {
        oid: ObjectIdentifier,
    },
    SetOrdering,
    Overflow,
    Overlength,
    TagModeUnknown,
    TagNumberInvalid,
    TagUnexpected {
        expected: Option<Tag>,
        actual: Tag,
    },
    TagUnknown {
        byte: u8,
    },
    TrailingData {
        decoded: Length,
        remaining: Length,
    },
    Utf8(Utf8Error),
    Value {
        tag: Tag,
    },
}

Error type.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

DateTime

Date-and-time related errors.

Failed

This error indicates a previous DER parsing operation resulted in an error and tainted the state of a Decoder or Encoder.

Once this occurs, the overall operation has failed and cannot be subsequently resumed.

Incomplete

Message is incomplete and does not contain all of the expected data.

Fields

expected_len: Length

Expected message length.

Note that this length represents a minimum lower bound on how much additional data is needed to continue parsing the message.

It’s possible upon subsequent message parsing that the parser will discover even more data is needed.

actual_len: Length

Actual length of the message buffer currently being processed.

Length

Incorrect length for a given field.

Fields

tag: Tag

Tag of the value being decoded.

Noncanonical

Message is not canonically encoded.

Fields

tag: Tag

Tag of the value which is not canonically encoded.

OidMalformed

OID is improperly encoded.

OidUnknown

Unknown OID.

This error is intended to be used by libraries which parse DER-based formats which encounter unknown or unsupported OID libraries.

It enables passing back the OID value to the caller, which allows them to determine which OID(s) are causing the error (and then potentially contribute upstream support for algorithms they care about).

Fields

oid: ObjectIdentifier

OID value that was unrecognized by a parser for a DER-based format.

SetOrdering

SET ordering error: items not in canonical order.

Overflow

Integer overflow occurred (library bug!).

Overlength

Message is longer than this library’s internal limits support.

TagModeUnknown

Unknown tag mode.

TagNumberInvalid

Invalid tag number.

The “tag number” is the lower 5-bits of a tag’s octet. This error occurs in the case that all 5-bits are set to 1, which indicates a multi-byte tag which is unsupported by this library.

TagUnexpected

Unexpected tag.

Fields

expected: Option<Tag>

Tag the decoder was expecting (if there is a single such tag).

None if multiple tags are expected/allowed, but the actual tag does not match any of them.

actual: Tag

Actual tag encountered in the message.

TagUnknown

Unknown/unsupported tag.

Fields

byte: u8

Raw byte value of the tag.

TrailingData

Undecoded trailing data at end of message.

Fields

decoded: Length

Length of the decoded data.

remaining: Length

Total length of the remaining data left in the buffer.

Utf8(Utf8Error)

UTF-8 errors.

Value

Unexpected value.

Fields

tag: Tag

Tag of the unexpected value.

Implementations

impl ErrorKind

pub fn at(self, position: Length) -> Error

Annotate an ErrorKind with context about where it occurred, returning an error.

pub fn incomplete(self) -> Option<usize>

If this is an ErrorKind::Incomplete, return the expected_len.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl From<ErrorKind> for Error

fn from(kind: ErrorKind) -> Error

Converts to this type from the input type.

impl PartialEq for ErrorKind

fn eq(&self, other: &ErrorKind) -> 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 Copy for ErrorKind

impl Eq for ErrorKind

impl StructuralPartialEq for ErrorKind