1 // Copyright (C) 1999-2005 Open Source Telecom Corporation.
2 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
3 //
4 // This program is free software; you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation; either version 2 of the License, or
7 // (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with this program; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 //
18 // As a special exception, you may use this file as part of a free software
19 // library without restriction. Specifically, if other files instantiate
20 // templates or use macros or inline functions from this file, or you compile
21 // this file and link it with other files to produce an executable, this
22 // file does not by itself cause the resulting executable to be covered by
23 // the GNU General Public License. This exception does not however
24 // invalidate any other reasons why the executable file might be covered by
25 // the GNU General Public License.
26 //
27 // This exception applies only to the code released under the name GNU
28 // Common C++. If you copy code from other releases into a copy of GNU
29 // Common C++, as the General Public License permits, the exception does
30 // not apply to the code that you add in this way. To avoid misleading
31 // anyone as to the status of such modified files, you must delete
32 // this exception notice from them.
33 //
34 // If you write modifications of your own for GNU Common C++, it is your choice
35 // whether to permit this exception to apply to your modifications.
36 // If you do not wish that, delete this exception notice.
37 //
38
44 #ifndef CCXX_ADDRESS_H_
45 #define CCXX_ADDRESS_H_
46
47 #ifndef CCXX_CONFIG_H_
48 #include <cc++/config.h>
49 #endif
50
51 #ifndef CCXX_MISSING_H_
53 #endif
54
55 #ifndef CCXX_THREAD_H_
57 #endif
58
59 #ifndef CCXX_EXCEPTION_H_
61 #endif
62
63 #ifdef CCXX_NAMESPACES
64 namespace ost {
65 #endif
66
67 // future definition of ipv4 specific classes, now defines
68
69 #define INET_IPV4_ADDRESS_SIZE 16
70 #define CIDR_IPV4_ADDRESS_SIZE 32
71 #define INET_IPV6_ADDRESS_SIZE 40
72 #define CIDR_IPV6_ADDRESS_SIZE 45
73
75 #define InetAddress IPV4Address
76 #define InetHostAddress IPV4Host
77 #define InetMaskAddress IPV4Mask
78 #define InetMcastAddress IPV4Multicast
79 #define InetMcastAddressValidator IPV4MulticastValidator
80 #define InetAddrValidator IPV4Validator
81 #define BroadcastAddress IPV4Broadcast
82
87
89
99 {
100 public:
105
110
115 virtual void
116 operator()(const in_addr address) const = 0;
117 };
118
128 {
129 public:
134
139
144 void operator()(const in_addr address) const;
145 private:
146 #if __BYTE_ORDER == __BIG_ENDIAN
147 enum {
148 MCAST_VALID_MASK = 0xF0000000,
149 MCAST_VALID_VALUE = 0xE0000000
150 };
151 #else
152 enum {
153 MCAST_VALID_MASK = 0x000000F0,
154 MCAST_VALID_VALUE = 0x000000E0
155 };
156 #endif
157 };
158
167 {
168 protected:
169 struct in_addr netmask, network;
170
171 unsigned getMask(const char *cp) const;
172 public:
178 inline struct in_addr getNetwork(void) const
179 {return network;};
180
186 inline struct in_addr getNetmask(void) const
187 {return netmask;};
188
194 struct in_addr getBroadcast(void) const;
195
202 void set(const char *cidr);
203
210
215
222
229 bool isMember(const struct sockaddr *saddr) const;
230
237 bool isMember(const struct in_addr &inaddr) const;
238
240 {return isMember(a);};
241
243 {return isMember(a);};
244 };
245
246 #ifdef CCXX_IPV6
247
255 {
256 protected:
257 struct in6_addr netmask, network;
258
259 unsigned getMask(const char *cp) const;
260 public:
266 inline struct in6_addr getNetwork(void) const
267 {return network;};
268
274 inline struct in6_addr getNetmask(void) const
275 {return netmask;};
276
282 struct in6_addr getBroadcast(void) const;
283
290 void set(const char *cidr);
291
297 IPV6Cidr(const char *cidr);
298
302 IPV6Cidr();
303
309 IPV6Cidr(IPV6Cidr &);
310
317 bool isMember(const struct sockaddr *saddr) const;
318
325 bool isMember(const struct in6_addr &inaddr) const;
326
327 inline bool operator==(const struct sockaddr *sa) const
328 {return isMember(sa);};
329
330 inline bool operator==(const struct in6_addr &a) const
331 {return isMember(a);};
332 };
333
334 #endif
335
351 {
352 private:
353 // The validator given to an IPV4Address object must not be a
354 // transient object, but that must exist at least until the
355 // last address object of its kind is deleted. This is an
356 // artifact to be able to do specific checks for derived
357 // classes inside constructors.
359
360 protected:
363 mutable char*
hostname;
// hostname for ipaddr[0]. Used by getHostname
364 #if defined(WIN32)
366 #else
368 #endif
369
376 bool setIPAddress(const char *host);
377
384 void setAddress(const char *host);
385
386 public:
395
405
417
422
427
434 const char *getHostname(void) const;
435
443 bool isInetAddress(void) const;
444
452 struct in_addr getAddress(void) const;
453
465 struct in_addr getAddress(size_t i) const;
466
473
477
483
485 {return *this = (unsigned long) addr; }
486
488 {return !isInetAddress();};
489
499
508 };
509
523 {
524 public:
532
545
552 };
553
562 {
563 private:
565
566 public:
580
589
596
602
606 };
607
613 {
614 public:
623 };
624
635 {
636 public:
642
650
661
662 private:
671 };
672
674
676 {return ia.getAddress();}
677
678
679 #ifdef CCXX_IPV6
680
682
692 {
693 public:
697 IPV6Validator() { };
698
702 virtual ~IPV6Validator() {};
703
708 virtual void operator()(const in6_addr address) const = 0;
709 };
710
719 class __EXPORT IPV6MulticastValidator:
public IPV6Validator
720 {
721 public:
725 IPV6MulticastValidator(){};
726
730 virtual ~IPV6MulticastValidator(){};
731
736 void operator()(const in6_addr address) const;
737 };
738
754 {
755 private:
756 // The validator given to an IPV4Address object must not be a
757 // transient object, but that must exist at least until the
758 // last address object of its kind is deleted. This is an
759 // artifact to be able to do specific checks for derived
760 // classes inside constructors.
761 const IPV6Validator *validator;
762
763 protected:
764 struct in6_addr * ipaddr;
765 size_t addr_count;
766 mutable char* hostname; // hostname for ipaddr[0]. Used by getHostname
767 #if defined(WIN32)
769 #else
771 #endif
772
779 bool setIPAddress(const char *host);
780
787 void setAddress(const char *host);
788
789 public:
797 IPV6Address(const IPV6Validator *validator = NULL);
798
807 IPV6Address(struct in6_addr addr, const IPV6Validator *validator = NULL);
808
819 IPV6Address(const char *address, const IPV6Validator *validator = NULL);
820
824 IPV6Address(const IPV6Address &rhs);
825
829 virtual ~IPV6Address();
830
837 const char *getHostname(void) const;
838
846 bool isInetAddress(void) const;
847
855 struct in6_addr getAddress(void) const;
856
868 struct in6_addr getAddress(size_t i) const;
869
875 size_t getAddressCount() const { return addr_count; }
876
877 IPV6Address &operator=(const char *str);
878 IPV6Address &operator=(struct in6_addr addr);
879 IPV6Address &operator=(const IPV6Address &rhs);
880
881 inline bool operator!() const
882 {return !isInetAddress();};
883
892 bool operator==(const IPV6Address &a) const;
893
901 bool operator!=(const IPV6Address &a) const;
902 };
903
916 class __EXPORT IPV6Mask :
public IPV6Address
917 {
918 public:
925 IPV6Mask(const char *mask);
926
937 friend __EXPORT IPV6Host operator&(
const IPV6Host &addr,
938 const IPV6Mask &mask);
939 };
940
948 class __EXPORT IPV6Host :
public IPV6Address
949 {
950 public:
963 IPV6Host(const char *host = NULL);
964
972 IPV6Host(struct in6_addr addr);
973
978 IPV6Host &operator&=(const IPV6Mask &mask);
979
981 friend __EXPORT IPV6Host operator&(
const IPV6Host &addr,
const IPV6Mask &mask);
982 };
983
988 class __EXPORT IPV6Broadcast :
public IPV6Address
989 {
990 public:
998 IPV6Broadcast(const char *net = "255.255.255.255");
999 };
1000
1010 class __EXPORT IPV6Multicast:
public IPV6Address
1011 {
1012 public:
1017 IPV6Multicast();
1018
1025 IPV6Multicast(const struct in6_addr address);
1026
1036 IPV6Multicast(const char *address);
1037
1038 private:
1046 static const IPV6MulticastValidator validator;
1047 };
1048
1050
1051 inline struct in6_addr
getaddress(const IPV6Address &ia)
1052 {return ia.getAddress();}
1053
1054
1055 #endif
1056
1057 #ifdef CCXX_NAMESPACES
1058 }
1059 #endif
1060
1061 #endif
1062
virtual ~IPV4MulticastValidator()
Keeps compilers happy.
IPV4Address & operator=(const char *str)
Internet addresses used specifically as masking addresses (such as " 255.255.255.0") are held in the ...
unsigned short tpport_t
Transport Protocol Ports.
substitute functions which may be missing in target platform libc.
The Mutex class is used to protect a section of code so that at any given time only a single thread c...
IPV4Address & operator=(unsigned int addr)
GNU Common C++ exception model base classes.
The Mutex Counter is a counter variable which can safely be incremented or decremented by multiple th...
Synchronization and threading services.
The broadcast address object is used to store the broadcast address for a specific subnet...
__EXPORT std::ostream & operator<<(std::ostream &os, const IPV4Address &ia)
Classes derived from IPV4Address would require an specific validator to pass to the IPV4Address const...
static const IPV4MulticastValidator validator
Check the address in addr is a valid multicast address.
IPV4Address & operator=(unsigned long addr)
Allows assignment from the return of functions like inet_addr() or htonl()
bool operator==(const struct sockaddr *a) const
size_t getAddressCount() const
Returns the number of internet addresses that an IPV4Address object contains.
Class for the function object that validates multicast addresses.
IPV4MulticastValidator()
Constructor.
bool operator==(const struct in_addr &a) const
struct in_addr getaddress(const IPV4Address &ia)
virtual ~IPV4Validator()
keeps compilers happy.
IPV4Validator()
Constructor.
A specialization of IPV4Address that provides address validation for multicast addresses.
The CIDR class is used to support routing tables and validate address policies.
This object is used to hold the actual and valid internet address of a specific host machine that wil...
The network name and address objects are all derived from a common IPV4Address base class...
const IPV4Validator * validator
#define InetAddrValidator
IPV4Address & operator=(unsigned long addr)
Allows assignment from the return of functions like inet_addr() or htonl()