mib-rs 0.8.0

SNMP MIB parser and resolver
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
142
143
144
145
146
147
148
149

//! Demonstrate all query formats: plain names, qualified names, numeric OIDs,
//! instance OIDs, and OID formatting.

use mib_rs::Loader;

fn main() {
    let source = mib_rs::source::memory(
        "DOC-EXAMPLE-MIB",
        include_bytes!("../tests/data/doc-example-mib.txt").as_slice(),
    );

    let mib = Loader::new()
        .source(source)
        .modules(["DOC-EXAMPLE-MIB"])
        .load()
        .expect("should load");

    // -- Plain name lookup --
    // resolve_node returns the Node handle for a name.
    let node = mib.resolve_node("docDeviceName").expect("should resolve");
    println!("Plain name lookup:");
    println!("  Name: {}", node.name());
    println!("  OID:  {}", node.oid());
    println!("  Kind: {:?}", node.kind());

    // -- Qualified name (MODULE::name) --
    // Scopes the lookup to a specific module.
    let node = mib
        .resolve_node("DOC-EXAMPLE-MIB::docDeviceName")
        .expect("should resolve");
    println!("\nQualified name lookup:");
    println!("  Name: {}", node.name());
    println!("  OID:  {}", node.oid());

    // -- Numeric OID --
    let oid_str = "1.3.6.1.4.1.99999.1.1";
    let node = mib.resolve_node(oid_str).expect("should resolve");
    println!("\nNumeric OID lookup ({oid_str}):");
    println!("  Name: {}", node.name());
    println!("  OID:  {}", node.oid());

    // -- Leading-dot numeric OID --
    let node = mib
        .resolve_node(".1.3.6.1.4.1.99999.1.1")
        .expect("should resolve");
    println!("\nLeading-dot OID: {}", node.name());

    // -- resolve_oid: symbolic name to numeric OID --
    let oid = mib.resolve_oid("docDescr").expect("should resolve");
    println!("\nresolve_oid(\"docDescr\"): {oid}");

    // -- Instance OIDs (name.suffix) --
    // resolve_node returns the deepest matching tree node.
    let node = mib
        .resolve_node("docDescr.7")
        .expect("should resolve instance");
    println!("\nInstance OID - resolve_node(\"docDescr.7\"):");
    println!(
        "  Node name: {} (the base node, not the instance)",
        node.name()
    );

    // resolve_oid returns the full numeric OID with suffix included.
    let instance_oid = mib
        .resolve_oid("docDescr.7")
        .expect("should resolve instance");
    println!("  Full OID:  {instance_oid}");

    // Multi-component instance suffix
    let deep = mib.resolve_oid("docDescr.1.2.3").expect("should resolve");
    println!("  Multi-suffix: {deep}");

    // -- Numeric instance OID --
    let parsed: mib_rs::Oid = "1.3.6.1.4.1.99999.2.1.1.2.42".parse().unwrap();
    let node = mib.lookup_oid(&parsed);
    println!(
        "\nlookup_oid(\"...2.42\"): {} (longest prefix match)",
        node.name()
    );

    // exact_node_by_oid only matches if the OID is an exact tree node.
    let exact = mib.exact_node_by_oid(&parsed);
    println!(
        "exact_node_by_oid: {:?} (None because .42 is an instance)",
        exact.map(|n| n.name())
    );

    let base_oid: mib_rs::Oid = "1.3.6.1.4.1.99999.2.1.1.2".parse().unwrap();
    let exact = mib.exact_node_by_oid(&base_oid);
    println!(
        "exact_node_by_oid(base): {:?} (exact match)",
        exact.map(|n| n.name())
    );

    // -- format_oid: numeric OID back to MODULE::name.suffix --
    let oid = mib.resolve_oid("docDescr.7").unwrap();
    let formatted = mib.format_oid(&oid);
    println!("\nformat_oid: {formatted}");

    // Round-trip: formatted string back to OID.
    let round_trip = mib.resolve_oid(&formatted).unwrap();
    println!("Round-trip:  {round_trip}");
    assert_eq!(oid, round_trip);

    // -- lookup_instance: node + suffix + index decoding --
    // Given a full instance OID (column.index), split it into the base
    // node and instance suffix, then decode the suffix into typed index
    // values using the row's INDEX clause.
    let oid = mib.resolve_oid("docDescr.7").unwrap();
    let lookup = mib.lookup_instance(&oid);
    println!("\nlookup_instance(\"docDescr.7\"):");
    println!("  Node:   {}", lookup.node().name());
    println!("  Suffix: {:?}", lookup.suffix());
    for idx in lookup.decode_indexes() {
        println!("  Index:  {}={}", idx.name(), idx.value());
    }

    // -- resolve: returns NodeId (lower-level) --
    let node_id = mib.raw().resolve("docTable");
    println!("\nresolve(\"docTable\"): {:?}", node_id);

    // -- symbol_by_name: untyped symbol lookup --
    let sym = mib.symbol_by_name("DocName").expect("type should exist");
    println!("symbol_by_name(\"DocName\"): {:?}", sym);

    // -- Module-scoped lookups --
    let module = mib.module("DOC-EXAMPLE-MIB").unwrap();
    let obj = module.object("docDeviceName").expect("in module");
    println!("\nModule-scoped: {}.{}", module.name(), obj.name());

    let ty = module.r#type("DocName").expect("type in module");
    println!(
        "Module-scoped type: {} (tc={})",
        ty.name(),
        ty.is_textual_convention()
    );

    // -- OID tree: children and subtree --
    let table_node = mib.resolve_node("docTable").unwrap();
    println!("\nChildren of {}:", table_node.name());
    for child in table_node.children() {
        println!("  {} ({})", child.name(), child.oid());
    }

    println!("\nSubtree of {}:", table_node.name());
    for node in table_node.subtree() {
        println!("  {} ({})", node.name(), node.oid());
    }
}