Struct Header

pub struct Header<'a> { /* private fields */ }

BER/DER object header (identifier and length)

Implementations

impl<'a> Header<'a>

pub const fn new( class: Class, constructed: bool, tag: Tag, length: Length, ) -> Self

Build a new BER/DER header from the provided values

pub const fn new_simple(tag: Tag) -> Self

Build a new BER/DER header from the provided tag, with default values for other fields

pub fn with_class(self, class: Class) -> Self

Set the class of this Header

pub fn with_constructed(self, constructed: bool) -> Self

Set the constructed flags of this Header

pub fn with_tag(self, tag: Tag) -> Self

Set the tag of this Header

pub fn with_length(self, length: Length) -> Self

Set the length of this Header

pub fn with_raw_tag(self, raw_tag: Option<Cow<'a, [u8]>>) -> Self

Update header to add reference to raw tag

pub fn with_raw_header(self, raw_header: Option<Input<'a>>) -> Self

Update header to add reference to raw header

pub const fn class(&self) -> Class

Return the class of this header.

pub const fn constructed(&self) -> bool

Return true if this header has the ‘constructed’ flag.

pub const fn tag(&self) -> Tag

Return the tag of this header.

pub const fn length(&self) -> Length

Return the length of this header.

pub fn raw_tag(&self) -> Option<&[u8]>

Return the raw tag encoding, if it was stored in this object

pub fn raw_header(&self) -> Option<&Input<'a>>

Return the raw tag encoding, if it was stored in this object

pub const fn is_primitive(&self) -> bool

Test if object is primitive

pub const fn is_constructed(&self) -> bool

Test if object is constructed

pub const fn assert_class(&self, class: Class) -> Result<()>

Return error if class is not the expected class

pub const fn assert_tag(&self, tag: Tag) -> Result<()>

Return error if tag is not the expected tag

pub const fn assert_primitive(&self) -> Result<()>

Return error if object is not primitive (returning an Error)

pub const fn assert_primitive_inner(&self) -> Result<(), InnerError>

Return error if object is not primitive (returning an InnerError)

pub const fn assert_primitive_input<'i>( &self, input: &Input<'i>, ) -> Result<(), BerError<Input<'i>>>

Return error if object is not primitive (returning a BerError)

pub const fn assert_constructed(&self) -> Result<()>

Return error if object is primitive

pub const fn assert_constructed_inner(&self) -> Result<(), InnerError>

Return error if object is primitive

pub const fn assert_constructed_input<'i>( &self, input: &Input<'i>, ) -> Result<(), BerError<Input<'i>>>

Return error if object is primitive (returning a BerError)

pub const fn is_universal(&self) -> bool

Test if object class is Universal

pub const fn is_application(&self) -> bool

Test if object class is Application

pub const fn is_contextspecific(&self) -> bool

Test if object class is Context-specific

pub const fn is_private(&self) -> bool

Test if object class is Private

pub const fn assert_definite(&self) -> Result<()>

Return error if object length is definite

pub const fn assert_definite_inner(&self) -> Result<(), InnerError>

Return error if object length is definite

pub fn parse_ber_content<'i>( &self, i: Input<'i>, ) -> IResult<Input<'i>, Input<'i>, BerError<Input<'i>>>

Get the content following a BER header

pub fn parse_der_content<'i>( &self, i: Input<'i>, ) -> IResult<Input<'i>, Input<'i>, BerError<Input<'i>>>

Get the content following a DER header

Trait Implementations

impl<'i> BerParser<'i> for Header<'i>

fn from_ber_content( header: &Header<'i>, input: Input<'i>, ) -> IResult<Input<'i>, Self, Self::Error>

This method is usually not called (and will create a useless clone)

type Error = BerError<Input<'i>>

The Error type for parsing errors.

fn parse_ber(input: Input<'i>) -> IResult<Input<'i>, Self, Self::Error>

Attempt to parse a new BER object from data.

fn parse_ber_optional( input: Input<'i>, ) -> IResult<Input<'i>, Option<Self>, Self::Error>

fn parse_ber_as_input( input: Input<'i>, ) -> IResult<Input<'i>, (Header<'i>, Input<'i>), Self::Error>

Parse object header (validating tag) and return header and content as Input

impl<'a> Clone for Header<'a>

fn clone(&self) -> Header<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Header<'a>

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

Formats the value using the given formatter.

impl<'i> DerParser<'i> for Header<'i>

fn from_der_content( header: &Header<'i>, input: Input<'i>, ) -> IResult<Input<'i>, Self, Self::Error>

This method is usually not called (and will create a useless clone)

type Error = BerError<Input<'i>>

The Error type for parsing errors.

fn parse_der(input: Input<'i>) -> IResult<Input<'i>, Self, Self::Error>

Attempt to parse a new DER object from data.

fn parse_der_optional( input: Input<'i>, ) -> IResult<Input<'i>, Option<Self>, Self::Error>

fn parse_der_as_input( input: Input<'i>, ) -> IResult<Input<'i>, (Header<'i>, Input<'i>), Self::Error>

Parse object header (validating tag) and return header and content as Input

impl DynTagged for Header<'_>

fn class(&self) -> Class

Return the class of the object

fn constructed(&self) -> bool

Return true if the object is constructed

fn tag(&self) -> Tag

Return the tag number of the object

fn accept_tag(_: Tag) -> bool

Return true if the tag number is acceptable for this object

impl From<Tag> for Header<'_>

fn from(tag: Tag) -> Self

Converts to this type from the input type.

impl<'a> FromBer<'a> for Header<'a>

fn from_ber(bytes: &'a [u8]) -> ParseResult<'a, Self>

Attempt to parse input bytes into a BER object

impl<'a> FromDer<'a> for Header<'a>

fn from_der(bytes: &'a [u8]) -> ParseResult<'a, Self>

Attempt to parse input bytes into a DER object (enforcing constraints)

impl Hash for Header<'_>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Header<'a>

Compare two BER headers. len fields are compared only if both objects have it set (same for raw_tag)

fn eq(&self, other: &Header<'_>) -> 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 ToBer for Header<'_>

type Encoder = BerGenericEncoder

fn ber_content_len(&self) -> Length

Returns the length of the encoded content of the object

fn ber_write_content<W: Write>(&self, _: &mut W) -> SerializeResult<usize>

Encode and write the content of the object to the writer target

fn ber_tag_info(&self) -> (Class, bool, Tag)

Return the tag information to be encoded in header

fn ber_total_len(&self) -> Length

Returns the total length (including header) of the encoded content of the object

fn ber_write_header<W: Write>(&self, target: &mut W) -> SerializeResult<usize>

Encode and write the header of the object to the writer target

fn ber_encode<W: Write>(&self, target: &mut W) -> SerializeResult<usize>

Encode and write the object (header + content) to the writer target

fn ber_encode_tagged_explicit<W: Write>( &self, class: Class, tag_number: u32, target: &mut W, ) -> SerializeResult<usize>

Encode and write the object (header + content) as TAGGED EXPLICIT and write it to the writer target

fn ber_encode_tagged_implicit<W: Write>( &self, class: Class, tag_number: u32, target: &mut W, ) -> SerializeResult<usize>

Encode and write the object (header + content) as TAGGED IMPLICIT and write it to the writer target

fn to_ber_vec(&self) -> SerializeResult<Vec<u8>>

Write the DER encoded representation to a newly allocated Vec<u8>

fn write_ber<W: Write>(&self, writer: &mut W) -> SerializeResult<usize>

Encode in BER and write the object (header + content) to the writer target

impl ToDer for Header<'_>

type Encoder = BerGenericEncoder

fn der_content_len(&self) -> Length

Returns the length of the encoded content of the object

fn der_write_content<W: Write>(&self, _: &mut W) -> SerializeResult<usize>

Encode and write the content of the object to the writer target

fn der_tag_info(&self) -> (Class, bool, Tag)

Return the tag information to be encoded in header

fn der_total_len(&self) -> Length

Returns the total length (including header) of the encoded content of the object

fn der_write_header<W: Write>(&self, target: &mut W) -> SerializeResult<usize>

Encode and write the header of the object to the writer target

fn der_encode<W: Write>(&self, target: &mut W) -> SerializeResult<usize>

Encode and write the object (header + content) to the writer target

fn der_encode_tagged_explicit<W: Write>( &self, class: Class, tag_number: u32, target: &mut W, ) -> SerializeResult<usize>

Encode and write the object (header + content) as TAGGED EXPLICIT and write it to the writer target

fn der_encode_tagged_implicit<W: Write>( &self, class: Class, tag_number: u32, target: &mut W, ) -> SerializeResult<usize>

Encode and write the object (header + content) as TAGGED IMPLICIT and write it to the writer target

fn to_der_vec(&self) -> SerializeResult<Vec<u8>>

Write the DER encoded representation to a newly allocated Vec<u8>

fn write_der<W: Write>(&self, writer: &mut W) -> SerializeResult<usize>

Encode in DER and write the object (header + content) to the writer target

fn to_der_len(&self) -> Result<usize>

👎Deprecated since 0.8.0: Use der_total_len() instead.

Get the length of the object (including the header), when encoded

fn to_der_vec_raw(&self) -> SerializeResult<Vec<u8>>

👎Deprecated since 0.8.0: Use to_der_vec() instead.

impl ToStatic for Header<'_>

type Owned = Header<'static>

fn to_static(&self) -> Self::Owned

impl Eq for Header<'_>