ACE/ASNMP/asnmp/address.h

   1 #ifndef ADDRESS_
   2 #define ADDRESS_
   3 //=============================================================================
   4 /**
   5  *  @file    address.h
   6  *
   7  *  Address class definition. Encapsulates various network
   8  *  addresses into easy to use, safe and portable classes.
   9  *
  10  *  @author Peter E Mellquist
  11  */
  12 //=============================================================================
  13
  14
  15 /*===================================================================
  16   Copyright (c) 1996
  17   Hewlett-Packard Company
  18
  19   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  20   Permission to use, copy, modify, distribute and/or sell this software
  21   and/or its documentation is hereby granted without fee. User agrees
  22   to display the above copyright notice and this license notice in all
  23   copies of the software and any documentation of the software. User
  24   agrees to assume all liability for the use of the software; Hewlett-Packard
  25   makes no representations about the suitability of this software for any
  26   purpose. It is provided "AS-IS without warranty of any kind,either express
  27   or implied. User hereby grants a royalty-free license to any and all
  28   derivatives based upon this software code base.
  29 =====================================================================*/
  30
  31 //----[ includes ]-----------------------------------------------------
  32 // ACE OS Adaption layer
  33 #include "ace/os_include/netinet/os_in.h"
  34 #include "ace/os_include/os_netdb.h"
  35 #include "ace/Log_Msg.h"
  36
  37 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  38 # pragma once
  39 #endif /* ACE_LACKS_PRAGMA_ONCE */
  40
  41 #include "asnmp/smival.h"
  42 #include "asnmp/octet.h"
  43
  44 //----[ enumerated types ] --------------------------------
  45 enum address_lengths {
  46    IPV4LEN=4,
  47    UDPIPV4LEN=6,
  48    IPV6LEN=16,
  49    UDPIPV6LEN=18,
  50    IPXLEN=10,
  51    IPXSOCKLEN=12,
  52    NETBIOSLEN=16,
  53    APPLETKLEN=3,
  54    DECNETLEN=2,
  55    MACLEN=6,
  56    HASH0LEN=19,
  57    HASH1LEN=13,
  58    HASH2LEN=7,
  59    MAX_ADDR_SZ=20,
  60    MAX_DISPLAY_SZ=MAXHOSTNAMELEN+1
  61 };
  62
  63 enum addr_type {
  64   type_ip,
  65   type_ipx,
  66   type_udp,
  67   type_ipxsock,
  68   type_mac,
  69   type_nb,
  70   type_atk,
  71   type_decnet,
  72   type_e164,
  73   type_sip, // IPv6
  74   type_invalid
  75 };
  76
  77 // TODO: get rest of nb service types added here
  78 enum nb_service {
  79   nb_workstation = 0x0, nb_server = 0x20
  80 };
  81
  82 //---[ forward declarations ]-----------------------------------------
  83 class GenAddress;
  84 class UdpAddress;
  85 class IpxSockAddress;
  86 class NetbiosAddress;
  87 class SIPAddress; // aka ipv6
  88
  89 // TODO:
  90 // class AtmE164Address;
  91
  92
  93 //--------------------------------------------------------------------
  94 //----[ Address class ]-----------------------------------------------
  95 //--------------------------------------------------------------------
  96 /**
  97  * @class
  98  *
  99  * @brief Defines the member functions for the abstract base class
 100  * Address. An Address is a unique network endpoint.
 101  */
 102 class  ASNMP_Export Address: public  SnmpSyntax
 103 {
 104 public:
 105    /// allow destruction of derived classes
 106    virtual ~Address();
 107
 108    /// overloaded equivlence operator, are two addresses equal?
 109    friend ASNMP_Export bool operator==( const Address &lhs,const Address &rhs);
 110
 111    /// overloaded not equivlence operator, are two addresses not equal?
 112    friend ASNMP_Export bool operator!=( const Address &lhs,const Address &rhs);
 113
 114    /// overloaded > operator, is a1 > a2
 115    friend ASNMP_Export bool operator>( const Address &lhs,const Address &rhs);
 116
 117    /// overloaded >= operator, is a1 >= a2
 118    friend ASNMP_Export bool operator>=( const Address &lhs,const Address &rhs);
 119
 120    /// overloaded < operator, is a1 < a2
 121    friend ASNMP_Export bool operator<( const Address &lhs,const Address &rhs);
 122
 123    /// overloaded <= operator, is a1 <= a2
 124    friend ASNMP_Export bool operator<=( const Address &lhs,const Address &rhs);
 125
 126    /// equivlence operator overloaded, are an address and a string equal?
 127    friend ASNMP_Export bool operator==( const Address &lhs,const char *rhs);
 128
 129    /// overloaded not equivlence operator, are an address and string not equal?
 130    friend ASNMP_Export bool operator!=( const Address &lhs,const char *rhs);
 131
 132    /// overloaded < , is an address greater than a string?
 133    friend ASNMP_Export bool operator>( const Address &lhs,const char *rhs);
 134
 135    /// overloaded >=, is an address greater than or equal to a string?
 136    friend ASNMP_Export bool operator>=( const Address &lhs,const char *rhs);
 137
 138    /// overloaded < , is an address less than a string?
 139    friend ASNMP_Export bool operator<( const Address &lhs,const char *rhs);
 140
 141    /// overloaded <=, is an address less than or equal to a string?
 142    friend ASNMP_Export bool operator<=( const Address &lhs,const char *rhs);
 143
 144    /// overloaded const char * cast
 145    virtual operator const char *() const = 0;
 146
 147   /// verify the is the address object constructed ok
 148   virtual int valid() const;
 149
 150   /// return a suitable buffer to contain the address
 151   virtual void to_octet(OctetStr& octet) const = 0;
 152
 153   /// (pure virtual) syntax type
 154   virtual SmiUINT32 get_syntax() = 0;
 155
 156   /// for non const [], allows reading and writing
 157   unsigned char& operator[]( const int position);
 158
 159   /// get a printable ASCII value
 160   virtual const char *to_string() = 0;
 161
 162   /// create a new instance of this Value
 163   virtual SnmpSyntax *clone() const = 0;
 164
 165   /// return the type of address
 166   virtual addr_type get_type() const = 0;
 167
 168   /// overloaded assignment operator
 169   virtual SnmpSyntax& operator=( SnmpSyntax &val) = 0;
 170
 171   /// return a hash key
 172   virtual unsigned int hashFunction() const { return 0;};
 173
 174
 175 protected:
 176   /// state of constructed object (1/0)
 177   /// addr internal representation
 178   int valid_flag;
 179   unsigned char address_buffer[MAX_ADDR_SZ];
 180
 181   /// parse the address string
 182   /// redefined for each specific address subclass
 183   virtual int parse_address( const char * inaddr) =0;
 184
 185   /// format the output
 186   /// redefined for each specific address subclass
 187   virtual void format_output() =0;
 188
 189   /// a reused trimm white space method
 190   void trim_white_space( char * ptr);
 191 };
 192
 193
 194 //-----------------------------------------------------------------------
 195 //---------[ IPv4 Address Class ]----------------------------------------
 196 //-----------------------------------------------------------------------
 197 /**
 198  * @class IpAddress
 199  *
 200  * @brief Defines the member functions for the concrete class IpAddress
 201  * An IP Version 4 Address is 4 bytes long and consists of a
 202  * Network, Sub Network, and host component.
 203  */
 204 class ASNMP_Export IpAddress : public Address
 205 {
 206 public:
 207   /// default construct an IP address with a string
 208   IpAddress( const char *inaddr = "");
 209
 210   /// construct an IP address with another IP address
 211   IpAddress( const IpAddress  &ipaddr);
 212
 213   /// construct an IP address with a GenAddress
 214   IpAddress( const GenAddress &genaddr);
 215
 216   /// destructor (ensure that SnmpSyntax::~SnmpSyntax() is overridden)
 217   ~IpAddress();
 218
 219   /// copy an instance of this Value
 220   SnmpSyntax& operator=( SnmpSyntax &val);
 221
 222   /// assignment to another IpAddress object overloaded
 223   IpAddress& operator=( const IpAddress &ipaddress);
 224
 225   // TODO: add ability to set addr given long
 226
 227   /// create a new instance of this Value
 228   SnmpSyntax *clone() const;
 229
 230   /// return the DNS Fully Qualified Domain Name (host.domain)
 231   /// on failure returns dotted_quad string
 232   const char *resolve_hostname(int& was_found);
 233
 234   /// return string representation of object (dotted quad returned)
 235   virtual const char *to_string() ;
 236
 237   /// const char * operator overloaded for streaming output
 238   virtual operator const char *() const;
 239
 240   /// logically AND two IPaddresses and
 241   /// return the new one
 242   void mask( const IpAddress& ipaddr);
 243
 244   /// return the type
 245   virtual addr_type get_type() const;
 246
 247   /// syntax type
 248   virtual SmiUINT32 get_syntax();
 249
 250   /// is this the loopback address? 127.0.0.1/loopback/1.0.0.127.in-addr.arpa
 251   int is_loopback() const;
 252
 253   /// determine if this is a multicast address
 254   int is_multicast() const;
 255
 256   /// determine if this a broadcast address
 257   int is_broadcast() const;
 258
 259   /// per RFC 1597,  private addresses are:: 10, 172.16, and 192.168.0
 260   int is_private() const;
 261
 262   /// convert address into octet string format in network byte order
 263   virtual void to_octet(OctetStr& octet) const;
 264
 265 protected:
 266   char output_buffer[MAX_DISPLAY_SZ];           // output buffer
 267
 268   /// friendly name storage
 269   char iv_friendly_name_[MAX_DISPLAY_SZ];
 270
 271   /// did resolver call work? some addrs won't resolve
 272   int  iv_friendly_name_status_;
 273
 274   /// redefined parse address
 275   /// specific to IP addresses
 276   virtual int parse_address( const char *inaddr);
 277
 278   /// redefined format output
 279   /// specific to IP addresses
 280   virtual void format_output();
 281
 282   /// parse a dotted string
 283   int parse_dotted_ipstring( const char *inaddr);
 284
 285   /// using the currently defined address, do a gethostbyname()
 286   /// and try to fill up the name
 287   int addr_to_friendly();
 288
 289   /// thread safe routine to lookup ip address given hostname
 290   /// return <> 0 on error
 291   static int resolve_to_address(const char *hostname, in_addr& quad_addr);
 292
 293   /// thread safe routine to lookup name given ip address
 294   /// return <> 0 on error
 295   static int resolve_to_hostname(const in_addr& quad_addr, char *hostname);
 296 };
 297
 298 //------------------------------------------------------------------------
 299 //--------------[ DNS Iterator Class ]------------------------------------
 300 //------------------------------------------------------------------------
 301
 302 /**
 303  * @class Address_Iter
 304  *
 305  * @brief Defines routines to obtain information on a hostname/FQDN
 306  * such as multiple addresses
 307  */
 308 class ASNMP_Export Address_Iter
 309 {
 310 public:
 311   Address_Iter(const char *hostname); // fully qualified domain name, hostname
 312
 313   /// did hostname resolve via DNS?
 314   int valid() const;
 315
 316   /// how many addresses associated with this hostname
 317   int how_many_addresses();
 318
 319   /// return next address
 320   int next(IpAddress& addr);
 321
 322 private:
 323   Address_Iter(const Address_Iter&);
 324   int valid_;                  // ctor status
 325   int count_;                   // number of addresses
 326   char **entry_;                // ptr to current address
 327   struct hostent lookupResult_;
 328   ACE_HOSTENT_DATA buffer_;
 329   int query_dns(const char *hostname);
 330 };
 331
 332 //------------------------------------------------------------------------
 333 //---------[ UDP/IPv4 Address Class ]-------------------------------------
 334 //------------------------------------------------------------------------
 335 /**
 336  * @class
 337  *
 338  * @brief Defines the member functions for the concrete class UdpAddress
 339  * A Udp Address consists of an IP Version 4 Address (IpAddress)
 340  * and a 2 byte unsigned port number.  (see /etc/services file)
 341  * User Datagram Protocol (UDP) is a best effort transport
 342  */
 343 class  ASNMP_Export UdpAddress : public IpAddress
 344 {
 345 public:
 346   /// default constructor with a dotted string in the form of addr:port
 347   UdpAddress( const char *inaddr = "");
 348
 349   /// construct an Udp address with another Udp address
 350   UdpAddress( const UdpAddress &udpaddr);
 351
 352   /// construct a Udp address with a GenAddress
 353   UdpAddress( const GenAddress &genaddr);
 354
 355   /// construct a Udp address with an IpAddress
 356   /// default port # to zero
 357   UdpAddress( const IpAddress &ipaddr);
 358
 359   /// destructor
 360   ~UdpAddress();
 361
 362   /// syntax type
 363   SmiUINT32 get_syntax();
 364
 365   /// copy an instance of this Value
 366   SnmpSyntax& operator=( SnmpSyntax &val);
 367
 368   /// assignment to another IpAddress object overloaded
 369   UdpAddress& operator=( const UdpAddress &udpaddr);
 370
 371   /// create a new instance of this Value
 372   SnmpSyntax *clone() const;
 373
 374   /// output in the form of address:port
 375   virtual const char *to_string() ;
 376
 377   /// const char * operator overloaded for streaming output
 378   virtual operator const char *() const;
 379
 380   /// set the port number
 381   void set_port( const unsigned short p);
 382
 383   /// get the port number
 384   unsigned short get_port() const;
 385
 386   /// return the type
 387   virtual addr_type get_type() const;
 388
 389 protected:
 390   /// output buffer
 391   char output_buffer[MAX_DISPLAY_SZ];
 392
 393   /// redefined parse address
 394   /// specific to IP addresses
 395   virtual int parse_address( const char *inaddr);
 396
 397   /// redefined format output
 398   /// specific to IP addresses
 399   virtual void format_output();
 400 };
 401
 402
 403 //-------------------------------------------------------------------------
 404 //---------[ 802.3 MAC Address Class ]-------------------------------------
 405 //-------------------------------------------------------------------------
 406 /**
 407  * @class
 408  *
 409  * @brief Defines the member functions for the concrete class MacAddress.
 410  * A Media Access Control Address consists of 48 bits as defined
 411  * in IEEE 802.3 specifications.
 412  */
 413 class  ASNMP_Export MacAddress : public Address
 414 {
 415 public:
 416   /// constructor with a string argument
 417   MacAddress( const char  *inaddr = "");
 418
 419   /// constructor with another MAC object
 420   MacAddress( const MacAddress  &macaddr);
 421
 422   /// construct a MacAddress with a GenAddress
 423   MacAddress( const GenAddress &genaddr);
 424
 425   /// destructor
 426   ~MacAddress();
 427
 428   /// syntax type
 429   SmiUINT32 get_syntax();
 430
 431   /// copy an instance of this Value
 432   SnmpSyntax& operator=( SnmpSyntax &val);
 433
 434   /// assignment to another IpAddress object overloaded
 435   MacAddress& operator=( const MacAddress &macaddress);
 436
 437   /// create a new instance of this Value
 438   SnmpSyntax *clone() const;
 439
 440   /// create a string to internal class storage representing object
 441   virtual const char *to_string();
 442
 443   /// const char * operator overloaded for streaming output
 444   virtual operator const char *() const;
 445
 446   /// return the type
 447   virtual addr_type get_type() const;
 448
 449   /// return a hash key
 450   unsigned int hashFunction() const;
 451
 452   /// return byte array of the mac address
 453   virtual void to_octet(OctetStr& octet) const;
 454
 455 protected:
 456   /// output buffer containing string representation of object
 457   char output_buffer[MAX_DISPLAY_SZ];
 458
 459   /// redefined parse address for macs
 460   virtual int parse_address( const char *inaddr);
 461
 462   /// redefined format output for MACs
 463   virtual void format_output();
 464 };
 465
 466 //------------------------------------------------------------------------
 467 //---------[ Netbios Address Class ]--------------------------------------
 468 //------------------------------------------------------------------------
 469 /**
 470  * @class
 471  *
 472  * @brief Defines the member functions for the concrete class NetbiosAddress.
 473  * The IBM/Microsoft address for NETBIOS, NETBEUI protocol transport.
 474  */
 475 class  ASNMP_Export NetbiosAddress : public Address
 476 {
 477 public:
 478    /// default constructor with string arg
 479    NetbiosAddress( const char *inaddr = "");
 480
 481    /// set name and service type
 482    NetbiosAddress( const char *inaddr, nb_service svc);
 483
 484    /// copy constructor
 485    NetbiosAddress( const NetbiosAddress& nbaddr);
 486
 487    /// construct with a GenAddress
 488    NetbiosAddress( const GenAddress& genaddr);
 489
 490    ~NetbiosAddress();
 491
 492    virtual const char *to_string();
 493
 494    NetbiosAddress& operator=( const NetbiosAddress &nbaddr);
 495
 496    /// retrieve the network service type
 497    nb_service get_service_type() const;
 498
 499    /// set the service type (workstation, server, etc)
 500    void set_service_type(nb_service nbservice);
 501
 502    /// const char * operator overloaded for streaming output
 503    virtual operator const char *() const;
 504
 505    /// syntax type
 506    virtual SmiUINT32 get_syntax();
 507
 508    /// copy an instance of this Value
 509    SnmpSyntax& operator=( SnmpSyntax &val);
 510
 511    /// create a new instance of this Value
 512    SnmpSyntax *clone() const;
 513
 514    /// output byte buffer containing netbios name
 515    virtual void to_octet(OctetStr& octet) const;
 516
 517 protected:
 518   void InitNBAddr(const char *inaddr);
 519   char output_buffer[MAX_DISPLAY_SZ];
 520
 521   /// output buffer to hold string representation
 522   virtual void format_output();
 523   virtual int parse_address( const char  *inaddr);
 524   virtual addr_type get_type() const;
 525 };
 526
 527 //------------------------------------------------------------------------
 528 //---------[ DecNet Address Class ]---------------------------------------
 529 //------------------------------------------------------------------------
 530 /**
 531  * @class
 532  *
 533  * @brief Defines the member functions for the concrete class DecNetAddress.
 534  * DecNet Phase ? address consists of two octets (CISCO-TC.my)
 535  */
 536 class  ASNMP_Export DecNetAddress : public Address
 537 {
 538 public:
 539   /// default constructor with string arg
 540   DecNetAddress( const char *inaddr = "");
 541
 542   /// copy constructor
 543   DecNetAddress( const DecNetAddress& decaddr);
 544
 545   /// construct with a GenAddress
 546   DecNetAddress( const GenAddress& genaddr);
 547
 548   ~DecNetAddress();
 549
 550   virtual const char *to_string();
 551
 552   DecNetAddress& operator=( const DecNetAddress &decaddr);
 553
 554   /// convert address into octet string format 2 bytes of decnet address
 555   virtual void to_octet(OctetStr& octet) const;
 556
 557   /// const char * operator overloaded for streaming output
 558   virtual operator const char *() const;
 559
 560   /// syntax type
 561   virtual SmiUINT32 get_syntax();
 562
 563   /// copy an instance of this Value
 564   SnmpSyntax& operator=( SnmpSyntax &val);
 565
 566   /// create a new instance of this Value
 567   SnmpSyntax *clone() const;
 568
 569 protected:
 570   virtual int parse_address( const char *inaddr);
 571   virtual addr_type get_type() const;
 572   virtual void format_output();
 573   char output_buffer[MAX_DISPLAY_SZ];
 574 };
 575
 576 //------------------------------------------------------------------------
 577 //---------[ AppleTalk Address Class ]------------------------------------
 578 //------------------------------------------------------------------------
 579 /**
 580  * @class
 581  *
 582  * @brief Defines the member functions for the concrete class DecNetAddress.
 583  * DecNet Phase ? address consists of two octets (CISCO-TC.my)
 584  */
 585 class  ASNMP_Export AppleTalkAddress :  public Address
 586 {
 587 public:
 588   /// default constructor with string arg
 589   AppleTalkAddress( const char *inaddr = "");
 590
 591   /// copy constructor
 592   AppleTalkAddress( const AppleTalkAddress& atkaddr);
 593
 594   /// construct with a GenAddress
 595   AppleTalkAddress( const GenAddress& genaddr);
 596
 597   ~AppleTalkAddress();
 598
 599   virtual const char *to_string();
 600
 601   AppleTalkAddress& operator=( const AppleTalkAddress &atkaddr);
 602
 603   /// convert address into octet string format 3 bytes of atk address
 604   virtual void to_octet(OctetStr& octet) const;
 605
 606   /// get the host part of the address
 607   char get_host_address() const;
 608
 609   /// set the host part of the address
 610   void set_host_address(const char);
 611
 612   /// get the 2 byte atk network address
 613   short get_net_address() const;
 614
 615   /// set the host 2 byte atk  network address
 616   void set_net_address(const short atknet);
 617
 618   /// const char * operator overloaded for streaming output
 619   virtual operator const char *() const;
 620
 621   /// syntax type
 622   virtual SmiUINT32 get_syntax();
 623
 624   /// copy an instance of this Value
 625   SnmpSyntax& operator=( SnmpSyntax &val);
 626
 627   /// create a new instance of this Value
 628   SnmpSyntax *clone() const;
 629
 630 private:
 631   virtual int parse_address( const char *inaddr);
 632   virtual addr_type get_type() const;
 633   virtual void format_output();
 634   char output_buffer[MAX_DISPLAY_SZ];
 635 };
 636
 637 //------------------------------------------------------------------------
 638 //---------[ IPX Address Class ]------------------------------------------
 639 //------------------------------------------------------------------------
 640 /**
 641  * @class IpxAddress
 642  *
 643  * @brief Defines the member functions for the concrete class IpxAddress.
 644  * Novell's IPX (version ?) network protocol endpoint
 645  */
 646 class ASNMP_Export IpxAddress : public Address
 647 {
 648 public:
 649   /// default constructor with a string arg
 650   IpxAddress( const char  *inaddr = "");
 651
 652   /// constructor with another ipx object
 653   IpxAddress( const IpxAddress  &ipxaddr);
 654
 655   /// construct with a GenAddress
 656   IpxAddress( const GenAddress &genaddr);
 657
 658   /// destructor
 659   ~IpxAddress();
 660
 661   /// syntax type
 662   virtual SmiUINT32 get_syntax();
 663
 664   /// copy an instance of this Value
 665   SnmpSyntax& operator=( SnmpSyntax &val);
 666
 667   /// assignment to another IpxAddress object overloaded
 668   IpxAddress& operator=( const IpxAddress &ipxaddress);
 669
 670   /// get the host id portion of an ipx address
 671   int get_hostid( MacAddress& mac);
 672
 673   /// create a new instance of this Value
 674   SnmpSyntax *clone() const;
 675
 676   /// create string represtation of object value
 677   virtual const char *to_string();
 678
 679   /// const char * operator overloaded for streaming output
 680   virtual operator const char *() const;
 681
 682   /// return the type
 683   virtual addr_type get_type() const;
 684
 685   /// return byte sequence containing ipx address
 686   virtual void to_octet(OctetStr& octet) const;
 687
 688 protected:
 689   /// ipx format separator {:,/}
 690   char separator;
 691
 692   /// output buffer to hold string representation
 693   char output_buffer[MAX_DISPLAY_SZ];
 694
 695   /// redefined parse address for ipx strings
 696   virtual int parse_address( const char  *inaddr);
 697
 698   /// redefined format output for ipx strings
 699   /// uses same separator as when constructed
 700   virtual void format_output();
 701 };
 702
 703
 704 //------------------------------------------------------------------------
 705 //---------[ IpxSock Address Class ]--------------------------------------
 706 //------------------------------------------------------------------------
 707 /**
 708  * @class IpxSockAddress
 709  *
 710  * @brief Defines the member functions for the concrete class IpxAddress.
 711  * Novell's IPX (version ?) network protocol endpoint
 712  */
 713 class ASNMP_Export IpxSockAddress : public IpxAddress
 714 {
 715 public:
 716   /// constructor with a dotted string
 717   IpxSockAddress( const char *inaddr = "");
 718
 719   /// construct an Udp address with another Udp address
 720   IpxSockAddress( const IpxSockAddress &ipxaddr);
 721
 722   ///constructor with a GenAddress
 723   IpxSockAddress( const GenAddress &genaddr);
 724
 725   ///constructor with a IpxAddress
 726   /// default socket # is 0
 727   IpxSockAddress( const IpxAddress &ipxaddr);
 728
 729   /// destructor
 730   ~IpxSockAddress();
 731
 732   /// syntax type
 733   virtual SmiUINT32 get_syntax();
 734
 735   /// copy an instance of this Value
 736   SnmpSyntax& operator=( SnmpSyntax &val);
 737
 738   /// assignment to another IpxAddress object overloaded
 739   IpxSockAddress& operator=( const IpxSockAddress &ipxaddr);
 740
 741   /// create a new instance of this Value
 742   SnmpSyntax *clone() const;
 743
 744   /// set the socket number
 745   void set_socket( const unsigned short s);
 746
 747   /// get the socket number
 748   unsigned short get_socket() const;
 749
 750   /// create string representation of object value
 751   virtual const char *to_string();
 752
 753   /// const char * operator overloaded for streaming output
 754   virtual operator const char *() const;
 755
 756   /// return the type
 757   virtual addr_type get_type() const;
 758
 759 protected:
 760   /// output buffer to hold string representation of object
 761   char output_buffer[MAX_DISPLAY_SZ];
 762
 763   /// redefined parse address for ipx strings
 764   virtual int parse_address( const char  *inaddr);
 765
 766   /// redefined format output
 767   /// specific to IP addresses
 768   virtual void format_output();
 769 };
 770
 771 //-------------------------------------------------------------------------
 772 //--------[ Generic Address ]----------------------------------------------
 773 //-------------------------------------------------------------------------
 774 /**
 775  * @class GenAddress
 776  *
 777  * @brief Defines the member functions for the concrete class GenAddress.
 778  * This class attempts to determine an address type given a char string.
 779  */
 780 class ASNMP_Export GenAddress : public Address
 781 {
 782 public:
 783   /// constructor with a string argument
 784   GenAddress( const char  *addr = "");
 785
 786   /// constructor with an Address
 787   GenAddress( const Address &addr);
 788
 789   /// constructor with another GenAddress
 790   GenAddress( const GenAddress &addr);
 791
 792   /// destructor
 793   ~GenAddress();
 794
 795   /// get the snmp syntax of the contained address
 796   SmiUINT32 get_syntax();
 797
 798   /// create a new instance of this Value
 799   SnmpSyntax *clone() const;
 800
 801   /// assignment of a GenAddress
 802   GenAddress& operator=( const GenAddress &addr);
 803
 804   /// copy an instance of this Value
 805   SnmpSyntax& operator=( SnmpSyntax &val);
 806
 807   /// string representation of object value
 808   virtual const char *to_string();
 809
 810   /// const char * operator overloaded for streaming output
 811   virtual operator const char *() const;
 812
 813   /// return the type
 814   virtual addr_type get_type() const;
 815
 816   /// return the address as a octet sequence
 817   virtual void to_octet(OctetStr& octet) const;
 818
 819 protected:
 820   /// pointer to a a concrete address
 821   Address *address;
 822
 823   /// output buffer of objects value
 824   char output_buffer[MAX_DISPLAY_SZ];
 825
 826   /// redefined parse address for macs
 827   virtual int parse_address( const char *addr);
 828
 829   /// format output for a generic address
 830   virtual void format_output();
 831
 832   /// initialize smi data structure
 833   void init_smi();
 834 };
 835
 836 #endif  //_ADDRESS