unit SNMP;

interface

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Additional header files                                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

uses Windows;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP API return type definitions                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

// #define SNMPAPI                         INT
// #define SNMP_FUNC_TYPE                  WINAPI

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP API return code definitions                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMPAPI_NOERROR                 = INTEGER(TRUE);
  SNMPAPI_ERROR                   = INTEGER(FALSE);

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP API error code definitions                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_MEM_ALLOC_ERROR            = 1;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// BER API error code definitions                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_BERAPI_INVALID_LENGTH      = 10;
  SNMP_BERAPI_INVALID_TAG         = 11;
  SNMP_BERAPI_OVERFLOW            = 12;
  SNMP_BERAPI_SHORT_BUFFER        = 13;
  SNMP_BERAPI_INVALID_OBJELEM     = 14;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// PDU API error code definitions                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_PDUAPI_UNRECOGNIZED_PDU    = 20;
  SNMP_PDUAPI_INVALID_ES          = 21;
  SNMP_PDUAPI_INVALID_GT          = 22;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// AUTH API error code definitions                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_AUTHAPI_INVALID_VERSION    = 30;
  SNMP_AUTHAPI_INVALID_MSG_TYPE   = 31;
  SNMP_AUTHAPI_TRIV_AUTH_FAILED   = 32;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP PDU error status definitions                                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_ERRORSTATUS_NOERROR        = 0;
  SNMP_ERRORSTATUS_TOOBIG         = 1;
  SNMP_ERRORSTATUS_NOSUCHNAME     = 2;
  SNMP_ERRORSTATUS_BADVALUE       = 3;
  SNMP_ERRORSTATUS_READONLY       = 4;
  SNMP_ERRORSTATUS_GENERR         = 5;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP PDU generic trap definitions                                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_GENERICTRAP_COLDSTART      = 0;
  SNMP_GENERICTRAP_WARMSTART      = 1;
  SNMP_GENERICTRAP_LINKDOWN       = 2;
  SNMP_GENERICTRAP_LINKUP         = 3;
  SNMP_GENERICTRAP_AUTHFAILURE    = 4;
  SNMP_GENERICTRAP_EGPNEIGHLOSS   = 5;
  SNMP_GENERICTRAP_ENTERSPECIFIC  = 6;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// BER encoding definitions                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  ASN_UNIVERSAL                   = $00;
  ASN_APPLICATION                 = $40;
  ASN_CONTEXTSPECIFIC             = $80;
  ASN_PRIVATE                     = $C0;

const
  ASN_PRIMITIVE                   = $00;
  ASN_CONSTRUCTOR                 = $20;

//
// For BER tags with a number ranging from 0 to 30 (inclusive), the
// identifier octets consists of a single octet encoded as follows:
//
//   7 6 5 4 3 2 1 0
//  +---+-+---------+
//  |Cls|P| Tag Num |
//  +---+-+---------+
//
//  where
//
//      Cls - is the class of the tag
//
//          00 - universal
//          01 - application
//          10 - context-specific
//          11 - private
//
//      P - indicates whether encoding is primitive
//
//           0 - primitive
//           1 - constructed
//
//      Tag Num - is the number of the tag
//

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// ASN.1 simple types                                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  ASN_INTEGER                = (ASN_UNIVERSAL or ASN_PRIMITIVE or $02);
  ASN_OCTETSTRING            = (ASN_UNIVERSAL or ASN_PRIMITIVE or $04);
  ASN_NULL                   = (ASN_UNIVERSAL or ASN_PRIMITIVE or $05);
  ASN_OBJECTIDENTIFIER       = (ASN_UNIVERSAL or ASN_PRIMITIVE or $06);

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// ASN.1 constructor types                                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  ASN_SEQUENCE               = (ASN_UNIVERSAL or ASN_CONSTRUCTOR or $10);
  ASN_SEQUENCEOF             = ASN_SEQUENCE;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// ASN.1 application specific primatives                                     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  ASN_RFC1155_IPADDRESS     = (ASN_APPLICATION or ASN_PRIMITIVE or $00);
  ASN_RFC1155_COUNTER       = (ASN_APPLICATION or ASN_PRIMITIVE or $01);
  ASN_RFC1155_GAUGE         = (ASN_APPLICATION or ASN_PRIMITIVE or $02);
  ASN_RFC1155_TIMETICKS     = (ASN_APPLICATION or ASN_PRIMITIVE or $03);
  ASN_RFC1155_OPAQUE        = (ASN_APPLICATION or ASN_PRIMITIVE or $04);
  ASN_RFC1213_DISPSTRING    = ASN_OCTETSTRING;


  ASN_INTEGER32             = ASN_INTEGER;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP Application Syntax Values                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

  ASN_IPADDRESS               = (ASN_APPLICATION OR ASN_PRIMITIVE OR $00);
  ASN_COUNTER32               = (ASN_APPLICATION OR ASN_PRIMITIVE OR $01);
  ASN_GAUGE32                 = (ASN_APPLICATION OR ASN_PRIMITIVE OR $02);
  ASN_TIMETICKS               = (ASN_APPLICATION OR ASN_PRIMITIVE OR $03);
  ASN_OPAQUE                  = (ASN_APPLICATION OR ASN_PRIMITIVE OR $04);
  ASN_COUNTER64               = (ASN_APPLICATION OR ASN_PRIMITIVE OR $06);
  ASN_UNSIGNED32              = (ASN_APPLICATION OR ASN_PRIMITIVE OR $07);

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// ASN.1 application specific constructors                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  ASN_RFC1157_GETREQUEST     = (ASN_CONTEXTSPECIFIC or ASN_CONSTRUCTOR or $00);
  ASN_RFC1157_GETNEXTREQUEST = (ASN_CONTEXTSPECIFIC or ASN_CONSTRUCTOR or $01);
  ASN_RFC1157_GETRESPONSE    = (ASN_CONTEXTSPECIFIC or ASN_CONSTRUCTOR or $02);
  ASN_RFC1157_SETREQUEST     = (ASN_CONTEXTSPECIFIC or ASN_CONSTRUCTOR or $03);
  ASN_RFC1157_TRAP           = (ASN_CONTEXTSPECIFIC or ASN_CONSTRUCTOR or $04);

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP ASN type definitions                                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

type
  PAsnOctetString = ^TAsnOctetString;
  TAsnOctetString = packed record
    stream  : PBYTE;    // pointer to octet stream
    length  : CARDINAL; // number of octets in stream
    dynamic : BOOL;     // true if octets must be freed
  end;

  PAsnObjectIdentifier = ^TAsnObjectIdentifier;
  TAsnObjectIdentifier = packed record
    idLength : CARDINAL;        // number of integers in oid
    ids      : ^CARDINAL;       // pointer to integer stream
  end;

  TAsnInteger   = LONGINT;
  TAsnCounter   = LONGINT;
  TAsnGauge     = LONGINT;
  TAsnTimeticks = LONGINT;

  TAsnSequence         = TAsnOctetString;
  TAsnImplicitSequence = TAsnSequence;
  TAsnIPAddress        = TAsnOctetString;
  TAsnDisplayString    = TAsnOctetString;
  TAsnOpaque           = TAsnOctetString;

  TAsnObjectName       = TAsnObjectIdentifier;
  TAsnNetworkAddress   = TAsnIPAddress;

  TAsnAny = packed record
    asnType        : BYTE;                       // must be one byte
    estidetabarnak : array [ 0 .. 2 ] of BYTE;   // alignment
    case Integer of
      // RFC 1155 SimpleSyntax (subset of ISO ASN.1)
      0: (number: TAsnInteger);
      1: (asnstring: TAsnOctetString);           // name clash
      2: (asnobject: TAsnObjectIdentifier);      // name clash

      // ISO ASN.1
      3: (sequence: TAsnSequence);

      // RFC 1155 ApplicationSyntax
      4: (address: TAsnIPAddress);
      5: (counter: TAsnCounter);
      6: (gauge: TAsnGauge);
      7: (ticks: TAsnTimeticks);
      8: (arbitrary: TAsnOpaque);
  end;

  TAsnObjectSyntax = TAsnAny;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP API type definitions                                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

type
  PRFC1157VarBind = ^TRFC1157VarBind;
  TRFC1157VarBind = packed record
    name : TAsnObjectName;    // variable's object identifier
    value : TAsnObjectSyntax; // variable's value (in asn terms)
  end;

  PRFC1157VarBindList = ^TRFC1157VarBindList;
  TRFC1157VarBindList = packed record
    list : PRFC1157VarBind;   // array of variable bindings
    len  : CARDINAL;          // number of bindings in array
  end;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP API prototypes                                                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

function SnmpUtilOidCpy ( var DstObjId: TAsnObjectIdentifier; const SrcObjId: TAsnObjectIdentifier ): INTEGER; stdcall;
function SnmpUtilOidAppend ( var DstObjId: TAsnObjectIdentifier; const SrcObjId: TAsnObjectIdentifier ): INTEGER; stdcall;
function SnmpUtilOidNCmp ( const ObjIdA, ObjIdB: TAsnObjectIdentifier; Len: CARDINAL ): INTEGER; stdcall;
function SnmpUtilOidCmp ( const ObjIdA, ObjIdB: TAsnObjectIdentifier ): INTEGER; stdcall;
procedure SnmpUtilOidFree ( var ObjId: TAsnObjectIdentifier ); stdcall;
function SnmpUtilVarBindListCpy ( var DstVarBindList: TRFC1157VarBindList; const SrcVarBindList: TRFC1157VarBindList ): INTEGER; stdcall;
function SnmpUtilVarBindCpy ( var DstVarBind: TRFC1157VarBind; const SrcVarBind: TRFC1157VarBind ): INTEGER; stdcall;
procedure SnmpUtilVarBindListFree ( var VarBindList: TRFC1157VarBindList ); stdcall;
procedure SnmpUtilVarBindFree ( var VarBind: TRFC1157VarBind ); stdcall;
procedure SnmpUtilPrintAsnAny ( const Any: TAsnAny ); stdcall;
procedure SnmpUtilMemFree ( var Addr: POINTER ); stdcall;
function SnmpUtilMemAlloc ( Size: CARDINAL ): POINTER; stdcall;
function SnmpUtilMemReAlloc ( Addr: POINTER; NewSize: CARDINAL ): POINTER; stdcall;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// SNMP debugging definitions                                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_LOG_SILENT            = $0;
  SNMP_LOG_FATAL             = $1;
  SNMP_LOG_ERROR             = $2;
  SNMP_LOG_WARNING           = $3;
  SNMP_LOG_TRACE             = $4;
  SNMP_LOG_VERBOSE           = $5;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Miscellaneous definitions                                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

const
  SNMP_MAX_OID_LEN           = $7f00; // max number of elements in oid

implementation

const
  SNMPAPI = 'snmpapi.dll';

function  SnmpUtilOidCpy;                external SNMPAPI name 'SnmpUtilOidCpy';
function  SnmpUtilOidAppend;             external SNMPAPI name 'SnmpUtilOidAppend';
function  SnmpUtilOidNCmp;               external SNMPAPI name 'SnmpUtilOidNCmp';
function  SnmpUtilOidCmp;                external SNMPAPI name 'SnmpUtilOidCmp';
procedure SnmpUtilOidFree;               external SNMPAPI name 'SnmpUtilOidFree';
function  SnmpUtilVarBindListCpy;        external SNMPAPI name 'SnmpUtilVarBindListCpy';
function  SnmpUtilVarBindCpy;            external SNMPAPI name 'SnmpUtilVarBindCpy';
procedure SnmpUtilVarBindListFree;       external SNMPAPI name 'SnmpUtilVarBindListFree';
procedure SnmpUtilVarBindFree;           external SNMPAPI name 'SnmpUtilVarBindFree';
procedure SnmpUtilPrintAsnAny;           external SNMPAPI name 'SnmpUtilPrintAsnAny';
procedure SnmpUtilMemFree;               external SNMPAPI name 'SnmpUtilMemFree';
function  SnmpUtilMemAlloc;              external SNMPAPI name 'SnmpUtilMemAlloc';
function  SnmpUtilMemReAlloc;            external SNMPAPI name 'SnmpUtilMemReAlloc';

end.

