00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef __WVADDR_H
00010 #define __WVADDR_H
00011
00012 #include "wvstring.h"
00013
00014 #ifndef ISLINUX
00015 #ifndef ISBSD
00016 #define ISLINUX
00017 #endif
00018 #endif
00019
00020 #ifdef ISLINUX
00021 #include <linux/if_ether.h>
00022 #endif
00023
00024 #ifdef ISBSD
00025 #include <sys/param.h>
00026 #include <sys/socket.h>
00027 #include <net/if_arp.h>
00028 #include <netinet/in_systm.h>
00029 #include <net/ethernet.h>
00030 #define ETH_ALEN ETHER_ADDR_LEN
00031 #endif
00032
00033 #include <netinet/in.h>
00034
00035 typedef unsigned int __u32;
00036 typedef short unsigned int __u16;
00037
00043 class WvEncap
00044 {
00045 static char strings[][20];
00046 static int extypes[];
00047 public:
00048
00049
00050 enum CapType {
00051
00052 Unknown = 0,
00053 Loopback,
00054 Ethertap,
00055 Ethernet,
00056 ARCnet,
00057 SLIP,
00058 CSLIP,
00059 PPP,
00060
00061
00062 IPv4,
00063 Unix,
00064
00065
00066 NUM_ENCAP_TYPES
00067 };
00068 CapType cap;
00069
00070 WvEncap(CapType _cap = Unknown)
00071 { cap = _cap; }
00072
00073 WvEncap(int extype);
00074
00075 operator CapType () const
00076 { return cap; }
00077
00078 operator WvString () const
00079 { return strings[cap]; }
00080 };
00081
00082
00088 class WvAddr
00089 {
00090 protected:
00091 virtual WvString printable() const = 0;
00092 const char *addrtype;
00093
00094 public:
00095 WvAddr();
00096 virtual ~WvAddr();
00097 static WvAddr *gen(struct sockaddr *addr);
00098
00099 virtual WvEncap encap() const = 0;
00100 operator WvString() const
00101 { return printable(); }
00102
00103 virtual bool isbroadcast() const;
00104
00105 virtual struct sockaddr *sockaddr() const = 0;
00106 virtual size_t sockaddr_len() const = 0;
00107 virtual const unsigned char *rawdata() const;
00108 virtual size_t rawdata_len() const;
00109
00110 virtual unsigned WvHash() const;
00111 virtual bool comparator(const WvAddr *a2) const;
00112
00113 bool operator== (const WvAddr &a2) const
00114 { return addrtype == a2.addrtype && comparator(&a2); }
00115 bool operator!= (const WvAddr &a2) const
00116 { return ! (*this == a2); }
00117 };
00118
00119
00120
00121 unsigned WvHash(const WvAddr &addr);
00122
00123
00128 class WvStringAddr : public WvAddr
00129 {
00130 WvString addr;
00131 WvEncap cap;
00132
00133 protected:
00134 virtual WvString printable() const;
00135
00136 public:
00137 WvStringAddr(const WvString &s, const WvEncap &_cap);
00138 WvStringAddr(const struct sockaddr *_addr);
00139 virtual ~WvStringAddr();
00140 virtual WvEncap encap() const;
00141 virtual struct sockaddr *sockaddr() const;
00142 virtual size_t sockaddr_len() const;
00143 virtual const unsigned char *rawdata() const;
00144 virtual size_t rawdata_len() const;
00145 };
00146
00147
00152 class WvEtherAddr : public WvAddr
00153 {
00154 unsigned char binaddr[ETH_ALEN];
00155
00156 protected:
00157 virtual WvString printable() const;
00158
00159 public:
00160 WvEtherAddr(const unsigned char _binaddr[ETH_ALEN] = NULL)
00161 { if (_binaddr) memcpy(binaddr, _binaddr, ETH_ALEN); }
00162 WvEtherAddr(const char string[])
00163 { string_init(string); }
00164 WvEtherAddr(const WvString &string)
00165 { string_init(string); }
00166 void string_init(const char string[]);
00167 WvEtherAddr(const struct sockaddr *addr)
00168 { memcpy(binaddr, (void *)addr->sa_data, ETH_ALEN); }
00169 virtual ~WvEtherAddr();
00170
00171 virtual WvEncap encap() const;
00172 virtual bool isbroadcast() const;
00173 virtual struct sockaddr *sockaddr() const;
00174 virtual size_t sockaddr_len() const;
00175 virtual const unsigned char *rawdata() const;
00176 virtual size_t rawdata_len() const;
00177 };
00178
00179
00183 class WvARCnetAddr : public WvAddr
00184 {
00185 unsigned char binaddr;
00186
00187 protected:
00188 virtual WvString printable() const;
00189
00190 public:
00191 WvARCnetAddr(const unsigned char _binaddr[1] = NULL)
00192 { if (_binaddr) binaddr = _binaddr[0]; }
00193 WvARCnetAddr(const char string[])
00194 { binaddr = strtoul(string, NULL, 16); }
00195 WvARCnetAddr(const WvString &string)
00196 { binaddr = strtoul(string, NULL, 16); }
00197 WvARCnetAddr(const struct sockaddr *addr)
00198 { binaddr = ((unsigned char *)addr->sa_data)[0]; }
00199 virtual ~WvARCnetAddr();
00200
00201 virtual WvEncap encap() 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
00217 class WvIPAddr : public WvAddr
00218 {
00219 protected:
00220 virtual WvString printable() const;
00221 public:
00222 unsigned char binaddr[4];
00223
00224 WvIPAddr(const unsigned char _binaddr[4])
00225 { if (_binaddr) memcpy(binaddr, _binaddr, 4); }
00226 WvIPAddr(const __u32 _binaddr = 0)
00227 { memcpy(binaddr, &_binaddr, 4); }
00228 WvIPAddr(const char string[])
00229 { string_init(string); }
00230 WvIPAddr(const WvString &string)
00231 { string_init(string); }
00232 void string_init(const char string[]);
00233 WvIPAddr(const struct sockaddr *addr)
00234 { memcpy(binaddr,
00235 (void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, 4); }
00236 WvIPAddr(const WvIPAddr &_addr)
00237 { memcpy(binaddr, _addr.binaddr, 4); }
00238 virtual ~WvIPAddr();
00239
00240 WvIPAddr operator& (const WvIPAddr &a2) const;
00241 WvIPAddr operator| (const WvIPAddr &a2) const;
00242 WvIPAddr operator^ (const WvIPAddr &a2) const;
00243 WvIPAddr operator~ () const;
00244 WvIPAddr operator+ (int n) const;
00245 WvIPAddr operator- (int n) const;
00246 __u32 s_addr() const
00247 { return *(__u32 *)binaddr; }
00248
00249 virtual WvEncap encap() const;
00250
00251 virtual struct sockaddr *sockaddr() const;
00252 virtual size_t sockaddr_len() const;
00253 virtual const unsigned char *rawdata() const;
00254 virtual size_t rawdata_len() const;
00255 };
00256
00257
00272 class WvIPNet : public WvIPAddr
00273 {
00274 protected:
00275 WvIPAddr mask;
00276 virtual WvString printable() const;
00277
00278 public:
00279 WvIPNet(const WvIPNet &_net);
00280 WvIPNet(const char string[]) : WvIPAddr(string)
00281 { string_init(string); }
00282 WvIPNet(const WvString &string) : WvIPAddr(string)
00283 { string_init(string); }
00284 void string_init(const char string[]);
00285 WvIPNet(const WvIPAddr &base, const WvIPAddr &_mask);
00286
00292 WvIPNet(const WvIPAddr &base, int bits = 32);
00293
00297 WvIPNet();
00298
00299 virtual ~WvIPNet();
00300
00304 virtual unsigned WvHash() const;
00305 virtual bool comparator(const WvAddr *a2) const;
00306
00310 WvIPAddr base() const
00311 { return WvIPAddr(binaddr); }
00312 const WvIPAddr &netmask() const
00313 { return mask; }
00314 WvIPAddr network() const
00315 { return *this & mask; }
00316 WvIPAddr broadcast() const
00317 { return *this | ~mask; }
00318
00322 void include(const WvIPNet &addr);
00323
00327 bool includes(const WvIPNet &addr) const;
00328
00339 int bits() const;
00340 void normalize();
00341
00345 bool is_default() const
00346 { return mask.binaddr[0] == 0; }
00347
00351 bool is_host() const
00352 { return mask.binaddr[3] == 255; }
00353 };
00354
00355
00356
00364 class WvIPPortAddr : public WvIPAddr
00365 {
00366 protected:
00367 virtual WvString printable() const;
00368 public:
00369 __u16 port;
00370
00371 WvIPPortAddr();
00372 WvIPPortAddr(const unsigned char _ipaddr[4], __u16 _port = 0);
00373 WvIPPortAddr(const WvIPAddr &_ipaddr, __u16 _port = 0);
00374 WvIPPortAddr(const char string[]) : WvIPAddr(string)
00375 { string_init(string); }
00376 WvIPPortAddr(const WvString &string) : WvIPAddr(string)
00377 { string_init(string); }
00378 void string_init(const char string[]);
00379 WvIPPortAddr(__u16 _port);
00380 WvIPPortAddr(const char string[], __u16 _port);
00381
00382 WvIPPortAddr(struct sockaddr_in *sin) : WvIPAddr(sin->sin_addr.s_addr)
00383 { port = ntohs(sin->sin_port); }
00384 virtual ~WvIPPortAddr();
00385
00386 virtual struct sockaddr *sockaddr() const;
00387
00388
00389 virtual unsigned WvHash() const;
00390 virtual bool comparator(const WvAddr *a2) const;
00391 };
00392
00393
00397 class WvUnixAddr : public WvAddr
00398 {
00399 protected:
00400 WvString sockname;
00401 virtual WvString printable() const;
00402
00403 public:
00404 WvUnixAddr(const char *_sockname);
00405 WvUnixAddr(const WvString &_sockname);
00406 WvUnixAddr(const WvUnixAddr &_addr);
00407 virtual ~WvUnixAddr();
00408
00409 virtual WvEncap encap() const;
00410
00411 virtual struct sockaddr *sockaddr() const;
00412 virtual size_t sockaddr_len() const;
00413 virtual const unsigned char *rawdata() const;
00414 virtual size_t rawdata_len() const;
00415 };
00416
00417
00418 #endif // __WVADDR_H