开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
snmpmsg.cpp
资源名称：snmp_pp.rar　[点击查看]
上传用户：ets1996
上传日期：2014-09-30
资源大小：353k
文件大小：23k
源码类别：

SNMP编程

开发平台：

Visual C++

snmpmsg.cpp：源码内容
  1. /*_############################################################################
  2.   _## 
  3.   _##  snmpmsg.cpp  
  4.   _##
  5.   _##  SNMP++v3.2.22
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2007 Jochen Katz, Frank Fock
  8.   _##
  9.   _##  This software is based on SNMP++2.6 from Hewlett Packard:
  10.   _##  
  11.   _##    Copyright (c) 1996
  12.   _##    Hewlett-Packard Company
  13.   _##  
  14.   _##  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  15.   _##  Permission to use, copy, modify, distribute and/or sell this software 
  16.   _##  and/or its documentation is hereby granted without fee. User agrees 
  17.   _##  to display the above copyright notice and this license notice in all 
  18.   _##  copies of the software and any documentation of the software. User 
  19.   _##  agrees to assume all liability for the use of the software; 
  20.   _##  Hewlett-Packard and Jochen Katz make no representations about the 
  21.   _##  suitability of this software for any purpose. It is provided 
  22.   _##  "AS-IS" without warranty of any kind, either express or implied. User 
  23.   _##  hereby grants a royalty-free license to any and all derivatives based
  24.   _##  upon this software code base. 
  25.   _##  
  26.   _##  Stuttgart, Germany, Wed May  2 23:22:30 CEST 2007 
  27.   _##  
  28.   _##########################################################################*/
  29. /*===================================================================
  31.   Copyright (c) 1996
  32.   Hewlett-Packard Company
  34.   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  35.   Permission to use, copy, modify, distribute and/or sell this software
  36.   and/or its documentation is hereby granted without fee. User agrees
  37.   to display the above copyright notice and this license notice in all
  38.   copies of the software and any documentation of the software. User
  39.   agrees to assume all liability for the use of the software; Hewlett-Packard
  40.   makes no representations about the suitability of this software for any
  41.   purpose. It is provided "AS-IS" without warranty of any kind,either express
  42.   or implied. User hereby grants a royalty-free license to any and all
  43.   derivatives based upon this software code base.
  46.   SNMP++ S N M P M S G . C P P
  48.   SNMPMESSAGE CLASS DEFINITION
  50.   DESIGN + AUTHOR:  Peter E Mellquist
  52.   LANGUAGE:         ANSI C++
  54.   DESCRIPTION:      ASN.1 encoding / decoding class
  56. =====================================================================*/
  57. char snmpmsg_cpp_version[]="#(@) SNMP++ $Id: snmpmsg.cpp 284 2007-03-22 22:09:46Z katz $";
  59. #ifdef WIN32
  60. #include <winsock.h>
  61. #elif defined(_AIX)
  62. #include <unistd.h>
  63. #endif
  64. #include <stdio.h>                      // standard io file
  66. #include "snmp_pp/snmpmsg.h"                    // header file for SnmpMessage
  67. #include "snmp_pp/oid_def.h"                    // changed (Frank Fock)
  68. #include "snmp_pp/log.h"
  69. #include "snmp_pp/vb.h"
  71. #ifdef SNMP_PP_NAMESPACE
  72. namespace Snmp_pp {
  73. #endif
  75. #define MAX_LEN_COMMUNITY 254
  77. const coldStartOid coldStart;
  78. const warmStartOid warmStart;
  79. const linkDownOid linkDown;
  80. const linkUpOid linkUp;
  81. const authenticationFailureOid authenticationFailure;
  82. const egpNeighborLossOid egpNeighborLoss;
  83. const snmpTrapEnterpriseOid snmpTrapEnterprise;
  85. //------------[ convert SNMP++ VB to WinSNMP smiVALUE ]----------------
  86. int convertVbToSmival( const Vb &tempvb, SmiVALUE *smival )
  87. {
  88.   smival->syntax = tempvb.get_syntax();
  89.   switch ( smival->syntax ) {
  91.     // case sNMP_SYNTAX_NULL
  92.   case sNMP_SYNTAX_NULL:
  93.   case sNMP_SYNTAX_NOSUCHOBJECT:
  94.   case sNMP_SYNTAX_NOSUCHINSTANCE:
  95.   case sNMP_SYNTAX_ENDOFMIBVIEW:
  96.     break;
  98.     // case sNMP_SYNTAX_INT32:
  99.   case sNMP_SYNTAX_INT:
  100.     tempvb.get_value(smival->value.sNumber);
  101.     break;
  103.     //    case sNMP_SYNTAX_UINT32:
  104.   case sNMP_SYNTAX_GAUGE32:
  105.   case sNMP_SYNTAX_CNTR32:
  106.   case sNMP_SYNTAX_TIMETICKS:
  107.     //  case sNMP_SYNTAX_UINT32:
  108.     tempvb.get_value(smival->value.uNumber);
  109.     break;
  111.     // case Counter64
  112.   case sNMP_SYNTAX_CNTR64:
  113.     {
  114.       Counter64 c64;
  115.       tempvb.get_value(c64);
  116.       smival->value.hNumber.hipart = c64.high();
  117.       smival->value.hNumber.lopart = c64.low();
  118.     }
  119.     break;
  121.   case sNMP_SYNTAX_BITS:
  122.   case sNMP_SYNTAX_OCTETS:
  123.   case sNMP_SYNTAX_OPAQUE:
  124.   case sNMP_SYNTAX_IPADDR:
  125.     {
  126.       OctetStr os;
  127.       tempvb.get_value(os);
  128.       smival->value.string.ptr = NULL;
  129.       smival->value.string.len = os.len();
  130.       if ( smival->value.string.len > 0 )
  131.       {
  132.         smival->value.string.ptr
  133.           = (SmiLPBYTE) new  unsigned char [smival->value.string.len];
  134.         if ( smival->value.string.ptr )
  135.         {
  136.           for (int i=0; i<(int) smival->value.string.len ; i++)
  137.             smival->value.string.ptr[i] = os[i];
  138.         }
  139.         else
  140.         {
  141.           smival->syntax = sNMP_SYNTAX_NULL;  // invalidate the smival
  142.           return SNMP_CLASS_RESOURCE_UNAVAIL;
  143.         }
  144.       }
  145.     }
  146.     break;
  148.   case sNMP_SYNTAX_OID:
  149.     {
  150.       Oid oid;
  151.       tempvb.get_value(oid);
  152.       smival->value.oid.ptr = NULL;
  153.       smival->value.oid.len = oid.len();
  154.       if ( smival->value.oid.len > 0 )
  155.       {
  156.         smival->value.oid.ptr
  157.           = (SmiLPUINT32) new unsigned long [ smival->value.oid.len];
  158.         if ( smival->value.oid.ptr )
  159.         {
  160.           for (int i=0; i<(int)smival->value.oid.len ; i++)
  161.             smival->value.oid.ptr[i] = oid[i];
  162.         }
  163.         else
  164.         {
  165.           smival->syntax = sNMP_SYNTAX_NULL;  // invalidate the smival
  166.           return SNMP_CLASS_RESOURCE_UNAVAIL;
  167.         }
  168.       }
  169.     }
  170.     break;
  172.   default:
  173.     return SNMP_CLASS_INTERNAL_ERROR;
  174.   }
  175.   return SNMP_CLASS_SUCCESS;
  176. }
  178. // free a SMI value
  179. void freeSmivalDescriptor( SmiVALUE *smival )
  180. {
  181.   switch ( smival->syntax ) {
  182.   case sNMP_SYNTAX_OCTETS:
  183.   case sNMP_SYNTAX_OPAQUE:
  184.   case sNMP_SYNTAX_IPADDR:
  185.   case sNMP_SYNTAX_BITS:     // obsoleted in SNMPv2 Draft Std
  186.     delete [] smival->value.string.ptr;
  187.     break;
  189.   case sNMP_SYNTAX_OID:
  190.     delete [] smival->value.oid.ptr;
  191.     break;
  192.   }
  193.   smival->syntax = sNMP_SYNTAX_NULL;
  194. }
  196. #ifdef _SNMPv3
  198. int SnmpMessage::unloadv3( Pdu &pdu,                // Pdu returned
  199.                            snmp_version &version,   // version
  200.                            OctetStr &engine_id,     // optional v3
  201.                            OctetStr &security_name, // optional v3
  202.                            long int &security_model,
  203.                            UdpAddress &from_addr,
  204.    Snmp &snmp_session)
  205. {
  206.   OctetStr tmp;
  207.   return unload(pdu, tmp, version, &engine_id,
  208.                 &security_name, &security_model, &from_addr, &snmp_session);
  209. }
  211. #endif
  213. int SnmpMessage::load(const Pdu &cpdu,
  214.                       const OctetStr &community,
  215.                       const snmp_version version,
  216.                       const OctetStr* engine_id,
  217.                       const OctetStr* security_name,
  218.                       const int security_model)
  219. {
  220.   int status;
  221.   const Pdu *pdu = &cpdu;
  222.   Pdu temppdu;
  224.   // make sure pdu is valid
  225.   if ( !pdu->valid())
  226.     return SNMP_CLASS_INVALID_PDU;
  228.   // create a raw pdu
  229.   snmp_pdu *raw_pdu;
  230.   raw_pdu = snmp_pdu_create( (int) pdu->get_type());
  232.   Oid enterprise;
  234.   // load it up
  235.   raw_pdu->reqid = pdu->get_request_id();
  236. #ifdef _SNMPv3
  237.   raw_pdu->msgid = pdu->get_message_id();
  238. #endif
  239.   raw_pdu->errstat= (unsigned long) pdu->get_error_status();
  240.   raw_pdu->errindex= (unsigned long) pdu->get_error_index();
  242.   // if its a V1 trap then load up other values
  243.   // for v2, use normal pdu format
  244.   if (raw_pdu->command == sNMP_PDU_V1TRAP)
  245.   {
  246.     // DON'T forget about the v1 trap agent address (changed by Frank Fock)
  247.     GenAddress gen_addr;
  248.     IpAddress ip_addr;
  249.     int addr_set = FALSE;
  251.     if (pdu->get_v1_trap_address(gen_addr))
  252.     {
  253.       /* User did set the v1 trap address */
  254.       if ((gen_addr.get_type() != Address::type_ip) &&
  255.           (gen_addr.get_type() != Address::type_udp) )
  256.       {
  257. LOG_BEGIN(ERROR_LOG | 4);
  258. LOG("SNMPMessage: Bad v1 trap address type in pdu");
  259. LOG(gen_addr.get_type());
  260. LOG_END;
  262.         snmp_free_pdu( raw_pdu);
  263.         return SNMP_CLASS_INVALID_PDU;
  264.       }
  266.       ip_addr = gen_addr;
  267.       if (!ip_addr.valid())
  268.       {
  269. LOG_BEGIN(ERROR_LOG | 1);
  270. LOG("SNMPMessage: Copied v1 trap address not valid");
  271. LOG_END;
  273.         snmp_free_pdu( raw_pdu);
  274.         return SNMP_CLASS_RESOURCE_UNAVAIL;
  275.       }
  276.       addr_set = TRUE;
  277.     }
  278.     else
  279.     {
  280.       /* User did not set the v1 trap address */
  281.       char addrString[256];
  282.       if (gethostname(addrString, 255) == 0)
  283.       {
  284.           ip_addr = addrString;
  285.           addr_set = TRUE;
  286.       }
  287.     }
  288.     struct sockaddr_in agent_addr;  // agent address socket struct
  289.     // prepare the agent address
  290.     memset(&agent_addr, 0, sizeof(agent_addr));
  291.     agent_addr.sin_family = AF_INET;
  292.     if (addr_set)
  293.     {
  294.       agent_addr.sin_addr.s_addr
  295.         = inet_addr(((IpAddress &)ip_addr).IpAddress::get_printable());
  296.       LOG_BEGIN(INFO_LOG | 7);
  297.       LOG("SNMPMessage: Setting v1 trap address");
  298.       LOG(((IpAddress &)ip_addr).IpAddress::get_printable());
  299.       LOG_END;
  300.     }
  301.     raw_pdu->agent_addr = agent_addr;
  303.     //-----[ compute generic trap value ]-------------------------------
  304.     // determine the generic value
  305.     // 0 - cold start
  306.     // 1 - warm start
  307.     // 2 - link down
  308.     // 3 - link up
  309.     // 4 - authentication failure
  310.     // 5 - egpneighborloss
  311.     // 6 - enterprise specific
  312.     Oid trapid;
  313.     pdu->get_notify_id( trapid);
  314.     if ( !trapid.valid() || trapid.len() < 2 )
  315.       {
  316.         snmp_free_pdu( raw_pdu);
  317.         return SNMP_CLASS_INVALID_NOTIFYID;
  318.       }
  319.     raw_pdu->specific_type=0;
  320.     if ( trapid == coldStart)
  321.       raw_pdu->trap_type = 0;  // cold start
  322.     else if ( trapid == warmStart)
  323.       raw_pdu->trap_type = 1;  // warm start
  324.     else if( trapid == linkDown)
  325.       raw_pdu->trap_type = 2;  // link down
  326.     else if ( trapid == linkUp)
  327.       raw_pdu->trap_type = 3;  // link up
  328.     else if ( trapid == authenticationFailure )
  329.       raw_pdu->trap_type = 4;  // authentication failure
  330.     else if ( trapid == egpNeighborLoss)
  331.       raw_pdu->trap_type = 5;  // egp neighbor loss
  332.     else {
  333.       raw_pdu->trap_type = 6;     // enterprise specific
  334.       // last oid subid is the specific value
  335.       // if 2nd to last subid is "0", remove it
  336.       // enterprise is always the notify oid prefix
  337.       raw_pdu->specific_type = (int) trapid[(int) (trapid.len()-1)];
  339.       trapid.trim(1);
  340.       if ( trapid[(int)(trapid.len()-1)] == 0 )
  341.         trapid.trim(1);
  342.       enterprise = trapid;
  343.     }
  345.     if ( raw_pdu->trap_type !=6)
  346.       pdu->get_notify_enterprise( enterprise);
  347.     if ( enterprise.len() >0) {
  348.       // note!!
  349.       // these are hooks into an SNMP++ oid
  350.       // and therefor the raw_pdu enterprise
  351.       // should not free them. null them out!!
  352.       SmiLPOID rawOid;
  353.       rawOid = enterprise.oidval();
  354.       raw_pdu->enterprise = rawOid->ptr;
  355.       raw_pdu->enterprise_length = (int) rawOid->len;
  356.     }
  358.     // timestamp
  359.     TimeTicks timestamp;
  360.     pdu->get_notify_timestamp( timestamp);
  361.     raw_pdu->time = ( unsigned long) timestamp;
  363.   }
  365.   // if its a v2 trap then we need to make a few adjustments
  366.   // vb #1 is the timestamp
  367.   // vb #2 is the id, represented as an Oid
  368.   if (( raw_pdu->command == sNMP_PDU_TRAP) ||
  369.       ( raw_pdu->command == sNMP_PDU_INFORM))
  370.   {
  371.     Vb tempvb;
  373.     temppdu = *pdu;
  374.     temppdu.trim(temppdu.get_vb_count());
  376.     // vb #1 is the timestamp
  377.     TimeTicks timestamp;
  378.     tempvb.set_oid(SNMP_MSG_OID_SYSUPTIME);   // sysuptime
  379.     pdu->get_notify_timestamp( timestamp);
  380.     tempvb.set_value ( timestamp);
  381.     temppdu += tempvb;
  383.     // vb #2 is the id
  384.     Oid trapid;
  385.     tempvb.set_oid(SNMP_MSG_OID_TRAPID);
  386.     pdu->get_notify_id( trapid);
  387.     tempvb.set_value( trapid);
  388.     temppdu += tempvb;
  390.     // append the remaining vbs
  391.     for (int z=0; z<pdu->get_vb_count(); z++) {
  392.       pdu->get_vb( tempvb,z);
  393.       temppdu += tempvb;
  394.     }
  396.     pdu = &temppdu;          // reassign the pdu to the temp one
  397.   }
  398.   // load up the payload
  399.   // for all Vbs in list, add them to the pdu
  400.   int vb_count;
  401.   Vb tempvb;
  402.   Oid tempoid;
  403.   SmiLPOID smioid;
  404.   SmiVALUE smival;
  406.   vb_count = pdu->get_vb_count();
  407.   for (int z=0;z<vb_count;z++) {
  408.     pdu->get_vb( tempvb,z);
  409.     tempvb.get_oid( tempoid);
  410.     smioid = tempoid.oidval();
  411.     // clear the value portion, in case its
  412.     // not already been done so by the app writer
  413.     // only do it in the case its a get,next or bulk
  414.     if ((raw_pdu->command == sNMP_PDU_GET) ||
  415.         (raw_pdu->command == sNMP_PDU_GETNEXT) ||
  416.         (raw_pdu->command == sNMP_PDU_GETBULK))
  417.       tempvb.set_null();
  418.     status = convertVbToSmival( tempvb, &smival );
  419.     if ( status != SNMP_CLASS_SUCCESS) {
  420.       snmp_free_pdu( raw_pdu);
  421.       return status;
  422.     }
  423.     // add the vb to the raw pdu
  424.     snmp_add_var( raw_pdu, smioid->ptr, (int) smioid->len, &smival);
  426.     freeSmivalDescriptor( &smival);
  427.   }
  429.   // ASN1 encode the pdu
  430. #ifdef _SNMPv3
  431.   if (version == version3)
  432.   {
  433.     if ((!engine_id) || (!security_name))
  434.     {
  435.       LOG_BEGIN(ERROR_LOG | 4);
  436.       LOG("SNMPMessage: Need security name and engine id for v3 message");
  437.       LOG_END;
  439.       // prevention of SNMP++ Enterprise Oid death
  440.       if ( enterprise.len() >0) {
  441. raw_pdu->enterprise = 0;
  442. raw_pdu->enterprise_length=0;
  443.       }
  444.       snmp_free_pdu( raw_pdu);
  445.       return SNMP_CLASS_INVALID_TARGET;
  446.     }
  448.     status = v3MP::I->snmp_build(raw_pdu, databuff, (int *)&bufflen,
  449.  *engine_id, *security_name, security_model,
  450.  pdu->get_security_level(),
  451.  pdu->get_context_engine_id(),
  452.  pdu->get_context_name());
  453.     if (status == SNMPv3_MP_OK) {
  454.       if ((pdu->get_type() == sNMP_PDU_RESPONSE) &&
  455.           ((int)pdu->get_maxsize_scopedpdu() < pdu->get_asn1_length())) {
  457. LOG_BEGIN(ERROR_LOG | 1);
  458. LOG("SNMPMessage: *BUG*: Serialized response pdu is too big (len) (max)");
  459. LOG(pdu->get_asn1_length());
  460. LOG(pdu->get_maxsize_scopedpdu());
  461. LOG_END;
  463.         // prevention of SNMP++ Enterprise Oid death
  464.         if ( enterprise.len() >0) {
  465.           raw_pdu->enterprise = 0;
  466.           raw_pdu->enterprise_length=0;
  467.         }
  468.         snmp_free_pdu( raw_pdu);
  469.         return SNMP_ERROR_TOO_BIG;
  470.       }
  471.     }
  472.   }
  473.   else
  474. #endif
  475.     status = snmp_build( raw_pdu, databuff, (int *) &bufflen, version,
  476.                          community.data(), (int) community.len());
  478.   LOG_BEGIN(DEBUG_LOG | 4);
  479.   LOG("SNMPMessage: return value for build message");
  480.   LOG(status);
  481.   LOG_END;
  483.   if ((status != 0)
  484. #ifdef _SNMPv3
  485.       && ((version != version3) || (status != SNMPv3_MP_OK))
  486. #endif
  487.       ) {
  488.     valid_flag = false;
  489.     // prevention of SNMP++ Enterprise Oid death
  490.     if ( enterprise.len() >0) {
  491.       raw_pdu->enterprise = 0;
  492.       raw_pdu->enterprise_length=0;
  493.     }
  494.     snmp_free_pdu( raw_pdu);
  495. #ifdef _SNMPv3
  496.     if (version == version3)
  497.       return status;
  498.     else
  499. #endif
  500.       // NOTE: This is an assumption - in most cases during normal
  501.       // operation the reason is a tooBig - another could be a
  502.       // damaged variable binding.
  503.       return SNMP_ERROR_TOO_BIG;
  504.   }
  505.   valid_flag = true;
  507.   // prevention of SNMP++ Enterprise Oid death
  508.   if ( enterprise.len() >0) {
  509.     raw_pdu->enterprise = 0;
  510.     raw_pdu->enterprise_length=0;
  511.   }
  513.   snmp_free_pdu( raw_pdu);
  515.   return SNMP_CLASS_SUCCESS;
  516. }
  518. // load up a SnmpMessage
  519. int SnmpMessage::load( unsigned char *data,
  520.                        unsigned long len)
  521. {
  522.   bufflen = MAX_SNMP_PACKET;
  523.   valid_flag = false;
  525.   if (len <= MAX_SNMP_PACKET)
  526.   {
  527.     memcpy( (unsigned char *) databuff, (unsigned char *) data,
  528.             (unsigned int) len);
  529.     bufflen = len;
  530.     valid_flag = true;
  531.   }
  532.   else
  533.     return SNMP_ERROR_WRONG_LENGTH;
  535.   return SNMP_CLASS_SUCCESS;
  536. }
  538. // unload the data into SNMP++ objects
  539. int SnmpMessage::unload(Pdu &pdu,                 // Pdu object
  540. OctetStr &community,      // community object
  541. snmp_version &version,    // SNMP version #
  542.                         OctetStr *engine_id,      // optional v3
  543.                         OctetStr *security_name,  // optional v3
  544.                         long int *security_model,
  545.                         UdpAddress *from_addr,
  546.                         Snmp *snmp_session)
  547. {
  548.   pdu.clear();
  550.   if (!valid_flag)
  551.     return SNMP_CLASS_INVALID;
  553.   snmp_pdu *raw_pdu;
  554.   raw_pdu = snmp_pdu_create(0); // do a "snmp_free_pdu( raw_pdu)" before return
  556.   int status;
  558. #ifdef _SNMPv3
  559.   OctetStr context_engine_id;
  560.   OctetStr context_name;
  561.   long int security_level;
  563.   if ((security_model) && (security_name) && (engine_id) && (snmp_session)) {
  564.     status = v3MP::I->snmp_parse(snmp_session, raw_pdu,
  565.                          databuff, (int)bufflen, *engine_id,
  566.                          *security_name, context_engine_id, context_name,
  567.                          security_level, *security_model, version, *from_addr);
  568.     if (status != SNMPv3_MP_OK) {
  569.       pdu.set_request_id( raw_pdu->reqid);
  570.       pdu.set_type( raw_pdu->command);
  571.       snmp_free_pdu( raw_pdu);
  572.       return status;
  573.     }
  574.     pdu.set_context_engine_id(context_engine_id);
  575.     pdu.set_context_name(context_name);
  576.     pdu.set_security_level(security_level);
  577.     pdu.set_message_id(raw_pdu->msgid);
  578.     pdu.set_maxsize_scopedpdu(raw_pdu->maxsize_scopedpdu);
  579.   }
  580.   else {
  581. #endif
  582.     unsigned char community_name[MAX_LEN_COMMUNITY + 1];
  583.     int           community_len = MAX_LEN_COMMUNITY + 1;
  585.     status = snmp_parse(raw_pdu, databuff, (int) bufflen,
  586.                         community_name, community_len, version);
  587.     if (status != SNMP_CLASS_SUCCESS) {
  588.       snmp_free_pdu(raw_pdu);
  589.       return status;
  590.     }
  591.     community.set_data( community_name, community_len);
  593. #ifdef _SNMPv3
  594.   }
  595. #endif
  596.   // load up the SNMP++ variables
  597.   pdu.set_request_id(raw_pdu->reqid);
  598.   pdu.set_error_status((int) raw_pdu->errstat);
  599.   pdu.set_error_index((int) raw_pdu->errindex);
  600.   pdu.set_type( raw_pdu->command);
  602.   // deal with traps a little different
  603.   if ( raw_pdu->command == sNMP_PDU_V1TRAP) {
  604.     // timestamp
  605.     TimeTicks timestamp;
  606.     timestamp = raw_pdu->time;
  607.     pdu.set_notify_timestamp( timestamp);
  609.     // set the agent address
  610.     IpAddress agent_addr(inet_ntoa(raw_pdu->agent_addr.sin_addr));
  611.     if (agent_addr != "0.0.0.0")
  612.     {
  613.       pdu.set_v1_trap_address(agent_addr);
  615.       LOG_BEGIN(DEBUG_LOG | 4);
  616.       LOG("SNMPMessage: Trap address of received v1 trap");
  617.       LOG(agent_addr.get_printable());
  618.       LOG_END;
  619.     }
  621.     // set enterprise, notifyid
  622.     Oid enterprise;
  624.     if (raw_pdu->enterprise_length >0) {
  625.       for (int i=0; i< raw_pdu->enterprise_length; i++) {
  626.         enterprise += (int) (raw_pdu->enterprise[i]);
  627.       }
  628.       pdu.set_notify_enterprise(enterprise);
  629.     }
  630.     switch (raw_pdu->trap_type) {
  631.     case 0:
  632.       pdu.set_notify_id(coldStart);
  633.       break;
  635.     case 1:
  636.       pdu.set_notify_id(warmStart);
  637.       break;
  639.     case 2:
  640.       pdu.set_notify_id(linkDown);
  641.       break;
  643.     case 3:
  644.       pdu.set_notify_id(linkUp);
  645.       break;
  647.     case 4:
  648.       pdu.set_notify_id(authenticationFailure);
  649.       break;
  651.     case 5:
  652.       pdu.set_notify_id(egpNeighborLoss);
  653.       break;
  655.     case 6: { // enterprise specific
  656.       // base id + specific #
  657.       Oid eOid = enterprise;
  658.       eOid += 0ul;
  659.       eOid += raw_pdu->specific_type;
  660.       pdu.set_notify_id( eOid);
  661.       break;
  662.       }
  663.     default:
  664.       {
  665. LOG_BEGIN(WARNING_LOG | 3);
  666. LOG("SNMPMessage: Received trap with illegal trap type");
  667. LOG(raw_pdu->trap_type);
  668. LOG_END;
  669.       }
  670.     }
  671.   }
  673.   // vbs
  674.   Vb tempvb;
  675.   Oid tempoid;
  676.   struct   variable_list *vp;
  677.   int vb_nr = 1;
  679.   for(vp = raw_pdu->variables; vp; vp = vp->next_variable, vb_nr++) {
  681.     // extract the oid portion
  682.     tempoid.set_data( (unsigned long *)vp->name,
  683.                       ( unsigned int) vp->name_length);
  684.     tempvb.set_oid( tempoid);
  686.     // extract the value portion
  687.     switch(vp->type){
  689.       // octet string
  690.     case sNMP_SYNTAX_OCTETS:
  691.       {
  692. OctetStr octets( (unsigned char *) vp->val.string,
  693.  (unsigned long) vp->val_len);
  694. tempvb.set_value( octets);
  695.       }
  696.       break;
  697.     case sNMP_SYNTAX_OPAQUE:
  698.       {
  699. OpaqueStr octets( (unsigned char *) vp->val.string,
  700.           (unsigned long) vp->val_len);
  701. tempvb.set_value( octets);
  702.       }
  703.       break;
  705.       // object id
  706.     case sNMP_SYNTAX_OID:
  707.       {
  708. Oid oid( (unsigned long*) vp->val.objid,
  709.  (int) vp->val_len);
  710. tempvb.set_value( oid);
  711.         if ((vb_nr == 2) &&
  712.             ((raw_pdu->command == sNMP_PDU_TRAP) ||
  713.              (raw_pdu->command == sNMP_PDU_INFORM)) &&
  714.             (tempoid == SNMP_MSG_OID_TRAPID))
  715.         {
  716.           // set notify_id
  717.           pdu.set_notify_id(oid);
  718.   continue; // don't add vb to pdu
  719.         }
  720.       }
  721.       break;
  723.       // timeticks
  724.     case sNMP_SYNTAX_TIMETICKS:
  725.       {
  726. TimeTicks timeticks( (unsigned long) *(vp->val.integer));
  727. tempvb.set_value( timeticks);
  728.         if ((vb_nr == 1) &&
  729.             ((raw_pdu->command == sNMP_PDU_TRAP) ||
  730.              (raw_pdu->command == sNMP_PDU_INFORM)) &&
  731.             (tempoid == SNMP_MSG_OID_SYSUPTIME))
  732.         {
  733.           // set notify_timestamp
  734.           pdu.set_notify_timestamp( timeticks);
  735.   continue; // don't add vb to pdu
  736.         }
  737.       }
  738.       break;
  740.       // 32 bit counter
  741.     case sNMP_SYNTAX_CNTR32:
  742.       {
  743. Counter32 counter32( (unsigned long) *(vp->val.integer));
  744. tempvb.set_value( counter32);
  745.       }
  746.       break;
  748.       // 32 bit gauge
  749.     case sNMP_SYNTAX_GAUGE32:
  750.       {
  751. Gauge32 gauge32( (unsigned long) *(vp->val.integer));
  752. tempvb.set_value( gauge32);
  753.       }
  754.       break;
  756.       // ip address
  757.     case sNMP_SYNTAX_IPADDR:
  758.       {
  759. char buffer[42];
  761. if (vp->val_len == 16)
  762.   sprintf( buffer, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:"
  763.    "%02x%02x:%02x%02x:%02x%02x:%02x%02x",
  764.    vp->val.string[ 0], vp->val.string[ 1], vp->val.string[ 2],
  765.    vp->val.string[ 3], vp->val.string[ 4], vp->val.string[ 5],
  766.    vp->val.string[ 6], vp->val.string[ 7], vp->val.string[ 8],
  767.    vp->val.string[ 9], vp->val.string[10], vp->val.string[11],
  768.    vp->val.string[12], vp->val.string[13], vp->val.string[14],
  769.    vp->val.string[15]);
  770. else
  771.   sprintf( buffer,"%d.%d.%d.%d",
  772.    vp->val.string[0], vp->val.string[1],
  773.    vp->val.string[2], vp->val.string[3]);
  774. IpAddress ipaddress( buffer);
  775. tempvb.set_value( ipaddress);
  776.       }
  777.       break;
  779.       // 32 bit integer
  780.     case sNMP_SYNTAX_INT:
  781.       {
  782. SnmpInt32 int32( (long) *(vp->val.integer));
  783. tempvb.set_value( int32);
  784.       }
  785.       break;
  787.       // 32 bit unsigned integer
  788. /* Not distinguishable from Gauge32
  789.     case sNMP_SYNTAX_UINT32:
  790.       {
  791. SnmpUInt32 uint32( (unsigned long) *(vp->val.integer));
  792. tempvb.set_value( uint32);
  793.       }
  794.       break;
  795. */
  796.       // v2 counter 64's
  797.     case sNMP_SYNTAX_CNTR64:
  798.       { // Frank Fock (was empty before)
  799. Counter64 c64(((counter64*)vp->val.counter64)->high,
  800.       ((counter64*)vp->val.counter64)->low);
  801. tempvb.set_value( c64);
  802. break;
  803.       }
  804.     case sNMP_SYNTAX_NULL:
  805.     tempvb.set_null();
  806.     break;
  808.     // v2 vb exceptions
  809.     case sNMP_SYNTAX_NOSUCHOBJECT:
  810.     case sNMP_SYNTAX_NOSUCHINSTANCE:
  811.     case sNMP_SYNTAX_ENDOFMIBVIEW:
  812.       tempvb.set_exception_status(vp->type);
  813.       break;
  815.     default:
  816.       tempvb.set_null();
  818.     } // end switch
  820.     // append the vb to the pdu
  821.     pdu += tempvb;
  822.   }
  824.   snmp_free_pdu( raw_pdu);
  826.   return SNMP_CLASS_SUCCESS;
  827. }
  829. #ifdef SNMP_PP_NAMESPACE
  830. }; // end of namespace Snmp_pp
  831. #endif