1 | #ifndef ENDPOINT_SET_HPP_
|
---|
2 | #define ENDPOINT_SET_HPP_
|
---|
3 |
|
---|
4 | #include "addressing.hpp"
|
---|
5 | #include "tcpip_endpoint.hpp"
|
---|
6 |
|
---|
7 | #include <sstream>
|
---|
8 | #include <boost/unordered_set.hpp>
|
---|
9 | #include <boost/foreach.hpp>
|
---|
10 | #include <boost/thread.hpp>
|
---|
11 |
|
---|
12 | namespace ariba {
|
---|
13 | namespace addressing {
|
---|
14 |
|
---|
15 | using boost::unordered_set;
|
---|
16 |
|
---|
17 | /**
|
---|
18 | * This end-point set shelters known addresses of a device.
|
---|
19 | * Transport protocols use this class to address devices.
|
---|
20 | *
|
---|
21 | * Example of a string representation:
|
---|
22 | * "tcp{500|501};ip{10.11.12.13};bluetooth{01:02:03:04:05:06};rfcomm{1234}"
|
---|
23 | * Inside a address type specification, addresses are separated by a bar (|).
|
---|
24 | *
|
---|
25 | * @author Sebastian Mies <mies@tm.uka.de>
|
---|
26 | */
|
---|
27 | class endpoint_set {
|
---|
28 | public:
|
---|
29 | // layer 2
|
---|
30 | unordered_set<mac_address> bluetooth;
|
---|
31 |
|
---|
32 | // layer 3
|
---|
33 | unordered_set<ip_address> ip;
|
---|
34 |
|
---|
35 | // layer 4
|
---|
36 | unordered_set<tcp_port_address> tcp;
|
---|
37 | unordered_set<rfcomm_channel_address> rfcomm;
|
---|
38 |
|
---|
39 | // mutex
|
---|
40 | boost::mutex io_mutex;
|
---|
41 | typedef boost::mutex::scoped_lock scoped_lock;
|
---|
42 |
|
---|
43 | private:
|
---|
44 | template<uint8_t type, class V>
|
---|
45 | size_t to_bytes_dynamic( const unordered_set<V>& set, uint8_t* bytes ) const {
|
---|
46 | size_t size = 0;
|
---|
47 | bytes[0] = type;
|
---|
48 | uint8_t* size_ptr = bytes+1;
|
---|
49 | bytes +=2;
|
---|
50 | size += 2;
|
---|
51 | BOOST_FOREACH( const V& value, set ) {
|
---|
52 | bytes[0] = (uint8_t)value.to_bytes_size();
|
---|
53 | bytes++;
|
---|
54 | size++;
|
---|
55 | value.to_bytes(bytes);
|
---|
56 | bytes += value.to_bytes_size();
|
---|
57 | size += value.to_bytes_size();
|
---|
58 | }
|
---|
59 | *size_ptr = size-2;
|
---|
60 | return size;
|
---|
61 | }
|
---|
62 |
|
---|
63 | template<class V>
|
---|
64 | void from_bytes_dynamic( unordered_set<V>& set, const uint8_t* bytes, uint8_t size ) {
|
---|
65 | size_t pos = 0;
|
---|
66 | while (pos < size) {
|
---|
67 | uint8_t length = bytes[0];
|
---|
68 | bytes++; pos++;
|
---|
69 | V obj(bytes,length);
|
---|
70 | set.insert(obj);
|
---|
71 | bytes+=length; pos+=length;
|
---|
72 | }
|
---|
73 | }
|
---|
74 |
|
---|
75 | template<uint8_t type, class V>
|
---|
76 | size_t to_bytes_fixed( const unordered_set<V>& set, uint8_t* bytes ) const {
|
---|
77 | size_t fixed_size = V().to_bytes_size();
|
---|
78 | bytes[0] = type;
|
---|
79 | bytes[1] = (uint8_t)(set.size()* fixed_size);
|
---|
80 | bytes+=2;
|
---|
81 | BOOST_FOREACH( const V& value, set ) {
|
---|
82 | value.to_bytes(bytes);
|
---|
83 | bytes += value.to_bytes_size();
|
---|
84 | }
|
---|
85 | return 2 + set.size() * fixed_size;
|
---|
86 | }
|
---|
87 |
|
---|
88 | template<class V>
|
---|
89 | void from_bytes_fixed( unordered_set<V>& set, const uint8_t* bytes, uint8_t size ) {
|
---|
90 | size_t fixed_size = V().to_bytes_size();
|
---|
91 | uint8_t num = size/fixed_size;
|
---|
92 | for (uint8_t i=0; i<num; i++) {
|
---|
93 | V obj(bytes, fixed_size);
|
---|
94 | set.insert(obj);
|
---|
95 | bytes += fixed_size;
|
---|
96 | }
|
---|
97 | }
|
---|
98 |
|
---|
99 | template<class V>
|
---|
100 | std::string to_string_set( const unordered_set<V>& set, const std::string& type ) const {
|
---|
101 | if (set.size()==0) return std::string("");
|
---|
102 | std::ostringstream buf;
|
---|
103 | buf << type << "{";
|
---|
104 | bool first = true;
|
---|
105 | BOOST_FOREACH( const V& value, set ) {
|
---|
106 | if (!first) {
|
---|
107 | buf << " | ";
|
---|
108 | } else
|
---|
109 | first = false;
|
---|
110 | buf << value.to_string();
|
---|
111 | }
|
---|
112 | buf << "};";
|
---|
113 | return buf.str();
|
---|
114 | }
|
---|
115 |
|
---|
116 | static void trim(string& str) {
|
---|
117 | string::size_type pos = str.find_last_not_of(' ');
|
---|
118 | if(pos != string::npos) {
|
---|
119 | str.erase(pos + 1);
|
---|
120 | pos = str.find_first_not_of(' ');
|
---|
121 | if(pos != string::npos) str.erase(0, pos);
|
---|
122 | }
|
---|
123 | else str.erase(str.begin(), str.end());
|
---|
124 | }
|
---|
125 |
|
---|
126 | static string::size_type skip( const char* chars, string::size_type pos, const std::string& str ) {
|
---|
127 | bool found = true;
|
---|
128 | while (pos<str.size() && found) {
|
---|
129 | found = false;
|
---|
130 | for (size_t i=0; chars[i]!=0 && !found; i++)
|
---|
131 | if (str.at(pos)==chars[i]) {
|
---|
132 | pos++;
|
---|
133 | found = true;
|
---|
134 | }
|
---|
135 | }
|
---|
136 | return pos;
|
---|
137 | }
|
---|
138 |
|
---|
139 | template<class V>
|
---|
140 | size_t from_string_set( unordered_set<V>& set, string::size_type pos, const std::string& str ) {
|
---|
141 | while (pos < str.size() && pos != string::npos) {
|
---|
142 | pos = skip("} |\n\r", pos, str);
|
---|
143 | string::size_type nend1 = str.find('}',pos);
|
---|
144 | string::size_type nend2 = str.find('|',pos);
|
---|
145 | if (nend1==string::npos && nend2==string::npos) break;
|
---|
146 | if (nend1==string::npos) nend1=str.size();
|
---|
147 | if (nend2==string::npos) nend2=str.size();
|
---|
148 | string::size_type nend = nend2 < nend1 ? nend2:nend1;
|
---|
149 | std::string sub = str.substr(pos, min(nend2,nend1)-pos);
|
---|
150 | trim(sub);
|
---|
151 | // cout << sub << endl;
|
---|
152 | V obj( sub );
|
---|
153 | set.insert(obj);
|
---|
154 | pos = nend+1;
|
---|
155 | if (nend1<nend2) break;
|
---|
156 | }
|
---|
157 | return pos-1;
|
---|
158 | }
|
---|
159 |
|
---|
160 | public:
|
---|
161 | enum layers {
|
---|
162 | Layer1 = 1, Layer2 = 2, Layer3 = 4, Layer4 = 8, Layer5 = 16,
|
---|
163 | Layer6 = 32, Layer7 = 64, Layer8 = 128, NoLoopback = 256,AllLayers = ~0,
|
---|
164 | Layer1_3 = Layer1|Layer2|Layer3,
|
---|
165 | Layer1_4 = Layer1|Layer2|Layer3|Layer4,
|
---|
166 | };
|
---|
167 |
|
---|
168 | endpoint_set() {
|
---|
169 |
|
---|
170 | }
|
---|
171 |
|
---|
172 | endpoint_set( const endpoint_set& copy ) :
|
---|
173 | bluetooth(copy.bluetooth), ip(copy.ip), tcp(copy.tcp), rfcomm(copy.rfcomm) {
|
---|
174 | }
|
---|
175 |
|
---|
176 | endpoint_set( const std::string& str ) {
|
---|
177 | assign(str);
|
---|
178 | }
|
---|
179 |
|
---|
180 | endpoint_set( const uint8_t* bytes, size_t size ) {
|
---|
181 | assign(bytes, size);
|
---|
182 | }
|
---|
183 |
|
---|
184 | /// adds an address or endpoint to this set
|
---|
185 | void add( const address_v* address, int layers = AllLayers ) {
|
---|
186 | scoped_lock lock(io_mutex);
|
---|
187 | if ( address->instanceof<tcpip_endpoint> () ) {
|
---|
188 | const tcpip_endpoint& addr = *address;
|
---|
189 | if (layers & Layer3 && !(layers & NoLoopback) && addr.is_loopback()) insert( addr.address() );
|
---|
190 | if (layers & Layer4) tcp.insert( addr.port() );
|
---|
191 | } else
|
---|
192 | if ( address->instanceof<ip_address>() ) {
|
---|
193 | const ip_address& addr = *address;
|
---|
194 | if ((layers & Layer3) && !(layers & NoLoopback) && addr.is_loopback())
|
---|
195 | ip.insert( addr );
|
---|
196 | } else
|
---|
197 | if (address->instanceof<rfcomm_endpoint>() ) {
|
---|
198 | const rfcomm_endpoint& endp = *address;
|
---|
199 | if (layers & Layer2) bluetooth.insert( endp.mac() );
|
---|
200 | if (layers & Layer4) rfcomm.insert( endp.channel() );
|
---|
201 | } else
|
---|
202 | if (address->instanceof<mac_address>() ) {
|
---|
203 | const mac_address& endp = *address;
|
---|
204 | if (layers & Layer2) bluetooth.insert( endp );
|
---|
205 | }
|
---|
206 | }
|
---|
207 |
|
---|
208 | /// adds addresses from another endpoint set
|
---|
209 | void add( const endpoint_set& eps, int layers = AllLayers ) {
|
---|
210 | scoped_lock lock(io_mutex);
|
---|
211 |
|
---|
212 | // merge layer 2 addresses
|
---|
213 | if (layers & Layer2) {
|
---|
214 | bluetooth.insert(eps.bluetooth.begin(), eps.bluetooth.end() );
|
---|
215 | }
|
---|
216 |
|
---|
217 | // merge layer 3 addresses
|
---|
218 | if (layers & Layer3) {
|
---|
219 | ip.insert(eps.ip.begin(), eps.ip.end() );
|
---|
220 | }
|
---|
221 |
|
---|
222 | // merge layer 4 addresses
|
---|
223 | if (layers & Layer4) {
|
---|
224 | tcp.insert(eps.tcp.begin(), eps.tcp.end() );
|
---|
225 | rfcomm.insert(eps.rfcomm.begin(), eps.rfcomm.end() );
|
---|
226 | }
|
---|
227 | }
|
---|
228 |
|
---|
229 | /// removes an address or endpoint from this set
|
---|
230 | void remove( const address_vf address ) {
|
---|
231 | scoped_lock lock(io_mutex);
|
---|
232 | if ( address->instanceof<tcpip_endpoint> () ) {
|
---|
233 | const tcpip_endpoint& addr = *address;
|
---|
234 | ip.erase( addr.address() );
|
---|
235 | tcp.erase( addr.port() );
|
---|
236 | } else
|
---|
237 | if ( address->instanceof<ip_address>() ) {
|
---|
238 | const ip_address& addr = *address;
|
---|
239 | ip.erase( addr );
|
---|
240 | } else
|
---|
241 | if (address->instanceof<rfcomm_endpoint>() ) {
|
---|
242 | const rfcomm_endpoint& endp = *address;
|
---|
243 | bluetooth.erase( endp.mac() );
|
---|
244 | rfcomm.erase( endp.channel() );
|
---|
245 | }
|
---|
246 | }
|
---|
247 |
|
---|
248 | /// checks whether two end-points are disjoint
|
---|
249 | /// (only check lower level addresses)
|
---|
250 | bool disjoint_to( const endpoint_set& set ) const {
|
---|
251 | scoped_lock lock(const_cast<boost::mutex&>(io_mutex));
|
---|
252 | BOOST_FOREACH( const mac_address& mac, bluetooth )
|
---|
253 | if (set.bluetooth.count(mac) !=0 ) return false;
|
---|
254 | BOOST_FOREACH( const ip_address& ip_, ip )
|
---|
255 | if (set.ip.count(ip_) !=0 ) return false;
|
---|
256 | return true;
|
---|
257 | }
|
---|
258 |
|
---|
259 | bool intersects_with( const endpoint_set& set ) const {
|
---|
260 | return !disjoint_to(set);
|
---|
261 | }
|
---|
262 |
|
---|
263 | bool is_subset_of( const endpoint_set& set ) const {
|
---|
264 | throw "Not implemented!";
|
---|
265 | return false;
|
---|
266 | }
|
---|
267 |
|
---|
268 | /// returns true, if this address has a fixed size in bytes
|
---|
269 | bool is_bytes_size_static() const {
|
---|
270 | return false;
|
---|
271 | }
|
---|
272 |
|
---|
273 | /// returns the number of bytes used for serialization of this address
|
---|
274 | size_t to_bytes_size() const {
|
---|
275 | scoped_lock lock(const_cast<boost::mutex&>(io_mutex));
|
---|
276 | size_t size = 0;
|
---|
277 |
|
---|
278 | // bluetooth mac list (layer 2)
|
---|
279 | size += bluetooth.size() * mac_address().to_bytes_size();
|
---|
280 |
|
---|
281 | // ip list (layer 3)
|
---|
282 | BOOST_FOREACH( const ip_address& ip_, ip )
|
---|
283 | size += (ip_.to_bytes_size() + 1 /* =length */);
|
---|
284 |
|
---|
285 | // tcp ports (layer 4)
|
---|
286 | size += tcp.size() * tcp_port_address().to_bytes_size();
|
---|
287 |
|
---|
288 | // bluetooth rfcomm channels (layer 4)
|
---|
289 | size += rfcomm.size() * rfcomm_channel_address().to_bytes_size();
|
---|
290 |
|
---|
291 | // length/type encoding
|
---|
292 | size += 4 /* number of items*/ * 2 /* length of type and length */;
|
---|
293 |
|
---|
294 | return size;
|
---|
295 | }
|
---|
296 |
|
---|
297 | /// converts this address to a binary representation
|
---|
298 | void to_bytes(uint8_t* bytes) const {
|
---|
299 | scoped_lock lock(const_cast<boost::mutex&>(io_mutex));
|
---|
300 |
|
---|
301 | /// bluetooth mac list (layer 2)
|
---|
302 | bytes += to_bytes_fixed<0x21, mac_address>( bluetooth, bytes );
|
---|
303 |
|
---|
304 | // ip list (layer 3)
|
---|
305 | bytes += to_bytes_dynamic<0x31, ip_address>(ip, bytes);
|
---|
306 |
|
---|
307 | // tcp ports (layer 4)
|
---|
308 | bytes += to_bytes_fixed<0x41, tcp_port_address>( tcp, bytes );
|
---|
309 |
|
---|
310 | // rfcomm channels (layer 4)
|
---|
311 | bytes += to_bytes_fixed<0x42, rfcomm_channel_address>( rfcomm, bytes );
|
---|
312 | }
|
---|
313 |
|
---|
314 | /// Assigns an address using a bunch of bytes
|
---|
315 | bool assign(const uint8_t* bytes, size_t size) {
|
---|
316 | scoped_lock lock(io_mutex);
|
---|
317 |
|
---|
318 | size_t pos = 0;
|
---|
319 | while (pos < size) {
|
---|
320 | uint8_t type = bytes[0];
|
---|
321 | uint8_t length = bytes[1];
|
---|
322 | bytes+=2; pos+=2;
|
---|
323 |
|
---|
324 | switch (type) {
|
---|
325 |
|
---|
326 | // bluetooth mac
|
---|
327 | case 0x21: {
|
---|
328 | from_bytes_fixed<mac_address>( bluetooth, bytes, length );
|
---|
329 | break;
|
---|
330 | }
|
---|
331 |
|
---|
332 | // ip
|
---|
333 | case 0x31: {
|
---|
334 | from_bytes_dynamic<ip_address>( ip, bytes, length );
|
---|
335 | break;
|
---|
336 | }
|
---|
337 | // tcp
|
---|
338 | case 0x41: {
|
---|
339 | from_bytes_fixed<tcp_port_address>( tcp, bytes, length );
|
---|
340 | break;
|
---|
341 | }
|
---|
342 | // rfcomm
|
---|
343 | case 0x42: {
|
---|
344 | from_bytes_fixed<rfcomm_channel_address>( rfcomm, bytes, length );
|
---|
345 | break;
|
---|
346 | }
|
---|
347 |
|
---|
348 | default: {
|
---|
349 | pos = size;
|
---|
350 | break;
|
---|
351 | }
|
---|
352 | }
|
---|
353 | bytes += length; pos+=length;
|
---|
354 | }
|
---|
355 | return false;
|
---|
356 | }
|
---|
357 |
|
---|
358 | /// generates a string out of this endpoint-set
|
---|
359 | std::string to_string() const {
|
---|
360 | scoped_lock lock(const_cast<boost::mutex&>(io_mutex));
|
---|
361 | std::string smac = to_string_set<mac_address>(bluetooth, "bluetooth");
|
---|
362 | std::string sip = to_string_set<ip_address>(ip, "ip");
|
---|
363 | std::string stcp = to_string_set<tcp_port_address>(tcp, "tcp");
|
---|
364 | std::string srfcomm = to_string_set<rfcomm_channel_address>(rfcomm, "rfcomm");
|
---|
365 | return smac+sip+stcp+srfcomm;
|
---|
366 | }
|
---|
367 |
|
---|
368 | /// assigns an endpoint-set out of a string
|
---|
369 | void assign( const std::string& str ) {
|
---|
370 | scoped_lock lock(io_mutex);
|
---|
371 | string::size_type pos = 0;
|
---|
372 | while (pos < str.size() && pos!=string::npos) {
|
---|
373 | pos = skip("}; \n\r", pos, str );
|
---|
374 | string::size_type nend = str.find('{',pos);
|
---|
375 | if (nend == string::npos) break;
|
---|
376 | std::string type = str.substr(pos,nend-pos);
|
---|
377 | pos = nend+1;
|
---|
378 | trim(type);
|
---|
379 | if (type=="bluetooth")
|
---|
380 | pos = from_string_set<mac_address>(bluetooth, pos, str );
|
---|
381 | else if (type=="ip")
|
---|
382 | pos = from_string_set<ip_address>(ip, pos, str );
|
---|
383 | else if (type=="tcp")
|
---|
384 | pos = from_string_set<tcp_port_address>(tcp, pos, str );
|
---|
385 | else if (type=="rfcomm")
|
---|
386 | pos = from_string_set<rfcomm_channel_address>(rfcomm, pos, str );
|
---|
387 | else
|
---|
388 | pos = str.find('}',pos);
|
---|
389 | }
|
---|
390 | }
|
---|
391 |
|
---|
392 | endpoint_set& operator=( const endpoint_set& rhs ) {
|
---|
393 | scoped_lock lock(io_mutex);
|
---|
394 | this->bluetooth = rhs.bluetooth;
|
---|
395 | this->ip = rhs.ip;
|
---|
396 | this->rfcomm = rhs.rfcomm;
|
---|
397 | this->tcp = rhs.tcp;
|
---|
398 | }
|
---|
399 |
|
---|
400 | /// checks wheter the two endpoint sets are identical
|
---|
401 | bool operator== ( const endpoint_set& rhs ) const {
|
---|
402 | return (rhs.rfcomm == rfcomm && rhs.ip == ip && rhs.tcp == tcp &&
|
---|
403 | rhs.bluetooth == bluetooth);
|
---|
404 | }
|
---|
405 |
|
---|
406 | bool operator!= ( const endpoint_set& rhs ) const {
|
---|
407 | return !(*this==rhs);
|
---|
408 | }
|
---|
409 | };
|
---|
410 |
|
---|
411 | }} // namespace ariba::addressing
|
---|
412 |
|
---|
413 | #endif /* ENDPOINT_SET_HPP_ */
|
---|