00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef __WVADDR_H
00010 #define __WVADDR_H
00011
00012 #include "wvautoconf.h"
00013 #include "if_arp.h"
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];
00071 static int extypes[];
00072 public:
00073
00074
00075 enum CapType {
00076
00077 Unknown = 0,
00078 Loopback,
00079 Ethertap,
00080 Ethernet,
00081 ARCnet,
00082 SLIP,
00083 CSLIP,
00084 PPP,
00085 IPsec,
00086
00087
00088 IPv4,
00089 Unix,
00090
00091
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
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
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);
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
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