WvStreams
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 #ifdef _MSC_VER
00050 typedef unsigned int uint32_t;
00051 typedef unsigned short uint16_t;
00052 #endif
00053 
00054 #include "wvstring.h"
00055 
00056 static const char * type_wvaddr = "WvAddr";
00057 static const char * type_wvipaddr = "WvIPAddr";
00058 static const char * type_wvipnet = "WvIPNet";
00059 static const char * type_wvipportaddr = "WvIPPortAddr";
00060 
00061 #define WVADDR type_wvaddr
00062 #define WVIPADDR type_wvipaddr
00063 #define WVIPNET type_wvipnet
00064 #define WVIPPORTADDR type_wvipportaddr
00065 
00066 
00072 class WvEncap
00073 {
00074     static const char strings[][20];   // printable-string names per type
00075     static int extypes[];              // external types (ARPHRD_*, etc)
00076 public:
00077     // NOTE:  if you change enum CapType, don't forget to change extypes[]
00078     //   and strings[] in wvaddr.cc!
00079     enum CapType {
00080         // hardware encapsulation
00081         Unknown = 0,
00082         Loopback,
00083         Ethertap,
00084         Ethernet,
00085         ARCnet,
00086         SLIP,
00087         CSLIP,
00088         PPP,
00089         IPsec,
00090         
00091         // protocol encapsulation
00092         IPv4,
00093         Unix,
00094         
00095         // END
00096         NUM_ENCAP_TYPES
00097     };
00098     CapType cap;
00099     
00100     WvEncap(CapType _cap = Unknown)
00101         { cap = _cap; }
00102     
00103     WvEncap(int extype);
00104     
00105     operator CapType () const
00106         { return cap; }
00107     
00108     operator WvString () const
00109         { return strings[cap]; }
00110 };
00111 
00112 
00118 class WvAddr
00119 {
00120 protected:
00121     virtual WvString printable() const = 0;
00122 
00123 public:
00124     WvAddr() {};
00125     virtual ~WvAddr() {};
00126     static WvAddr *gen(struct sockaddr *addr);
00127     
00128     virtual WvEncap encap() const = 0;
00129     operator WvString() const
00130         { return printable(); }
00131 
00132     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00133     // Poor man's rtti
00134     virtual const char *type() const
00135         { return WVADDR; };
00136     
00137     virtual bool isbroadcast() const;
00138 
00139     virtual struct sockaddr *sockaddr() const = 0;
00140     virtual size_t sockaddr_len() const = 0;
00141     virtual const unsigned char *rawdata() const;
00142     virtual size_t rawdata_len() const;
00143     
00144     virtual unsigned WvHash() const;
00145     
00146     bool operator== (const WvAddr &a2) const
00147         { return comparator(&a2); }
00148     bool operator!= (const WvAddr &a2) const
00149         { return ! (*this == a2); }
00150 };
00151 
00152 
00153 // useful for hash tables (see wvhashtable.h)
00154 unsigned WvHash(const WvAddr &addr);
00155 
00156 
00161 class WvStringAddr : public WvAddr
00162 {
00163     WvString addr;
00164     WvEncap cap;
00165 
00166 protected:
00167     virtual WvString printable() const;
00168 
00169 public:
00170     WvStringAddr(WvStringParm s, const WvEncap &_cap);
00171     WvStringAddr(const struct sockaddr *_addr);
00172     virtual ~WvStringAddr();
00173     virtual WvEncap encap() const;
00174     virtual struct sockaddr *sockaddr() const;
00175     virtual size_t sockaddr_len() const;
00176     virtual const unsigned char *rawdata() const;
00177     virtual size_t rawdata_len() const;
00178 };
00179 
00180 
00181 #ifndef _WIN32
00182 
00186 class WvEtherAddr : public WvAddr
00187 {
00188     unsigned char binaddr[ETHER_ADDR_LEN];
00189 
00190 protected:
00191     virtual WvString printable() const;
00192 
00193 public:
00194     WvEtherAddr(const unsigned char _binaddr[ETHER_ADDR_LEN] = NULL)
00195         { if (_binaddr) memcpy(binaddr, _binaddr, ETHER_ADDR_LEN); }
00196     WvEtherAddr(const char string[])
00197         { string_init(string); }
00198     WvEtherAddr(WvStringParm string)
00199         { string_init(string); }
00200     void string_init(const char string[]);
00201     WvEtherAddr(const struct sockaddr *addr)
00202         { memcpy(binaddr, (void *)addr->sa_data, ETHER_ADDR_LEN); }
00203     virtual ~WvEtherAddr();
00204     
00205     virtual WvEncap encap() const;
00206     virtual bool isbroadcast() const;
00207     virtual struct sockaddr *sockaddr() const;
00208     virtual size_t sockaddr_len() const;
00209     virtual const unsigned char *rawdata() const;
00210     virtual size_t rawdata_len() const;
00211 };
00212 
00213 
00215 class WvARCnetAddr : public WvAddr
00216 {
00217     unsigned char binaddr;
00218 
00219 protected:
00220     virtual WvString printable() const;
00221 
00222 public:
00223     WvARCnetAddr(const unsigned char _binaddr[1] = NULL)
00224         { if (_binaddr) binaddr = _binaddr[0]; }
00225     WvARCnetAddr(const char string[])
00226         { binaddr = strtoul(string, NULL, 16); }
00227     WvARCnetAddr(WvStringParm string)
00228         { binaddr = strtoul(string, NULL, 16); }
00229     WvARCnetAddr(const struct sockaddr *addr)
00230         { binaddr = ((unsigned char *)addr->sa_data)[0]; }
00231     virtual ~WvARCnetAddr();
00232     
00233     virtual WvEncap encap() const;
00234     virtual struct sockaddr *sockaddr() const;
00235     virtual size_t sockaddr_len() const;
00236     virtual const unsigned char *rawdata() const;
00237     virtual size_t rawdata_len() const;
00238 };
00239 #endif // !_WIN32
00240 
00249 class WvIPAddr : public WvAddr
00250 {
00251 protected:
00252     virtual WvString printable() const;
00253 public:
00254     unsigned char binaddr[4];
00255 
00256     WvIPAddr(const unsigned char *_binaddr)
00257         { if (_binaddr) memcpy(binaddr, _binaddr, 4); }
00258     WvIPAddr(const uint32_t _binaddr = 0)
00259         { memcpy(binaddr, &_binaddr, 4); }
00260     WvIPAddr(const char string[])
00261         { string_init(string); }
00262     WvIPAddr(WvStringParm string)
00263         { string_init(string); }
00264     void string_init(const char string[]);
00265     WvIPAddr(const struct sockaddr *addr)
00266         { memcpy(binaddr,
00267                  (void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, 4); }
00268     WvIPAddr(const WvIPAddr &_addr)
00269         { memcpy(binaddr, _addr.binaddr, 4); }
00270     virtual ~WvIPAddr();
00271 
00272     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00273     virtual const char *type() const
00274         { return WVIPADDR; };
00275     
00276     WvIPAddr operator& (const WvIPAddr &a2) const;
00277     WvIPAddr operator| (const WvIPAddr &a2) const;
00278     WvIPAddr operator^ (const WvIPAddr &a2) const;
00279     WvIPAddr operator~ () const;
00280     WvIPAddr operator+ (int n) const;
00281     WvIPAddr operator- (int n) const;
00282 
00283     uint32_t addr() const
00284         { return *(uint32_t *)binaddr; }
00285 
00286     bool is_zero() const
00287         { return addr() == 0; }
00288 
00289     virtual WvEncap encap() const;
00290 
00291     virtual struct sockaddr *sockaddr() const;
00292     virtual size_t sockaddr_len() const;
00293     virtual const unsigned char *rawdata() const;
00294     virtual size_t rawdata_len() const;
00295 };
00296 
00297 
00312 class WvIPNet : public WvIPAddr
00313 {
00314 protected:
00315     WvIPAddr mask;
00316     virtual WvString printable() const;
00317     
00318 public:
00319     WvIPNet(const WvIPNet &_net);
00320     WvIPNet(const char string[]) : WvIPAddr(string)
00321         { string_init(string); }
00322     WvIPNet(WvStringParm string) : WvIPAddr(string)
00323         { string_init(string); }
00324     void string_init(const char string[]);
00325     WvIPNet(const WvIPAddr &base, const WvIPAddr &_mask);
00326 
00327     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00328     virtual const char *type() const
00329         { return WVIPNET; };
00330     
00336     WvIPNet(const WvIPAddr &base, int bits = 32);
00337     
00339     WvIPNet();
00340     
00341     virtual ~WvIPNet();
00342     
00344     virtual unsigned WvHash() const;
00345     
00347     WvIPAddr base() const
00348         { return *this; }
00349     WvIPAddr netmask() const
00350         { return mask; }
00351     WvIPAddr network() const
00352         { return *this & mask; }
00353     WvIPAddr broadcast() const
00354         { return *this | ~mask; }
00355     
00357     void include(const WvIPNet &addr);
00358     
00360     bool includes(const WvIPNet &addr) const;
00361     
00372     int bits() const;
00373     void normalize();
00374     
00376     bool is_default() const
00377         { return mask.binaddr[0] == 0; }
00378     
00380     bool is_host() const
00381         { return mask.binaddr[3] == 255; }
00382 };
00383 
00384 
00385 
00393 class WvIPPortAddr : public WvIPAddr
00394 {
00395 protected:
00396     virtual WvString printable() const;
00397 
00398 public:
00399     uint16_t port;
00400     
00401     WvIPPortAddr();
00402     WvIPPortAddr(const unsigned char _ipaddr[4], uint16_t _port = 0) 
00403           : WvIPAddr(_ipaddr), port(_port) { };
00404     WvIPPortAddr(const WvIPAddr &_ipaddr, uint16_t _port = 0);
00405     WvIPPortAddr(const char string[]) : WvIPAddr(string)
00406         { string_init(string); }
00407     WvIPPortAddr(WvStringParm string) : WvIPAddr(string)
00408         { string_init(string); }
00409     void string_init(const char string[]);
00410     WvIPPortAddr(uint16_t _port);          // assumes address 0.0.0.0, (ie local)
00411     WvIPPortAddr(const char string[], uint16_t _port);
00412     
00413     WvIPPortAddr(struct sockaddr_in *sin) : WvIPAddr(sin->sin_addr.s_addr)
00414         { port = ntohs(sin->sin_port); }
00415     virtual ~WvIPPortAddr();
00416 
00417     virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00418     virtual const char *type() const
00419         { return WVIPPORTADDR; };
00420 
00421     virtual struct sockaddr *sockaddr() const;
00422 
00423     // Override the hash and comparison functions
00424     virtual unsigned WvHash() const;
00425 };
00426 
00427 #ifndef _WIN32
00428 
00429 class WvUnixAddr : public WvAddr
00430 {
00431 protected:
00432     WvString sockname;
00433     virtual WvString printable() const;
00434     
00435 public:
00436     WvUnixAddr(const char *_sockname);
00437     WvUnixAddr(WvStringParm _sockname);
00438     WvUnixAddr(const WvUnixAddr &_addr);
00439     virtual ~WvUnixAddr();
00440     
00441     virtual WvEncap encap() const;
00442 
00443     virtual struct sockaddr *sockaddr() const;
00444     virtual size_t sockaddr_len() const;
00445     virtual const unsigned char *rawdata() const;
00446     virtual size_t rawdata_len() const;
00447 };
00448 
00449 #endif //windows
00450 #endif // __WVADDR_H