Struct NegTokenResp

pub struct NegTokenResp<'a> {
    pub neg_state: Option<NegState>,
    pub supported_mech: Option<MechType>,
    pub response_token: Option<OctetStringRef<'a>>,
    pub mech_list_mic: Option<OctetStringRef<'a>>,
}

NegTokenResp as defined in RFC 4178 Section 4.2.2.

NegTokenResp ::= SEQUENCE {
negState       [0] ENUMERATED {
    accept-completed    (0),
    accept-incomplete   (1),
    reject              (2),
    request-mic         (3)
}                                 OPTIONAL,
  -- REQUIRED in the first reply from the target
supportedMech   [1] MechType      OPTIONAL,
  -- present only in the first reply from the target
responseToken   [2] OCTET STRING  OPTIONAL,
mechListMIC     [3] OCTET STRING  OPTIONAL,
...
}

Fields

neg_state: Option<NegState>

This field is REQUIRED in the first reply from the target, and is OPTIONAL thereafter. When negState is absent, the actual state should be inferred from the state of the negotiated mechanism context.

supported_mech: Option<MechType>

This field SHALL only be present in the first reply from the target. It MUST be one of the mechanism(s) offered by the initiator.

response_token: Option<OctetStringRef<'a>>

This field, if present, contains tokens specific to the mechanism selected.

mech_list_mic: Option<OctetStringRef<'a>>

This field, if present, contains an MIC token for the mechanism list in the initial negotiation message. This MIC token is computed according to Section 5.

Trait Implementations

impl<'a> Clone for NegTokenResp<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for NegTokenResp<'a>

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

Formats the value using the given formatter.

impl<'a> DecodeValue<'a> for NegTokenResp<'a>

fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>

Attempt to decode this message using the provided Reader.

impl<'a> EncodeValue for NegTokenResp<'a>

fn value_len(&self) -> Result<Length>

Compute the length of this value (sans [Tag]+Length header) when encoded as ASN.1 DER.

fn encode_value(&self, writer: &mut impl Writer) -> Result<()>

Encode value (sans [Tag]+Length header) as ASN.1 DER using the provided Writer.

fn header(&self) -> Result<Header, Error>

where Self: Tagged,

Get the Header used to encode this value.

impl<'a> PartialEq for NegTokenResp<'a>

fn eq(&self, other: &NegTokenResp<'a>) -> bool

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

const 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<'a> Eq for NegTokenResp<'a>

impl<'a> Sequence<'a> for NegTokenResp<'a>

impl<'a> StructuralPartialEq for NegTokenResp<'a>