rsnmp 0.1.0

An SNMP library for Rust (wip)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use crate::oid::IntoObjectIdentifier;
use crate::oid::ObjectIdentifierExt;
use crate::session::{Error, Session, SessionOptions, VersionedSession};
use rasn::prelude::{ObjectIdentifier, OctetString};
use rasn_smi::v1::{ObjectSyntax, SimpleSyntax};
use rasn_snmp::v1;
use rasn_snmp::v1::{GetNextRequest, GetRequest, Message, Pdus, VarBind};
use tokio::io;

/// An implementation of [`VersionedSession`] for SNMPv1.
pub struct V1;

impl VersionedSession for V1 {
    type Message = Message<Pdus>;
    type Options = V1Options;
}

pub struct V1Options {
    pub community: String,
}

impl Session<V1> {
    /// Constructs a new SNMPv1 session.
    pub async fn v1(options: SessionOptions<V1Options>) -> io::Result<Session<V1>> {
        Self::new(options).await
    }

    /// Performs an SNMPv1 GET request using the provided OID.
    pub async fn get<S>(&self, oid: S) -> Result<VarBind, Error>
    where
        S: AsRef<str>,
    {
        let mut results = self.get_bulk([oid]).await?;
        results.pop().ok_or(Error::UnexpectedResponseType(
            "Expected at least one result, got none".to_string(),
        ))
    }

    /// Performs an SNMPv1 GET request using the provided OIDs.
    pub async fn get_bulk<I, S>(&self, oids: I) -> Result<Vec<VarBind>, Error>
    where
        I: IntoIterator<Item = S>,
        S: AsRef<str>,
    {
        // Convert each oid into variable bindings
        let bindings = oids
            .into_iter()
            .map(|oid| {
                ObjectIdentifier::parse(oid.as_ref()).map(|oid| VarBind {
                    name: oid,
                    value: ObjectSyntax::Simple(SimpleSyntax::Empty),
                })
            })
            .collect::<Result<Vec<_>, _>>()?;
        let bindings_len = bindings.len();

        // Construct the SNMPv1 message
        let message = Message {
            version: 1.into(),
            community: OctetString::from(self.inner.options.snmp.community.clone()),
            data: Pdus::GetRequest(GetRequest(v1::Pdu {
                request_id: self.next_request_id(),
                variable_bindings: bindings,
                error_index: Default::default(),
                error_status: Default::default(),
            })),
        };

        // Send the message and wait for the response
        match self.send(message).await?.data {
            Pdus::GetResponse(response) => {
                let results = response.0.variable_bindings.to_vec();
                if results.len() != bindings_len {
                    Err(Error::UnexpectedResponseType(format!(
                        "Expected {} results, got {}",
                        bindings_len,
                        results.len()
                    )))
                } else {
                    Ok(results)
                }
            }
            data => Err(Error::UnexpectedResponseType(format!(
                "Expected GetResponse, got {:?}",
                data
            ))),
        }
    }

    /// Performs an SNMPv1 GET NEXT request, returning the next [`VarBind`] in the MIB.
    pub async fn get_next<T>(&self, oid: T) -> Result<VarBind, Error>
    where
        T: IntoObjectIdentifier,
    {
        let message = Message {
            version: 1.into(),
            community: OctetString::from(self.inner.options.snmp.community.clone()),
            data: Pdus::GetNextRequest(GetNextRequest(v1::Pdu {
                request_id: self.next_request_id(),
                variable_bindings: vec![oid.into().map(|oid| VarBind {
                    name: oid,
                    value: ObjectSyntax::Simple(SimpleSyntax::Empty),
                })?],
                error_index: Default::default(),
                error_status: Default::default(),
            })),
        };

        // Send the message and wait for the response
        match self.send(message).await?.data {
            Pdus::GetResponse(response) => Ok(response.0.variable_bindings.to_vec().pop().ok_or(
                Error::UnexpectedResponseType("Expected at least one result, got none".to_string()),
            )?),
            data => Err(Error::UnexpectedResponseType(format!(
                "Expected GetResponse, got {:?}",
                data
            ))),
        }
    }

    pub async fn walk<T>(&self, root: T) -> Result<Vec<VarBind>, Error>
    where
        T: IntoObjectIdentifier,
    {
        let root = root.into()?;
        let mut next = root.clone();
        let mut results = Vec::new();

        loop {
            let result = self.get_next(next.clone()).await?;
            if result.name.is_within(&root) {
                next = result.name.clone();
                results.push(result);
            } else {
                break;
            }
        }

        Ok(results)
    }
}