Rust SNMP SDK 1.0 FAQ

It is a Rust-first SDK for building SNMP manager applications. It provides typed blocking and asynchronous client APIs, notification reception, and owned SMIv1 and SMIv2 MIB models. The package combines a safe Rust facade with target-specific compiled native libraries.

Both products support SNMP management applications and MIB processing, but they use separate language-native interfaces and packaging. The Java API is the established pure-Java library. The Rust SDK presents owned Rust data types through a safe facade over a versioned native ABI, with no Java, JDK, JVM, or JNI dependency.

No. The SDK is for manager-side applications that send requests and receive notifications. Use MIBGen Rust SNMP Agent Builder when you need to create an SNMP agent.

The SDK supports SNMPv1, SNMPv2c, and SNMPv3. SNMPv3 includes USM authentication, privacy, authoritative-engine discovery, and timeliness handling. Supported algorithms include MD5, SHA-1, SHA-2, DES, 3DES, and AES-128/192/256, subject to the credentials and protocol configuration selected by the application.

The SDK requires Rust 1.85 or newer. Target archives are available for x86-64 and Arm64 Linux, Intel and Apple silicon macOS, and x86-64 Windows with the MSVC toolchain. Use the archive that matches the final application target.

No. It does not require a JDK, JVM, JNI runtime, native cryptography package, or external ASN.1 library. Tokio is a dependency of the safe crate for its asynchronous facade, but a blocking-only application does not need to create a Tokio runtime.

Yes. Static linking is the default, and dynamic libraries are also included. Enable exactly one linkage mode. A dynamically linked deployment must make the matching shared library available to the operating-system loader.

Rust SDK access is currently sales-assisted. Contact iReasoning with your target platforms and intended application so we can provide the appropriate package and commercial terms. The applicable license and signed written terms govern use, redistribution, maintenance, and fees.

The safe API supports GET, GET-NEXT, SET, GET-BULK, walk, and subtree operations. Responses use typed Rust models for messages, PDUs, variable bindings, OIDs, and values. GET-BULK is not valid for SNMPv1, so the SDK reports a configuration error if that combination is requested.

Yes. Blocking clients work directly in synchronous applications. Async clients use bounded blocking jobs and can be used inside an existing Tokio application without creating a nested runtime. Clones of the same async client share and serialize access to the same underlying session.

Cancellation is cooperative. Dropping the future stops waiting for its result, but the active native request may continue until its configured network timeout. Choose bounded timeouts that are appropriate for your application's shutdown and recovery requirements.

Use streaming traversal when a result may be large or when the application should process batches as they arrive instead of accumulating the complete result in memory. Async streaming callbacks must be Send + 'static and run on a bounded blocking worker.

Operations return typed Result<T> values with structured SDK errors. The safe facade validates the native ABI major version and JSON schema before using native handles. A mismatched library is reported as IncompatibleAbi rather than being used silently.

Yes. The notification receiver accepts SNMPv1 traps and SNMPv2c or SNMPv3 traps and INFORM requests over UDP. A valid INFORM is acknowledged before the receive call returns. Blocking and asynchronous receiver interfaces are available.

No. The SDK maintains receiver state while the receiver is running, but the application is responsible for persisting and restoring authoritative-engine state when its deployment requires continuity across restarts.

It parses SMIv1 and SMIv2 modules into owned, serializable Rust models. The registry resolves imports and qualified symbolic names, builds OID trees, formats values using MIB metadata, and looks up trap and notification definitions.

Load the defining MIB and all required imported modules before resolving the name. Use a qualified name when the same symbol could appear in more than one module. Numeric OIDs can still be parsed directly when no MIB registry is needed.

Confirm that the SDK archive matches the Rust target, that static and dynamic features are not enabled together, and that the build can locate the native library. For dynamic linking, also verify the operating-system loader path. If startup reports IncompatibleAbi, replace the native library and Rust crates with versions from the same SDK archive.

Verify the destination address, port, transport, SNMP version, community or USM credentials, timeout, retries, firewall, and agent access policy. For SNMPv3, also confirm the authentication and privacy protocols, passwords or localized keys, security level, engine discovery, and clock or timeliness behavior.

The Rust SNMP SDK 1.0 Developer Guide includes installation instructions, blocking and async examples, the complete safe API reference, notification and MIB workflows, deployment guidance, and a troubleshooting checklist. Generated Rust API documentation is also included in each SDK archive.