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