Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

wvaddr.h

Go to the documentation of this file.
00001 /*
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 "wvstring.h"
00013 
00014 #ifndef ISLINUX
00015 #ifndef ISBSD
00016 #define ISLINUX
00017 #endif
00018 #endif
00019 
00020 #ifdef ISLINUX
00021 #include <linux/if_ether.h>
00022 #endif
00023 
00024 #ifdef ISBSD
00025 #include <sys/param.h>
00026 #include <sys/socket.h>
00027 #include <net/if_arp.h>
00028 #include <netinet/in_systm.h>
00029 #include <net/ethernet.h>
00030 #define ETH_ALEN ETHER_ADDR_LEN
00031 #endif
00032 
00033 #include <netinet/in.h>
00034 
00035 typedef unsigned int __u32;
00036 typedef short unsigned int __u16;
00037 
00043 class WvEncap
00044 {
00045     static char strings[][20];         // printable-string names per type
00046     static int extypes[];              // external types (ARPHRD_*, etc)
00047 public:
00048     // NOTE:  if you change enum CapType, don't forget to change extypes[]
00049     //   and strings[] in wvaddr.cc!
00050     enum CapType {
00051         // hardware encapsulation
00052         Unknown = 0,
00053         Loopback,
00054         Ethertap,
00055         Ethernet,
00056         ARCnet,
00057         SLIP,
00058         CSLIP,
00059         PPP,
00060         
00061         // protocol encapsulation
00062         IPv4,
00063         Unix,
00064         
00065         // END
00066         NUM_ENCAP_TYPES
00067     };
00068     CapType cap;
00069     
00070     WvEncap(CapType _cap = Unknown)
00071         { cap = _cap; }
00072     
00073     WvEncap(int extype);
00074     
00075     operator CapType () const
00076         { return cap; }
00077     
00078     operator WvString () const
00079         { return strings[cap]; }
00080 };
00081 
00082 
00088 class WvAddr
00089 {
00090 protected:
00091     virtual WvString printable() const = 0;
00092     const char *addrtype;
00093 
00094 public:
00095     WvAddr();
00096     virtual ~WvAddr();
00097     static WvAddr *gen(struct sockaddr *addr);
00098     
00099     virtual WvEncap encap() const = 0;
00100     operator WvString() const
00101         { return printable(); }
00102     
00103     virtual bool isbroadcast() const;
00104 
00105     virtual struct sockaddr *sockaddr() const = 0;
00106     virtual size_t sockaddr_len() const = 0;
00107     virtual const unsigned char *rawdata() const;
00108     virtual size_t rawdata_len() const;
00109     
00110     virtual unsigned WvHash() const;
00111     virtual bool comparator(const WvAddr *a2) const;
00112     
00113     bool operator== (const WvAddr &a2) const
00114         { return addrtype == a2.addrtype && comparator(&a2); }
00115     bool operator!= (const WvAddr &a2) const
00116         { return ! (*this == a2); }
00117 };
00118 
00119 
00120 // useful for hash tables (see wvhashtable.h)
00121 unsigned WvHash(const WvAddr &addr);
00122 
00123 
00128 class WvStringAddr : public WvAddr
00129 {
00130     WvString addr;
00131     WvEncap cap;
00132 
00133 protected:
00134     virtual WvString printable() const;
00135 
00136 public:
00137     WvStringAddr(const WvString &s, const WvEncap &_cap);
00138     WvStringAddr(const struct sockaddr *_addr);
00139     virtual ~WvStringAddr();
00140     virtual WvEncap encap() const;
00141     virtual struct sockaddr *sockaddr() const;
00142     virtual size_t sockaddr_len() const;
00143     virtual const unsigned char *rawdata() const;
00144     virtual size_t rawdata_len() const;
00145 };
00146 
00147 
00152 class WvEtherAddr : public WvAddr
00153 {
00154     unsigned char binaddr[ETH_ALEN];
00155 
00156 protected:
00157     virtual WvString printable() const;
00158 
00159 public:
00160     WvEtherAddr(const unsigned char _binaddr[ETH_ALEN] = NULL)
00161         { if (_binaddr) memcpy(binaddr, _binaddr, ETH_ALEN); }
00162     WvEtherAddr(const char string[])
00163         { string_init(string); }
00164     WvEtherAddr(const WvString &string)
00165         { string_init(string); }
00166     void string_init(const char string[]);
00167     WvEtherAddr(const struct sockaddr *addr)
00168         { memcpy(binaddr, (void *)addr->sa_data, ETH_ALEN); }
00169     virtual ~WvEtherAddr();
00170     
00171     virtual WvEncap encap() const;
00172     virtual bool isbroadcast() const;
00173     virtual struct sockaddr *sockaddr() const;
00174     virtual size_t sockaddr_len() const;
00175     virtual const unsigned char *rawdata() const;
00176     virtual size_t rawdata_len() const;
00177 };
00178 
00179 
00183 class WvARCnetAddr : public WvAddr
00184 {
00185     unsigned char binaddr;
00186 
00187 protected:
00188     virtual WvString printable() const;
00189 
00190 public:
00191     WvARCnetAddr(const unsigned char _binaddr[1] = NULL)
00192         { if (_binaddr) binaddr = _binaddr[0]; }
00193     WvARCnetAddr(const char string[])
00194         { binaddr = strtoul(string, NULL, 16); }
00195     WvARCnetAddr(const WvString &string)
00196         { binaddr = strtoul(string, NULL, 16); }
00197     WvARCnetAddr(const struct sockaddr *addr)
00198         { binaddr = ((unsigned char *)addr->sa_data)[0]; }
00199     virtual ~WvARCnetAddr();
00200     
00201     virtual WvEncap encap() 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 
00217 class WvIPAddr : public WvAddr
00218 {
00219 protected:
00220     virtual WvString printable() const;
00221 public:
00222     unsigned char binaddr[4];
00223 
00224     WvIPAddr(const unsigned char _binaddr[4])
00225         { if (_binaddr) memcpy(binaddr, _binaddr, 4); }
00226     WvIPAddr(const __u32 _binaddr = 0)
00227         { memcpy(binaddr, &_binaddr, 4); }
00228     WvIPAddr(const char string[])
00229         { string_init(string); }
00230     WvIPAddr(const WvString &string)
00231         { string_init(string); }
00232     void string_init(const char string[]);
00233     WvIPAddr(const struct sockaddr *addr)
00234         { memcpy(binaddr,
00235                  (void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, 4); }
00236     WvIPAddr(const WvIPAddr &_addr)
00237         { memcpy(binaddr, _addr.binaddr, 4); }
00238     virtual ~WvIPAddr();
00239     
00240     WvIPAddr operator& (const WvIPAddr &a2) const;
00241     WvIPAddr operator| (const WvIPAddr &a2) const;
00242     WvIPAddr operator^ (const WvIPAddr &a2) const;
00243     WvIPAddr operator~ () const;
00244     WvIPAddr operator+ (int n) const;
00245     WvIPAddr operator- (int n) const;
00246     __u32 s_addr() const
00247         { return *(__u32 *)binaddr; }
00248     
00249     virtual WvEncap encap() const;
00250 
00251     virtual struct sockaddr *sockaddr() const;
00252     virtual size_t sockaddr_len() const;
00253     virtual const unsigned char *rawdata() const;
00254     virtual size_t rawdata_len() const;
00255 };
00256 
00257 
00272 class WvIPNet : public WvIPAddr
00273 {
00274 protected:
00275     WvIPAddr mask;
00276     virtual WvString printable() const;
00277 
00278 public:
00279     WvIPNet(const WvIPNet &_net);
00280     WvIPNet(const char string[]) : WvIPAddr(string)
00281         { string_init(string); }
00282     WvIPNet(const WvString &string) : WvIPAddr(string)
00283         { string_init(string); }
00284     void string_init(const char string[]);
00285     WvIPNet(const WvIPAddr &base, const WvIPAddr &_mask);
00286     
00292     WvIPNet(const WvIPAddr &base, int bits = 32);
00293     
00297     WvIPNet();
00298     
00299     virtual ~WvIPNet();
00300     
00304     virtual unsigned WvHash() const;
00305     virtual bool comparator(const WvAddr *a2) const;
00306     
00310     WvIPAddr base() const
00311         { return WvIPAddr(binaddr); }
00312     const WvIPAddr &netmask() const
00313         { return mask; }
00314     WvIPAddr network() const
00315         { return *this & mask; }
00316     WvIPAddr broadcast() const
00317         { return *this | ~mask; }
00318     
00322     void include(const WvIPNet &addr);
00323     
00327     bool includes(const WvIPNet &addr) const;
00328     
00339     int bits() const;
00340     void normalize();
00341     
00345     bool is_default() const
00346         { return mask.binaddr[0] == 0; }
00347     
00351     bool is_host() const
00352         { return mask.binaddr[3] == 255; }
00353 };
00354 
00355 
00356 
00364 class WvIPPortAddr : public WvIPAddr
00365 {
00366 protected:
00367     virtual WvString printable() const;
00368 public:
00369     __u16 port;
00370     
00371     WvIPPortAddr();
00372     WvIPPortAddr(const unsigned char _ipaddr[4], __u16 _port = 0);
00373     WvIPPortAddr(const WvIPAddr &_ipaddr, __u16 _port = 0);
00374     WvIPPortAddr(const char string[]) : WvIPAddr(string)
00375         { string_init(string); }
00376     WvIPPortAddr(const WvString &string) : WvIPAddr(string)
00377         { string_init(string); }
00378     void string_init(const char string[]);
00379     WvIPPortAddr(__u16 _port);          // assumes address 0.0.0.0, (ie local)
00380     WvIPPortAddr(const char string[], __u16 _port);
00381     
00382     WvIPPortAddr(struct sockaddr_in *sin) : WvIPAddr(sin->sin_addr.s_addr)
00383         { port = ntohs(sin->sin_port); }
00384     virtual ~WvIPPortAddr();
00385     
00386     virtual struct sockaddr *sockaddr() const;
00387 
00388     // Override the hash and comparison functions
00389     virtual unsigned WvHash() const;
00390     virtual bool comparator(const WvAddr *a2) const;
00391 };
00392 
00393 
00397 class WvUnixAddr : public WvAddr
00398 {
00399 protected:
00400     WvString sockname;
00401     virtual WvString printable() const;
00402     
00403 public:
00404     WvUnixAddr(const char *_sockname);
00405     WvUnixAddr(const WvString &_sockname);
00406     WvUnixAddr(const WvUnixAddr &_addr);
00407     virtual ~WvUnixAddr();
00408     
00409     virtual WvEncap encap() const;
00410 
00411     virtual struct sockaddr *sockaddr() const;
00412     virtual size_t sockaddr_len() const;
00413     virtual const unsigned char *rawdata() const;
00414     virtual size_t rawdata_len() const;
00415 };
00416 
00417 
00418 #endif // __WVADDR_H

Generated on Sat Aug 24 23:07:54 2002 for WvStreams by doxygen1.2.15