00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef __WVADDR_H
00010 #define __WVADDR_H
00011
00012 #include "wvstring.h"
00013
00014
00015 #ifdef __linux
00016 #include <linux/if_ether.h>
00017 #endif
00018
00019 #if 0
00020
00021 #include <sys/param.h>
00022 #include <sys/socket.h>
00023 #include <net/if_arp.h>
00024 #include <netinet/in_systm.h>
00025 #include <net/ethernet.h>
00026 #define ETH_ALEN ETHER_ADDR_LEN
00027 #endif
00028
00029 #if defined(ISBSD) || defined(ISDARWIN)
00030 #include <arpa/inet.h>
00031 #include "if_arp.h"
00032 #endif
00033
00034 #ifndef _WIN32
00035 #include <netinet/in.h>
00036 #else
00037
00038 #include <winsock2.h>
00039 #define ETH_ALEN 6
00040 #define IP_ALEN 4
00041 #endif
00042
00043 #ifndef __u32
00044 typedef unsigned int __u32;
00045 #endif
00046 #ifndef __u16
00047 typedef short unsigned int __u16;
00048 #endif
00049
00050
00051 static const char * type_wvaddr = "WvAddr";
00052 static const char * type_wvipaddr = "WvIPAddr";
00053 static const char * type_wvipnet = "WvIPNet";
00054 static const char * type_wvipportaddr = "WvIPPortAddr";
00055
00056 #define WVADDR type_wvaddr
00057 #define WVIPADDR type_wvipaddr
00058 #define WVIPNET type_wvipnet
00059 #define WVIPPORTADDR type_wvipportaddr
00060
00061
00062
00063
00064
00065
00066
00067 class WvEncap
00068 {
00069 static char strings[][20];
00070 static int extypes[];
00071 public:
00072
00073
00074 enum CapType {
00075
00076 Unknown = 0,
00077 Loopback,
00078 Ethertap,
00079 Ethernet,
00080 ARCnet,
00081 SLIP,
00082 CSLIP,
00083 PPP,
00084
00085
00086 IPv4,
00087 Unix,
00088
00089
00090 NUM_ENCAP_TYPES
00091 };
00092 CapType cap;
00093
00094 WvEncap(CapType _cap = Unknown)
00095 { cap = _cap; }
00096
00097 WvEncap(int extype);
00098
00099 operator CapType () const
00100 { return cap; }
00101
00102 operator WvString () const
00103 { return strings[cap]; }
00104 };
00105
00106
00107
00108
00109
00110
00111
00112 class WvAddr
00113 {
00114 protected:
00115 virtual WvString printable() const = 0;
00116
00117 public:
00118 WvAddr() {};
00119 virtual ~WvAddr() {};
00120 static WvAddr *gen(struct sockaddr *addr);
00121
00122 virtual WvEncap encap() const = 0;
00123 operator WvString() const
00124 { return printable(); }
00125
00126 virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00127
00128 virtual const char *type() const
00129 { return WVADDR; };
00130
00131 virtual bool isbroadcast() const;
00132
00133 virtual struct sockaddr *sockaddr() const = 0;
00134 virtual size_t sockaddr_len() const = 0;
00135 virtual const unsigned char *rawdata() const;
00136 virtual size_t rawdata_len() const;
00137
00138 virtual unsigned WvHash() const;
00139
00140 bool operator== (const WvAddr &a2) const
00141 { return comparator(&a2); }
00142 bool operator!= (const WvAddr &a2) const
00143 { return ! (*this == a2); }
00144 };
00145
00146
00147
00148 unsigned WvHash(const WvAddr &addr);
00149
00150
00151
00152
00153
00154
00155 class WvStringAddr : public WvAddr
00156 {
00157 WvString addr;
00158 WvEncap cap;
00159
00160 protected:
00161 virtual WvString printable() const;
00162
00163 public:
00164 WvStringAddr(WvStringParm s, const WvEncap &_cap);
00165 WvStringAddr(const struct sockaddr *_addr);
00166 virtual ~WvStringAddr();
00167 virtual WvEncap encap() const;
00168 virtual struct sockaddr *sockaddr() const;
00169 virtual size_t sockaddr_len() const;
00170 virtual const unsigned char *rawdata() const;
00171 virtual size_t rawdata_len() const;
00172 };
00173
00174
00175 #ifndef _WIN32
00176
00177
00178
00179
00180 class WvEtherAddr : public WvAddr
00181 {
00182 unsigned char binaddr[ETH_ALEN];
00183
00184 protected:
00185 virtual WvString printable() const;
00186
00187 public:
00188 WvEtherAddr(const unsigned char _binaddr[ETH_ALEN] = NULL)
00189 { if (_binaddr) memcpy(binaddr, _binaddr, ETH_ALEN); }
00190 WvEtherAddr(const char string[])
00191 { string_init(string); }
00192 WvEtherAddr(WvStringParm string)
00193 { string_init(string); }
00194 void string_init(const char string[]);
00195 WvEtherAddr(const struct sockaddr *addr)
00196 { memcpy(binaddr, (void *)addr->sa_data, ETH_ALEN); }
00197 virtual ~WvEtherAddr();
00198
00199 virtual WvEncap encap() const;
00200 virtual bool isbroadcast() const;
00201 virtual struct sockaddr *sockaddr() const;
00202 virtual size_t sockaddr_len() const;
00203 virtual const unsigned char *rawdata() const;
00204 virtual size_t rawdata_len() const;
00205 };
00206
00207
00208
00209 class WvARCnetAddr : public WvAddr
00210 {
00211 unsigned char binaddr;
00212
00213 protected:
00214 virtual WvString printable() const;
00215
00216 public:
00217 WvARCnetAddr(const unsigned char _binaddr[1] = NULL)
00218 { if (_binaddr) binaddr = _binaddr[0]; }
00219 WvARCnetAddr(const char string[])
00220 { binaddr = strtoul(string, NULL, 16); }
00221 WvARCnetAddr(WvStringParm string)
00222 { binaddr = strtoul(string, NULL, 16); }
00223 WvARCnetAddr(const struct sockaddr *addr)
00224 { binaddr = ((unsigned char *)addr->sa_data)[0]; }
00225 virtual ~WvARCnetAddr();
00226
00227 virtual WvEncap encap() const;
00228 virtual struct sockaddr *sockaddr() const;
00229 virtual size_t sockaddr_len() const;
00230 virtual const unsigned char *rawdata() const;
00231 virtual size_t rawdata_len() const;
00232 };
00233 #endif // !_WIN32
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243 class WvIPAddr : public WvAddr
00244 {
00245 protected:
00246 virtual WvString printable() const;
00247 public:
00248 unsigned char binaddr[4];
00249
00250 WvIPAddr(const unsigned char _binaddr[4])
00251 { if (_binaddr) memcpy(binaddr, _binaddr, 4); }
00252 WvIPAddr(const __u32 _binaddr = 0)
00253 { memcpy(binaddr, &_binaddr, 4); }
00254 WvIPAddr(const char string[])
00255 { string_init(string); }
00256 WvIPAddr(WvStringParm string)
00257 { string_init(string); }
00258 void string_init(const char string[]);
00259 WvIPAddr(const struct sockaddr *addr)
00260 { memcpy(binaddr,
00261 (void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, 4); }
00262 WvIPAddr(const WvIPAddr &_addr)
00263 { memcpy(binaddr, _addr.binaddr, 4); }
00264 virtual ~WvIPAddr();
00265
00266 virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00267 virtual const char *type() const
00268 { return WVIPADDR; };
00269
00270 WvIPAddr operator& (const WvIPAddr &a2) const;
00271 WvIPAddr operator| (const WvIPAddr &a2) const;
00272 WvIPAddr operator^ (const WvIPAddr &a2) const;
00273 WvIPAddr operator~ () const;
00274 WvIPAddr operator+ (int n) const;
00275 WvIPAddr operator- (int n) const;
00276
00277 __u32 addr() const
00278 { return *(__u32 *)binaddr; }
00279
00280 bool is_zero() const
00281 { return addr() == 0; }
00282
00283 virtual WvEncap encap() const;
00284
00285 virtual struct sockaddr *sockaddr() const;
00286 virtual size_t sockaddr_len() const;
00287 virtual const unsigned char *rawdata() const;
00288 virtual size_t rawdata_len() const;
00289 };
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306 class WvIPNet : public WvIPAddr
00307 {
00308 protected:
00309 WvIPAddr mask;
00310 virtual WvString printable() const;
00311
00312 public:
00313 WvIPNet(const WvIPNet &_net);
00314 WvIPNet(const char string[]) : WvIPAddr(string)
00315 { string_init(string); }
00316 WvIPNet(WvStringParm string) : WvIPAddr(string)
00317 { string_init(string); }
00318 void string_init(const char string[]);
00319 WvIPNet(const WvIPAddr &base, const WvIPAddr &_mask);
00320
00321 virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00322 virtual const char *type() const
00323 { return WVIPNET; };
00324
00325
00326
00327
00328
00329
00330 WvIPNet(const WvIPAddr &base, int bits = 32);
00331
00332
00333 WvIPNet();
00334
00335 virtual ~WvIPNet();
00336
00337
00338 virtual unsigned WvHash() const;
00339
00340
00341 WvIPAddr base() const
00342 { return *this; }
00343 WvIPAddr netmask() const
00344 { return mask; }
00345 WvIPAddr network() const
00346 { return *this & mask; }
00347 WvIPAddr broadcast() const
00348 { return *this | ~mask; }
00349
00350
00351 void include(const WvIPNet &addr);
00352
00353
00354 bool includes(const WvIPNet &addr) const;
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366 int bits() const;
00367 void normalize();
00368
00369
00370 bool is_default() const
00371 { return mask.binaddr[0] == 0; }
00372
00373
00374 bool is_host() const
00375 { return mask.binaddr[3] == 255; }
00376 };
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387 class WvIPPortAddr : public WvIPAddr
00388 {
00389 protected:
00390 virtual WvString printable() const;
00391
00392 public:
00393 __u16 port;
00394
00395 WvIPPortAddr();
00396 WvIPPortAddr(const unsigned char _ipaddr[4], __u16 _port = 0)
00397 : WvIPAddr(_ipaddr), port(_port) { };
00398 WvIPPortAddr(const WvIPAddr &_ipaddr, __u16 _port = 0);
00399 WvIPPortAddr(const char string[]) : WvIPAddr(string)
00400 { string_init(string); }
00401 WvIPPortAddr(WvStringParm string) : WvIPAddr(string)
00402 { string_init(string); }
00403 void string_init(const char string[]);
00404 WvIPPortAddr(__u16 _port);
00405 WvIPPortAddr(const char string[], __u16 _port);
00406
00407 WvIPPortAddr(struct sockaddr_in *sin) : WvIPAddr(sin->sin_addr.s_addr)
00408 { port = ntohs(sin->sin_port); }
00409 virtual ~WvIPPortAddr();
00410
00411 virtual bool comparator(const WvAddr *a2, bool first_pass = true) const;
00412 virtual const char *type() const
00413 { return WVIPPORTADDR; };
00414
00415 virtual struct sockaddr *sockaddr() const;
00416
00417
00418 virtual unsigned WvHash() const;
00419 };
00420
00421 #ifndef _WIN32
00422
00423 class WvUnixAddr : public WvAddr
00424 {
00425 protected:
00426 WvString sockname;
00427 virtual WvString printable() const;
00428
00429 public:
00430 WvUnixAddr(const char *_sockname);
00431 WvUnixAddr(WvStringParm _sockname);
00432 WvUnixAddr(const WvUnixAddr &_addr);
00433 virtual ~WvUnixAddr();
00434
00435 virtual WvEncap encap() const;
00436
00437 virtual struct sockaddr *sockaddr() const;
00438 virtual size_t sockaddr_len() const;
00439 virtual const unsigned char *rawdata() const;
00440 virtual size_t rawdata_len() const;
00441 };
00442
00443 #endif //windows
00444 #endif // __WVADDR_H