uxsnmp.cpp

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

#else
  struct sockaddr_in from_addr;
#endif // SNMP_PP_IPv6

#if !(defined (CPU) && CPU == PPC603) && (defined __GNUC__ || defined __FreeBSD__ || defined _AIX) && ! defined __MINGW32__
  socklen_t fromlen;
#else
  int fromlen;
#endif
  fromlen = sizeof(from_addr);

  memset(&from_addr, 0, sizeof(from_addr));

  // do the read
  do {
    receive_buffer_len = (long) recvfrom(sock, (char *) receive_buffer,
                                         MAX_SNMP_PACKET + 1, 0,
                                         (struct sockaddr*)&from_addr,
                                         &fromlen);
  } while (receive_buffer_len < 0 && EINTR == errno);

  if (receive_buffer_len < 0 )                // error or no data pending
    return SNMP_CLASS_TL_FAILED;

  if (receive_buffer_len == MAX_SNMP_PACKET + 1)
  {
    // Message is too long...
    debugprintf(1, "Received message is ignored (packet too long)");
    return SNMP_CLASS_ERROR;
  }

  // copy fromaddress and remote port
  UdpAddress fromaddress;

  if (((sockaddr_in&)from_addr).sin_family == AF_INET)
  {
    // IPv4
    fromaddress = inet_ntoa(((sockaddr_in&)from_addr).sin_addr);
    fromaddress.set_port(ntohs(((sockaddr_in&)from_addr).sin_port));
  }
#ifdef SNMP_PP_IPv6
  else if (from_addr.ss_family == AF_INET6)
  {
    // IPv6
    char tmp_buffer[INET6_ADDRSTRLEN+1];

    inet_ntop(AF_INET6, &(((sockaddr_in6&)from_addr).sin6_addr),
              tmp_buffer, INET6_ADDRSTRLEN);

    fromaddress = tmp_buffer;
    fromaddress.set_port(ntohs(((sockaddr_in6&)from_addr).sin6_port));
  }
#endif // SNMP_PP_IPv6
  else
  {
    debugprintf(0, "Unknown socket address family (%i).",
                ((sockaddr_in&)from_addr).sin_family);
    return SNMP_CLASS_TL_FAILED;
  }

  debugprintf(1, "++ SNMP++: data received from %s.",
              fromaddress.get_printable());
  debughexprintf(5, receive_buffer, receive_buffer_len);

  SnmpMessage snmpmsg;
  if ( snmpmsg.load( receive_buffer, receive_buffer_len) != SNMP_CLASS_SUCCESS)
    return SNMP_CLASS_ERROR;

  OctetStr community_name;
  snmp_version version;
  OctetStr engine_id;
  OctetStr security_name;

#ifdef _SNMPv3
  long int security_model;
  if (snmpmsg.is_v3_message() == TRUE)
  {
    int returncode = snmpmsg.unloadv3(pdu, version, engine_id,
                                      security_name, security_model,
                                      fromaddress, snmp_session);
    if (returncode != SNMP_CLASS_SUCCESS)
      return returncode;
  }
  else
  {
#endif
    int returncode = snmpmsg.unload( pdu, community_name, version);
    if (returncode != SNMP_CLASS_SUCCESS)
      return SNMP_CLASS_ERROR;
#ifdef _SNMPv3
  }

  if (version == version3) {
    *target = new UTarget();
    (*target)->set_address(fromaddress);
    (*target)->set_version(version);
    ((UTarget*)*target)->set_engine_id(engine_id);
    ((UTarget*)*target)->set_security_name(security_name);
    ((UTarget*)*target)->set_security_model(security_model);

    v3MP::I->add_to_engine_id_table(engine_id,
                         (char*)((IpAddress &)fromaddress).get_printable(),
                         fromaddress.get_port());

    debugprintf(4,"receive_snmp_notification: engine_id (%s), security_name "
		"(%s), security_model (%i), security_level (%i)",
                engine_id.get_printable(), security_name.get_printable(),
                security_model, pdu.get_security_level());
  }
  else
  {
#endif
    *target = new CTarget();
    (*target)->set_version(version);
    (*target)->set_address(fromaddress);
    ((CTarget*)*target)->set_readcommunity( community_name);
    ((CTarget*)*target)->set_writecommunity( community_name);
#ifdef _SNMPv3
  }
#endif
  return SNMP_CLASS_SUCCESS;   // Success! return
}


//--------[ map action ]------------------------------------------------
// map the snmp++ action to a SMI pdu type
void Snmp::map_action( unsigned short action, unsigned short & pdu_action)
{
  switch( action)
    {
    case sNMP_PDU_GET:
    case sNMP_PDU_GET_ASYNC:
      pdu_action = sNMP_PDU_GET;
      break;

    case sNMP_PDU_SET:
    case sNMP_PDU_SET_ASYNC:
      pdu_action = sNMP_PDU_SET;
      break;

    case sNMP_PDU_GETNEXT:
    case sNMP_PDU_GETNEXT_ASYNC:
      pdu_action = sNMP_PDU_GETNEXT;
      break;

    case sNMP_PDU_GETBULK:
    case sNMP_PDU_GETBULK_ASYNC:
      pdu_action = sNMP_PDU_GETBULK;
      break;

    case sNMP_PDU_RESPONSE:
      pdu_action = sNMP_PDU_RESPONSE;
      break;

    case sNMP_PDU_INFORM:
    case sNMP_PDU_INFORM_ASYNC:
      pdu_action = sNMP_PDU_INFORM;
      break;

    case sNMP_PDU_REPORT:
      pdu_action = sNMP_PDU_REPORT;
      break;

    default:
      pdu_action = sNMP_PDU_GET;  // TM ?? error ??
      break;

    };  // end switch
}

//------[ Snmp Class Constructor ]--------------------------------------

Snmp::Snmp(int &status, const unsigned short port, const bool bind_ipv6)
    : SnmpSynchronized(),
      m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
{
  IpAddress *addresses[2];

  if (bind_ipv6)
  {
    listen_address = "::";

    addresses[0] = NULL;
    addresses[1] = &listen_address;

    init(status, addresses, 0, port);
  }
  else
  {
    listen_address = "0.0.0.0";

    addresses[0] = &listen_address;
    addresses[1] = NULL;

    init(status, addresses, port, 0);
  }

}

Snmp::Snmp( int &status, const UdpAddress& addr)
    : SnmpSynchronized(),
      m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
{
  IpAddress *addresses[2];

  listen_address = addr;

  if (listen_address.get_ip_version() == Address::version_ipv4)
  {
    addresses[0] = &listen_address;
    addresses[1] = NULL;
    init(status, addresses, addr.get_port(), 0);
  }
  else
  {
    addresses[0] = NULL;
    addresses[1] = &listen_address;
    init(status, addresses, 0, addr.get_port());
  }
}

Snmp::Snmp( int &status,  const UdpAddress& addr_v4,
            const UdpAddress& addr_v6)
    : SnmpSynchronized(),
      m_bThreadRunning(false), m_iPollTimeOut(DEFAULT_TIMEOUT)
{
  IpAddress *addresses[2];

  listen_address = addr_v4;
  IpAddress address_v6((IpAddress)addr_v6);
  addresses[0] = &listen_address;
  addresses[1] = &address_v6;

  init(status, addresses, addr_v4.get_port(), addr_v6.get_port());
}

void Snmp::socket_startup()
{
#ifdef WIN32
  WSADATA WSAData;
  (void)WSAStartup(0x0101, &WSAData);
#endif
}

void Snmp::socket_cleanup()
{
#ifdef WIN32
  int iRetValue = WSACleanup();
  debugprintf(4, "WSACleanup: ReturnValue (%i)", iRetValue);
#endif
}

void Snmp::init(int& status, IpAddress *addresses[2],
                const unsigned short port_v4,
                const unsigned short port_v6)
{
  eventListHolder = new EventListHolder(this);
  // initialize the request_id
  eventListHolder->snmpEventList()->lock();
//  srand(time(0)); // better than nothing
  current_rid = (rand() % (PDU_MAX_RID - PDU_MIN_RID -1)) + PDU_MIN_RID;
  debugprintf(4, "Initialized request_id to %i.", current_rid);
  eventListHolder->snmpEventList()->unlock();

  // intialize all the trap receiving member variables
  notifycallback = 0;
  notifycallback_data = 0;
#ifdef HPUX
  int errno = 0;
#endif

  status = SNMP_CLASS_ERROR;
  iv_snmp_session = INVALID_SOCKET;
  iv_snmp_session_ipv6 = INVALID_SOCKET;

  /* Open IPv4 socket */
  if (addresses[0])
  {
    // open a socket to be used for the session
    if (( iv_snmp_session = socket( AF_INET, SOCK_DGRAM,0)) == INVALID_SOCKET)
    {
#ifdef WIN32
      int werr = WSAGetLastError();
      debugprintf(1, "Call to socket throws error %d", werr);
      if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr)
        status = SNMP_CLASS_RESOURCE_UNAVAIL;
      else if (WSAEHOSTDOWN == werr)
        status = SNMP_CLASS_TL_FAILED;
      else
        status = SNMP_CLASS_TL_UNSUPPORTED;
#else
      if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno)
        status = SNMP_CLASS_RESOURCE_UNAVAIL;
      else if (EHOSTDOWN == errno)
        status = SNMP_CLASS_TL_FAILED;
      else
        status = SNMP_CLASS_TL_UNSUPPORTED;
#endif
    }
    else
    {
      // set up the manager socket attributes
      unsigned long inaddr = inet_addr(addresses[0]->get_printable());
      struct sockaddr_in mgr_addr;
      memset(&mgr_addr, 0, sizeof(mgr_addr));
      mgr_addr.sin_family = AF_INET;
      mgr_addr.sin_addr.s_addr = inaddr;
      mgr_addr.sin_port = htons( port_v4);
#ifdef CYGPKG_NET_OPENBSD_STACK
      mgr_addr.sin_len = sizeof(mgr_addr);
#endif

      // bind the socket
      if (bind(iv_snmp_session, (struct sockaddr*)&mgr_addr,
               sizeof(mgr_addr)) < 0)
      {
#ifdef WIN32
        int werr = WSAGetLastError();
	debugprintf(1, "Call to bind throws error %d", werr);
        if (WSAEADDRINUSE  == werr)
          status = SNMP_CLASS_TL_IN_USE;
        else if (WSAENOBUFS == werr)
          status = SNMP_CLASS_RESOURCE_UNAVAIL;
        else if (werr == WSAEAFNOSUPPORT)
          status = SNMP_CLASS_TL_UNSUPPORTED;
        else if (werr == WSAENETUNREACH)
          status = SNMP_CLASS_TL_FAILED;
        else if (werr == EACCES)
          status = SNMP_CLASS_TL_ACCESS_DENIED;
        else
          status = SNMP_CLASS_INTERNAL_ERROR;
#else
        if (EADDRINUSE  == errno)
          status = SNMP_CLASS_TL_IN_USE;
        else if (ENOBUFS == errno)
          status = SNMP_CLASS_RESOURCE_UNAVAIL;
        else if (errno == EAFNOSUPPORT)
          status = SNMP_CLASS_TL_UNSUPPORTED;
        else if (errno == ENETUNREACH)
          status = SNMP_CLASS_TL_FAILED;
        else if (errno == EACCES)
          status = SNMP_CLASS_TL_ACCESS_DENIED;
        else
	{
	  debugprintf(0, "Uncatched errno value %d, returning internal error.",
		      errno);
          status = SNMP_CLASS_INTERNAL_ERROR;
	}
#endif
	close(iv_snmp_session);    // close the dynamic socket
	iv_snmp_session = INVALID_SOCKET;
      }
      else
      {
        status = SNMP_CLASS_SUCCESS;
#ifdef SNMP_BROADCAST
        int enable_broadcast = 1;
        setsockopt(iv_snmp_session, SOL_SOCKET, SO_BROADCAST,
                   (char*)&enable_broadcast, sizeof(enable_broadcast));
#endif
      }
    }
    if (status != SNMP_CLASS_SUCCESS)
      return;
  }

  /* Open IPv6 socket */
  if (addresses[1])
  {
#ifdef SNMP_PP_IPv6
    // open a socket to be used for the session
    if (( iv_snmp_session_ipv6 = socket( AF_INET6, SOCK_DGRAM,0)) 
	== INVALID_SOCKET)
    {
#ifdef WIN32
      int werr = WSAGetLastError();
      if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr)
        status = SNMP_CLASS_RESOURCE_UNAVAIL;
      else if (WSAEHOSTDOWN == werr)
        status = SNMP_CLASS_TL_FAILED;
      else
        status = SNMP_CLASS_TL_UNSUPPORTED;
#else
      if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno)
        status = SNMP_CLASS_RESOURCE_UNAVAIL;
      else if (EHOSTDOWN == errno)
        status = SNMP_CLASS_TL_FAILED;
      else
        status = SNMP_CLASS_TL_UNSUPPORTED;
#endif
    }
    else
    {
      // set up the manager socket attributes
      struct sockaddr_in6 mgr_addr;

      memset(&mgr_addr, 0, sizeof(mgr_addr));
      inet_pton(AF_INET6, addresses[1]->get_printable(), &mgr_addr.sin6_addr);
      mgr_addr.sin6_family = AF_INET6;
      mgr_addr.sin6_port = htons( port_v6);
      // bind the socket
      if (bind(iv_snmp_session_ipv6, (struct sockaddr*) &mgr_addr,
               sizeof(mgr_addr)) < 0)
      {
#ifdef WIN32
        int werr = WSAGetLastError();
        if (WSAEADDRINUSE  == werr)
          status = SNMP_CLASS_TL_IN_USE;
        else if (WSAENOBUFS == werr)
          status = SNMP_CLASS_RESOURCE_UNAVAIL;
        else if (werr == WSAEAFNOSUPPORT)
          status = SNMP_CLASS_TL_UNSUPPORTED;
        else if (werr == WSAENETUNREACH)
          status = SNMP_CLASS_TL_FAILED;
        else if (werr == EACCES)
          status = SNMP_CLASS_TL_ACCESS_DENIED;
        else
          status = SNMP_CLASS_INTERNAL_ERROR;
#else
        if (EADDRINUSE  == errno)
          status = SNMP_CLASS_TL_IN_USE;
        else if (ENOBUFS == errno)
          status = SNMP_CLASS_RESOURCE_UNAVAIL;
        else if (errno == EAFNOSUPPORT)
          status = SNMP_CLASS_TL_UNSUPPORTED;
        else if (errno == ENETUNREACH)