Struct EngineState 

pub struct EngineState {
    pub engine_id: Bytes,
    pub engine_boots: u32,
    pub engine_time: u32,
    pub synced_at: Instant,
    pub latest_received_engine_time: u32,
    pub msg_max_size: u32,
}

Discovered engine state.

Fields

engine_id: Bytes

Authoritative engine ID

engine_boots: u32

Engine boot count

engine_time: u32

Engine time at last sync

synced_at: Instant

Local time when engine_time was received

latest_received_engine_time: u32

Latest received engine time (for anti-replay, RFC 3414 Section 2.3)

msg_max_size: u32

Maximum message size the remote engine can accept (from its advertised msgMaxSize header). This is the remote’s outbound limit and is used to constrain the size of messages we send to it. It is NOT the value we advertise in our own outgoing messages: RFC 3412 Section 6.3 requires msgMaxSize to carry the sender’s OWN receive capacity (our transport’s max_message_size), tracked separately from this field.

Implementations

impl EngineState

pub fn new(engine_id: Bytes, engine_boots: u32, engine_time: u32) -> Self

Create new engine state from discovery response.

pub fn with_msg_max_size( engine_id: Bytes, engine_boots: u32, engine_time: u32, msg_max_size: u32, ) -> Self

Create with explicit msgMaxSize from agent’s header.

pub fn with_msg_max_size_capped( engine_id: Bytes, engine_boots: u32, engine_time: u32, reported_msg_max_size: u32, session_max: u32, ) -> Self

Create with msgMaxSize capped to session maximum.

Non-compliant agents may advertise msgMaxSize values larger than they can handle. This caps the value to a known safe session limit.

pub fn estimated_time(&self) -> u32

Get the estimated current engine time.

This adds elapsed local time to the synced engine time. Per RFC 3414 Section 2.2.1, the result is capped at MAX_ENGINE_TIME (2^31-1).

Note: the client does not locally increment engine_boots when the estimated time reaches MAX_ENGINE_TIME. The authoritative engine (agent) is responsible for the boots increment; the client will learn the new boots value from the agent’s next response or from a notInTimeWindow Report. Until that happens, the capped time is the best estimate the client can produce.

pub fn update_time(&mut self, response_boots: u32, response_time: u32) -> bool

Update time from a response.

Per RFC 3414 Section 3.2 Step 7b, only update if:

• Response boots > local boots, OR
• Response boots == local boots AND response time > latest_received_engine_time

pub fn resync(&mut self, boots: u32, time: u32)

Unconditionally set boots/time from an authenticated source, allowing the local notion to move backward.

Unlike update_time, which only moves forward for anti-replay, this replaces the boots/time even when the new values are lower. It must only be called after the source message’s authenticity has been verified: per RFC 3414 Section 2.3, an authenticated notInTimeWindow Report carries the authoritative engine’s true boots/time, so trusting it recovers from an agent that reset its time without incrementing boots (e.g. a restart that does not persist snmpEngineBoots).

pub fn check_and_update_timeliness( &mut self, msg_boots: u32, msg_time: u32, ) -> bool

Timeliness check for messages from a remote authoritative engine (RFC 3414 Section 3.2 Step 7b, non-authoritative role).

First updates the local notion of the remote engine’s boots/time if the message is newer (see update_time), then evaluates the asymmetric time window: the message is outside the window only if the local boots notion is latched at the maximum, the message’s boots value is older than the local notion, or the message’s time is more than 150 seconds behind the local notion.

The caller must verify the message is authentic before calling this, since it mutates the timeliness state.

Returns true if the message is within the time window.

pub fn is_in_time_window(&self, msg_boots: u32, msg_time: u32) -> bool

Check if a message time is within the time window.

Per RFC 3414 Section 2.2.3, a message is outside the window if:

• Local boots is 2,147,483,647 (latched), OR
• Message boots differs from local boots, OR
• |message_time - local_time| > 150 seconds

Trait Implementations

impl Clone for EngineState

fn clone(&self) -> EngineState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineState

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

Formats the value using the given formatter.