An Overlay-based
Virtual Network Substrate
SpoVNet

source: source/ariba/utility/addressing/ip_address.hpp @ 9992

Last change on this file since 9992 was 6919, checked in by mies, 14 years ago

Fixed tons of warnings when using CXXFLAGS="-Wall"!

File size: 5.0 KB
Line 
1#ifndef IP_ADDRESS_HPP_
2#define IP_ADDRESS_HPP_
3
4#include <string>
5#include <boost/tr1/functional.hpp>
6#include <boost/asio/ip/address.hpp>
7
8#include "detail/address_convenience.hpp"
9
10namespace ariba {
11namespace addressing {
12
13using boost::asio::ip::address;
14using boost::asio::ip::address_v4;
15using boost::asio::ip::address_v6;
16
17/**
18 * TODO: Doc
19 *
20 * @author Sebastian Mies <mies@tm.uka.de>
21 */
22class ip_address: public detail::address_convenience<ip_address> {
23private:
24        address addr;
25        static const std::string type_name_ip;
26
27public:
28        ip_address() : addr() {
29        }
30
31        ip_address(const ip_address& copy) : addr(copy.addr) {
32        }
33
34        ip_address(const address& addr) : addr(addr) {
35
36        }
37
38        ip_address(const address_v4& addr) : addr(addr) {
39
40        }
41
42        ip_address(const address_v6& addr) : addr(addr) {
43
44        }
45
46        ip_address(const std::string& text) {
47                assign(text);
48        }
49
50        ip_address(const char* text) {
51                assign(std::string(text));
52        }
53
54        ip_address(const uint8_t* bytes, size_t size) {
55                assign(bytes, size);
56        }
57
58        //--- compare operations --------------------------------------------------
59
60        /// implements comparison operators
61        int compare_to(const ip_address& rhs) const {
62                if (addr == rhs.addr) return 0;
63                if (addr < rhs.addr) return -1; else return 1;
64        }
65
66        //--- byte representation -------------------------------------------------
67
68        /// returns true, if this address has a fixed size in bytes
69        bool is_bytes_size_static() const {
70                return false;
71        }
72
73        /// returns the number of bytes used for serialization of this address
74        size_t to_bytes_size() const {
75                return addr.is_v4() ? 4 : 16;
76        }
77
78        /// converts this address to a binary representation
79        void to_bytes(uint8_t* bytes) const {
80                if (addr.is_v4()) {
81                        address_v4::bytes_type bytes_ = addr.to_v4().to_bytes();
82                        for (size_t i=0; i<bytes_.size(); i++) bytes[i] = bytes_[i];
83                } else {
84                        address_v6::bytes_type bytes_ = addr.to_v6().to_bytes();
85                        for (size_t i=0; i<bytes_.size(); i++) bytes[i] = bytes_[i];
86                }
87        }
88
89        /// Assigns an address using a bunch of bytes
90        bool assign(const uint8_t* bytes, size_t size) {
91                if (size == 4) {
92                        address_v4::bytes_type bytes_;
93                        for (size_t i=0; i<bytes_.size(); i++) bytes_[i] = bytes[i];
94                        addr = address_v4(bytes_);
95                        return false;
96                } else
97                if (size == 16) {
98                        address_v6::bytes_type bytes_;
99                        for (size_t i=0; i<bytes_.size(); i++) bytes_[i] = bytes[i];
100                        addr = address_v6(bytes_);
101                        return false;
102                }
103                return true;
104        }
105
106        //--- string representation -----------------------------------------------
107
108        /// convert address to a string that can be used to reconstruct the address
109        std::string to_string() const {
110                if (addr.is_v6() && (addr.to_v6().is_v4_compatible()
111                        || addr.to_v6().is_v4_mapped()))
112                        return addr.to_v6().to_v4().to_string();
113                return addr.to_string();
114        }
115
116        /// Assigns an address using a human-readable
117        bool assign(const std::string& text) {
118                addr = address::from_string(text);
119                return false;
120        }
121
122        //--- assignment ----------------------------------------------------------
123
124        /// Assigns an address
125        bool assign(const ip_address& rhs) {
126                addr = rhs.addr;
127                return false;
128        }
129
130        //--- address info --------------------------------------------------------
131
132        static const std::string& type_name() {
133                return type_name_ip;
134        }
135
136        static const uint16_t type_id() {
137                return 0x81DD;
138        }
139
140        //--- address delegates ---------------------------------------------------
141
142        bool is_multicast() const {
143                if (addr.is_v4()) return addr.to_v4().is_multicast();
144                return addr.to_v6().is_multicast();
145        }
146
147        bool is_loopback() const {
148                if (addr.is_v4()) return addr.to_v4() == address_v4::loopback();
149                return addr.to_v6().is_loopback();
150        }
151
152        bool is_link_local() const {
153                if (addr.is_v4()) return false;
154                return addr.to_v6().is_link_local();
155        }
156
157        bool is_multicast_link_local() const {
158                if (addr.is_v4()) return false;
159                return addr.to_v6().is_multicast_link_local();
160
161        }
162
163        bool is_multicast_node_local() const {
164                if (addr.is_v4()) return false;
165                return addr.to_v6().is_multicast_node_local();
166        }
167
168        bool is_multicast_site_local() const {
169                if (addr.is_v4()) return false;
170                return addr.to_v6().is_multicast_site_local();
171        }
172
173        bool is_any() const {
174                if (addr.is_v4()) return addr.to_v4() == address_v4::any();
175                return addr.to_v6() == address_v6::any();
176        }
177
178        bool is_v4_compatible() const {
179                if (addr.is_v4()) return true;
180                return addr.to_v6().is_v4_compatible();
181        }
182
183        bool is_v4_mapped() {
184                if (addr.is_v4()) return true;
185                return addr.to_v6().is_v4_mapped();
186        }
187
188        bool is_v4() const {
189                return addr.is_v4();
190        }
191
192        bool is_v6() const {
193                return addr.is_v6();
194        }
195
196        //--- address conversions -------------------------------------------------
197
198        const address& asio() const {
199                return addr;
200        }
201
202        void asio( const address& addr ) {
203                this->addr = addr;
204        }
205};
206
207}} // namespace ariba::addressing
208
209namespace boost {
210
211// boost hash function
212template<>
213struct hash<ariba::addressing::ip_address>: public std::unary_function<ariba::addressing::ip_address, std::size_t> {
214        std::size_t operator()(const ariba::addressing::ip_address& ep) const {
215                return hash_value(ep.to_string());
216        }
217};
218
219}
220
221
222#endif /* IP_ADDRESS_HPP_ */
Note: See TracBrowser for help on using the repository browser.