address.h
上传用户:czjinwang
上传日期:2007-01-12
资源大小:2484k
文件大小:16k
源码类别:

SNMP编程

开发平台:

Visual C++

  1. /*===================================================================
  2.   Copyright (c) 1999
  3.   Hewlett-Packard Company
  4.   ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  5.   Permission to use, copy, modify, distribute and/or sell this software 
  6.   and/or its documentation is hereby granted without fee. User agrees 
  7.   to display the above copyright notice and this license notice in all 
  8.   copies of the software and any documentation of the software. User 
  9.   agrees to assume all liability for the use of the software; Hewlett-Packard 
  10.   makes no representations about the suitability of this software for any 
  11.   purpose. It is provided "AS-IS without warranty of any kind,either express 
  12.   or implied. User hereby grants a royalty-free license to any and all 
  13.   derivatives based upon this software code base. 
  14.  
  15.   SNMP++ A D D R E S S . H
  16.   ADDRESS CLASS DEFINITION
  17.   VERSION:
  18.   2.8
  19.   RCS INFO:
  20.   $Header: address.h,v 1.36 96/09/11 14:01:20 hmgr Exp $
  21.   DESIGN:
  22.   Peter E Mellquist
  23.   AUTHOR:
  24.   Peter E Mellquist
  25.   LANGUAGE:
  26.   ANSI C++
  27.   OPERATING SYSTEMS:
  28.   MS-Windows Win32
  29.   BSD UNIX
  30.   DESCRIPTION:
  31.   Address class definition. Encapsulates various network
  32.   addresses into easy to use, safe and portable classes.
  33. =====================================================================*/
  34. #ifndef _ADDRESS
  35. #define _ADDRESS
  36. //----[ includes ]-----------------------------------------------------
  37. extern "C"
  38. {
  39. #include <string.h>
  40. #include <memory.h>
  41. }
  42. #include "smival.h"
  43. #include "collect.h"
  44. // include sockets header files
  45. // for Windows16 and Windows32 include Winsock
  46. // otherwise assume UNIX
  47. #ifdef __unix
  48. // The /**/ stuff below is meant to fool MS C++ into skipping these 
  49. // files when creating its makefile.  8-Dec-95 TM
  50. #include /**/ <sys/socket.h>
  51. #include /**/ <netinet/in.h>
  52. #include /**/ <netdb.h>
  53. #include /**/ <arpa/inet.h>
  54. #include /**/ <unistd.h>
  55. typedef in_addr IN_ADDR;
  56. extern int h_errno;  // defined in WinSock header, but not for UX?!
  57. #endif // __unix
  58. #ifdef WIN32
  59. #ifndef __unix         // __unix overrides WIN32 if both options are present
  60. #include <winsock.h>
  61. #endif
  62. #endif
  63. //----[ macros ]-------------------------------------------------------
  64. #define BUFSIZE 40     // worst case of address lens
  65. #define OUTBUFF 80     // worst case of output lens
  66. #define IPLEN      4
  67. #define UDPIPLEN   6
  68. #define IPXLEN     10
  69. #define IPXSOCKLEN 12
  70. #define MACLEN     6
  71. #define MAX_FRIENDLY_NAME 80
  72. #define HASH0 19
  73. #define HASH1 13
  74. #define HASH2 7
  75. //----[ enumerated types for address types ]---------------------------
  76. enum addr_type {
  77.   type_ip,
  78.   type_ipx,
  79.   type_udp,
  80.   type_ipxsock,
  81.   type_mac,
  82.   type_invalid
  83. };
  84. //---[ forward declarations ]-----------------------------------------
  85. class GenAddress; 
  86. class UdpAddress;
  87. class IpxSockAddress;
  88. //--------------------------------------------------------------------
  89. //----[ Address class ]-----------------------------------------------
  90. //--------------------------------------------------------------------
  91. class DLLOPT Address: public  SnmpSyntax {
  92. public:
  93.   // allow destruction of derived classes
  94.   virtual ~Address();
  95.   // overloaded equivlence operator, are two addresses equal?
  96.   DLLOPT friend int operator==( const Address &lhs,const Address &rhs);
  97.   // overloaded not equivlence operator, are two addresses not equal?
  98.   DLLOPT friend int operator!=( const Address &lhs,const Address &rhs);
  99.   // overloaded > operator, is a1 > a2
  100.   DLLOPT friend int operator>( const Address &lhs,const Address &rhs);
  101.   // overloaded >= operator, is a1 >= a2
  102.   DLLOPT friend int operator>=( const Address &lhs,const Address &rhs);
  103.   // overloaded < operator, is a1 < a2
  104.   DLLOPT friend int operator<( const Address &lhs,const Address &rhs);
  105.   // overloaded <= operator, is a1 <= a2
  106.   DLLOPT friend int operator<=( const Address &lhs,const Address &rhs);
  107.   // equivlence operator overloaded, are an address and a string equal?
  108.   DLLOPT friend int operator==( const Address &lhs,const char *rhs);
  109.   // overloaded not equivlence operator, are an address and string not equal?
  110.   DLLOPT friend int operator!=( const Address &lhs,const char *rhs);
  111.   // overloaded < , is an address greater than a string?
  112.   DLLOPT friend int operator>( const Address &lhs,const char *rhs);
  113.   // overloaded >=, is an address greater than or equal to a string?
  114.   DLLOPT friend int operator>=( const Address &lhs,const char *rhs);
  115.   // overloaded < , is an address less than a string?
  116.   DLLOPT friend int operator<( const Address &lhs,const char *rhs);
  117.   // overloaded <=, is an address less than or equal to a string?
  118.   DLLOPT friend int operator<=( const Address &lhs,const char *rhs);
  119.   // const char * operator overloaded for streaming output
  120.   virtual operator const char *() const = 0;
  121.   // is the address object valid?
  122.   virtual int valid() const;            
  123.   // syntax type
  124.   virtual SmiUINT32 get_syntax() = 0;
  125.   // for non const [], allows reading and writing
  126.   unsigned char& operator[]( const int position);
  127.   // get a printable ASCII value
  128.   virtual char *get_printable() = 0;
  129.   // create a new instance of this Value
  130.   virtual SnmpSyntax *clone() const = 0;
  131.   // return the type of address
  132.   virtual addr_type get_type() const = 0; 
  133.   // overloaded assignment operator
  134.   virtual SnmpSyntax& operator=( SnmpSyntax &val) = 0;
  135.   // return a hash key
  136.   virtual unsigned int hashFunction() const { return 0;};
  137. protected:
  138.   int valid_flag;
  139.   unsigned char address_buffer[BUFSIZE]; // internal representation
  140.   // parse the address string
  141.   // redefined for each specific address subclass
  142.   virtual int parse_address( const char * inaddr) =0;
  143.   // format the output
  144.   // redefined for each specific address subclass
  145.   virtual void format_output() =0;
  146.   // a reused trimm white space method
  147.   void trim_white_space( char * ptr);
  148. };
  149. //-----------------------------------------------------------------------
  150. //---------[ IP Address Class ]------------------------------------------
  151. //-----------------------------------------------------------------------
  152. class DLLOPT IpAddress : public Address {
  153. public:
  154.   // construct an IP address with no agrs
  155.   IpAddress( void);
  156.   // construct an IP address with a string
  157.   IpAddress( const char *inaddr);
  158.   // construct an IP address with another IP address
  159.   IpAddress( const IpAddress  &ipaddr);
  160.   // construct an IP address with a GenAddress
  161.   IpAddress( const GenAddress &genaddr);
  162.   // destructor (ensure that SnmpSyntax::~SnmpSyntax() is overridden)
  163.   ~IpAddress();
  164.   // copy an instance of this Value
  165.   SnmpSyntax& operator=( SnmpSyntax &val);
  166.   // assignment to another IpAddress object overloaded
  167.   IpAddress& operator=( const IpAddress &ipaddress);
  168.   // create a new instance of this Value
  169.   SnmpSyntax *clone() const;
  170.   // return the friendly name
  171.   // returns a NULL string if there isn't one
  172.   char *friendly_name(int &status);
  173.   virtual char *get_printable() ;
  174.   // const char * operator overloaded for streaming output
  175.   virtual operator const char *() const;
  176.   // logically AND two IPaddresses and
  177.   // return the new one
  178.   void mask( const IpAddress& ipaddr);
  179.   // return the type
  180.   virtual addr_type get_type() const;
  181.   // syntax type
  182.   virtual SmiUINT32 get_syntax();
  183. protected:
  184.   char output_buffer[OUTBUFF];           // output buffer
  185.   // friendly name storage
  186.   char iv_friendly_name[MAX_FRIENDLY_NAME];
  187.   int  iv_friendly_name_status;
  188.   // redefined parse address
  189.   // specific to IP addresses
  190.   virtual int parse_address( const char *inaddr);
  191.    
  192.   // redefined format output
  193.   // specific to IP addresses
  194.   virtual void format_output();
  195.   // parse a dotted string
  196.   int parse_dotted_ipstring( const char *inaddr);
  197.   // using the currently defined address, do a DNS
  198.   // and try to fill up the name
  199.   int addr_to_friendly();
  200. };
  201. //------------------------------------------------------------------------
  202. //---------[ UDP Address Class ]------------------------------------------
  203. //------------------------------------------------------------------------
  204. class DLLOPT UdpAddress : public IpAddress {
  205. public:
  206.   // constructor, no args
  207.   UdpAddress( void);
  208.   // constructor with a dotted string
  209.   UdpAddress( const char *inaddr);
  210.   // construct an Udp address with another Udp address
  211.   UdpAddress( const UdpAddress &udpaddr);
  212.   // construct a Udp address with a GenAddress
  213.   UdpAddress( const GenAddress &genaddr);
  214.   // construct a Udp address with an IpAddress
  215.   // default port # to zero
  216.   UdpAddress( const IpAddress &ipaddr);
  217.   // destructor
  218.   ~UdpAddress();
  219.   // syntax type
  220.   SmiUINT32 get_syntax();
  221.   // copy an instance of this Value
  222.   SnmpSyntax& operator=( SnmpSyntax &val);
  223.   // assignment to another IpAddress object overloaded
  224.   UdpAddress& operator=( const UdpAddress &udpaddr);
  225.   // create a new instance of this Value
  226.   SnmpSyntax *clone() const;
  227.   virtual char *get_printable() ;
  228.   // const char * operator overloaded for streaming output
  229.   virtual operator const char *() const;
  230.   // set the port number
  231.   void set_port( const unsigned short p);
  232.   // get the port number
  233.   unsigned short get_port() const; 
  234.   // return the type
  235.   virtual addr_type get_type() const;
  236. protected:
  237.   char output_buffer[OUTBUFF];           // output buffer
  238.   // redefined parse address
  239.   // specific to IP addresses
  240.   virtual int parse_address( const char *inaddr);
  241.   // redefined format output
  242.   // specific to IP addresses
  243.   virtual void format_output();
  244. };
  245. //-------------------------------------------------------------------------
  246. //---------[ 802.3 MAC Address Class ]-------------------------------------
  247. //-------------------------------------------------------------------------
  248. class DLLOPT MacAddress : public Address {
  249. public:
  250.   // constructor, no arguments
  251.   MacAddress( void);
  252.   // constructor with a string argument
  253.   MacAddress( const char  *inaddr);
  254.   // constructor with another MAC object
  255.   MacAddress( const MacAddress  &macaddr);
  256.   // construct a MacAddress with a GenAddress
  257.   MacAddress( const GenAddress &genaddr);
  258.   // destructor 
  259.   ~MacAddress();
  260.   // syntax type
  261.   SmiUINT32 get_syntax();
  262.   // copy an instance of this Value
  263.   SnmpSyntax& operator=( SnmpSyntax &val);
  264.   // assignment to another IpAddress object overloaded
  265.   MacAddress& operator=( const MacAddress &macaddress);
  266.   // create a new instance of this Value
  267.   SnmpSyntax *clone() const; 
  268.   virtual char *get_printable();
  269.   // const char * operator overloaded for streaming output
  270.   virtual operator const char *() const;
  271.   // return the type
  272.   virtual addr_type get_type() const;
  273.   // return a hash key
  274.   unsigned int hashFunction() const;
  275. protected:
  276.   char output_buffer[OUTBUFF];           // output buffer
  277.   // redefined parse address for macs
  278.   virtual int parse_address( const char *inaddr);
  279.   // redefined format output for MACs
  280.   virtual void format_output();
  281. };
  282. //------------------------------------------------------------------------
  283. //---------[ IPX Address Class ]------------------------------------------
  284. //------------------------------------------------------------------------
  285. class DLLOPT IpxAddress : public Address {
  286. public:
  287.   // constructor no args
  288.   IpxAddress( void);
  289.   // constructor with a string arg
  290.   IpxAddress( const char  *inaddr);
  291.   // constructor with another ipx object
  292.   IpxAddress( const IpxAddress  &ipxaddr);
  293.   // construct with a GenAddress
  294.   IpxAddress( const GenAddress &genaddr);
  295.   // destructor 
  296.   ~IpxAddress();
  297.   // syntax type
  298.   virtual SmiUINT32 get_syntax();
  299.   // copy an instance of this Value
  300.   SnmpSyntax& operator=( SnmpSyntax &val); 
  301.   // assignment to another IpAddress object overloaded
  302.   IpxAddress& operator=( const IpxAddress &ipxaddress);
  303.   // get the host id portion of an ipx address
  304.   int get_hostid( MacAddress& mac);
  305.   // create a new instance of this Value
  306.   SnmpSyntax *clone() const; 
  307.   virtual char *get_printable();
  308.   // const char * operator overloaded for streaming output
  309.   virtual operator const char *() const;
  310.   // return the type
  311.   virtual addr_type get_type() const;
  312. protected:
  313.   // ipx format separator
  314.   char separator;
  315.   char output_buffer[OUTBUFF];           // output buffer
  316.   // redefined parse address for ipx strings
  317.   virtual int parse_address( const char  *inaddr);
  318.   // redefined format output for ipx strings
  319.   // uses same separator as when constructed
  320.   virtual void format_output();
  321.  
  322. };
  323. //------------------------------------------------------------------------
  324. //---------[ IpxSock Address Class ]--------------------------------------
  325. //------------------------------------------------------------------------
  326. class DLLOPT IpxSockAddress : public IpxAddress {
  327. public:
  328.   // constructor, no args
  329.   IpxSockAddress( void);
  330.   // constructor with a dotted string
  331.   IpxSockAddress( const char *inaddr);
  332.   // construct an Udp address with another Udp address
  333.   IpxSockAddress( const IpxSockAddress &ipxaddr);
  334.   //constructor with a GenAddress
  335.   IpxSockAddress( const GenAddress &genaddr);
  336.   //constructor with a IpxAddress
  337.   // default socket # is 0
  338.   IpxSockAddress( const IpxAddress &ipxaddr);
  339.   // destructor
  340.   ~IpxSockAddress();
  341.   // syntax type
  342.   virtual SmiUINT32 get_syntax();
  343.   // copy an instance of this Value
  344.   SnmpSyntax& operator=( SnmpSyntax &val); 
  345.   // assignment to another IpAddress object overloaded
  346.   IpxSockAddress& operator=( const IpxSockAddress &ipxaddr);
  347.   // create a new instance of this Value
  348.   SnmpSyntax *clone() const;
  349.   // set the socket number
  350.   void set_socket( const unsigned short s);
  351.   // get the socket number
  352.   unsigned short get_socket() const;
  353.   virtual char *get_printable();
  354.   // const char * operator overloaded for streaming output
  355.   virtual operator const char *() const;
  356.   // return the type
  357.   virtual addr_type get_type() const;
  358. protected:
  359.   char output_buffer[OUTBUFF];           // output buffer
  360.   // redefined parse address for ipx strings
  361.   virtual int parse_address( const char  *inaddr);
  362.   // redefined format output
  363.   // specific to IP addresses
  364.   virtual void format_output();
  365. };
  366. //-------------------------------------------------------------------------
  367. //--------[ Generic Address ]----------------------------------------------
  368. //-------------------------------------------------------------------------
  369. class DLLOPT GenAddress : public Address {
  370. public:
  371.   // constructor, no arguments
  372.   GenAddress( void);
  373.   // constructor with a string argument
  374.   GenAddress( const char  *addr);
  375.   // constructor with an Address
  376.   GenAddress( const Address &addr);
  377.   // constructor with another GenAddress
  378.   GenAddress( const GenAddress &addr);
  379.   // destructor
  380.   ~GenAddress();
  381.   // get the snmp syntax of the contained address
  382.   SmiUINT32 get_syntax();
  383.   // create a new instance of this Value
  384.   SnmpSyntax *clone() const;
  385.   // assignment of a GenAddress
  386.   GenAddress& operator=( const GenAddress &addr);
  387.   // copy an instance of this Value
  388.   SnmpSyntax& operator=( SnmpSyntax &val);
  389.   virtual char *get_printable();
  390.   // const char * operator overloaded for streaming output
  391.   virtual operator const char *() const;
  392.   // return the type
  393.   virtual addr_type get_type() const;
  394. protected:
  395.   // pointer to a a concrete address
  396.   Address *address;
  397.   char output_buffer[OUTBUFF];           // output buffer
  398.   // redefined parse address for macs
  399.   virtual int parse_address( const char *addr);
  400.   // format output for a generic address
  401.   virtual void format_output();
  402. };
  403. // create OidCollection type
  404. typedef SnmpCollection <GenAddress> AddressCollection;
  405. #endif  //_ADDRESS