Add SNMP lib benchmark doc

2025-05-17 15:32:55 +02:00
parent 52ce58adda
commit ef81eb5319
1 changed files with 803 additions and 0 deletions
--- a/SNMP_LIB_PERF_COMP.md
+++ b/SNMP_LIB_PERF_COMP.md
@@ -0,0 +1,803 @@
 # Benchmarking Python SNMP Libraries for Epson Printer Communication
 This document compares pure Python SNMP libraries, with the goal of performing unauthenticated, sequential SNMPv1 queries to a single Epson printer.
 We aim to use libraries implemented entirely in Python to avoid the complexity and overhead of wrappers around native libraries, while maintaining acceptable performance.
 For our use case, that is interfacing with Epson printers, synchronous SNMP simplifies development and maintenance without compromising performance.
 We compared:
 - Ilya Etingof’s [etingof/pysnmp](https://github.com/etingof/pysnmp) project (unmaintained) in synchronous mode,
 - [pysnmplib](https://github.com/pysnmp/pysnmp) in synchronous mode,
 - [lextudio](https://github.com/lextudio/pysnmp/) v5.1 synchronous mode,
 - [lextudio](https://github.com/lextudio/pysnmp/) v7.1 asynchronous mode,
 - raw socket SNMPv1 implementation (synchronous mode).
 To compare implementations, we developed a trivial benchmark that performs 100 SNMPv1 GET requests of the same OID to the same printer, measuring total execution time. We used OID `1.3.6.1.2.1.25.3.2.1.3.1` (`sysName`).
 Benchmark results show that older libraries with reduced abstraction layers tend to offer better performance and simpler, more readable code with fewer lines: the legacy synchronous backend `pysnmp.hlapi.v1arch` from [etingof/pysnmp](https://github.com/etingof/pysnmp) performs on par with the most efficient asynchronous implementation. In contrast, newer versions such as `pysnmp.hlapi` from [pysnmplib](https://github.com/pysnmp/pysnmp) or `pysnmp==5.1.0` from [lextudio](https://docs.lextudio.com/snmp/) introduce approximately 40% performance overhead compared to `v1arch`.
 In our current codebase, we use the unmaintained `etingof/pysnmp`, specifically the `v1arch` synchronous mode, which performs well due to:
 * A streamlined architecture (e.g., no SNMP engine instantiation per request)
 * Minimal overhead in request dispatch
 However, `etingof/pysnmp` is not available on PyPI. To support PyPI installation, we would need to switch to a newer version such as `pysnmp` or `pysnmplib`.
 Older versions of `pysnmp` supported both synchronous and asynchronous modes. However, recent versions have removed synchronous support, leaving only asynchronous interfaces. This evolution mirrors broader industry tensions between legacy compatibility and modern performance demands. While `pysnmp` v7+'s async-only architecture theoretically enables better resource utilization, it imposes significant refactoring costs for traditional SNMPv1 workflows.
 The most suboptimal implementation strategy for sequential SNMPv1 operations involves forcibly adapting asynchronous pysnmp architectures to synchronous workflows through repeated asyncio.run() invocations. This anti-pattern incurs catastrophic performance degradation due to fundamental resource management failures:
 - Event loop thrashing due to each iteration, that recreates and destroys the entire asyncio infrastructure; calling `asyncio.run()` 100 times results in excessive overhead, as each iteration initializes and tears down the event loop.
 - Protocol engine reinitialization, where essential SNMP components get recreated per-request, like `SnmpDispatcher()`.
 - Concurrency opportunity cost, that forces sequential execution despite async capabilities: sequential use of async code negates the benefits of concurrency and parallelism.
 The evaluations reported below reveal a stark contrast between implementation strategies using `pysnmp 7.1`. The simulated synchronous approach (artificially forcing async-to-sync behavior through sequential `asyncio.run()` calls) required 13.5-13.8 seconds for 100 requests. By comparison, a native asynchronous implementation using identical library versions completed the same workload in 0.47-0.49 seconds, demonstrating a 28× throughput improvement.
 This performance disparity comes with significant architectural consequences, as the examples can show.
 ## Code used for the benchmarks
 ### Usage of https://github.com/etingof/pysnmp
 ```python
 # Usage of https://github.com/etingof/pysnmp
 # pip uninstall pysnmplib
 # pip uninstall pysnmp
 # pip install pyasn1==0.4.8
 # pip install git+https://github.com/etingof/pysnmp.git@master#egg=pysnmp
 import platform
 import time
 import sys
 from pysnmp.hlapi.v1arch import *
 def snmp_get(*snmp_conf):
    for errorIndication, errorStatus, errorIndex, varBinds in getCmd(
        *snmp_conf, ('1.3.6.1.2.1.25.3.2.1.3.1', None)
    ):
        if errorIndication:
            return f"Error: {errorIndication}"
        elif errorStatus:
            return f"{errorStatus.prettyPrint()} at {errorIndex}"
        elif len(varBinds) != 1:
            return f"varBinds error: {len(varBinds)}"
        elif len(list(varBinds[0])) != 2:
            return f"varBinds[0] error: {len(list(varBinds[0]))}"
        return varBinds[0][1]
 if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python script.py <target-ip>")
        sys.exit(1)
    start_time = time.time()
    snmp_conf = (
        SnmpDispatcher(),
        CommunityData('public', mpModel=0),
        UdpTransportTarget((sys.argv[1], 161)),
    )
    for i in range(100):
        response = snmp_get(*snmp_conf)
        print(response)
    print("--- %s seconds ---" % (time.time() - start_time))
    # --- 0.8790323734283447 seconds ---
    # --- 0.866567850112915 seconds ---
    # --- 0.8512802124023438 seconds ---
    # --- 0.8214724063873291 seconds ---
 ```
 ### Usage of https://github.com/pysnmp/pysnmp
 ```python
 # Usage of https://github.com/pysnmp/pysnmp
 # pip uninstall pysnmp
 # pip uninstall pysnmplib
 # pip install pyasn1==0.4.8
 # Alternative working library: pip install pysnmp==5.1.0 (https://docs.lextudio.com/snmp/)
 import platform
 import time
 import sys
 from pysnmp.hlapi import *
 def snmp_get(*snmp_conf):
    for errorIndication, errorStatus, errorIndex, varBinds in getCmd(
        *snmp_conf, ObjectType(ObjectIdentity('1.3.6.1.2.1.25.3.2.1.3.1'))
    ):
        if errorIndication:
            return f"Error: {errorIndication}"
        elif errorStatus:
            return f"{errorStatus.prettyPrint()} at {errorIndex}"
        elif len(varBinds) != 1:
            return f"varBinds error: {len(varBinds)}"
        elif len(list(varBinds[0])) != 2:
            return f"varBinds[0] error: {len(list(varBinds[0]))}"
        return varBinds[0][1]
 if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python script.py <target-ip>")
        sys.exit(1)
    start_time = time.time()
    snmp_conf = (
        SnmpEngine(),
        CommunityData('public', mpModel=0),
        UdpTransportTarget((sys.argv[1], 161)),
        ContextData(),
    )
    for i in range(100):
        response = snmp_get(*snmp_conf)
        print(response)
    print("--- %s seconds ---" % (time.time() - start_time))
    # --- 1.0873637199401855 seconds ---
    # --- 1.0969550609588623 seconds ---
 ```
 ### Usage of https://github.com/lextudio/pysnmp 7.1 simulating sync behaviour
 ```python
 # Usage of https://github.com/lextudio/pysnmp 7.1
 # Simulate sync behaviour in an extremely inefficient and slow mode
 # pip uninstall pysnmplib
 # pip uninstall pyasn1==0.4.8
 # pip uninstall pysnmp # git+https://github.com/etingof/pysnmp.git@master#egg=pysnmp
 # pip install pysnmp
 import platform
 import asyncio
 import sys
 import time
 from pysnmp.hlapi.v1arch.asyncio import *  # synchronous mode is not allowed
 async def snmp_get(community_data, transport_target):
    errorIndication, errorStatus, errorIndex, varBinds = await get_cmd(
        SnmpDispatcher(),  # It cannot be initialized once and then reused!
        community_data,
        transport_target,
        ObjectType(ObjectIdentity('1.3.6.1.2.1.25.3.2.1.3.1')),  # Model
        lookupMib=False,
        lexicographicMode=False,
    )
    if errorIndication:
        return f"Error: {errorIndication}"
    elif errorStatus:
        return f"{errorStatus.prettyPrint()} at {errorIndex}"
    elif len(varBinds) != 1:
        return f"varBinds error: {len(varBinds)}"
    elif len(list(varBinds[0])) != 2:
        return f"varBinds[0] error: {len(list(varBinds[0]))}"
    return varBinds[0][1]
 if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python script.py <target-ip>")
        sys.exit(1)
    if platform.system()=='Windows':
        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    start_time = time.time()
    community_data = CommunityData("public", mpModel=0)
    transport_target = asyncio.run(
        UdpTransportTarget.create((sys.argv[1], 161))
    )
    for i in range(100):
        response = asyncio.run(snmp_get(community_data, transport_target))
        print(response)
    print("--- %s seconds ---" % (time.time() - start_time))
    # --- 13.862501621246338 seconds ---
    # --- 13.586702585220337 seconds ---
    # --- 13.565954208374023 seconds ---
 ```
 ### Usage of https://github.com/lextudio/pysnmp in async mode
 ```python
 # Usage of https://github.com/lextudio/pysnmp
 # Same as mytest4, but single ObjectType in get_cmd
 # pip uninstall pysnmplib
 # pip uninstall pysnmp # git+https://github.com/etingof/pysnmp.git@master#egg=pysnmp
 # pip install pysnmp
 import platform
 import asyncio
 import sys
 import time
 from pysnmp.hlapi.v1arch.asyncio import *
 async def snmp_get(dispatcher, community_data, transport_target):
    errorIndication, errorStatus, errorIndex, varBinds = await get_cmd(
        dispatcher,
        community_data,
        transport_target,
        ObjectType(ObjectIdentity('1.3.6.1.2.1.25.3.2.1.3.1')),
        lookupMib=False,
        lexicographicMode=False,
    )
    if errorIndication:
        return f"Error: {errorIndication}"
    elif errorStatus:
        return f"{errorStatus.prettyPrint()} at {errorIndex}"
    elif len(varBinds) != 1:
        return f"varBinds error: {len(varBinds)}"
    elif len(list(varBinds[0])) != 2:
        return f"varBinds[0] error: {len(list(varBinds[0]))}"
    return varBinds[0][1]
 async def main(target_ip):
    # Reuse dispatcher and target
    dispatcher = SnmpDispatcher()
    community_data = CommunityData("public", mpModel=0)
    transport_target = await UdpTransportTarget.create((target_ip, 161))
    tasks = [
        snmp_get(dispatcher, community_data, transport_target)
        for _ in range(100)
    ]
    results = await asyncio.gather(*tasks)
    for r in results:
        print(r)
    print("--- %s seconds ---" % (time.time() - start_time))
 if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python script.py <target-ip>")
        sys.exit(1)
    if platform.system()=='Windows':
        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    start_time = time.time()
    asyncio.run(main(sys.argv[1]))
    # --- 1.4966695308685303 seconds ---
    # --- 1.4908103942871094 seconds ---
    # --- 1.4765450954437256 seconds ---
    # --- 1.4733057022094727 seconds ---
 ```
 ### Usage of https://github.com/lextudio/pysnmp maximizing performance
 ```python
 # Usage of https://github.com/lextudio/pysnmp
 # Max performance (same as mytest3, but multiple ObjectType in get_cmd)
 # pip uninstall pysnmplib
 # pip uninstall pysnmp # git+https://github.com/etingof/pysnmp.git@master#egg=pysnmp
 # pip install pysnmp
 import platform
 import asyncio
 import sys
 import time
 from pysnmp.hlapi.v3arch.asyncio import *
 async def snmp_get(dispatcher, community_data, transport_target):
    object_types = [
        ObjectType(
            ObjectIdentity('1.3.6.1.2.1.25.3.2.1.3.1')
        ) for _ in range(10)
    ]
    """
 Note: we cannot put too many data into a single PDU due to a protocol-level
 limit, otherwise we get the SNMP error "tooBig" like "tooBig at 54", that
 indicates that the SNMP response PDU exceeds the maximum size supported by the
 agent or the transport (typically 484 bytes by default for UDP). For this
 reason, to get the 100 queries benckmark, we build a taks of 10 requests, each
 including 10 queries.
    """
    errorIndication, errorStatus, errorIndex, varBinds = await get_cmd(
        dispatcher,
        community_data,
        transport_target,
        ContextData(),
        *object_types,
        lookupMib=False
    )
    if errorIndication:
        return [f"Error: {errorIndication}"]
    elif errorStatus:
        return [f"{errorStatus.prettyPrint()} at {errorIndex}"]
    return [val.prettyPrint() for _, val in varBinds]
 async def main(target_ip):
    dispatcher = SnmpEngine()
    community_data = CommunityData("public", mpModel=0)
    transport_target = await UdpTransportTarget.create((target_ip, 161))
    tasks = [
        snmp_get(dispatcher, community_data, transport_target)
        for _ in range(10)
    ]
    results = await asyncio.gather(*tasks)
    for r in results:
        for i in r:
            print(i)
    print("--- %s seconds ---" % (time.time() - start_time))
 if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Usage: python script.py <target-ip>")
        sys.exit(1)
    if platform.system() == 'Windows':
        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    start_time = time.time()
    asyncio.run(main(sys.argv[1]))
    # --- 0.47261977195739746 seconds ---
    # --- 0.47225403785705566 seconds ---
    # --- 0.4908156394958496 seconds ---
 ```
 ### Usage of the oneliner package, being deprecated in newer versions of pysnmp
 ```python
 # Usage of the oneliner package, being deprecated in newer versions of pysnmp
 # pip uninstall pysnmp
 # pip uninstall pysnmplib
 # pip install pysnmp==5.1.0
 # pip install pyasn1==0.4.8
 import platform
 import time
 import sys
 from pysnmp.entity.rfc3413.oneliner import cmdgen
 if len(sys.argv) < 2:
    print("Usage: python script.py <hostname>")
    sys.exit(1)
 host = sys.argv[1]
 # Create these objects outside the loop for better performance
 cmd_gen = cmdgen.CommandGenerator()
 transport = cmdgen.UdpTransportTarget((host, 161), timeout=5, retries=1)
 oid = '1.3.6.1.2.1.25.3.2.1.3.1'
 oid_tuple = tuple(int(part) for part in oid.split('.'))
 comm_data = cmdgen.CommunityData('public', mpModel=0)
 start_time = time.time()
 for i in range(100):
    # Execute the command directly in the loop for better performance
    error_indication, error_status, error_index, var_binds = cmd_gen.getCmd(
        comm_data,
        transport,
        oid_tuple
    )
    if error_indication:
        print(f"Error: {error_indication}")
    elif error_status:
        print(f"{error_status.prettyPrint()} at {error_index}")
    elif len(var_binds) != 1:
        print(f"varBinds error: {len(var_binds)}")
    else:
        print(var_binds[0][1])
 print("--- %s seconds ---" % (time.time() - start_time))
 # --- 1.1897211074829102 seconds ---
 # --- 1.0130093097686768 seconds ---
 ```
 ### Raw Python implementation of the SNMPv protocol
 ```python
 # Pure Python implementation of the SNMPv1 basic GetRequest/GetResponse
 # protocol with the sole usage of the default socket library.
 # Code Complexity: Very High
 # Performance: excellent
 # Protocol Compliance: manual
 # Maintenance: Error-Prone
 import socket
 import time
 import sys
 def encode_length(length):
    if length < 0x80:
        return bytes([length])
    else:
        num_bytes = (length.bit_length() + 7) // 8
        encoded = []
        for _ in range(num_bytes):
            encoded.append(length & 0xff)
            length >>= 8
        encoded = bytes(encoded[::-1])
        return bytes([0x80 | num_bytes]) + encoded
 def encode_base128(n):
    if n == 0:
        return bytes([0])
    bytes_list = []
    while n > 0:
        bytes_list.insert(0, n & 0x7f)
        n >>= 7
    for i in range(len(bytes_list) - 1):
        bytes_list[i] |= 0x80
    return bytes(bytes_list)
 def encode_oid(oid_str):
    parts = list(map(int, oid_str.split('.')))
    if len(parts) < 2:
        raise ValueError("OID must have at least two components")
    first = parts[0] * 40 + parts[1]
    encoded = bytes([first])
    for n in parts[2:]:
        encoded += encode_base128(n)
    return b'\x06' + encode_length(len(encoded)) + encoded
 def encode_integer(value):
    if value == 0:
        return b'\x02\x01\x00'
    byte_count = (value.bit_length() + 7) // 8
    bytes_val = value.to_bytes(byte_count, 'big', signed=False)
    return b'\x02' + encode_length(len(bytes_val)) + bytes_val
 def construct_snmp_get_request(oid, community='public', request_id=1):
    version = b'\x02\x01\x00'
    community_enc = b'\x04' + encode_length(len(community)) + community.encode()
    oid_enc = encode_oid(oid)
    null = b'\x05\x00'
    var_bind = b'\x30' + encode_length(len(oid_enc) + len(null)) + oid_enc + null
    var_bindings = b'\x30' + encode_length(len(var_bind)) + var_bind
    pdu_content = (
        encode_integer(request_id) +
        encode_integer(0) +
        encode_integer(0) +
        var_bindings
    )
    pdu = b'\xa0' + encode_length(len(pdu_content)) + pdu_content
    snmp_message = (
        b'\x30'
        + encode_length(len(version) + len(community_enc) + len(pdu))
        + version
        + community_enc
        + pdu
    )
    return snmp_message
 def parse_snmp_response(data):
    def parse_length(data, index):
        length_byte = data[index]
        index += 1
        if length_byte < 0x80:
            return (length_byte, index)
        else:
            num_bytes = length_byte & 0x7f
            length = 0
            for _ in range(num_bytes):
                length = (length << 8) | data[index]
                index += 1
            return (length, index)
    index = 0
    if data[index] != 0x30:
        raise ValueError("Expected SEQUENCE")
    index += 1
    length, index = parse_length(data, index)
    if data[index] != 0x02:
        raise ValueError("Expected version INTEGER")
    index += 1
    version_length, index = parse_length(data, index)
    index += version_length
    if data[index] != 0x04:
        raise ValueError("Expected community OCTET STRING")
    index += 1
    community_length, index = parse_length(data, index)
    index += community_length
    if data[index] != 0xa2:
        raise ValueError("Expected GetResponse PDU")
    index += 1
    pdu_length, index = parse_length(data, index)
    pdu_data = data[index:index+pdu_length]
    index += pdu_length
    pdu_index = 0
    if pdu_data[pdu_index] != 0x02:
        raise ValueError("Expected request-id INTEGER")
    pdu_index += 1
    req_id_len, pdu_index = parse_length(pdu_data, pdu_index)
    pdu_index += req_id_len
    if pdu_data[pdu_index] != 0x02:
        raise ValueError("Expected error-status INTEGER")
    pdu_index += 1
    err_status_len, pdu_index = parse_length(pdu_data, pdu_index)
    pdu_index += err_status_len
    if pdu_data[pdu_index] != 0x02:
        raise ValueError("Expected error-index INTEGER")
    pdu_index += 1
    err_index_len, pdu_index = parse_length(pdu_data, pdu_index)
    pdu_index += err_index_len
    if pdu_data[pdu_index] != 0x30:
        raise ValueError("Expected variable-bindings SEQUENCE")
    pdu_index += 1
    var_bindings_len, pdu_index = parse_length(pdu_data, pdu_index)
    var_bindings = pdu_data[pdu_index:pdu_index+var_bindings_len]
    pdu_index += var_bindings_len
    var_index = 0
    if var_bindings[var_index] != 0x30:
        raise ValueError("Expected variable-binding entry SEQUENCE")
    var_index += 1
    entry_len, var_index = parse_length(var_bindings, var_index)
    entry_data = var_bindings[var_index:var_index+entry_len]
    var_index += entry_len
    entry_idx = 0
    if entry_data[entry_idx] != 0x06:
        raise ValueError("Expected OID")
    entry_idx += 1
    oid_len, entry_idx = parse_length(entry_data, entry_idx)
    entry_idx += oid_len
    value_tag = entry_data[entry_idx]
    entry_idx += 1
    value_len, entry_idx = parse_length(entry_data, entry_idx)
    value_bytes = entry_data[entry_idx:entry_idx+value_len]
    if value_tag == 0x04:
        return value_bytes.decode()
    elif value_tag == 0x02:
        return int.from_bytes(value_bytes, 'big', signed=True)
    else:
        return value_bytes
 def main():
    if len(sys.argv) < 2:
        print("Usage: python script.py <hostname>")
        sys.exit(1)
    host = sys.argv[1]
    oid = '1.3.6.1.2.1.25.3.2.1.3.1'
    request_id = 1
    start_time = time.time()
    for _ in range(100):
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.settimeout(1)
        request = construct_snmp_get_request(oid, 'public', request_id)
        try:
            sock.sendto(request, (host, 161))
            response, _ = sock.recvfrom(65536)
            value = parse_snmp_response(response)
            print(value)
        except Exception as e:
            print(f"Error: {e}")
        finally:
            sock.close()
        request_id += 1
    print("--- %s seconds ---" % (time.time() - start_time))
 def main_performance():
    if len(sys.argv) < 2:
        print("Usage: python script.py <hostname>")
        sys.exit(1)
    host = sys.argv[1]
    oid = '1.3.6.1.2.1.25.3.2.1.3.1'
    request_id = 1
    start_time = time.time()
    # Create socket once and reuse it
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.settimeout(1)  # Timeout applies to all operations
    try:
        for _ in range(100):
            request = construct_snmp_get_request(oid, 'public', request_id)
            try:
                # Send and receive using the same socket
                sock.sendto(request, (host, 161))
                response, _ = sock.recvfrom(65536)
                value = parse_snmp_response(response)
                print(value)
            except socket.timeout:
                print("Error: Request timed out")
            except Exception as e:
                print(f"Error: {e}")
            finally:
                request_id += 1
    finally:
        sock.close()  # Close socket once at the end
    print("--- %s seconds ---" % (time.time() - start_time))
 if __name__ == '__main__':
    main_performance()
    # --- 0.7888898849487305 seconds ---
    # --- 0.7544982433319092 seconds ---
    # --- 0.7131996154785156 seconds ---
 ```
 ## EPSON SNMP Protocol analysis
 The EPSON printer uses **SNMPv1** with basic read-only community string authentication and no security features. It implements standard and proprietary MIBs.
 - Simple Network Management Protocol Version 1.
 - No encryption (SNMPv1 has no security beyond community strings).
 - Community string: `public` sent in cleartext (default for read-only access in SNMPv1).
 - UDP port 161 (defaultfor SNMP agents). Connectionless, lightweight communication.
 ### Full decoding of the SNMP request
 Full decoding of the SNMP request for the OID `1.3.6.1.2.1.25.3.2.1.3.1`.
 #### Raw Bytes (hex):
 ```
 0)  30 29
 2)  02 01 00
 5)  04 06 70 75 62 6c 69 63
 11) a0 1c
 13) 02 01 26
 16) 02 01 00
 19) 02 01 00
 22) 30 11
 24) 30 0d
 26) 06 0b 2b 06 01 02 01 19 03 02 01 03 01
 39) 05 00
 ```
 #### Breakdown (SNMPv1 Structure):
 1. **SNMP Message (SEQUENCE)**: `30 29`  
   - Tag: `0x30` (SEQUENCE)  
   - Length: `0x29` (41 bytes total for the entire message).
 2. **SNMP Version (INTEGER)**: `02 01 00`  
   - Tag: `0x02` (INTEGER)  
   - Length: `0x01` (1 byte)  
   - Value: `0x00` (SNMPv1).
 3. **Community String (OCTET STRING)**: `04 06 70 75 62 6c 69 63`  
   - Tag: `0x04` (OCTET STRING)  
   - Length: `0x06` (6 bytes)  
   - Value: `70 75 62 6c 69 63` ("public" in ASCII).
 4. **GetRequest-PDU**: `a0 1c`  
   - Tag: `0xA0` (SNMPv1 GetRequest)  
   - Length: `0x1C` (28 bytes for the PDU contents).
 5. **Request-ID (INTEGER)**: `02 01 26`  
   - Tag: `0x02` (INTEGER)  
   - Length: `0x01` (1 byte)  
   - Value: `0x26` (request ID = 38).
 6. **Error-Status (INTEGER)**: `02 01 00`  
   - Tag: `0x02` (INTEGER)  
   - Length: `0x01` (1 byte)  
   - Value: `0x00` (noError).
 7. **Error-Index (INTEGER)**: `02 01 00`  
   - Tag: `0x02` (INTEGER)  
   - Length: `0x01` (1 byte)  
   - Value: `0x00` (no error index).
 8. **Variable-Bindings (SEQUENCE)**: `30 11`  
   - Tag: `0x30` (SEQUENCE)  
   - Length: `0x11` (17 bytes).
    - **VarBind Entry (SEQUENCE)**: `30 0d`  
      - Tag: `0x30` (SEQUENCE)  
      - Length: `0x0D` (13 bytes).
      - **OID (OBJECT IDENTIFIER)**: `06 0b 2b 06 01 02 01 19 03 02 01 03 01`  
        - Tag: `0x06` (OID)  
        - Length: `0x0B` (11 bytes)  
        - Encoded OID: `2b 06 01 02 01 19 03 02 01 03 01`  
          - Decoded: `1.3.6.1.2.1.25.3.2.1.3.1` (matches your target OID).
      - **Value (NULL)**: `05 00`  
        - Tag: `0x05` (NULL)  
        - Length: `0x00` (no value).
 ### Full decoding of the SNMPv1 response
 ```plaintext
 SNMP Message (SEQUENCE, 64 bytes)
 ├─ Version (INTEGER): 0 (SNMPv1)
 ├─ Community (OCTET STRING): "public"
 └─ GetResponse-PDU (0xA2, 51 bytes)
   ├─ Request-ID (INTEGER): 100
   ├─ Error-Status (INTEGER): 0 (noError)
   ├─ Error-Index (INTEGER): 0
   └─ Variable-Bindings (SEQUENCE, 40 bytes)
      └─ VarBind (SEQUENCE, 38 bytes)
         ├─ OID (OBJECT IDENTIFIER): 1.3.6.1.2.1.25.3.2.1.3.1
         └─ Value (OCTET STRING): "EPSON XP-205 207 Series"
 ```
 #### Step-by-Step Breakdown:
 1. **SNMP Message Header**:
   - **Tag**: `0x30` (SEQUENCE)
   - **Length**: `0x40` (64 bytes total)
 2. **SNMP Version**:
   - **Tag**: `0x02` (INTEGER)
   - **Length**: `0x01` (1 byte)
   - **Value**: `0x00` → SNMPv1
 3. **Community String**:
   - **Tag**: `0x04` (OCTET STRING)
   - **Length**: `0x06` (6 bytes)
   - **Value**: `70 75 62 6c 69 63` → "public"
 4. **GetResponse-PDU**:
   - **Tag**: `0xA2` (SNMPv1 GetResponse)
   - **Length**: `0x33` (51 bytes)
 5. **Request-ID**:
   - **Tag**: `0x02` (INTEGER)
   - **Length**: `0x01` (1 byte)
   - **Value**: `0x64` → 100
 6. **Error-Status**:
   - **Tag**: `0x02` (INTEGER)
   - **Length**: `0x01` (1 byte)
   - **Value**: `0x00` → noError
 7. **Error-Index**:
   - **Tag**: `0x02` (INTEGER)
   - **Length**: `0x01` (1 byte)
   - **Value**: `0x00` → no error index
 8. **Variable-Bindings**:
   - **Tag**: `0x30` (SEQUENCE)
   - **Length**: `0x28` (40 bytes)
   - **VarBind Entry**:
     - **Tag**: `0x30` (SEQUENCE)
     - **Length**: `0x26` (38 bytes)
     - **OID**:
       - **Tag**: `0x06` (OBJECT IDENTIFIER)
       - **Length**: `0x0B` (11 bytes)
       - **Encoded OID**: `2B 06 01 02 01 19 03 02 01 03 01`
         - Decoded: `1.3.6.1.2.1.25.3.2.1.3.1`
     - **Value**:
       - **Tag**: `0x04` (OCTET STRING)
       - **Length**: `0x17` (23 bytes)
       - **Value**: `45 50 53 4F 4E 20 58 50 2D 32 30 35 20 32 30 37 20 53 65 72 69 65 73` → "EPSON XP-205 207 Series"
 #### sysName
 The OID `1.3.6.1.2.1.25.3.2.1.3.1` is part of the **Host Resources MIB** (`HOST-RESOURCES-MIB`), defined in RFC 2790 and returns the sysName.
 Here's the breakdown:
 ```
 1.3.6.1.2.1.25.3.2.1.3.1
 │ │ │ │ │ │ │  │ │ │ │ └─ sysName, index of the hrDevice entry (1st device)
 │ │ │ │ │ │ │  │ │ │ └─── hrDeviceDescr 
 │ │ │ │ │ │ │  │ │ └───── hrDeviceEntry
 │ │ │ │ │ │ │  │ └─────── hrDeviceTable
 │ │ │ │ │ │ │  └───────── hrDevice
 │ │ │ │ │ │ └──────────── host, hostResourcesMibModule
 │ │ │ │ │ └────────────── mib-2, mib mgmt
 │ │ │ │ └──────────────── Mgmt
 │ │ │ └────────────────── Internet
 │ │ └──────────────────── DOD
 │ └────────────────────── identified-organization, org, iso-identified-organization
 └──────────────────────── ISO
 ```