ACE/ASNMP/asnmp/target.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file     target.cpp
   5  *
   6  * Target class defines target SNMP agents.
   7  *
   8  *  @author Peter E MellquistMichael R MacFaden  mrm@cisco.com - rework & ACE port
   9  */
  10 //=============================================================================
  11
  12 /*===================================================================
  13   Copyright (c) 1996
  14   Hewlett-Packard Company
  15
  16   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  17   Permission to use, copy, modify, distribute and/or sell this software
  18   and/or its documentation is hereby granted without fee. User agrees
  19   to display the above copyright notice and this license notice in all
  20   copies of the software and any documentation of the software. User
  21   agrees to assume all liability for the use of the software; Hewlett-Packard
  22   makes no representations about the suitability of this software for any
  23   purpose. It is provided "AS-IS without warranty of any kind,either express
  24   or implied. User hereby grants a royalty-free license to any and all
  25   derivatives based upon this software code base.
  26   =====================================================================*/
  27
  28 #include "asnmp/target.h"
  29 #include "ace/OS_NS_stdio.h"
  30
  31 //----------------------------------------------------------------------
  32 //--------[ Class default values ]----------------------
  33 //----------------------------------------------------------------------
  34 u_long SnmpTarget::default_timeout_ = DEF_TIMEOUT;
  35 int SnmpTarget::default_retries_ = DEF_RETRIES;
  36 u_long SnmpTarget::default_max_pdu_size_ = DEF_MAX_SNMP_PACKET;
  37 snmp_version SnmpTarget::default_version_ = version1;
  38
  39 OctetStr UdpTarget::default_rd_community_(READ_COMM_STR);
  40 OctetStr UdpTarget::default_wr_community_(WRITE_COMM_STR);
  41
  42 //----------------------------------------------------------------------
  43 //--------[ Abstract SnmpTarget Member Functions ]----------------------
  44 //----------------------------------------------------------------------
  45 SnmpTarget::SnmpTarget():
  46   validity_(0), timeout_(default_timeout_), retries_(default_retries_),
  47   max_pdu_size_(default_max_pdu_size_), version_(default_version_)
  48 {
  49 }
  50
  51 // return validity of target
  52 int SnmpTarget::valid() const
  53 {
  54   return validity_;
  55 }
  56
  57 // allow destruction of derived classes
  58 SnmpTarget::~SnmpTarget()
  59 {
  60 }
  61
  62 // set the timeout
  63 void SnmpTarget::set_timeout( const u_long t)
  64 {
  65   timeout_ = t;
  66 }
  67
  68 // change the default timeout
  69 void SnmpTarget::set_default_timeout( const u_long t)
  70 {
  71   default_timeout_ = t;
  72 }
  73
  74 // set the retry value
  75 void SnmpTarget::set_retry( const int r)
  76 {
  77   retries_ = r;
  78 }
  79
  80 // change the default retries
  81 void SnmpTarget::set_default_retry( const int r)
  82 {
  83   default_retries_ = r;
  84 }
  85
  86 void SnmpTarget:: set_max_pdu_size(const u_long max_pdu_sz)
  87 {
  88   max_pdu_size_ = max_pdu_sz;
  89 }
  90
  91
  92 void SnmpTarget::set_default_max_pdu_size(const u_long max_pdu_sz)
  93 {
  94   default_max_pdu_size_ = max_pdu_sz;
  95 }
  96
  97 void SnmpTarget::set_version( const snmp_version v)
  98 {
  99   version_ = v;
 100 }
 101
 102 void SnmpTarget::set_default_version( const snmp_version v)
 103 {
 104   default_version_ = v;
 105 }
 106
 107 snmp_version SnmpTarget::get_version() const
 108 {
 109   return version_;
 110 }
 111
 112 snmp_version SnmpTarget::get_default_version() const
 113 {
 114   return default_version_;
 115 }
 116
 117 u_long SnmpTarget::get_max_pdu_size() const
 118 {
 119   return max_pdu_size_;
 120 }
 121
 122 // get the retry value
 123 int SnmpTarget::get_retry() const
 124 {
 125   return retries_;
 126 }
 127
 128 // get the retry value
 129 int SnmpTarget::get_default_retry() const
 130 {
 131   return default_retries_;
 132 }
 133
 134 // get the timeout
 135 u_long SnmpTarget::get_timeout() const
 136 {
 137   return timeout_;
 138 }
 139
 140 SnmpTarget& SnmpTarget::operator=(const SnmpTarget& lhs)
 141 {
 142   if (this == &lhs)
 143     return *this;
 144
 145   validity_ = lhs.validity_;
 146   timeout_ = lhs.timeout_;
 147   retries_ = lhs.retries_;
 148   max_pdu_size_ =lhs.max_pdu_size_;
 149   version_ = lhs.version_;
 150   return *this;
 151 }
 152
 153 bool operator==(const SnmpTarget& lhs, const SnmpTarget& rhs)
 154 {
 155   if (lhs.timeout_ != rhs.timeout_)
 156      return false;
 157
 158   if (lhs.retries_ != rhs.retries_)
 159      return false;
 160
 161   if (lhs.max_pdu_size_ != rhs.max_pdu_size_)
 162     return false;
 163
 164   if (lhs.version_ != rhs.version_)
 165     return false;
 166
 167   return true;
 168 }
 169
 170
 171 //----------------------------------------------------------------------
 172 //--------[ IpTarget Member Functions ]----------------------------------
 173 //----------------------------------------------------------------------
 174
 175
 176 //---------[ UdpTarget::UdpTarget() ]----------------------------------
 177
 178 UdpTarget::UdpTarget()
 179 {
 180   validity_ = 0;
 181   read_community_ = default_rd_community_; // assign by init fails
 182   write_community_ = default_wr_community_;
 183 }
 184
 185 UdpTarget::UdpTarget(const UdpAddress& udp) : udp_address_(udp)
 186 {
 187   if (udp_address_.valid())
 188     validity_ = 1;
 189   read_community_ = default_rd_community_;
 190   write_community_ = default_wr_community_;
 191 }
 192
 193 // - copy constructor can be synthesised by compiler
 194
 195 //-----------[ UdpTarget::~UdpTarget() ]--------------------------------
 196 UdpTarget::~UdpTarget()
 197 {
 198 }
 199
 200 //-----------[ UdpTarget::clone() ]--------------------------------
 201 SnmpTarget * UdpTarget::clone() const
 202 {
 203   return (SnmpTarget *) new UdpTarget(*this);
 204 }
 205
 206
 207 void UdpTarget::set_default_read_community(const OctetStr& rd_community)
 208 {
 209    default_rd_community_ = rd_community;
 210 }
 211
 212 void UdpTarget::set_default_write_community(const OctetStr& wr_community)
 213 {
 214    default_wr_community_ = wr_community;
 215 }
 216
 217
 218 // get the read community name as an u_char and len
 219 void UdpTarget::get_read_community( OctetStr& read_community_oct) const
 220 {
 221   read_community_oct = read_community_;
 222 }
 223
 224 //---------[ UdpTarget::set_getcommunity ]---------------------------------
 225 // set the read community name
 226 void UdpTarget::set_read_community( const OctetStr& new_read_community)
 227 {
 228   read_community_ = new_read_community;
 229 }
 230
 231 //---------[ UdpTarget::get_writecommunity ]----------------------------
 232 // get the write community
 233 void UdpTarget::get_write_community( OctetStr &write_community_oct) const
 234 {
 235   write_community_oct = write_community_;
 236 }
 237
 238 //-----------[ UdpTarget::set_writecommunity ]---------------------------
 239 // set the write community
 240 void UdpTarget::set_write_community( const OctetStr& write_community_oct)
 241 {
 242   write_community_ = write_community_oct;
 243 }
 244
 245 //------------[ Address& UdpTarget::get_address() ]---------------------
 246 // get the address
 247 void UdpTarget::get_address( UdpAddress &address) const
 248 {
 249   address = udp_address_;
 250   return;
 251 }
 252
 253 //-------------[ UdpTarget::set_address ]--------------------------------
 254 // set the address
 255 int UdpTarget::set_address( UdpAddress &udp_address)
 256 {
 257   udp_address_ = udp_address;
 258   if ( udp_address_.valid())
 259     validity_ = 1;
 260   else
 261     validity_ = 0;
 262
 263   return validity_;
 264 }
 265
 266 // overloaded assignment
 267 UdpTarget& UdpTarget::operator=( const UdpTarget& lhs)
 268 {
 269   if (this == &lhs)
 270      return *this;
 271
 272   // assign base part
 273   *((SnmpTarget *) this) = *((SnmpTarget *)&lhs);
 274
 275   udp_address_ = lhs.udp_address_;
 276   read_community_ = lhs.read_community_;
 277   write_community_ = lhs.write_community_;
 278   validity_ = lhs.validity_;
 279
 280   return *this;
 281 }
 282
 283 const char *UdpTarget::to_string()
 284 {
 285   ACE_OS::sprintf(output_buffer_,"UdpTarget: [ valid: %d addr: %s rd: %s wr: %s \
 286                   ver: %d, timeout: %d, retries: %d max_pdu_size: %d]",
 287                   valid(), udp_address_.to_string(), read_community_.to_string(),
 288                   write_community_.to_string(), version_, (int) timeout_,
 289                   retries_, max_pdu_size_);
 290
 291   return output_buffer_;
 292 }
 293
 294 //=============[ int operator == UdpTarget, UdpTarget ]===============
 295 // equivlence operator overloaded
 296 bool operator==( const UdpTarget &lhs,const UdpTarget &rhs)
 297 {
 298   // need to compare all the members of a UdpTarget
 299   if ( lhs.read_community_ != rhs.read_community_)
 300     return false;  // !=
 301
 302   if ( lhs.write_community_ != rhs.write_community_)
 303     return false;  // !=
 304
 305   if ( lhs.udp_address_ != rhs.udp_address_)
 306     return false;
 307
 308   if ( lhs.timeout_ != rhs.timeout_)
 309     return false;
 310
 311   if ( lhs.retries_ != rhs.retries_)
 312     return false;
 313
 314   return true;  // they are equal
 315 }