ACE/ASNMP/asnmp/snmp.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    snmp.cpp
   5  *
   6  * The basic SNMPv1 API - blocking version using UDP/IPv4 transport
   7  * and addressing.
   8  *
   9  *  @author Peter E Mellquist class design/orig codeMichael R MacFaden  mrm@cisco.com / rework API
  10  *  @author use ACE facilities
  11  */
  12 //=============================================================================
  13
  14 /*===================================================================
  15   Copyright (c) 1996
  16   Hewlett-Packard Company
  17
  18   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  19   Permission to use, copy, modify, distribute and/or sell this software
  20   and/or its documentation is hereby granted without fee. User agrees
  21   to display the above copyright notice and this license notice in all
  22   copies of the software and any documentation of the software. User
  23   agrees to assume all liability for the use of the software; Hewlett-Packard
  24   makes no representations about the suitability of this software for any
  25   purpose. It is provided "AS-IS without warranty of any kind,either express
  26   or implied. User hereby grants a royalty-free license to any and all
  27   derivatives based upon this software code base.
  28 =====================================================================*/
  29
  30
  31 #define INCLUDE_SNMP_ERR_STRINGS_
  32
  33 //----[ snmp++ includes ]----------------------------------------------
  34 #include "asnmp/snmp.h"    // class def for this module
  35 #include "asnmp/oid.h"     // class def for oids
  36 #include "asnmp/enttraps.h" // class def for well known trap oids
  37 #include "asnmp/vb.h"        // class def for vbs
  38 #include "asnmp/address.h" // class def for addresses
  39 #include "asnmp/wpdu.h"    // adapter to cmu_library / wire protocol
  40 #include "asnmp/transaction.h" // synchronous transaction processor
  41 #include "ace/OS_NS_string.h"
  42 #include "ace/OS_NS_unistd.h"
  43 #include "ace/OS_NS_time.h"
  44
  45 const coldStartOid coldStart;
  46 const warmStartOid warmStart;
  47 const linkDownOid linkDown;
  48 const linkUpOid linkUp;
  49 const authenticationFailureOid authenticationFailure;
  50 const egpNeighborLossOid egpNeighborLoss;
  51 const snmpTrapEnterpriseOid snmpTrapEnterprise;
  52
  53 char Snmp::host_name_[MAXHOSTNAMELEN] = "";
  54
  55 Snmp::Snmp(unsigned short port): result_(0), construct_status_(SNMP_CLASS_ERROR), last_transaction_status_(0)
  56 {
  57   ACE_TRACE("Snmp::Snmp");
  58
  59   ACE_INET_Addr addr(port); // any port,address is ok
  60   if (iv_snmp_session_.open(addr) < 0) {
  61      last_transaction_status_ = errno; // open udp/ipv4 socket
  62      ACE_DEBUG((LM_DEBUG, "Snmp::snmp::open port %d failed", port));
  63      return;
  64   }
  65
  66   // initial request id randomly generated then monotonically incremented
  67   req_id_ = (unsigned) ACE_OS::time(0);
  68
  69   construct_status_ = SNMP_CLASS_SUCCESS;
  70   return;
  71 }
  72
  73 Snmp::~Snmp()
  74 {
  75   ACE_TRACE("Snmp::~Snmp");
  76   iv_snmp_session_.close();
  77 }
  78
  79 int Snmp::valid() const
  80 {
  81   return construct_status_;
  82 }
  83
  84 // given error code, return string definition
  85 // class version
  86 // static
  87 const char * Snmp::error_string(int last_transaction_status_)
  88 {
  89   ACE_TRACE("Snmp::error_string");
  90
  91   return ((last_transaction_status_ < 0) ?
  92            ((last_transaction_status_ < MAX_NEG_ERROR)?
  93         nErrs[ abs(MAX_NEG_ERROR) + 1] : nErrs[abs(last_transaction_status_)]):
  94             ((last_transaction_status_ > MAX_POS_ERROR)?
  95         pErrs[MAX_POS_ERROR+1] : pErrs[last_transaction_status_]));
  96 }
  97
  98 // instance version
  99 const char * Snmp::error_string()
 100 {
 101    return Snmp::error_string(last_transaction_status_);
 102 }
 103
 104 void Snmp::check_default_port(UdpTarget& target, unsigned short port)
 105 {
 106   UdpAddress tmp;
 107   target.get_address(tmp);
 108   if (tmp.get_port() == 0) {
 109     tmp.set_port(port);
 110     target.set_address(tmp);
 111   }
 112 }
 113
 114 int Snmp::run_transaction(Pdu& pdu, UdpTarget& target)
 115 {
 116   int rc, done = 0;
 117
 118   // 1. set unique id to match this packet on return
 119   size_t hold_req_id = req_id_++;
 120   set_request_id(&pdu, hold_req_id);
 121
 122   // 2. write request to agent
 123   transaction trans(pdu, target, iv_snmp_session_);
 124
 125   // this call blocks while it attempts to retrieve agent response
 126   while (!done) {
 127     if ((rc = trans.run()) < 0) {
 128        last_transaction_status_ = rc;
 129        return rc;
 130     }
 131     else {
 132       trans.result(pdu);
 133       // verify this is the pdu we are after
 134       if (pdu.get_request_id() == hold_req_id)
 135         done = 1 ;
 136     }
 137   }
 138   return 0;
 139 }
 140
 141 int Snmp::run_transaction(Pdu& pdu, UdpTarget& target, Snmp_Result * cb)
 142 {
 143   if (!cb)
 144      return run_transaction(pdu, target);
 145
 146   // 1. set unique id to match this packet on return
 147   hold_req_id_ = req_id_++;
 148   set_request_id(&pdu, hold_req_id_);
 149   pdu_ = &pdu;
 150   result_ = cb;
 151
 152   // 2. write request to agent
 153   transaction * trans = new transaction(pdu, target, iv_snmp_session_);
 154   return trans->run(this);
 155 }
 156
 157 void Snmp::result(transaction *t, int rc)
 158 {
 159     t->result(*pdu_);
 160     // verify this is the pdu we are after
 161     if (pdu_->get_request_id() == hold_req_id_)
 162     {
 163         last_transaction_status_ = rc;
 164         delete t;
 165         result_->result(this, rc);
 166     }
 167     else
 168     {
 169         rc = t->run(this);
 170         if (rc < 0)
 171         {
 172             delete t;
 173             result_->result(this, rc);
 174         }
 175     }
 176 }
 177
 178 int Snmp::validate_args(const Pdu& pdu, const UdpTarget& target) const
 179 {
 180   // 0. check object status
 181   if (construct_status_ != SNMP_CLASS_SUCCESS)
 182      return construct_status_;
 183
 184   // 1. check args passed
 185   if ( !pdu.valid() || !target.valid() )
 186      return SNMP_INVALID_ARGS;
 187   return 0;
 188 }
 189
 190 // SYNC API: write request to wire then wait for reply or timeout
 191 int Snmp::get( Pdu &pdu, UdpTarget &target, Snmp_Result * cb)
 192 {
 193    ACE_TRACE("Snmp::get");
 194   int rc;
 195   if ((rc = validate_args(pdu, target)) != 0)
 196      return rc;
 197
 198   pdu.set_type( sNMP_PDU_GET);
 199   check_default_port(target);
 200   return run_transaction(pdu, target, cb);
 201 }
 202
 203 int Snmp::get_next( Pdu &pdu, UdpTarget &target, Snmp_Result * cb)
 204 {
 205   ACE_TRACE("Snmp::get_next");
 206   int rc;
 207   if ((rc = validate_args(pdu, target)) != 0)
 208      return rc;
 209
 210   pdu.set_type( sNMP_PDU_GETNEXT);
 211   check_default_port(target);
 212   return run_transaction(pdu, target, cb);
 213 }
 214
 215 int Snmp::set( Pdu &pdu, UdpTarget &target, Snmp_Result * cb)
 216 {
 217   ACE_TRACE("Snmp::set");
 218   int rc;
 219   if ((rc = validate_args(pdu, target)) != 0)
 220      return rc;
 221
 222    pdu.set_type( sNMP_PDU_SET);
 223    check_default_port(target);
 224    return run_transaction(pdu, target, cb);
 225 }
 226
 227 // one way, best of luck, non-confirmed alert
 228 int Snmp::trap( Pdu &pdu, UdpTarget &target)
 229 {
 230   ACE_TRACE("Snmp::trap");
 231   int rc;
 232   if ((rc = validate_args(pdu, target)) != 0)
 233      return rc;
 234
 235   pdu.set_type( sNMP_PDU_V1TRAP);
 236   check_default_port(target, DEF_TRAP_PORT);
 237
 238   // 2. write request to agent
 239   transaction trans(pdu, target, iv_snmp_session_);
 240   if (trans.send() > 0)  // expect number of bytes sent on
 241     return 0;
 242
 243   last_transaction_status_ = SNMP_CLASS_INTERNAL_ERROR;
 244   return -1;
 245 }
 246
 247 // Allow host name to be overriden. Supplying a null pointer or zero
 248 // length string removes the override.
 249 void Snmp::override_host_name(const char* name)
 250 {
 251   if (name)
 252   {
 253     ACE_OS::strncpy(host_name_, name, MAXHOSTNAMELEN);
 254     host_name_[MAXHOSTNAMELEN-1] = 0;
 255   }
 256   else {
 257     host_name_[0] = 0;
 258   }
 259 }
 260
 261 // Returns the current host name in the supplied string.
 262 void Snmp::get_host_name(char* name, int len)
 263 {
 264   if (name)
 265   {
 266     if (ACE_OS::strlen(host_name_) > 0)
 267     {
 268       ACE_OS::strncpy(name, host_name_, len);
 269       name[len-1] = 0;
 270     }
 271     else
 272     {
 273       if (ACE_OS::hostname(name, len-1) == -1)
 274         name[0] = 0;
 275     }
 276   }
 277 }
 278
 279 Snmp_Result::~Snmp_Result()
 280 {
 281 }
 282
 283 Snmp_Result::Snmp_Result()
 284 {
 285 }