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         IPsec,
00086         
00087         // protocol encapsulation
00088         IPv4,
00089         Unix,
00090         
00091         // END
00092         NUM_ENCAP_TYPES
00093     };
00094     CapType cap;
00095     
00096     WvEncap(CapType _cap = Unknown)
00097         { cap = _cap; }
00098     
00099     WvEncap(int extype);
00100     
00101     operator CapType () const
00102         { return cap; }
00103     
00104     operator WvString () const
00105         { return strings[cap]; }
00106 };
00107 
00108 
00114 class WvAddr
00115 {
00116 protected:
00117     virtual WvString printable() const = 0;
00118 
00119 public:
00120     WvAddr() {};
00121     virtual ~WvAddr() {};
00122     static WvAddr *gen(struct sockaddr *addr);
00123     
00124     virtual WvEncap encap() const = 0;
00125     operator WvString() const
00126         { return printable(); }
00127 
00128     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00129     // Poor man's rtti
00130     virtual const char *type() const
00131         { return WVADDR; };
00132     
00133     virtual bool isbroadcast() const;
00134 
00135     virtual struct sockaddr *sockaddr() const = 0;
00136     virtual size_t sockaddr_len() const = 0;
00137     virtual const unsigned char *rawdata() const;
00138     virtual size_t rawdata_len() const;
00139     
00140     virtual unsigned WvHash() const;
00141     
00142     bool operator== (const WvAddr &a2) const
00143         { return comparator(&a2); }
00144     bool operator!= (const WvAddr &a2) const
00145         { return ! (*this == a2); }
00146 };
00147 
00148 
00149 // useful for hash tables (see wvhashtable.h)
00150 unsigned WvHash(const WvAddr &addr);
00151 
00152 
00157 class WvStringAddr : public WvAddr
00158 {
00159     WvString addr;
00160     WvEncap cap;
00161 
00162 protected:
00163     virtual WvString printable() const;
00164 
00165 public:
00166     WvStringAddr(WvStringParm s, const WvEncap &_cap);
00167     WvStringAddr(const struct sockaddr *_addr);
00168     virtual ~WvStringAddr();
00169     virtual WvEncap encap() const;
00170     virtual struct sockaddr *sockaddr() const;
00171     virtual size_t sockaddr_len() const;
00172     virtual const unsigned char *rawdata() const;
00173     virtual size_t rawdata_len() const;
00174 };
00175 
00176 
00177 #ifndef _WIN32
00178 
00182 class WvEtherAddr : public WvAddr
00183 {
00184     unsigned char binaddr[ETHER_ADDR_LEN];
00185 
00186 protected:
00187     virtual WvString printable() const;
00188 
00189 public:
00190     WvEtherAddr(const unsigned char _binaddr[ETHER_ADDR_LEN] = NULL)
00191         { if (_binaddr) memcpy(binaddr, _binaddr, ETHER_ADDR_LEN); }
00192     WvEtherAddr(const char string[])
00193         { string_init(string); }
00194     WvEtherAddr(WvStringParm string)
00195         { string_init(string); }
00196     void string_init(const char string[]);
00197     WvEtherAddr(const struct sockaddr *addr)
00198         { memcpy(binaddr, (void *)addr->sa_data, ETHER_ADDR_LEN); }
00199     virtual ~WvEtherAddr();
00200     
00201     virtual WvEncap encap() const;
00202     virtual bool isbroadcast() const;
00203     virtual struct sockaddr *sockaddr() const;
00204     virtual size_t sockaddr_len() const;
00205     virtual const unsigned char *rawdata() const;
00206     virtual size_t rawdata_len() const;
00207 };
00208 
00209 
00211 class WvARCnetAddr : public WvAddr
00212 {
00213     unsigned char binaddr;
00214 
00215 protected:
00216     virtual WvString printable() const;
00217 
00218 public:
00219     WvARCnetAddr(const unsigned char _binaddr[1] = NULL)
00220         { if (_binaddr) binaddr = _binaddr[0]; }
00221     WvARCnetAddr(const char string[])
00222         { binaddr = strtoul(string, NULL, 16); }
00223     WvARCnetAddr(WvStringParm string)
00224         { binaddr = strtoul(string, NULL, 16); }
00225     WvARCnetAddr(const struct sockaddr *addr)
00226         { binaddr = ((unsigned char *)addr->sa_data)[0]; }
00227     virtual ~WvARCnetAddr();
00228     
00229     virtual WvEncap encap() const;
00230     virtual struct sockaddr *sockaddr() const;
00231     virtual size_t sockaddr_len() const;
00232     virtual const unsigned char *rawdata() const;
00233     virtual size_t rawdata_len() const;
00234 };
00235 #endif // !_WIN32
00236 
00245 class WvIPAddr : public WvAddr
00246 {
00247 protected:
00248     virtual WvString printable() const;
00249 public:
00250     unsigned char binaddr[4];
00251 
00252     WvIPAddr(const unsigned char _binaddr[4])
00253         { if (_binaddr) memcpy(binaddr, _binaddr, 4); }
00254     WvIPAddr(const uint32_t _binaddr = 0)
00255         { memcpy(binaddr, &_binaddr, 4); }
00256     WvIPAddr(const char string[])
00257         { string_init(string); }
00258     WvIPAddr(WvStringParm string)
00259         { string_init(string); }
00260     void string_init(const char string[]);
00261     WvIPAddr(const struct sockaddr *addr)
00262         { memcpy(binaddr,
00263                  (void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, 4); }
00264     WvIPAddr(const WvIPAddr &_addr)
00265         { memcpy(binaddr, _addr.binaddr, 4); }
00266     virtual ~WvIPAddr();
00267 
00268     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00269     virtual const char *type() const
00270         { return WVIPADDR; };
00271     
00272     WvIPAddr operator& (const WvIPAddr &a2) const;
00273     WvIPAddr operator| (const WvIPAddr &a2) const;
00274     WvIPAddr operator^ (const WvIPAddr &a2) const;
00275     WvIPAddr operator~ () const;
00276     WvIPAddr operator+ (int n) const;
00277     WvIPAddr operator- (int n) const;
00278 
00279     uint32_t addr() const
00280         { return *(uint32_t *)binaddr; }
00281 
00282     bool is_zero() const
00283         { return addr() == 0; }
00284 
00285     virtual WvEncap encap() const;
00286 
00287     virtual struct sockaddr *sockaddr() const;
00288     virtual size_t sockaddr_len() const;
00289     virtual const unsigned char *rawdata() const;
00290     virtual size_t rawdata_len() const;
00291 };
00292 
00293 
00308 class WvIPNet : public WvIPAddr
00309 {
00310 protected:
00311     WvIPAddr mask;
00312     virtual WvString printable() const;
00313     
00314 public:
00315     WvIPNet(const WvIPNet &_net);
00316     WvIPNet(const char string[]) : WvIPAddr(string)
00317         { string_init(string); }
00318     WvIPNet(WvStringParm string) : WvIPAddr(string)
00319         { string_init(string); }
00320     void string_init(const char string[]);
00321     WvIPNet(const WvIPAddr &base, const WvIPAddr &_mask);
00322 
00323     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00324     virtual const char *type() const
00325         { return WVIPNET; };
00326     
00332     WvIPNet(const WvIPAddr &base, int bits = 32);
00333     
00335     WvIPNet();
00336     
00337     virtual ~WvIPNet();
00338     
00340     virtual unsigned WvHash() const;
00341     
00343     WvIPAddr base() const
00344         { return *this; }
00345     WvIPAddr netmask() const
00346         { return mask; }
00347     WvIPAddr network() const
00348         { return *this & mask; }
00349     WvIPAddr broadcast() const
00350         { return *this | ~mask; }
00351     
00353     void include(const WvIPNet &addr);
00354     
00356     bool includes(const WvIPNet &addr) const;
00357     
00368     int bits() const;
00369     void normalize();
00370     
00372     bool is_default() const
00373         { return mask.binaddr[0] == 0; }
00374     
00376     bool is_host() const
00377         { return mask.binaddr[3] == 255; }
00378 };
00379 
00380 
00381 
00389 class WvIPPortAddr : public WvIPAddr
00390 {
00391 protected:
00392     virtual WvString printable() const;
00393 
00394 public:
00395     uint16_t port;
00396     
00397     WvIPPortAddr();
00398     WvIPPortAddr(const unsigned char _ipaddr[4], uint16_t _port = 0) 
00399           : WvIPAddr(_ipaddr), port(_port) { };
00400     WvIPPortAddr(const WvIPAddr &_ipaddr, uint16_t _port = 0);
00401     WvIPPortAddr(const char string[]) : WvIPAddr(string)
00402         { string_init(string); }
00403     WvIPPortAddr(WvStringParm string) : WvIPAddr(string)
00404         { string_init(string); }
00405     void string_init(const char string[]);
00406     WvIPPortAddr(uint16_t _port);          // assumes address 0.0.0.0, (ie local)
00407     WvIPPortAddr(const char string[], uint16_t _port);
00408     
00409     WvIPPortAddr(struct sockaddr_in *sin) : WvIPAddr(sin->sin_addr.s_addr)
00410         { port = ntohs(sin->sin_port); }
00411     virtual ~WvIPPortAddr();
00412 
00413     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00414     virtual const char *type() const
00415         { return WVIPPORTADDR; };
00416 
00417     virtual struct sockaddr *sockaddr() const;
00418 
00419     // Override the hash and comparison functions
00420     virtual unsigned WvHash() const;
00421 };
00422 
00423 #ifndef _WIN32
00424 
00425 class WvUnixAddr : public WvAddr
00426 {
00427 protected:
00428     WvString sockname;
00429     virtual WvString printable() const;
00430     
00431 public:
00432     WvUnixAddr(const char *_sockname);
00433     WvUnixAddr(WvStringParm _sockname);
00434     WvUnixAddr(const WvUnixAddr &_addr);
00435     virtual ~WvUnixAddr();
00436     
00437     virtual WvEncap encap() const;
00438 
00439     virtual struct sockaddr *sockaddr() const;
00440     virtual size_t sockaddr_len() const;
00441     virtual const unsigned char *rawdata() const;
00442     virtual size_t rawdata_len() const;
00443 };
00444 
00445 #endif //windows
00446 #endif // __WVADDR_H

Generated on Fri Oct 5 18:20:27 2007 for WvStreams by  doxygen 1.5.3