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 #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];
00075 static int extypes[];
00076 public:
00077
00078
00079 enum CapType {
00080
00081 Unknown = 0,
00082 Loopback,
00083 Ethertap,
00084 Ethernet,
00085 ARCnet,
00086 SLIP,
00087 CSLIP,
00088 PPP,
00089 IPsec,
00090
00091
00092 IPv4,
00093 Unix,
00094
00095
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
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
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);
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
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