Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

wvaddr.h

00001 /* -*- Mode: C++ -*-
00002  * Worldvisions Weaver Software:
00003  *   Copyright (C) 1997-2002 Net Integration Technologies, Inc.
00004  *
00005  * Device-independent and device-specific hardware/protocol address classes
00006  * that can store themselves efficiently as well as create a printable string
00007  * version of themselves.
00008  */
00009 #ifndef __WVADDR_H
00010 #define __WVADDR_H
00011 
00012 #include "wvautoconf.h"
00013 #include "if_arp.h" /* To define ARPHRD_.* */
00014 
00015 
00016 #include <stdio.h>
00017 #if HAVE_SYS_TYPES_H
00018 # include <sys/types.h>
00019 #endif
00020 #if STDC_HEADERS
00021 # include <stdlib.h>
00022 # include <stddef.h>
00023 #else
00024 # if HAVE_STDLIB_H
00025 #  include <stdlib.h>
00026 # endif
00027 #endif
00028 #if HAVE_SYS_SOCKET_H
00029 # include <sys/socket.h>
00030 #endif
00031 #if HAVE_NET_ETHERNET_H
00032 # include <net/ethernet.h>
00033 #endif
00034 #if HAVE_NET_IF_H
00035 # include <net/if.h>
00036 #endif
00037 #if HAVE_NETINET_IF_ETHER_H
00038 # include <netinet/if_ether.h>
00039 #endif
00040 #if HAVE_NETINET_IN_H
00041 # include <netinet/in.h>
00042 #endif
00043 
00044 #ifdef _WIN32
00045 #include <winsock2.h>
00046 #define ETHER_ADDR_LEN          6
00047 #define IP_ALEN                 4
00048 #endif
00049 
00050 #include "wvstring.h"
00051 
00052 static const char * type_wvaddr = "WvAddr";
00053 static const char * type_wvipaddr = "WvIPAddr";
00054 static const char * type_wvipnet = "WvIPNet";
00055 static const char * type_wvipportaddr = "WvIPPortAddr";
00056 
00057 #define WVADDR type_wvaddr
00058 #define WVIPADDR type_wvipaddr
00059 #define WVIPNET type_wvipnet
00060 #define WVIPPORTADDR type_wvipportaddr
00061 
00062 
00068 class WvEncap
00069 {
00070     static const char strings[][20];   // printable-string names per type
00071     static int extypes[];              // external types (ARPHRD_*, etc)
00072 public:
00073     // NOTE:  if you change enum CapType, don't forget to change extypes[]
00074     //   and strings[] in wvaddr.cc!
00075     enum CapType {
00076         // hardware encapsulation
00077         Unknown = 0,
00078         Loopback,
00079         Ethertap,
00080         Ethernet,
00081         ARCnet,
00082         SLIP,
00083         CSLIP,
00084         PPP,
00085         
00086         // protocol encapsulation
00087         IPv4,
00088         Unix,
00089         
00090         // END
00091         NUM_ENCAP_TYPES
00092     };
00093     CapType cap;
00094     
00095     WvEncap(CapType _cap = Unknown)
00096         { cap = _cap; }
00097     
00098     WvEncap(int extype);
00099     
00100     operator CapType () const
00101         { return cap; }
00102     
00103     operator WvString () const
00104         { return strings[cap]; }
00105 };
00106 
00107 
00113 class WvAddr
00114 {
00115 protected:
00116     virtual WvString printable() const = 0;
00117 
00118 public:
00119     WvAddr() {};
00120     virtual ~WvAddr() {};
00121     static WvAddr *gen(struct sockaddr *addr);
00122     
00123     virtual WvEncap encap() const = 0;
00124     operator WvString() const
00125         { return printable(); }
00126 
00127     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00128     // Poor man's rtti
00129     virtual const char *type() const
00130         { return WVADDR; };
00131     
00132     virtual bool isbroadcast() const;
00133 
00134     virtual struct sockaddr *sockaddr() const = 0;
00135     virtual size_t sockaddr_len() const = 0;
00136     virtual const unsigned char *rawdata() const;
00137     virtual size_t rawdata_len() const;
00138     
00139     virtual unsigned WvHash() const;
00140     
00141     bool operator== (const WvAddr &a2) const
00142         { return comparator(&a2); }
00143     bool operator!= (const WvAddr &a2) const
00144         { return ! (*this == a2); }
00145 };
00146 
00147 
00148 // useful for hash tables (see wvhashtable.h)
00149 unsigned WvHash(const WvAddr &addr);
00150 
00151 
00156 class WvStringAddr : public WvAddr
00157 {
00158     WvString addr;
00159     WvEncap cap;
00160 
00161 protected:
00162     virtual WvString printable() const;
00163 
00164 public:
00165     WvStringAddr(WvStringParm s, const WvEncap &_cap);
00166     WvStringAddr(const struct sockaddr *_addr);
00167     virtual ~WvStringAddr();
00168     virtual WvEncap encap() const;
00169     virtual struct sockaddr *sockaddr() const;
00170     virtual size_t sockaddr_len() const;
00171     virtual const unsigned char *rawdata() const;
00172     virtual size_t rawdata_len() const;
00173 };
00174 
00175 
00176 #ifndef _WIN32
00177 
00181 class WvEtherAddr : public WvAddr
00182 {
00183     unsigned char binaddr[ETHER_ADDR_LEN];
00184 
00185 protected:
00186     virtual WvString printable() const;
00187 
00188 public:
00189     WvEtherAddr(const unsigned char _binaddr[ETHER_ADDR_LEN] = NULL)
00190         { if (_binaddr) memcpy(binaddr, _binaddr, ETHER_ADDR_LEN); }
00191     WvEtherAddr(const char string[])
00192         { string_init(string); }
00193     WvEtherAddr(WvStringParm string)
00194         { string_init(string); }
00195     void string_init(const char string[]);
00196     WvEtherAddr(const struct sockaddr *addr)
00197         { memcpy(binaddr, (void *)addr->sa_data, ETHER_ADDR_LEN); }
00198     virtual ~WvEtherAddr();
00199     
00200     virtual WvEncap encap() const;
00201     virtual bool isbroadcast() const;
00202     virtual struct sockaddr *sockaddr() const;
00203     virtual size_t sockaddr_len() const;
00204     virtual const unsigned char *rawdata() const;
00205     virtual size_t rawdata_len() const;
00206 };
00207 
00208 
00210 class WvARCnetAddr : public WvAddr
00211 {
00212     unsigned char binaddr;
00213 
00214 protected:
00215     virtual WvString printable() const;
00216 
00217 public:
00218     WvARCnetAddr(const unsigned char _binaddr[1] = NULL)
00219         { if (_binaddr) binaddr = _binaddr[0]; }
00220     WvARCnetAddr(const char string[])
00221         { binaddr = strtoul(string, NULL, 16); }
00222     WvARCnetAddr(WvStringParm string)
00223         { binaddr = strtoul(string, NULL, 16); }
00224     WvARCnetAddr(const struct sockaddr *addr)
00225         { binaddr = ((unsigned char *)addr->sa_data)[0]; }
00226     virtual ~WvARCnetAddr();
00227     
00228     virtual WvEncap encap() const;
00229     virtual struct sockaddr *sockaddr() const;
00230     virtual size_t sockaddr_len() const;
00231     virtual const unsigned char *rawdata() const;
00232     virtual size_t rawdata_len() const;
00233 };
00234 #endif // !_WIN32
00235 
00244 class WvIPAddr : public WvAddr
00245 {
00246 protected:
00247     virtual WvString printable() const;
00248 public:
00249     unsigned char binaddr[4];
00250 
00251     WvIPAddr(const unsigned char _binaddr[4])
00252         { if (_binaddr) memcpy(binaddr, _binaddr, 4); }
00253     WvIPAddr(const uint32_t _binaddr = 0)
00254         { memcpy(binaddr, &_binaddr, 4); }
00255     WvIPAddr(const char string[])
00256         { string_init(string); }
00257     WvIPAddr(WvStringParm string)
00258         { string_init(string); }
00259     void string_init(const char string[]);
00260     WvIPAddr(const struct sockaddr *addr)
00261         { memcpy(binaddr,
00262                  (void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, 4); }
00263     WvIPAddr(const WvIPAddr &_addr)
00264         { memcpy(binaddr, _addr.binaddr, 4); }
00265     virtual ~WvIPAddr();
00266 
00267     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00268     virtual const char *type() const
00269         { return WVIPADDR; };
00270     
00271     WvIPAddr operator& (const WvIPAddr &a2) const;
00272     WvIPAddr operator| (const WvIPAddr &a2) const;
00273     WvIPAddr operator^ (const WvIPAddr &a2) const;
00274     WvIPAddr operator~ () const;
00275     WvIPAddr operator+ (int n) const;
00276     WvIPAddr operator- (int n) const;
00277 
00278     uint32_t addr() const
00279         { return *(uint32_t *)binaddr; }
00280 
00281     bool is_zero() const
00282         { return addr() == 0; }
00283 
00284     virtual WvEncap encap() const;
00285 
00286     virtual struct sockaddr *sockaddr() const;
00287     virtual size_t sockaddr_len() const;
00288     virtual const unsigned char *rawdata() const;
00289     virtual size_t rawdata_len() const;
00290 };
00291 
00292 
00307 class WvIPNet : public WvIPAddr
00308 {
00309 protected:
00310     WvIPAddr mask;
00311     virtual WvString printable() const;
00312     
00313 public:
00314     WvIPNet(const WvIPNet &_net);
00315     WvIPNet(const char string[]) : WvIPAddr(string)
00316         { string_init(string); }
00317     WvIPNet(WvStringParm string) : WvIPAddr(string)
00318         { string_init(string); }
00319     void string_init(const char string[]);
00320     WvIPNet(const WvIPAddr &base, const WvIPAddr &_mask);
00321 
00322     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00323     virtual const char *type() const
00324         { return WVIPNET; };
00325     
00331     WvIPNet(const WvIPAddr &base, int bits = 32);
00332     
00334     WvIPNet();
00335     
00336     virtual ~WvIPNet();
00337     
00339     virtual unsigned WvHash() const;
00340     
00342     WvIPAddr base() const
00343         { return *this; }
00344     WvIPAddr netmask() const
00345         { return mask; }
00346     WvIPAddr network() const
00347         { return *this & mask; }
00348     WvIPAddr broadcast() const
00349         { return *this | ~mask; }
00350     
00352     void include(const WvIPNet &addr);
00353     
00355     bool includes(const WvIPNet &addr) const;
00356     
00367     int bits() const;
00368     void normalize();
00369     
00371     bool is_default() const
00372         { return mask.binaddr[0] == 0; }
00373     
00375     bool is_host() const
00376         { return mask.binaddr[3] == 255; }
00377 };
00378 
00379 
00380 
00388 class WvIPPortAddr : public WvIPAddr
00389 {
00390 protected:
00391     virtual WvString printable() const;
00392 
00393 public:
00394     uint16_t port;
00395     
00396     WvIPPortAddr();
00397     WvIPPortAddr(const unsigned char _ipaddr[4], uint16_t _port = 0) 
00398           : WvIPAddr(_ipaddr), port(_port) { };
00399     WvIPPortAddr(const WvIPAddr &_ipaddr, uint16_t _port = 0);
00400     WvIPPortAddr(const char string[]) : WvIPAddr(string)
00401         { string_init(string); }
00402     WvIPPortAddr(WvStringParm string) : WvIPAddr(string)
00403         { string_init(string); }
00404     void string_init(const char string[]);
00405     WvIPPortAddr(uint16_t _port);          // assumes address 0.0.0.0, (ie local)
00406     WvIPPortAddr(const char string[], uint16_t _port);
00407     
00408     WvIPPortAddr(struct sockaddr_in *sin) : WvIPAddr(sin->sin_addr.s_addr)
00409         { port = ntohs(sin->sin_port); }
00410     virtual ~WvIPPortAddr();
00411 
00412     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00413     virtual const char *type() const
00414         { return WVIPPORTADDR; };
00415 
00416     virtual struct sockaddr *sockaddr() const;
00417 
00418     // Override the hash and comparison functions
00419     virtual unsigned WvHash() const;
00420 };
00421 
00422 #ifndef _WIN32
00423 
00424 class WvUnixAddr : public WvAddr
00425 {
00426 protected:
00427     WvString sockname;
00428     virtual WvString printable() const;
00429     
00430 public:
00431     WvUnixAddr(const char *_sockname);
00432     WvUnixAddr(WvStringParm _sockname);
00433     WvUnixAddr(const WvUnixAddr &_addr);
00434     virtual ~WvUnixAddr();
00435     
00436     virtual WvEncap encap() const;
00437 
00438     virtual struct sockaddr *sockaddr() const;
00439     virtual size_t sockaddr_len() const;
00440     virtual const unsigned char *rawdata() const;
00441     virtual size_t rawdata_len() const;
00442 };
00443 
00444 #endif //windows
00445 #endif // __WVADDR_H

Generated on Sun Jul 10 15:34:13 2005 for WvStreams by  doxygen 1.4.0