Since we are dealing only with traps, we will ignore the id, status, and index parameters. The vbl parameter is the most important, as it contains all of the trap information sent by the SNMP device.

Displaying the Trap Information
Now that we have extracted the data components from the trap message given to us by the WinSNMP stack, we can get on with the business of formatting and displaying the trap information to the console.

First, we must verify that the message we received is actually a trap. In our case this will always be so because we are working only with trap messages in this application. But in a more complicated SNMP application in which you would be sending and receiving SNMP messages as well as traps, you would need a way to tell the difference between a trap message and a message from a device sent in response to an SNMP GET command.

The type parameter gives us this information, and we should check to see that it is set to the value SNMPAPI_PDU.SNMP_PDU_TRAP. This tells us it is a trap message.

After we have determined that we have a trap message, we can start to display the trap information. First, we display a header message along with the trap id.

Console.WriteLine("Trap received...");
Console.WriteLine("Id: " + id);

To display the SNMP variables in the vbl, we will need to do a bit more work.

Decoding the Variable Binding List
In order to display the information in the variable binding list we first need to get the number of variables that are in the vbl. For this we use the SnmpCountVbl function. SnmpCountVbl takes the vbl as a parameter and returns a count of the number of variables the vbl contains.

Second, we need to iterate over each variable in the vbl, translate it, then write it to the console. To translate each variable, we need to call SnmpGetVb and pass it the vbl and the index of the variable we are interested in. It will return the name and value of the variable at that position.

SMIOID name = new SMIOID();
SMIVALUE val = new SMIVALUE();

SNMPAPI_STATUS rc = SnmpAPI.SnmpGetVb
(vbl, index, ref name, ref val);

Note: The name and value parameters are passed as refs, so you need to initialize them first.

The next step is to convert the variable name to a string. The variable name is an OID, so we convert it by calling SnmpOidToStr. SnmpOidToStr takes a reference to the OID and returns a string in the buffer specified by the buffer parameter. We must allocate this buffer ourselves ­ but how big does it need to be?

If we look at the WinSNMP documentation, we see that the largest an OID can be is 1408 bytes, so we allocate a buffer of this size. This might seem like an odd size, but it's not. SNMP uses UDP (User Datagram Protocol) for its transport protocol, and each SNMP message must fit into one UDP message. The standard MTU (Maximum Transmission Unit) on most networks is 1500 bytes, so, 1408 is what's left over when you subtract all the message headers needed to get one variable across the network. We allocate this buffer by calling the .NET marshaler.

IntPtr buffer = Marshal.AllocHGlobal(1408);

After we have the buffer, we can call SnmpOidToStr.

SNMPAPI_STATUS rc = SnmpAPI.SnmpOidToStr(ref oid, 1408, buffer);

This gives us a string in a global buffer allocated by the marshaler. But all we have is an opaque internal pointer to a buffer. We must convert it to a string type. For this, we call another .NET marshaler function, PtrToStringAnsi.

string str = Marshal.PtrToStringAnsi(buffer);

Now we have a string representation of the OID. Whew! All this work and we still haven't decoded the data.

To convert the data to a displayable format, we need to first check the type of data that was sent in the variable. Each variable value in SNMP includes a type code to help determine the type of data the variable contains. We will use this type to determine how to convert the data to a string. Most of the conversions are straightforward, so I will refer you to the function in Listing 1 that performs the conversions. Most of the conversions are straightforward, but if you look at the string conversion for the SNMP type OCTET_STRING, you will see that in order to determine whether we have an ASCII string or a binary buffer we scan the buffer looking for binary characters. If all the characters are ASCII, we make it a string; If there are binary characters, we encode the buffer so it can be displayed. I chose to unencode it because it was quicker to call the ToBase64String function than to write a hex converter.

Running the Trap Handler
If you open the accompanying project in Visual Studio (I have VS.NET 2003, so you will have to make a new project and add the files if you have an earlier version), and run SnmpTrapHandler, you will see the screen shown in Figure 1.

Now you are ready to receive traps. An easy way to generate a couple of traps is to stop and start the SNMP service on the machine where the trap handler is running. Note that there are two SNMP services, one is called "SNMP Service", and the other is "SNMP Trap Service". You will want to stop "SNMP Service", then restart it. Once you've done this, you should see traps appear in the trap handler console, as shown in Figure 2.

Conclusion
That's it. WinSNMP Traps 101. In the future, I will be writing more about SNMP, including how to communicate with and manage real-world devices such as Cisco network equipment.

About The Author
Jim Thomas is a telecommunications and networking consultant and the operating manager at Bocacom.net LLC, a dedicated server provider located in Boca Raton, FL. In addition to writing, he spends his spare time developing network management applications for the .NET Framework. jimt@bocacom.net

	



Listing 1

 protected string VbToString(ref SMIVALUE sval)
{
    string    val = "";

    //
    //  Convert all types to a string value
    //
    switch (sval.type) {
        //
        //  Standard 32 bit integer conversion
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_INT:
            val = sval.val.sNumber.ToString();
            break;

        //
        //  Standard 32 bit unsigned integer conversion
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_UINT32:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_CNTR32:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_GAUGE32:
            val = sval.val.uNumber.ToString();
            break;

        //
        //  Timeticks are in hundredths of a second (.01).  We need to mul-
//  tiply by ten to send ms (.001) to TimeSpan.
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_TIMETICKS:
        val = TimeSpan.FromMilliseconds((long)sval.val.uNumber*10)
        .ToString();
            val = val.Substring(0, val.Length-4);
            break;

        //
        //  Standard 64 bit integer conversion
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_CNTR64:
            val = sval.val.hNumber.ToString();
            break;

        //
        //  Byte array conversion.  SNMP doesn't differentiate between
        //  ASCII and binary data, so we perform a check ourselves and
        //  convert binary data to ASCII (using ToBase64String, which is
//  uuencode).
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_BITS:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_OPAQUE:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_OCTETS:
            if (sval.val.str.size > 0) {
                int i = 0;
                byte[] bits = new byte[sval.val.str.size];

                Marshal.Copy(sval.val.str.octets, bits, 0,
                (int)sval.val.str.size);

                for (i = 0; i < bits.Length; i++) {
                    if (char.IsControl((char)bits[i]) &&
					(i < bits.Length-1 || bits[i] != 0)) {
                        val = Convert.ToBase64String(bits, 0, bits.Length);
                        break;
                    }
                }
                if (i == bits.Length)
                    val = Marshal.PtrToStringAnsi(sval.val.str.octets,
                    (int)sval.val.str.size);

                SnmpAPI.SnmpFreeDescriptor
				((int)sval.type, ref sval.val.str);
            }
            break;

        //
        //  Ip Address conversion
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_NSAPADDR:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_IPADDR:
            IPAddress addr = new IPAddress((long)(UInt32)Marshal
            .ReadIntPtr(sval.val.str.octets));
            val = addr.ToString();
            SnmpAPI.SnmpFreeDescriptor((int)sval.type, ref sval.val.str);
            break;

        //
        //  SNMP OID conversion
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_OID:
            val = OidToString(ref sval.val.oid);
            break;

        //
        //  Catch the rest
        //
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_NULL:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_NOSUCHOBJECT:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_NOSUCHINSTANCE:
        case SNMPAPI_SYNTAX.SNMP_SYNTAX_ENDOFMIBVIEW:
            val = "(null)";
            break;
    }
    return(val);
}