uxsnmp.cpp

来自「JdonFramework need above jdk 1.4.0 This」· C++ 代码 · 共 2,128 行 · 第 1/5 页

          status = SNMP_CLASS_TL_FAILED;
        else if (errno == EACCES)
          status = SNMP_CLASS_TL_ACCESS_DENIED;
        else
          status = SNMP_CLASS_INTERNAL_ERROR;
#endif
	close(iv_snmp_session_ipv6);    // close the dynamic socket
	iv_snmp_session_ipv6 = INVALID_SOCKET;
      }
      else
      {
        status = SNMP_CLASS_SUCCESS;
#ifdef SNMP_BROADCAST
        int enable_broadcast = 1;
        setsockopt(iv_snmp_session_ipv6, SOL_SOCKET, SO_BROADCAST,
                   (char*)&enable_broadcast, sizeof(enable_broadcast));
#endif
      }
    }
#else
    debugprintf(0, "User error: Enable IPv6 and recompile snmp++.");
#endif // SNMP_PP_IPv6
  }
  return;
}


//---------[ Snmp Class Destructor ]----------------------------------
Snmp::~Snmp()
{
  stop_poll_thread();

  // if we failed during construction then don't try
  // to free stuff up that was not allocated
  if (iv_snmp_session != INVALID_SOCKET)
  {
    // go through the snmpEventList and delete any outstanding
    // events on this socket
    eventListHolder->snmpEventList()->DeleteSocketEntry(iv_snmp_session);

    close(iv_snmp_session);    // close the dynamic socket
  }
  // if we failed during construction then don't try
  // to free stuff up that was not allocated
  if (iv_snmp_session_ipv6 != INVALID_SOCKET)
  {
    // go through the snmpEventList and delete any outstanding
    // events on this socket
    eventListHolder->snmpEventList()->DeleteSocketEntry(iv_snmp_session_ipv6);

    close(iv_snmp_session_ipv6);    // close the dynamic socket
  }

  // shut down trap reception if used
  notify_unregister();

  delete eventListHolder;
}

// Get the version of the snmp++ library at runtime
// This function MUST stay in the cpp file!
const char *Snmp::get_version()
{
  return SNMP_PP_VERSION_STRING;
}

//-------------------[ returns error string ]--------------------------
const char *Snmp::error_msg(const int c)
{
#ifdef _SNMPv3
  if (c>=SNMPv3_USM_MIN_ERROR)
    return ((c>SNMPv3_USM_MAX_ERROR)?pv3Errs[SNMPv3_USM_ERRORCOUNT]:pv3Errs[c-SNMPv3_USM_MIN_ERROR]);
  if (c<=SNMPv3_MP_MAX_ERROR)
    return ((c<SNMPv3_MP_MIN_ERROR)?nv3Errs[SNMPv3_MP_ERRORCOUNT]:nv3Errs[SNMPv3_MP_MAX_ERROR - c]);
#endif
  return ((c<0)?
          ((c<MAX_NEG_ERROR)?nErrs[-(MAX_NEG_ERROR)+1]:nErrs[-c]):
          ((c>MAX_POS_ERROR)?pErrs[MAX_POS_ERROR+1]:pErrs[c]));
}

#ifdef _SNMPv3
const char* Snmp::error_msg(const Oid& v3Oid)
{
  // UsmStats
  if (v3Oid == oidUsmStatsUnsupportedSecLevels)
    return error_msg(SNMPv3_USM_UNSUPPORTED_SECURITY_LEVEL);

  if (v3Oid == oidUsmStatsNotInTimeWindows)
    return error_msg(SNMPv3_USM_NOT_IN_TIME_WINDOW);

  if (v3Oid == oidUsmStatsUnknownUserNames )
    return error_msg(SNMPv3_USM_UNKNOWN_SECURITY_NAME);

  if (v3Oid == oidUsmStatsUnknownEngineIDs)
    return error_msg(SNMPv3_USM_UNKNOWN_ENGINEID);

  if (v3Oid == oidUsmStatsWrongDigests)
    return error_msg(SNMPv3_USM_AUTHENTICATION_FAILURE);

  if (v3Oid == oidUsmStatsDecryptionErrors)
    return error_msg(SNMPv3_USM_DECRYPTION_ERROR);

  // MPDstats
  if (v3Oid == oidSnmpUnknownSecurityModels)
    return error_msg(SNMPv3_MP_UNSUPPORTED_SECURITY_MODEL);

  if (v3Oid == oidSnmpInvalidMsgs)
    return error_msg(SNMPv3_MP_INVALID_MESSAGE);

  if (v3Oid == oidSnmpUnknownPDUHandlers)
    return error_msg(SNMPv3_MP_UNKNOWN_PDU_HANDLERS);

  if (v3Oid == oidSnmpUnavailableContexts)
    return error_msg(SNMPv3_MP_UNAVAILABLE_CONTEXT);

  if (v3Oid == oidSnmpUnknownContexts)
    return error_msg(SNMPv3_MP_UNKNOWN_CONTEXT);

  return error_msg(MAX_POS_ERROR + 1);
}
#endif

//------------------------[ get ]---------------------------------------
int Snmp::get(Pdu &pdu, const SnmpTarget &target)
{
  pdu.set_type( sNMP_PDU_GET);
  return snmp_engine( pdu, 0, 0, target, NULL, 0);
}

//------------------------[ get async ]----------------------------------
int Snmp::get(Pdu &pdu, const SnmpTarget &target,
              const snmp_callback callback,
              const void * callback_data)
{
  pdu.set_type( sNMP_PDU_GET_ASYNC);
  return snmp_engine( pdu, 0, 0, target, callback, callback_data);
}

//------------------------[ get next ]-----------------------------------
int Snmp::get_next(Pdu &pdu, const SnmpTarget &target)
{
  pdu.set_type( sNMP_PDU_GETNEXT);
  return snmp_engine( pdu, 0, 0, target, NULL, 0);
}

//------------------------[ get next async ]-----------------------------
int Snmp::get_next(Pdu &pdu, const SnmpTarget &target,
                   const snmp_callback callback,
                   const void * callback_data)
{
  pdu.set_type( sNMP_PDU_GETNEXT_ASYNC);
  return snmp_engine( pdu, 0, 0, target, callback, callback_data);
}

//-------------------------[ set ]---------------------------------------
int Snmp::set(Pdu &pdu, const SnmpTarget &target)
{
  pdu.set_type( sNMP_PDU_SET);
  return snmp_engine( pdu, 0, 0, target, NULL, 0);
}

//------------------------[ set async ]----------------------------------
int Snmp::set(Pdu &pdu, const SnmpTarget &target,
              const snmp_callback callback,
              const void * callback_data)
{
  pdu.set_type( sNMP_PDU_SET_ASYNC);
  return snmp_engine( pdu, 0, 0, target, callback, callback_data);
}

//-----------------------[ get bulk ]------------------------------------
int Snmp::get_bulk(Pdu &pdu,                // pdu to use
                   const SnmpTarget &target,// destination target
                   const int non_repeaters, // number of non repeaters
                   const int max_reps)      // maximum number of repetitions
{
  pdu.set_type( sNMP_PDU_GETBULK);
  return snmp_engine( pdu, non_repeaters, max_reps, target, NULL, 0);
}

//-----------------------[ get bulk async ]------------------------------
int Snmp::get_bulk(Pdu &pdu,                 // pdu to use
                   const SnmpTarget &target, // destination target
                   const int non_repeaters,  // number of non repeaters
                   const int max_reps,       // maximum number of repetitions
                   const snmp_callback callback,// callback to use
                   const void * callback_data)  // callback data
{
  pdu.set_type( sNMP_PDU_GETBULK_ASYNC);
  return snmp_engine( pdu, non_repeaters, max_reps, target,
                      callback, callback_data);
}

//------------------------[ inform_response ]----------------------------
int Snmp::response(Pdu &pdu,                 // pdu to use
                   const SnmpTarget &target, // response target
		   const SnmpSocket fd)
{
  pdu.set_type( sNMP_PDU_RESPONSE);
  return snmp_engine(pdu, 0, 0, target, NULL, 0, fd);
}

int Snmp::send_raw_data(unsigned char *send_buf,
                        size_t send_len, UdpAddress &address, SnmpSocket fd)
  REENTRANT(
{
  if (fd != INVALID_SOCKET)
    return send_snmp_request(fd, send_buf, send_len, address);
  else
  {
    if (address.get_ip_version() == Address::version_ipv4)
    {
      if (iv_snmp_session != INVALID_SOCKET)
	return send_snmp_request(iv_snmp_session, send_buf,
				 send_len, address);
      else
	address.map_to_ipv6();
    }
    return send_snmp_request(iv_snmp_session_ipv6, send_buf,
			     send_len, address);
  }
})

//-----------------------[ cancel ]--------------------------------------
int Snmp::cancel( const unsigned long request_id)
{
  eventListHolder->snmpEventList()->lock();
  int status = eventListHolder->snmpEventList()->DeleteEntry(request_id);
  eventListHolder->snmpEventList()->unlock();

  return status;
}


//----------------------[ sending report, V3 only]-----------------------
int Snmp::report(Pdu &pdu,                // pdu to send
                 const SnmpTarget &target)// destination target
{
  pdu.set_type( sNMP_PDU_REPORT);
  return snmp_engine( pdu, 0, 0, target, NULL, 0);
}

//----------------------[ blocking inform, V2 only]------------------------
int Snmp::inform(Pdu &pdu,                // pdu to send
                 const SnmpTarget &target)// destination target
{
  if (target.get_version() == version1)
  {
    LOG_BEGIN(ERROR_LOG | 1);
    LOG("Snmp: Invalid Operation: Inform not defined for SNMPv1");
    LOG_END;

    return SNMP_CLASS_INVALID_OPERATION;
  }

  pdu.set_type( sNMP_PDU_INFORM);
  check_notify_timestamp(pdu);
  return snmp_engine( pdu, 0, 0, target, NULL, 0);
}

//----------------------[ asynch inform, V2 only]------------------------
int Snmp::inform(Pdu &pdu,                // pdu to send
                 const SnmpTarget &target,      // destination target
                 const snmp_callback callback,  // callback function
                 const void * callback_data)    // callback data
{
  if (target.get_version() == version1)
  {
    LOG_BEGIN(ERROR_LOG | 1);
    LOG("Snmp: Invalid Operation: Inform not defined for SNMPv1");
    LOG_END;

    return SNMP_CLASS_INVALID_OPERATION;
  }

  pdu.set_type( sNMP_PDU_INFORM);
  check_notify_timestamp(pdu);
  return snmp_engine( pdu, 0, 0, target, callback, callback_data);
}


//---------------------[ send a trap ]-----------------------------------
int Snmp::trap(Pdu &pdu,                        // pdu to send
               const SnmpTarget &target)        // destination target
{
  OctetStr my_get_community;
  OctetStr my_set_community;
  GenAddress address;
  unsigned long my_timeout;
  int my_retry;
  unsigned char version;
  int status;

  debugprintf(1, "++ SNMP++, Send a Trap");
  //---------[ make sure pdu is valid ]---------------------------------
  if (!pdu.valid())
  {
    debugprintf(0, "-- SNMP++, PDU Object Invalid");
    return  SNMP_CLASS_INVALID_PDU;
  }

  //---------[ make sure target is valid ]------------------------------
  if (!target.valid())
  {
    debugprintf(0, "-- SNMP++, Target Object Invalid");
    return SNMP_CLASS_INVALID_TARGET;
  }

  CTarget* ctarget = NULL;
  UTarget* utarget = NULL;
  OctetStr security_name;
  int security_model;

  switch (target.get_type()) {
    case SnmpTarget::type_ctarget:
      ctarget = (CTarget*)(&target);
      break;
    case SnmpTarget::type_utarget:
      utarget = (UTarget*)(&target);
      break;
    case SnmpTarget::type_base:
      debugprintf(0, "-- SNMP++, do not use SnmpTarget, use a  CTarget or UTarget");
      return SNMP_CLASS_INVALID_TARGET;
    default:
      // target is not known
      debugprintf(0, "-- SNMP++, type of target is unknown!");
      return SNMP_CLASS_UNSUPPORTED;
  }

  if (ctarget) {
    debugprintf(3, "snmp::trap called with CTarget");
    if (!ctarget->resolve_to_C( my_get_community, my_set_community, address,
                                my_timeout, my_retry, version))
    {
      debugprintf(0, "-- SNMP++, Resolve Fail (CTarget)");
      return SNMP_CLASS_UNSUPPORTED;
    }
#ifdef _SNMPv3
    if (version == version3)
    {
      debugprintf(0, "-- SNMP++, use UTarget for SNMPv3");
      return SNMP_CLASS_INVALID_TARGET;
    }
#endif
  }
  else { // target is not a CTarget:
    if (utarget) {
      debugprintf(3, "trap called with UTarget");
      if (!utarget->resolve_to_U( security_name, security_model, address,
				  my_timeout, my_retry, version))
      {
        debugprintf(0, "-- SNMP++, Resolve Fail (UTarget)");
        return SNMP_CLASS_UNSUPPORTED;
      }
#ifdef _SNMPv3
      if (version != version3) {
#endif
        my_get_community = security_name;
        if ((security_model != SecurityModel_v1) &&
            (security_model != SecurityModel_v2)) {
          debugprintf(0, "-- SNMP++, Target contains invalid security_model/version combination");
          return SNMP_CLASS_INVALID_TARGET;
        }
#ifdef _SNMPv3
      } // end if (version != version3)
#endif
    }
    else { // target is neither CTarget nor UTarget:
      debugprintf(0, "-- SNMP++, Resolve Fail");
      return SNMP_CLASS_INVALID_TARGET;
    }
  }

  //--------[ determine request id to use ]------------------------------
  pdu.set_request_id( MyMakeReqId());

  //--------[ check timestamp, if null use system time ]-----------------
  check_notify_timestamp(pdu);

  //------[ validate address to use ]-------------------------------------
  if (!address.valid()) {
    debugprintf(0, "-- SNMP++, Bad address");
    return SNMP_CLASS_INVALID_TARGET;
  }

  if ((address.get_type() != Address::type_ip) &&
      (address.get_type() != Address::type_udp) )
    {
      debugprintf(0, "-- SNMP++, Bad address type");
      return SNMP_CLASS_TL_UNSUPPORTED;
    }

  UdpAddress udp_address(address);
  if (!udp_address.valid()) {
    debugprintf(0, "-- SNMP++, copy address failed");
    return SNMP_CLASS_RESOURCE_UNAVAIL;
  }

  //----------[ choose the target address port ]-----------------------
  if ((address.get_type() == Address::type_ip) || !udp_address.get_port())
    udp_address.set_port(SNMP_TRAP_PORT);

  //----------[ based on the target type, choose v1 or v1 trap type ]-----
  if ( version == version1)
    pdu.set_type( sNMP_PDU_V1TRAP);
  else // v2 and v3 use v2TRAP
    pdu.set_type( sNMP_PDU_TRAP);

  SnmpMessage snmpmsg;

#ifdef _SNMPv3
  if ( version == version3) {

    OctetStr engine_id = v3MP::I->get_local_engine_id();
    if (!utarget) {
      debugprintf(0, "-- SNMP++, dont know how to handle SNMPv3 without UTarget!");
      return SNMP_CLASS_INVALID_TARGET;
    }

    // set context_engine_id of pdu, if it is not set
    if (pdu.get_context_engine_id().len() == 0)
    {
      debugprintf(8, "Setting contextEngineID of Pdu to (%s)",
                  engine_id.get_printable());
      pdu.set_context_engine_id(engine_id);
    }