source: source/ariba/utility/transport/tcpip/protlib/address.h@ 9323

Last change on this file since 9323 was 7026, checked in by Christoph Mayer, 15 years ago

-fehlerhaften string entfernt
File size: 36.4 KB
Line 
1/// ----------------------------------------*- mode: C++; -*--
2/// @file address.h
3/// GIST address objects
4/// ----------------------------------------------------------
5/// $Id: address.h 3063 2008-07-02 08:02:45Z bless $
6/// $HeadURL: https://svn.ipv6.tm.uka.de/nsis/protlib/trunk/include/address.h $
7// ===========================================================
8//
9// Copyright (C) 2005-2007, all rights reserved by
10// - Institute of Telematics, Universitaet Karlsruhe (TH)
11//
12// More information and contact:
13// https://projekte.tm.uka.de/trac/NSIS
14//
15// This program is free software; you can redistribute it and/or modify
16// it under the terms of the GNU General Public License as published by
17// the Free Software Foundation; version 2 of the License
18//
19// This program is distributed in the hope that it will be useful,
20// but WITHOUT ANY WARRANTY; without even the implied warranty of
21// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22// GNU General Public License for more details.
23//
24// You should have received a copy of the GNU General Public License along
25// with this program; if not, write to the Free Software Foundation, Inc.,
26// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27//
28// ===========================================================
29/** @ingroup ieaddress
30 *
31 * GIST address objects
32 */
33
34#ifndef PROTLIB__ADDRESS_H
35#define PROTLIB__ADDRESS_H
36
37#include "protlib_types.h"
38#include "ie.h"
39
40#include <boost/unordered_map.hpp>
41#include <boost/functional/hash.hpp>
42
43#include <netinet/in.h>
44#include <set>
45
46#include "logfile.h"
47#include "threadsafe_db.h"
48
49namespace protlib {
50 using namespace log;
51
52/// Address base class
53/** This is the base class for IP host and application addresses, router,
54 * interface and user identification and AS numbers.
55 */
56class address {
57 public:
58 virtual address* new_instance() const = 0;
59 virtual address* copy() const = 0;
60 virtual bool operator==(const address& address) const = 0;
61
62 inline bool operator!=(const address& address) const {
63 return (!(*this==address));
64 }
65
66
67 enum subtype_t {
68 /** 255 is not a valid subtype and is used to register for all
69 * subtypes.
70 * @note This is no valid subtype because it is not in 0..64.
71 */
72 all_subtypes = 255,
73 // @{
74 /// address subtypes
75 /** These are the address-specific subtypes. */
76 IPv4HostAddress = 1,
77 IPv6HostAddress = 2,
78 IPv4NetAddress = 3,
79 IPv6NetAddress = 4,
80 IPv4ApplAddress = 5,
81 IPv6ApplAddress = 6,
82 IPv6Unspecified = 7,
83 UDSAddress = 8,
84 FlowAddressSpec = 12,
85 AS16 = 14,
86 AS32 = 15,
87 IEEE48 = 16,
88 EUI48 = 17,
89 EUI64 = 18,
90 NAI = 32,
91 X509 = 33
92 // @}
93 }; // end subtype_t
94
95 virtual ~address() {};
96
97 subtype_t get_type() const { return subtype; };
98
99 protected:
100 /// constructor with subtype
101 address(subtype_t st);
102 /// virtual destructor
103
104 void throw_nomem_error() const;
105
106 subtype_t subtype;
107};
108
109// forward declaration
110class netaddress;
111
112/// IP Host Address
113/** This class can hold IPv4 and IPv6 Host Addresses. */
114class hostaddress : public address {
115
116 public:
117 virtual hostaddress* new_instance() const;
118 virtual hostaddress* copy() const;
119 virtual bool operator==(const address& ie) const;
120
121 /// constructor
122 hostaddress();
123 /// copy constructor
124 hostaddress(const hostaddress& h);
125 /// assignment
126 hostaddress& operator=(const hostaddress& h);
127 /// constructor from string
128 hostaddress(const char *str, bool *res = NULL);
129 /// constructor from in6_addr
130 hostaddress(const struct in6_addr& ipv6addr);
131 /// destructor
132 virtual ~hostaddress();
133 /// set IPv4 from string
134 bool set_ipv4(const char *str);
135 /// set IPv4 from in_addr
136 void set_ip(const struct in_addr &in);
137 /// set IPv6 from string
138 bool set_ipv6(const char *str);
139 /// set IPv6 from in6_addr
140 void set_ip(const struct in6_addr &in);
141 /// set IPv4 or IPv6 from string
142 bool set_ip(const char *str);
143 bool set_ip(const string& str);
144 /// set IP from hostaddress
145 void set_ip(const hostaddress& h);
146 /// is IP unspecified
147 bool is_ip_unspec() const;
148 /// get ip address as string
149 const char *get_ip_str() const;
150 /// get ip address as string
151 const char *get_ip_str(char *str) const;
152 /// is it IPv4
153 bool is_ipv4() const;
154 /// is it IPv6
155 bool is_ipv6() const;
156 /// is bogus source (e.g. localhost, multicast)
157 bool is_bogus_source() const;
158 /// is it a 4to6-mapped address?
159 bool is_mapped_ip() const;
160 /// get as in_addr?
161 bool get_ip(struct in_addr& in) const;
162 /// get as in6_addr?
163 bool get_ip(struct in6_addr& in) const;
164 /// get as in6_addr?
165 const struct in6_addr *get_ip() const { return ipv4flag ? 0 : &ipv6addr; };
166 /// convert to iPv6
167 virtual void convert_to_ipv6();
168 /// are they equivalent
169 virtual bool equiv(const hostaddress& h) const;
170 /// lookup host name
171 string get_host_name(bool *res = NULL) const;
172 /// hash function
173 virtual size_t get_hash() const;
174 /// match against IP address
175 virtual int match_against(const hostaddress& ha) const;
176 /// match against network prefix
177 virtual int match_against(const netaddress& na) const;
178protected:
179 /// IPv4 flag
180 bool ipv4flag;
181 /// set subtype and IPv4 flag
182 virtual void set_subtype(bool ipv4);
183 /// IP buffer
184 /** I in protected and NOT private scope because subclasses have to
185 * (de)serialize it.
186 */
187 union {
188 /// IPv4 address
189 struct in_addr ipv4addr;
190 /// IPv6 address
191 struct in6_addr ipv6addr;
192 }; // end union
193public:
194 /// clear IP buffer (sets IP address to undefined/any and deletes any outstring)
195 void clear_ip();
196private:
197 /// pointer to IP string representation
198 mutable char *outstring;
199}; // end hostaddress
200
201inline ostream &operator<<(ostream &out, const hostaddress &addr) {
202 return out << addr.get_ip_str();
203}
204
205inline
206hostaddress::hostaddress(const struct in6_addr& ipv6addr)
207 : address(IPv6HostAddress),
208 ipv4flag(false),
209 ipv6addr(ipv6addr),
210 outstring(NULL)
211{ set_subtype(false); }
212
213
214/// ========================================================
215/// IP Application Address
216/// ========================================================
217/** Consists of a IP Host Address and a port number. */
218class appladdress : public hostaddress {
219 public:
220 virtual appladdress* new_instance() const;
221 virtual appladdress* copy() const;
222 virtual bool operator==(const address& ie) const;
223
224 /// hash function
225 virtual size_t get_hash() const;
226
227 protected:
228 /// set subtype and IPv4 flag
229 virtual void set_subtype(bool ipv4);
230
231 public:
232 /// constructor
233 appladdress();
234 /// copy constructor
235 appladdress(const appladdress& app);
236 ///constructor for use as Unix Domain Address
237 appladdress(string socket);
238 ///constructor for use to specify a explicit socket number (used when no addressing for peer can be derived)
239 appladdress(int socket);
240 /// constructor from hostaddress, protocol ID and port
241 appladdress(const hostaddress& h, protocol_t prot, port_t p);
242 /// constructor from sockaddr_in6 sockaddr
243 appladdress(const sockaddr_in6& sockaddr, protocol_t prot);
244 /// constructor from hostaddress, protocol name and port
245 appladdress(const hostaddress& h, const char* pname, port_t p, bool *res = NULL);
246 /// constructor from string, protocol ID and port
247 appladdress(const char* str, protocol_t prot, port_t p, bool *res = NULL);
248 /// constructor from string, protocol name and port
249 appladdress(const char* str, const char* pname, port_t p, bool *res = NULL);
250 /// constructor from string, protocol name and port name
251 appladdress(const char* str, const char* pname, const char* portname, bool *res = NULL);
252 /// assignment
253 appladdress& operator=(const appladdress& app);
254 /// virtual destructor
255 virtual ~appladdress() {};
256
257
258 /// are they equivalent
259 ///virtual bool equiv(const appladdress& h) const { return hostaddress::equiv(h); }
260
261 /// set port
262 port_t set_port(port_t p);
263 /// set port
264 port_t set_port(const char* pname, bool *res = NULL);
265 /// set port
266 port_t set_port(const string& pname, bool *res = NULL);
267 /// get port
268 port_t get_port() const;
269
270 /// get sockaddr_in6
271 void get_sockaddr(struct sockaddr_in6& sockaddr) const;
272 /// get port name
273 string get_port_name(bool *res = NULL) const;
274 /// set protocol by ID
275 protocol_t set_protocol(protocol_t p);
276 /// set protocol by name
277 protocol_t set_protocol(const char* pname, bool *res = NULL);
278 /// set protocol by name
279 protocol_t set_protocol(const string& pname, bool *res = NULL);
280 /// get protocol ID
281 protocol_t get_protocol() const;
282 /// get protocol name
283 string get_protocol_name(bool *res = NULL) const;
284 /// get prefix
285 inline
286 uint8 get_prefix() const {
287 return prefix;
288 }
289
290 /// set prefix
291 inline
292 void set_prefix(uint8 prfx) {
293 prefix=prfx;
294 }
295
296 /// set IP TTL
297 inline
298 void set_ip_ttl(uint16 ttl) {
299 ip_ttl = ttl;
300 }
301
302
303 /// unset IP TTL
304 inline
305 void unset_ip_ttl() {
306 ip_ttl = 0;
307 }
308
309
310 /// get IP TTL, if == 0, no IP TTL should be set
311 inline
312 uint16 get_ip_ttl() const {
313 return ip_ttl;
314 }
315
316
317 /// set RAO value
318 inline
319 void set_rao(uint16 value) {
320 rao_presence = true;
321 rao = value;
322 }
323
324 /// unset RAO value
325 inline
326 void unset_rao() {
327 rao_presence = false;
328 rao = 0;
329 }
330
331 /// get RAO value
332 inline
333 uint16 get_rao() const {
334 return rao;
335 }
336
337
338 /// test if RAO present
339 inline
340 bool rao_present() const {
341 return rao_presence;
342 }
343
344 /// set outgoing Interface index
345 inline
346 void set_if_index(uint16 value) {
347 if_index = value;
348 }
349
350 /// get outgoing Interface index
351 inline
352 uint16 get_if_index() const {
353 return if_index;
354 }
355
356 /// unset outgoing Interface index
357 inline
358 void unset_if_index() {
359 if_index = 0;
360 }
361
362
363
364
365
366 private:
367 protocol_t proto;
368 port_t port;
369 uint8 prefix;
370
371 uint16 rao;
372 uint16 ip_ttl;
373 bool rao_presence;
374 uint16 if_index;
375
376 }; // end appladdress
377
378
379inline
380appladdress::appladdress(const sockaddr_in6& sockaddr, protocol_t prot)
381 : hostaddress(sockaddr.sin6_addr), proto(prot), port(ntohs(sockaddr.sin6_port)), rao(0), ip_ttl(0), rao_presence(false), if_index(0)
382{
383 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for sockaddr_in6");
384}
385
386/** Constructor sets address type and clears port sets prefix to 32 (ipv4). */
387inline
388appladdress::appladdress() : hostaddress(),
389 proto(0),
390 port(0),
391 prefix(32),
392 rao(0),
393 ip_ttl(0),
394 rao_presence(false),
395 if_index(0)
396
397{
398 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for bool ipv4=" << ipv4);
399 set_subtype(ipv4flag);
400} // end constructor
401
402inline
403appladdress::appladdress(const appladdress& app) : hostaddress(app),
404 proto(app.proto),
405 port(app.port),
406 prefix(app.prefix),
407 rao(app.rao),
408 ip_ttl(app.ip_ttl),
409 rao_presence(app.rao_presence),
410 if_index(app.if_index)
411
412{
413 //Log(DEBUG_LOG,LOG_NORMAL,"appladdress", "Copy address constructor called for appladdress& app:" << app);
414 //DLog("appladdress", "UDSsocket copied: " << uds_socket);
415 //DLog("appladdress", "ip_ttl: " << ip_ttl << " if_index: " << if_index);
416
417
418 set_subtype(ipv4flag);
419} // end copy constructor
420
421/** Initialize with the given host address, protocol ID and port number. */
422inline
423appladdress::appladdress(const hostaddress& h, protocol_t prot, port_t p)
424 : hostaddress(h),
425 proto(prot),
426 port(p),
427 prefix(0),
428 rao(0),
429 ip_ttl(0),
430 rao_presence(false),
431 if_index(0)
432{
433 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const hostaddress& h, protocol_t prot, port_t p)");
434
435 set_subtype(ipv4flag);
436} // end constructor(hostaddress,prot,port)
437
438/** Initialize with the given host address, protocol name and port number.
439 * If no protocol ID can be found in the protocol database, it is set to 0.
440 */
441inline
442appladdress::appladdress(const hostaddress& h, const char* pname, port_t p, bool *res)
443 : hostaddress(h),
444 proto(tsdb::getprotobyname(pname,res)),
445 port(p),
446 prefix(0),
447 rao(0),
448 ip_ttl(0),
449 rao_presence(false),
450 if_index(0)
451
452{
453 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const hostaddress& h, const char* pname, port_t p, bool *res)");
454
455 set_subtype(ipv4flag);
456} // end constructor(hostaddress,pname,port)
457
458/** Initialize from string, protocol ID and port.
459 * If the string does not contain a vaild IP address, it is set to all 0 by
460 * the hostaddress constructor.
461 */
462inline
463appladdress::appladdress(const char* str, protocol_t prot, port_t p, bool *res)
464 : hostaddress(str,res),
465 proto(prot),
466 port(p),
467 prefix(0),
468 rao(0),
469 ip_ttl(0),
470 rao_presence(false),
471 if_index(0)
472{
473 set_subtype(ipv4flag);
474} // end constructor(string,prot,port)
475
476/** Initialize from string, protocol name and port.
477 * If the string does not contain a vaild IP address, it is set to all 0 by
478 * the hostaddress constructor.
479 * If no protocol ID can be found in the protocol database, it is set to 0.
480 */
481inline
482appladdress::appladdress(const char* str, const char* pname, port_t p, bool *res)
483 : hostaddress(str,res),
484 port(p),
485 prefix(0),
486 rao(0),
487 ip_ttl(0),
488 rao_presence(false),
489 if_index(0)
490{
491 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const char* str, const char* pname, port_t p, bool *res)");
492
493 register bool tmpres = false;
494 proto = tsdb::getprotobyname(pname,&tmpres);
495 if (res) *res = ((*res) && tmpres);
496 set_subtype(ipv4flag);
497} // end constructor(string,pname,port)
498
499/** Initialize from string, protocol name and port name.
500 * If the string does not contain a vaild IP address, it is set to all 0 by
501 * the hostaddress constructor.
502 * If no protocol ID can be found in the protocol database, it is set to 0.
503 * If no port number can be found in the service database, it is set to 0.
504 */
505inline
506appladdress::appladdress(const char* str, const char* pname, const char* portname, bool *res)
507 : hostaddress(str,res),
508 prefix(0),
509 rao(0),
510 ip_ttl(0),
511 rao_presence(false),
512 if_index(0)
513{
514 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const char* str, const char* pname, const char* portname, bool *res)");
515
516 bool res1 = false;
517 bool res2 = false;
518 proto = tsdb::getprotobyname(pname,&res1);
519 port = tsdb::get_portnumber(portname,proto,&res2);
520 if (res) *res = ((*res) && res1 && res2);
521 set_subtype(ipv4flag);
522 prefix = 0;
523} // end constructor(string,pname,portname)
524
525/** Assigns the given application address by using hostaddress::operator=(). */
526inline
527appladdress&
528appladdress::operator=(const appladdress& app)
529{
530 hostaddress::operator=(app);
531 proto = app.proto;
532 port = app.port;
533 prefix = app.prefix;
534 ip_ttl = app.ip_ttl;
535 rao_presence = app.rao_presence;
536 rao = app.rao;
537 if_index = app.if_index;
538 return *this;
539} // end operator=
540
541
542/** Set port and return old value. */
543inline
544port_t appladdress::set_port(port_t p) {
545 register port_t op = port;
546 port = p;
547 return op;
548} // end set_port
549
550
551
552/** Set port and return old value.
553 * If the port name is not found in the service database, port is set to 0.
554 */
555inline
556port_t appladdress::set_port(const char* pname, bool *res) {
557 register port_t op = port;
558 port = tsdb::get_portnumber(pname,proto,res);
559 return op;
560} // end set_port
561
562/** Set port and return old value.
563 * If the port name is not found in the service database, port is set to 0.
564 */
565inline
566port_t appladdress::set_port(const string& pname, bool *res) {
567 register port_t op = port;
568 port = tsdb::get_portnumber(pname,proto,res);
569 return op;
570} // end set_port
571
572inline
573port_t appladdress::get_port() const { return port; }
574
575inline
576string appladdress::get_port_name(bool *res) const {
577 return tsdb::get_portname(port,proto,res);
578} // end get_port_name
579
580/** Set protocol ID and return old value. */
581inline
582protocol_t appladdress::set_protocol(protocol_t p) {
583 register protocol_t o = proto;
584 proto = p;
585 return o;
586} // end set_protocol
587
588/** Set protocol ID and return old value.
589 * If no protocol ID can be found in the protocol database, it is set to 0.
590 */
591inline
592protocol_t appladdress::set_protocol(const char* pname, bool *res) {
593 register protocol_t o = proto;
594 proto = tsdb::getprotobyname(pname,res);
595 return o;
596} // end set_protocol
597
598/** Set protocol ID and return old value.
599 * If no protocol ID can be found in the protocol database, it is set to 0.
600 */
601inline
602protocol_t appladdress::set_protocol(const string& pname, bool *res) {
603 register protocol_t o = proto;
604 proto = tsdb::getprotobyname(pname,res);
605 return o;
606} // end set_protocol
607
608inline
609protocol_t appladdress::get_protocol() const { return proto; }
610
611inline
612string appladdress::get_protocol_name(bool *res) const {
613 return tsdb::getprotobynumber(proto,res);
614} // end get_protocol_name
615
616inline
617size_t appladdress::get_hash() const {
618 uint32 tmp = (proto<<16)+port;
619 return (hostaddress::get_hash() ^ tmp);
620} // end get_hash
621
622inline
623void
624appladdress::get_sockaddr(struct sockaddr_in6& sa) const
625{
626 if (!ipv4flag)
627 {
628 sa.sin6_family= PF_INET6;
629 sa.sin6_port = htons(port);
630 sa.sin6_addr = ipv6addr;
631 }
632}
633
634/// Network Prefix (or net address)
635/** Holds an IP address and a prefix length in bits. */
636class netaddress : public hostaddress {
637/***** inherited from IE ****/
638public:
639 virtual netaddress* new_instance() const;
640 virtual netaddress* copy() const;
641 virtual bool operator==(const address& ie) const;
642
643 /// convert to iPv6
644 virtual void convert_to_ipv6();
645 /// hash function
646 virtual size_t get_hash() const;
647 virtual int match_against(const netaddress& na) const;
648protected:
649 /// set subtype and IPv4 flag
650 virtual void set_subtype(bool ipv4);
651/***** new members *****/
652public:
653 /// constructor
654 netaddress();
655 /// copy constructor
656 netaddress(const netaddress& na);
657 /// constructor from hostaddress and prefix length
658 netaddress(const hostaddress& h, prefix_length_t len = 128);
659 /// constructor from string
660 netaddress(const char* str, bool *res = NULL);
661 /// constructor from string and prefix length
662 netaddress(const char* str, prefix_length_t len, bool *res = NULL);
663 /// assignment
664 netaddress& operator=(const netaddress& na);
665 /// assignment
666 netaddress& operator=(const hostaddress& ha);
667
668 // set prefix length
669 prefix_length_t set_pref_len(prefix_length_t len);
670 // get prefix length
671 prefix_length_t get_pref_len() const;
672 /// comparison for prefixmap
673 bool operator<(const netaddress& na) const;
674
675 int rdx_cmp(const netaddress *na, int *pos) const;
676private:
677 prefix_length_t prefix_length;
678}; // end netaddress
679
680inline ostream &operator<<(ostream &out, const netaddress &addr) {
681 return out << addr.get_ip_str() << "/" << (int)addr.get_pref_len();
682}
683
684/// Unix Domain Socket Address
685/** This class can hold a Unix Domain Socket Address OR a Socket Number. */
686class udsaddress : public address {
687
688 public:
689 virtual udsaddress* new_instance() const;
690 virtual udsaddress* copy() const;
691 virtual bool operator==(const address& ie) const;
692
693 /// constructor
694 udsaddress() : address(UDSAddress) { uds_socket = ""; socknum=0;};
695 /// copy constructor
696 udsaddress(const udsaddress& h) : address(UDSAddress) { uds_socket = string(h.uds_socket.c_str()); socknum = h.socknum; };
697 /// assignment
698 udsaddress& operator=(const udsaddress& uds) {
699 uds_socket = string(uds.uds_socket);
700 socknum = uds.socknum;
701 return *this;
702 };
703 /// constructor from string
704 udsaddress(string sockstring): address(UDSAddress) { uds_socket = string(sockstring.c_str()); socknum=0; };
705 /// constructor from int
706 udsaddress(int num): address(UDSAddress) { socknum = num; uds_socket=""; };
707 /// constructor from both
708 udsaddress(string sockstring, int num): address(UDSAddress) { socknum = num; uds_socket=string(sockstring.c_str()); };
709 /// destructor
710 virtual ~udsaddress() {};
711
712 /// hash function
713 virtual size_t get_hash() const;
714
715private:
716 /// uds socket string
717 string uds_socket;
718 /// socket number
719 int socknum;
720
721public:
722
723/** Set UDS socket path. */
724inline
725void set_udssocket(string socket) {
726 uds_socket = socket;
727} // end set_uds socket path
728
729
730/** Get UDS socket path. */
731inline
732const string get_udssocket() const {
733 return uds_socket;
734} // end get_udspath
735
736
737/** Set Socket Number */
738inline
739void set_socknum(int socket) {
740 socknum = socket;
741} // end set_socknum
742
743/** Get Socket Number */
744inline
745const int get_socknum() const {
746 return socknum;
747} // end get_socknum
748
749
750
751}; // end udsaddress
752
753template <typename _dT>
754class RadixTrie {
755public:
756 typedef _dT data_type;
757
758 struct node {
759 node(netaddress *k, data_type *d) : key(k), data(d) {
760 left = right = this;
761 index = 0;
762 }
763 ~node() {
764 if (data)
765 delete data;
766 if (key)
767 delete key;
768 if (left != 0 && left->index > index)
769 delete left;
770 if (right != 0 && right->index > index)
771 delete right;
772 }
773 node *left;
774 node *right;
775 netaddress *key;
776 data_type *data;
777 int index;
778 };
779
780 RadixTrie() {
781 netaddress *def;
782 def = new netaddress("0.0.0.0", (prefix_length_t)0);
783 v4head = new node(def, 0);
784 def = new netaddress("::", (prefix_length_t)0);
785 v6head = new node(def, 0);
786 }
787
788 ~RadixTrie() {
789 delete v4head;
790 delete v6head;
791 }
792
793 node *insert(netaddress &key, data_type &dat) {
794 node *a, *b = NULL, *c, *n, *m;
795 int cmp = 0, pos = 0;
796
797 c = a = key.is_ipv4() ? v4head : v6head;
798
799 // search the tree as long as there are bits left in key
800 while (key.get_pref_len() > a->index) {
801
802 // compare key to key in node a from position a->index
803 pos = a->index - 1;
804 cmp = key.rdx_cmp(a->key, &pos);
805 if (pos < 0)
806 abort();
807
808 // in case of a perfect match
809 if ((cmp == 0) &&
810 (a->key->get_pref_len() == key.get_pref_len())) {
811 // replace data in node
812 if (a->data)
813 delete a->data;
814 a->data = &dat;
815 return a;
816 }
817
818 if (cmp == 0)
819 break;
820
821 // select node to continue the search based on the
822 // first different bit between a and key
823 b = cmp < 0 ? a->left : a->right;
824
825 // we reached a dead end
826 if (b->index <= a->index)
827 break;
828
829 // the first difference was before a's bitmask ended
830 // we must not make any more progress
831 if (pos <= a->key->get_pref_len())
832 break;
833
834 c = a;
835 a = b;
836 }
837
838 // first check if a and key share a common prefix
839 if ((key.get_pref_len() == a->key->get_pref_len()) ||
840 (pos > a->index && pos <= a->key->get_pref_len())) {
841 int opos = pos;
842
843 // make sure we didn't just miss the perfect match
844 pos = a->index;
845 cmp = key.rdx_cmp(a->key, &pos);
846 if (cmp == 0 &&
847 (a->key->get_pref_len() == key.get_pref_len())) {
848 // replace data in node
849 if (a->data)
850 delete a->data;
851 a->data = &dat;
852 return a;
853 }
854
855 // create a node with that prefix
856 pos = opos;
857 n = new node(new netaddress(key), 0);
858 n->key->set_pref_len(pos - 1);
859
860 // hook it to the previous node(c)
861 pos = c->index;
862 cmp = n->key->rdx_cmp(c->key, &pos);
863 n->index = pos;
864 if (n->index <= c->index) {
865 cout << "DEAD NODE INSERTION!!!" << endl;
866 abort();
867 }
868 if (cmp < 0) {
869 if (c->left != a) {
870 cout << "TREE CORRUPTION!!!" << endl;
871 abort();
872 }
873 c->left = n;
874 } else {
875 if (c->right != a) {
876 cout << "TREE CORRUPTION!!!" << endl;
877 abort();
878 }
879 c->right = n;
880 }
881
882 // hook the current node(a) to the common prefix
883 // node(n)
884 pos = n->index;
885 cmp = a->key->rdx_cmp(n->key, &pos);
886 a->index = pos;
887 if (a->index <= n->index) {
888 cout << "DEAD NODE INSERTION!!!" << endl;
889 abort();
890 }
891 if (cmp < 0)
892 n->left = a;
893 else
894 n->right = a;
895
896 // create a new node(m) for the insert
897 m = new node(new netaddress(key), &dat);
898 // hook node(m) to the common prefix node(n)
899 pos = n->index;
900 cmp = m->key->rdx_cmp(n->key, &pos);
901 m->index = pos;
902 if (cmp < 0) {
903 if (n->left == a) {
904 cout << "OVERWRITE!!!" << endl;
905 abort();
906 }
907 n->left = m;
908 } else {
909 if (n->right == a) {
910 cout << "OVERWRITE!!!" << endl;
911 abort();
912 }
913 n->right = m;
914 }
915
916 return m;
917 }
918
919 // c is a prefix of key, key is a prefix of a
920 if (a->index >= pos) {
921 // create a new node for the key
922 n = new node(new netaddress(key), &dat);
923 // hook it to the previous node(c)
924 n->index = pos;
925 if (n->index <= c->index) {
926 cout << "DEAD NODE INSERTION!!!" << endl;
927 abort();
928 }
929 if (cmp < 0) {
930 if (c->left != a) {
931 cout << "TREE CORRUPTION!!!" << endl;
932 abort();
933 }
934 c->left = n;
935 } else {
936 if (c->right != a) {
937 cout << "TREE CORRUPTION!!!" << endl;
938 abort();
939 }
940 c->right = n;
941 }
942
943 // hook the current node(a) to the newly created
944 // node(n)
945 pos = n->index;
946 cmp = a->key->rdx_cmp(n->key, &pos);
947 a->index = pos;
948 if (a->index <= c->index) {
949 cout << "DEAD NODE INSERTION!!!" << endl;
950 abort();
951 }
952 if (cmp < 0)
953 n->left = a;
954 else
955 n->right = a;
956
957 return n;
958 }
959
960 // reached a deadend, simply add a new node
961 n = new node(new netaddress(key), &dat);
962 n->index = pos;
963 if (n->index <= a->index) {
964 cout << "DEAD NODE INSERTION!!!" << endl;
965 abort();
966 }
967 if (b->index <= a->index) {
968 if (cmp < 0)
969 a->left = n;
970 else
971 a->right = n;
972 } else {
973 cout << "TREE CORRUPTION!!!" << endl;
974 abort();
975 }
976
977 return n;
978 }
979
980 node *lookup_node(netaddress &key, bool lpfm = true,
981 bool with_data = true) {
982 node *a, *b, *c, *lpfn;
983 int cmp, pos = 0;
984
985 lpfn = 0;
986 c = b = a = key.is_ipv4() ? v4head : v6head;
987 if (lpfm) {
988 if (!with_data)
989 lpfn = a;
990 else if (a->data)
991 lpfn = a;
992 }
993
994 // search the tree as long as there are bits left in key
995 while (key.get_pref_len() > a->index) {
996
997 // compare key to key in node a from pos
998 pos--;
999 cmp = key.rdx_cmp(a->key, &pos);
1000
1001 // all of key consumed
1002 if (cmp == 0) {
1003 // key is less specific than a
1004 if (key.get_pref_len() <
1005 a->key->get_pref_len())
1006 return lpfm ? lpfn : NULL;
1007
1008 // key is an exact match for a
1009 if (key.get_pref_len() >=
1010 a->key->get_pref_len()) {
1011 if (!with_data)
1012 return a;
1013 if (a->data)
1014 return a;
1015 return lpfm ? lpfn : NULL;
1016 }
1017 }
1018
1019 // all of a consumed -> a is a prefix of key
1020 if (pos > a->key->get_pref_len()) {
1021 if (!with_data)
1022 lpfn = a;
1023 else if (a->data)
1024 lpfn = a;
1025 }
1026
1027 // select node to continue the search based on the
1028 // first different bit between a and key
1029 b = cmp < 0 ? a->left : a->right;
1030
1031 // we reached a dead end
1032 if (b->index <= a->index)
1033 break;
1034
1035 c = a;
1036 a = b;
1037 }
1038
1039 return lpfm ? lpfn : NULL;
1040 }
1041
1042 data_type *lookup(netaddress &key, bool lpfm = true) {
1043 node *n = lookup_node(key, lpfm);
1044
1045 return n ? n->data : NULL;
1046 }
1047
1048 bool remove(netaddress &key) {
1049 node *n = lookup_node(key);
1050
1051 if (n && n->data) {
1052 delete n->data;
1053 n->data = NULL;
1054 }
1055
1056 return (n != 0);
1057 }
1058
1059 bool remove_all(netaddress &key) {
1060 node *n = lookup_node(key, false, false);
1061
1062 if (n == 0)
1063 return false;
1064
1065 if (n->data) {
1066 delete n->data;
1067 n->data = NULL;
1068 }
1069
1070 if (n->left->index > n->index) {
1071 delete n->left;
1072 n->left = n;
1073 }
1074 if (n->right->index > n->index) {
1075 delete n->right;
1076 n->right = n;
1077 }
1078
1079 return true;
1080 }
1081
1082 void print() {
1083 cout << "v4_TREE: " << endl;
1084 print_node(v4head);
1085 cout << "v6_TREE: " << endl;
1086 print_node(v6head);
1087 }
1088
1089 void print_node(node *x, bool decent = true) {
1090 if (x && x->key) {
1091 cout << "node: " << x << " key: " << *x->key;
1092 if (x->data != 0)
1093 cout << " data: " << x->data;
1094 else
1095 cout << " data: NULL";
1096 cout << " index: " << x->index << endl;
1097 cout << "\tleft: " << x->left << " right: " << x->right << endl;
1098 if (decent) {
1099 if (x->left->index > x->index)
1100 print_node(x->left);
1101 if (x->right->index > x->index)
1102 print_node(x->right);
1103 }
1104 }
1105 }
1106
1107private:
1108 struct node *v4head;
1109 struct node *v6head;
1110};
1111
1112
1113/*
1114 * AddressList
1115 */
1116
1117class AddressList {
1118public:
1119 class AddrProperty {
1120 public:
1121 AddrProperty(const char *name) {
1122 pname = new string(name);
1123 }
1124 ~AddrProperty() {
1125 delete pname;
1126 };
1127
1128 string *pname;
1129 };
1130
1131 // Default properties, N.B. Ignore will remove all other properties
1132 static AddrProperty *LocalAddr_P;
1133 static AddrProperty *ConfiguredAddr_P;
1134
1135private:
1136 // This is special
1137 static AddrProperty *IgnoreAddr_P;
1138 static AddrProperty *AnyAddr_P;
1139
1140public:
1141 struct ltstr {
1142 bool operator()(const char* s1, const char* s2) const
1143 { return strcmp(s1, s2) < 0; }
1144 };
1145 struct ltna {
1146 bool operator()(const netaddress &s1, const netaddress &s2)
1147 const {
1148 if (s1.is_ipv4() != s2.is_ipv4())
1149 return (s1.is_ipv4());
1150 int cmp, pos = 0;
1151 cmp = s1.rdx_cmp(&s2, &pos);
1152 return (cmp < 0);
1153 }
1154
1155 };
1156 typedef set<char *, ltstr> iflist_t;
1157 typedef set<netaddress, ltna> addrlist_t;
1158
1159 AddressList();
1160 ~AddressList();
1161
1162 // Configure by interfaces
1163 // Return a list of all local interfaces, which are monitored
1164 iflist_t *get_interfaces();
1165 // Begin interface list (otherwise the following have no effect)
1166 // If start_empty is true use an empty list, otherwise add all
1167 // currently configured interfaces
1168 bool by_interface(bool start_empty = true);
1169 // Add interface to monitoring
1170 bool add_interface(char *name);
1171 // Remove interface from monitoring
1172 bool del_interface(char *name);
1173
1174 // Manage properties
1175 // If 'all' is true operate on all matching addresses as well
1176 bool add_property(netaddress &na, AddrProperty *p = ConfiguredAddr_P,
1177 bool propagate = true);
1178 bool del_property(netaddress &na, AddrProperty *p = ConfiguredAddr_P,
1179 bool propagate = true);
1180 inline bool purge_properties(netaddress &na, bool prop = true) {
1181 return del_property(na, AnyAddr_P, prop);
1182 };
1183 bool add_host_prop(const char *name, AddrProperty *p = ConfiguredAddr_P);
1184 bool del_host_prop(const char *name, AddrProperty *p = ConfiguredAddr_P);
1185 inline bool purge_host_prop(const char *name) {
1186 return del_host_prop(name, AnyAddr_P);
1187 }
1188
1189 // Special property
1190 bool ignore(netaddress &na, bool propagate = true);
1191 bool unignore(netaddress &na, bool propagate = true);
1192 bool ignore_bogons(void);
1193 bool ignore_locals(void);
1194 bool ignore_loopback(void);
1195
1196 // Check if the given address has the given property
1197 bool addr_is(netaddress &na, AddrProperty *prop);
1198 bool addr_is(const hostaddress &ha, AddrProperty *prop) {
1199 netaddress na(ha);
1200 return addr_is(na, prop);
1201 }
1202 // Check if the given address is in a network with the given property
1203 bool addr_is_in(netaddress &na, AddrProperty *prop);
1204 bool addr_is_in(const hostaddress &ha, AddrProperty *prop) {
1205 netaddress na(ha);
1206 return addr_is_in(na, prop);
1207 }
1208
1209 addrlist_t *get_addrs(AddrProperty *prop = LocalAddr_P);
1210 netaddress *get_first(AddrProperty *p = LocalAddr_P, bool IPv4 = true);
1211
1212 netaddress *get_src_addr(const netaddress &dest, uint32_t *prefs);
1213private:
1214 typedef map<AddrProperty *, bool> propmap_t;
1215 typedef RadixTrie<propmap_t> addr2prop_t;
1216
1217 iflist_t *interfaces;
1218 addr2prop_t prop_trie;
1219
1220 // Backends for public functions
1221 void getifaddrs_iflist(iflist_t &list);
1222 bool getifaddrs_is_local(netaddress &na);
1223 void getifaddrs_get_addrs(addrlist_t &list);
1224
1225 void bequeath(addr2prop_t::node *head, AddrProperty *p,
1226 bool add = true);
1227 void collect(addr2prop_t::node *head, AddrProperty *p,
1228 addrlist_t &list);
1229 addr2prop_t::node *collect_first(addr2prop_t::node *head,
1230 AddrProperty *p);
1231};
1232
1233inline ostream &operator<<(ostream &out, const AddressList::AddrProperty &prop) {
1234 return out << *prop.pname;
1235}
1236
1237
1238/************************************* inline methods ***********************************/
1239
1240inline
1241size_t
1242hostaddress::get_hash() const
1243{
1244 return (ipv6addr.s6_addr32[0] ^ ipv6addr.s6_addr32[1] ^ ipv6addr.s6_addr32[2] ^ ipv6addr.s6_addr32[3]);
1245} // end get_hash
1246
1247/***** new in hostaddress *****/
1248
1249
1250/** Initialize a hostaddress object.
1251 * This calls virtual member set_subtype and therefore sets subtype in all
1252 * derived class which overwrite this member function correctly.
1253 */
1254inline
1255hostaddress::hostaddress()
1256 : address(IPv6HostAddress),
1257 ipv4flag(false),
1258 outstring(NULL)
1259{
1260 clear_ip();
1261 set_subtype(false);
1262} // end constructor hostaddress
1263
1264
1265/** Assign h to this object. */
1266inline
1267hostaddress&
1268hostaddress::operator=(const hostaddress& h) {
1269 address::operator=(h);
1270 this->set_ip(h);
1271 if (outstring)
1272 delete outstring;
1273 outstring= 0;
1274 return *this;
1275} // end operator=
1276
1277/** Copy constructor for hostaddress objects */
1278inline
1279hostaddress::hostaddress(const hostaddress& h) :
1280 address(h),
1281 outstring(NULL)
1282{
1283 this->set_ip(h);
1284
1285 //Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","hostaddress constructor called for const hostaddress& h:"); // << h << " outstring:" << static_cast<void*>(outstring) << " h.outstring:" << static_cast<void*>(h.outstring));
1286
1287} // end copy constructor hostaddress
1288
1289/** Check if this is an IPv4 address. */
1290inline
1291bool
1292hostaddress::is_ipv4() const {
1293 return ipv4flag;
1294} // end is_ipv4
1295
1296/** Check if this is an IPv6 address. */
1297inline
1298bool
1299hostaddress::is_ipv6() const {
1300 return (!ipv4flag);
1301} // end is_ipv6
1302
1303/** Check if this is a 6to4 mapped address. */
1304inline
1305bool
1306hostaddress::is_mapped_ip() const
1307{
1308 return (ipv4flag) ? false : IN6_IS_ADDR_V4MAPPED(ipv6addr.s6_addr);
1309} // end is_mapped_ip
1310
1311inline
1312bool
1313hostaddress::set_ip(const string& str) { return set_ip(str.c_str()); }
1314
1315inline
1316/** Delete outstring if it exists. */
1317hostaddress::~hostaddress() {
1318 if (outstring)
1319 {
1320 delete[] outstring;
1321 outstring= 0;
1322 }
1323} // end destructor hostaddress
1324
1325/** Set IPv4 or IPv6 from string or leave object unchanged.
1326 * This changes object type.
1327 * @return true on success.
1328 */
1329inline
1330bool
1331hostaddress::set_ip(const char *str)
1332{
1333 return (!str) ? false :
1334 ( strchr(str,':') ? set_ipv6(str) : set_ipv4(str)); // which IP version?
1335
1336} // end set_ipv
1337
1338
1339/** Lookup the host name associated with the current IP address. */
1340inline
1341string hostaddress::get_host_name(bool *res) const
1342{
1343 return ipv4flag ? tsdb::get_hostname(ipv4addr,res) : tsdb::get_hostname(ipv6addr,res);
1344} // end get_host_name
1345
1346/***** inherited from hostaddress *****/
1347
1348/** Set subtype and IPv4 flag. This does NOT clear the outstring buffer.
1349 * Use clear_ip().
1350 */
1351inline
1352void
1353appladdress::set_subtype(bool ipv4)
1354{
1355 ipv4flag = ipv4;
1356 subtype = (ipv4) ? IPv4ApplAddress : IPv6ApplAddress;
1357} // end set_subtype
1358
1359inline
1360prefix_length_t netaddress::get_pref_len() const { return prefix_length; }
1361
1362inline
1363size_t netaddress::get_hash() const {
1364 return (hostaddress::get_hash() ^ prefix_length);
1365} // end get_hash
1366
1367inline
1368int
1369netaddress::match_against(const netaddress& na) const
1370{
1371 // compare prefix lengths
1372 return (prefix_length<na.prefix_length) ? -1 : hostaddress::match_against(na);
1373} // end match_against
1374
1375
1376inline
1377ostream &operator<<(ostream &out, const appladdress &addr) {
1378 if (addr.is_mapped_ip()) return out << "[IPv4-mapped address]: " << addr.get_ip_str() << ":" << (int)addr.get_port() << ", " << addr.get_protocol_name();
1379 return out << "[IP address]: " << addr.get_ip_str() << ":" << (int)addr.get_port() << ", " << addr.get_protocol_name();
1380}
1381
1382inline
1383ostream &operator<<(ostream &out, const udsaddress &addr) {
1384 if (addr.get_socknum()) return out << "[Socketnumber]: " << addr.get_socknum();
1385 return out << "[Unix Domain Socket]: " << addr.get_udssocket();
1386}
1387
1388
1389
1390
1391
1392
1393inline
1394size_t udsaddress::get_hash() const {
1395 size_t tmp2 = 1;
1396 for (unsigned int i = 0; i<uds_socket.size(); i++) {
1397 tmp2 = tmp2 * (int) uds_socket[i];
1398 }
1399 return (tmp2 ^ socknum);
1400} // end get_hash
1401
1402
1403
1404} // end namespace protlib
1405
1406/*********************************** hash functions ***********************************/
1407
1408namespace boost {
1409/// hostaddress hasher
1410template <> struct hash<protlib::hostaddress> {
1411 inline size_t operator()(const protlib::hostaddress& addr) const { return addr.get_hash(); }
1412}; // end hostaddress hasher
1413
1414/// appladdress hasher
1415template <> struct hash<protlib::appladdress> {
1416 inline size_t operator()(const protlib::appladdress& addr) const { return addr.get_hash(); }
1417}; // end appladdress hasher
1418
1419/// udsaddress hasher
1420template <> struct hash<protlib::udsaddress> {
1421 inline size_t operator()(const protlib::udsaddress& addr) const { return addr.get_hash(); }
1422}; // end udsaddress hasher
1423
1424/// netaddress hasher
1425template <> struct hash<protlib::netaddress> {
1426 inline size_t operator() (const protlib::netaddress& addr) const { return addr.get_hash(); }
1427}; // end netaddress hasher
1428
1429} // end namespace __gnu_cxx
1430
1431
1432namespace std {
1433
1434/// hostaddress equal_to
1435template <> struct equal_to<protlib::hostaddress> {
1436 inline bool operator()(const protlib::hostaddress& addr1, const protlib::hostaddress& addr2) const { return addr1.equiv(addr2); }
1437}; // end hostaddress equal_to
1438
1439/// appladdress equal_to
1440
1441template <> struct equal_to<protlib::appladdress> {
1442 inline bool operator()(const protlib::appladdress& addr1, const protlib::appladdress& addr2) const { return addr1.equiv(addr2); }
1443}; // end appladdress equal_to
1444
1445/// netaddress equal_to
1446template <> struct equal_to<protlib::netaddress> {
1447 inline bool operator()(const protlib::netaddress& addr1, const protlib::netaddress& addr2) const { return addr1.equiv(addr2); }
1448
1449}; // end netaddress equal_to
1450
1451} // end namespace std
1452#endif // PROTLIB__ADDRESS_H
Note: See TracBrowser for help on using the repository browser.