source: source/ariba/utility/transport/tcpip/protlib/address.cpp@ 7911

Last change on this file since 7911 was 6786, checked in by mies, 15 years ago

Changed Data to Message conversion constructor in Message to explicit
Fixed some general bugs in Data: operator<<
Fixed bug in DHTMessage: allow unspecified key/values
Added local DHT message delivery
Adapted sources to work with gcc 4.4.1
File size: 37.6 KB
RevLine 
[5284]1/// ----------------------------------------*- mode: C++; -*--
2/// @file address.cpp
3/// GIST address objects
4/// ----------------------------------------------------------
5/// $Id: address.cpp 3046 2008-06-18 14:40:43Z hiwi-laier $
6/// $HeadURL: https://svn.ipv6.tm.uka.de/nsis/protlib/trunk/src/address.cpp $
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 * GIST address objects
31 */
32
33#include <sys/types.h>
34#include <sys/socket.h>
35
36#include "address.h"
37#include "threadsafe_db.h"
38#include "logfile.h"
39
40#include <net/if.h>
41#include <netinet/in.h>
42#include <arpa/inet.h>
43#include <ifaddrs.h>
44#include <iomanip>
45#include <netdb.h>
46
47namespace protlib {
48
49/** @addtogroup ieaddress Address Objects
50 * @{
51 */
52 using namespace log;
53/***** class address *****/
54
55/** Set subtype. */
56address::address(subtype_t st)
57 : subtype(st)
58{
59 //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for " << (void *) this);
60}
61
62/** Log and throw a nomem_error */
63void address::throw_nomem_error() const {
64 try {
65 ERRCLog("address", "Not enough memory for address");
66 } catch(...) {}
67 throw IEError(IEError::ERROR_NO_MEM);
68} // end throw_nomem_error
69
70
71/***** class hostaddress *****/
72
73/***** inherited from IE *****/
74
75hostaddress* hostaddress::new_instance() const {
76 hostaddress* ha = NULL;
77 catch_bad_alloc(ha = new hostaddress());
78 return ha;
79} // end new_instance
80
81hostaddress* hostaddress::copy() const {
82 hostaddress* ha = NULL;
83 catch_bad_alloc(ha = new hostaddress(*this));
84 return ha;
85} // end copy
86
87bool hostaddress::operator==(const address& ie) const {
88 const hostaddress* haddr = dynamic_cast<const hostaddress*>(&ie);
89 if (haddr) {
90#ifdef DEBUG_HARD
91 Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==()" << haddr->get_ip_str()<<"=="<<this->get_ip_str());
92 if (!ipv4flag)
93 Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==(), v6=" << IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr, haddr->ipv6addr.s6_addr));
94#endif
95 return ipv4flag ? (ipv4addr.s_addr==haddr->ipv4addr.s_addr) :
96 IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr, haddr->ipv6addr.s6_addr);
97 } else return false;
98} // end operator==
99
100/***** new in hostaddress *****/
101
102
103/** Initialize hostaddress from string if possible. */
104hostaddress::hostaddress(const char *str, bool *res)
105 : address(IPv6HostAddress),
106 ipv4flag(false),
107 outstring(NULL)
108{
109 register bool tmpres = false;
110 clear_ip();
111 tmpres = set_ip(str);
112 if (res) *res = tmpres;
113} // end string constructor hostaddress
114
115
116/** Set IPv4 from string or leave object unchanged.
117 * This changes object type to IPv4.
118 * @return true on success.
119 */
120bool
121hostaddress::set_ipv4(const char *str) {
122 struct in_addr in;
123 if (str && (inet_pton(AF_INET,str,&in)>0)) {
124 set_ip(in);
125 return true;
126 } else return false;
127} // end set_ipv4
128
129/** Set IPv4 address from struct in_addr.
130 * This changes object type to IPv4.
131 */
132void hostaddress::set_ip(const struct in_addr &in) {
133 clear_ip();
134 ipv4addr = in;
135 // set subtype to IPv4
136 set_subtype(true);
137 return;
138} // end set_ip(in_addr)
139
140/** Set IPv6 from string or leave object unchanged.
141 * This changes object type to IPv6.
142 * @return true on success.
143 */
144bool hostaddress::set_ipv6(const char *str) {
145 struct in6_addr in;
146 if (str && (inet_pton(AF_INET6,str,&in)>0)) {
147 set_ip(in);
148 return true;
149 } else return false;
150} // end set_ipv6
151
152/** Set IPv6 address from struct in6_addr.
153 * This changes object type to IPv6.
154 */
155void
156hostaddress::set_ip(const struct in6_addr &in) {
157 clear_ip();
158 ipv6addr = in;
159 // set subtype to IPv6
160 set_subtype(false);
161 return;
162} // end set_ip(in6_addr)
163
164
165
166void hostaddress::set_ip(const hostaddress& h) {
167 clear_ip();
168 if (h.ipv4flag) {
169 ipv4addr = h.ipv4addr;
170 } else {
171 ipv6addr = h.ipv6addr;
172 } // end if ipv4flag
173 set_subtype(h.ipv4flag);
174} // end set_ip(hostaddress)
175
176/** Check if IP address is unspecified (set to 0). */
177bool hostaddress::is_ip_unspec() const {
178 if (ipv4flag) return (ipv4addr.s_addr==0);
179 else return IN6_IS_ADDR_UNSPECIFIED(ipv6addr.s6_addr);
180 // never reached
181 return true;
182} // end is_unspec
183
184/** Get IP address as a string. The output string is kept inside the
185 * hostaddress object and should be copied if used for a longer time.
186 */
187const char* hostaddress::get_ip_str() const
188{
189 // If outstring exists then it is valid.
190 if (outstring)
191 return outstring;
192 else
193 outstring= (ipv4flag ? new(nothrow) char[INET_ADDRSTRLEN] :
194 new(nothrow) char[INET6_ADDRSTRLEN]);
195
196 if (hostaddress::get_ip_str(outstring))
197 return outstring;
198 else
199 {
200 // error
201 if (outstring)
202 delete[] outstring;
203
204 return (outstring = NULL);
205 } // end if get_ip_str()
206} // end get_ip_str
207
208/** Get IP address as a string.
209 * @param str string buffer
210 */
211const char* hostaddress::get_ip_str(char *str) const
212{
213 if (!str) return NULL;
214 memset(str,0, ipv4flag ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN);
215 return ipv4flag ? inet_ntop(AF_INET,(void*)&ipv4addr,str,INET_ADDRSTRLEN)
216 : inet_ntop(AF_INET6,(void*)&ipv6addr,str,INET6_ADDRSTRLEN);
217} // end get_ip_str(char*)
218
219
220/** Get IP address as an in_addr if possible.
221 * @return true on success.
222 */
223bool hostaddress::get_ip(struct in_addr& in) const {
224 if (ipv4flag) {
225 in = ipv4addr;
226 return true;
227 } else if (IN6_IS_ADDR_V4MAPPED(ipv6addr.s6_addr)) {
228 memcpy(&(in.s_addr),ipv6addr.s6_addr+12,4);
229 return true;
230 } else return false;
231} // get_ip
232
233/** Get IP address as an in6_addr.
234 * If this is an IPv4 address, it is mapped to IPv6.
235 * @return true since this is always possible.
236 */
237bool hostaddress::get_ip(struct in6_addr& in) const {
238 if (ipv4flag) {
239 // map to IPv6
240 memset(in.s6_addr,0,10);
241 memset(in.s6_addr+10,255,2);
242 memcpy(in.s6_addr+12,&(ipv4addr.s_addr),4);
243 } else in = ipv6addr;
244 return true;
245} // get_ip
246
247/// returns false if address is not allowed to be used
248/// as source address: loopback, multicast, broadcast, unspecified
249bool
250hostaddress::is_bogus_source() const
251{
252 if (ipv4flag)
253 { // IPv4
254 if ( IN_MULTICAST(ipv4addr.s_addr) ||
255 ipv4addr.s_addr == INADDR_LOOPBACK ||
256 ipv4addr.s_addr == INADDR_ANY ||
257 ipv4addr.s_addr == INADDR_BROADCAST
258 )
259 {
260 return true;
261 }
262 }
263 else
264 { // IPv6
265 if ( ipv6addr.s6_addr == in6addr_any.s6_addr ||
266 ipv6addr.s6_addr == in6addr_loopback.s6_addr )
267 return true;
268 }
269
270 return false;
271}
272
273
274/** Convert the IP address to IPv6 by mapping it from IPv4 to IPv6 if
275 * necessary
276 */
277void hostaddress::convert_to_ipv6() {
278 if (ipv4flag) {
279 if (is_ip_unspec()) {
280 // clear IP and set to IPv6
281 clear_ip();
282 set_subtype(false);
283 } else {
284 // map to IPv6
285 struct in6_addr in;
286 get_ip(in);
287 // set IP
288 set_ip(in);
289 } // end if is_ip_unspec()
290 } // end if ipv4flag
291} // end convert_to_ipv6
292
293/** Two addresses are equivalent if they are equal after converting both to
294 * IPv6.
295 */
296bool hostaddress::equiv(const hostaddress& h) const {
297 bool thisipv4 = is_ipv4();
298 bool result = false;
299 hostaddress* ipv4haddr = NULL;
300 const hostaddress* ipv6haddr = NULL;
301 // if both IPv4 or both IPv6 then just test for equality
302 if (thisipv4==h.is_ipv4()) return operator==(h);
303 // OK, one is IPv6 and the other is IPv4 (to be converted!).
304 // Allocating memory dynamically because I do not know the concrete
305 // type of *this or h.
306 try {
307 if (thisipv4) {
308 ipv6haddr = &h;
309 if (h.is_mapped_ip()) ipv4haddr = this->copy();
310 } else {
311 ipv6haddr = this;
312 if (is_mapped_ip()) ipv4haddr = h.copy();
313 } // end if thisipv4
314 } catch(IEError&) { ipv4haddr = NULL; }
315 if (ipv4haddr) {
316 ipv4haddr->convert_to_ipv6();
317 result = ((*ipv4haddr)==(*ipv6haddr));
318 delete ipv4haddr;
319 return result;
320 } else return false;
321} // end equiv
322
323
324/** Set subtype and IPv4 flag. This does NOT clear the outstring buffer.
325 * Use clear_ip().
326 */
327void hostaddress::set_subtype(bool ipv4) {
328 ipv4flag = ipv4;
329 subtype = ipv4flag ? IPv4HostAddress : IPv6HostAddress;
330} // end set_subtype
331
332/** Clear the IP address buffer and the outstring if it exists. */
333void hostaddress::clear_ip() {
334 // only need to clear ipv6 because of union
335 ipv6addr = in6addr_any;
336 if (outstring) {
337 delete[] outstring;
338 outstring = NULL;
339 } // end if outstring
340} // end clear_ip
341
342
343/** Match this IP address against another IP address.
344 * Two IP addresses match if they are equal.
345 * @return -1 on no match or error, e.g. when IPv4 and IPv6 are matched
346 * @return the length of the matched prefix.
347 */
348int hostaddress::match_against(const hostaddress& ha) const {
349 if (ipv4flag==ha.ipv4flag) {
350 if (operator==(ha)) {
351 if (ipv4flag) return 32;
352 else return 128;
353 } else return -1;
354 } else return -1;
355} // end match_against(
356
357/** Match this IP address against the given network prefix.
358 * @return -1 on no match or error, e.g. when IPv4 and IPv6 are matched
359 * @return the length of the matched prefix.
360 */
361int hostaddress::match_against(const netaddress& na) const {
362 uint32 word1 = 0;
363 uint32 word2 = 0;
364 const prefix_length_t preflen = na.get_pref_len();
365 prefix_length_t lenwords = preflen/32;
366 prefix_length_t lenbits = preflen%32;
367 // now 0<=lenwords<=4, 0<=lenbits<=31
368 prefix_length_t i;
369 const hostaddress& ha = dynamic_cast<const hostaddress&>(na);
370 if (ipv4flag==na.ipv4flag) {
371 if (ipv4flag) {
372 if (preflen >= 32)
373 lenbits = 32;
374 // match IPv4
375 word1 = ntohl(ipv4addr.s_addr);
376 word2 = ntohl(ha.ipv4addr.s_addr);
377 // shift right
378 word1 >>= (32-lenbits);
379 word2 >>= (32-lenbits);
380 if (word1==word2) return preflen;
381 else return -1;
382 } else {
383 if (preflen > 128)
384 return -1;
385 // match IPv6
386 // match words
387 for (i=0;i<lenwords;i++) {
388 word1 = ntohl(ipv6addr.s6_addr32[i]); // RB: as long as both words are in same order we dont need ntohl?!
389 word2 = ntohl(ha.ipv6addr.s6_addr32[i]);
390 if (word1!=word2) return -1;
391 } // end for i
392 // now i points to the next word to be matched
393 // match bits
394 if (lenbits) {
395 word1 = ntohl(ipv6addr.s6_addr32[i]);
396 word2 = ntohl(ha.ipv6addr.s6_addr32[i]);
397 // shift right
398 word1 >>= (32-lenbits);
399 word2 >>= (32-lenbits);
400 if (word1==word2) return preflen;
401 else return -1;
402 } else {
403 // no extra bits to match and everything OK
404 return preflen;
405 } // end if lenbits
406 } // end if ipv4flag
407 } else return -1;
408} // end match_against
409
410/***** class appladdress *****/
411
412/***** inherited from IE *****/
413
414appladdress* appladdress::new_instance() const {
415 appladdress* aa = NULL;
416 catch_bad_alloc(aa = new appladdress());
417 return aa;
418} // end new_instance
419
420appladdress* appladdress::copy() const {
421 appladdress* aa = NULL;
422 catch_bad_alloc(aa = new appladdress(*this));
423 return aa;
424} // end copy
425
426bool appladdress::operator==(const address& ie) const {
427 const appladdress* app = dynamic_cast<const appladdress*>(&ie);
428 if (app) {
429 // if the IEs are equal when casted to type hostaddress, then
430 // only protocols and ports have to be checked.
431 // Otherwise they are not equal.
432 if (hostaddress::operator==(ie)) {
[5876]433 //if (proto!=app->proto) cout << "protocols not matching" << endl;
434 //if (port !=app->port) cout << "ports not matching" << endl;
[5284]435
436 return ((proto==app->proto) && (port==app->port));
437 } else return false;
438 } else return false;
439} // end operator==
440
441
442/***** class netaddress *****/
443
444/***** inherited from IE *****/
445
446netaddress* netaddress::new_instance() const {
447 netaddress* na = NULL;
448 catch_bad_alloc(na = new netaddress());
449 return na;
450} // end new_instance
451
452netaddress* netaddress::copy() const {
453 netaddress* na = NULL;
454 catch_bad_alloc(na = new netaddress(*this));
455 return na;
456} // end copy
457
458bool netaddress::operator==(const address& ie) const {
459 const netaddress* na = dynamic_cast<const netaddress*>(&ie);
460 if (na) {
461 // if the IEs are equal when casted to type hostaddress, then
462 // only prefix lengths have to be checked.
463 // Otherwise they are not equal.
464 if (hostaddress::operator==(ie)) {
465 if (prefix_length!=na->prefix_length) cout << "Prefix length not matching" << endl;
466 return (prefix_length==na->prefix_length);
467 } else return false;
468 } else return false;
469} // end operator==
470
471
472/***** inherited from hostaddress *****/
473
474/** Convert the IP address to IPv6 by mapping it from IPv4 to IPv6 if
475 * necessary. The prefix length is converted, too.
476 */
477void netaddress::convert_to_ipv6() {
478 if (ipv4flag) {
479 // map IP
480 hostaddress::convert_to_ipv6();
481 // adjust prefix length
482 set_pref_len(prefix_length+96);
483 } // end if ipv4flag
484} // end convert_to_ipv6
485
486/** Set subtype and IPv4 flag. This does NOT clear the outstring buffer.
487 * Use clear_ip().
488 * In addition the prefix length is checked and set to reasonable values.
489 */
490void netaddress::set_subtype(bool ipv4) {
491 ipv4flag = ipv4;
492 if (ipv4) {
493 subtype = IPv4NetAddress;
494 if (prefix_length>32) prefix_length = 32;
495 } else {
496 subtype = IPv6NetAddress;
497 if (prefix_length>128) prefix_length = 128;
498 } // end if ipv4flag
499} // end set_subtype
500
501/***** new members in netaddress *****/
502
503/** Constructor sets address type and clears prefix length. */
504netaddress::netaddress() :
505 hostaddress(),
506 prefix_length(0)
507 {
508 set_subtype(ipv4flag);
509} // end constructor
510
511netaddress::netaddress(const netaddress& na) : hostaddress(na) {
512 prefix_length = na.prefix_length;
513 set_subtype(ipv4flag);
514} // end copy constructor
515
516/** Initialize with the given host address and prefix length.
517 * Prefix length is optional and set to 0 if missing.
518 */
519netaddress::netaddress(const hostaddress& h, prefix_length_t len) : hostaddress(h) {
520 set_subtype(ipv4flag);
521 set_pref_len(len); // this will cut the prefix value accordingly
522} // end constructor(hostaddress,len)
523
524/** Initialize from string which contains IP and prefix length separated by
525 * '/'.
526 */
527netaddress::netaddress(const char* str, bool *res) : hostaddress() {
528 bool tmpres = true; // MUST BE true
529 bool tmpres2 = false;
530 long int len = 0;
531 uint32 iplen;
532 char* i = NULL;
533 char* errptr = NULL;
534 char ipstr[INET6_ADDRSTRLEN] = {0};
535 // look for /
[6786]536 i = strchr((char*)str,'/');
[5284]537 if (i) {
538 iplen = i-str;
539 i++;
540 // decode prefix length
541 len = strtol(i,&errptr,10);
542 if ((*i) && errptr && ((*errptr)==0)) {
543 // prefix OK
544 prefix_length = len;
545 } else {
546 prefix_length = 0;
547 tmpres = false;
548 } // end if prefix OK
549 if (iplen<=INET6_ADDRSTRLEN) {
550 // copy IP string
551 strncpy(ipstr,str,iplen);
552 ipstr[INET6_ADDRSTRLEN-1] = 0;
553 // set str to ipstr
554 str = ipstr;
555 } // end if iplen valid
556 } else {
557 // no prefix found, OK
558 prefix_length = 0;
559 } // end if i
560 // set IP, this also sets ipvflag.
561 tmpres2 = set_ip(str);
562 if (res) *res = (tmpres && tmpres2);
563 set_subtype(ipv4flag);
564} // end constructor(string)
565
566/** Initialize from string and prefix length.
567 * If the string does not contain a valid IP address, it is set to all 0 by
568 * the hostaddress constructor.
569 */
570netaddress::netaddress(const char* str, prefix_length_t len, bool *res) : hostaddress(str,res) {
571 set_subtype(ipv4flag);
572 set_pref_len(len); // this will cut the prefix value accordingly
573} // end constructor(string,port)
574
575/** Assigns the given netaddress address by using hostaddress::operator=(). */
576netaddress& netaddress::operator=(const netaddress& na) {
577 prefix_length = na.prefix_length;
578 hostaddress::operator=(na);
579 return *this;
580} // end operator=
581
582
583/** Assigns the given netaddress address by using hostaddress::operator=(). */
584netaddress& netaddress::operator=(const hostaddress& na) {
585 hostaddress::operator=(na);
586 set_pref_len(128);
587 return *this;
588} // end operator=
589
590
591/** Set prefix length and return old value.
592 * will also cut prefix_length if needed (i.e., if len too large for addr type)
593 */
594prefix_length_t netaddress::set_pref_len(prefix_length_t len) {
595 register prefix_length_t olen = prefix_length;
596 prefix_length = ipv4flag ? ( (len>32) ? 32 : len ) :
597 ( (len>128) ? 128 : len );
598 return olen;
599} // end set_port
600
601
602
603/** Compare two netaddress objects. If neither a<b and b<a then a and b are
604 * considered equal.
605 */
606bool netaddress::operator<(const netaddress& na) const {
607 uint32 word1 = 0;
608 uint32 word2 = 0;
609 prefix_length_t lenwords = prefix_length/32;
610 prefix_length_t lenbits = prefix_length%32;
611 // now 0<=lenwords<=4, 0<=lenbits<=31
612 prefix_length_t i;
613 // IPv4 is always < IPv6
614 if ((!ipv4flag) && na.ipv4flag) return false;
615 else if (ipv4flag && (!na.ipv4flag)) return true;
616 // now ipv4flag == na.ipv4flag
617 else if (prefix_length<na.prefix_length) return true;
618 else if (prefix_length>na.prefix_length) return false;
619 // now prefix_length == na.prefix_length
620 else if (ipv4flag) {
621 // compare IPv4 with same prefix length
622 word1 = ntohl(ipv4addr.s_addr);
623 word2 = ntohl(na.ipv4addr.s_addr);
624 // shift right
625 word1 >>= (32-lenbits);
626 word2 >>= (32-lenbits);
627 if (word1<word2) return true;
628 else return false;
629 } else {
630 // compare IPv6 with same prefix length
631 // compare words
632 for (i=0;i<lenwords;i++) {
633 word1 = ntohl(ipv6addr.s6_addr32[i]);
634 word2 = ntohl(na.ipv6addr.s6_addr32[i]);
635 if (word1<word2) return true;
636 if (word1>word2) return false;
637 } // end for i
638 // now i points to the next word to be compared and previous words are equal
639 // compare bits
640 if (lenbits) {
641 word1 = ntohl(ipv6addr.s6_addr32[i]);
642 word2 = ntohl(na.ipv6addr.s6_addr32[i]);
643 // shift right
644 word1 >>= (32-lenbits);
645 word2 >>= (32-lenbits);
646 if (word1<word2) return true;
647 else return false;
648 } else {
649 // no extra bist to compare and everything equal
650 return false;
651 } // end if lenbits
652 } // end if ipv4flag, prefox
653} // end match_against
654
655/**
656 * Compare function for the radix trie:
657 *
658 * Compare this and na from *pos up to max(this->prefix, na->prefix)
659 *
660 * In pos return the position where the compare ended.
661 *
662 * The return value is 0 if the strings are equal and all of this' string
663 * was consumed, otherwise the sign will indicate the bit in this' string
664 * at pos (i.e. if the search should continue left or right of na).
665 *
666 * pos < 0 indicates error
667 */
668int
669netaddress::rdx_cmp(const netaddress *na, int *pos) const
670{
671 if (na == NULL) {
672 *pos = -1;
673 return 0;
674 }
675
676 if (na->ipv4flag != ipv4flag ||
677 *pos > na->prefix_length ||
678 *pos > prefix_length) {
679 *pos = -1;
680 return 0;
681 }
682
683 if (na->prefix_length == 0) {
684 *pos = 1;
685 if (ipv4flag)
686 return ((ntohl(ipv4addr.s_addr) & 0x80000000) == 0 ?
687 -1 : 1);
688 else
689 return ((htonl(ipv6addr.s6_addr32[0]) & 0x80000000) == 0 ?
690 -1 : 1);
691 }
692
693 if (*pos < 0)
694 *pos = 0;
695
696 uint32_t w1, w2, w3;
697 int diff, i, p1, p2;
698
699 if (ipv4flag) {
700 diff = *pos;
701 w1 = ntohl(ipv4addr.s_addr);
702 w2 = ntohl(na->ipv4addr.s_addr);
703 // in w3 store the difference
704 w3 = w1 ^ w2;
705 // mask out anything after prefix_length and before *pos
706 w3 = (w3 >> (32 - prefix_length)) << (32 - prefix_length + diff);
707 if (w3 == 0 && prefix_length <= na->prefix_length) {
708 *pos = min(prefix_length, na->prefix_length);
709 return 0;
710 }
711 // pos = 0 means start up front, so we need to fix up to that
712 diff++;
713 while (diff <= prefix_length && diff <= na->prefix_length) {
714 if ((w3 & 0x80000000) != 0) {
715 *pos = diff;
716 return (((w1 & (1 << (32 - diff))) >>
717 (32 - diff)) == 0 ? -1 : 1);
718 }
719 w3 = w3 << 1;
720 diff++;
721 }
722 // difference past na->prefix_length
723 *pos = diff;
724 return (((w1 & (1 << (32 - diff))) >>
725 (32 - diff)) == 0 ? -1 : 1);
726 }
727
728 diff = *pos;
729 for (i = diff / 32; i < 4; i++) {
730 diff = diff % 32;
731 w1 = ntohl(ipv6addr.s6_addr32[i]);
732 w2 = ntohl(na->ipv6addr.s6_addr32[i]);
733 w3 = w1 ^ w2;
734 p1 = (prefix_length - (i * 32));
735 p1 = p1 > 32 ? 32 : p1;
736 p2 = (na->prefix_length - (i * 32));
737 p1 = p2 > 32 ? 32 : p2;
738
739 w3 = (w3 >> (32 - p1)) << (32 - p1 + diff);
740 if (w3 == 0 && prefix_length <= na->prefix_length) {
741 *pos = min(prefix_length, na->prefix_length);
742 if (prefix_length <= ((i + 1) * 32))
743 return 0;
744 }
745 // pos = 0 means start up front, so we need to fix up to that
746 diff++;
747 while (diff <= p1 && diff <= p2) {
748 if ((w3 & 0x80000000) != 0) {
749 *pos = diff + (i * 32);
750 return (((w1 & (1 << (32 - diff))) >>
751 (32 - diff)) == 0 ? -1 : 1);
752 }
753 w3 = w3 << 1;
754 diff++;
755 }
756 if (diff + (32 * i) <= prefix_length &&
757 diff + (32 * i) <= na->prefix_length) {
758 diff--;
759 continue;
760 }
761 // difference past na->prefix_length
762 *pos = diff + (i * 32);
763 if (diff == 33) {
764 diff = 1;
765 if (i == 3)
766 abort();
767 w1 = ntohl(ipv6addr.s6_addr32[i+1]);
768 }
769 return (((w1 & (1 << (32 - diff))) >>
770 (32 - diff)) == 0 ? -1 : 1);
771 }
772
773 // Not reachable, but gcc complains
774 return 0;
775}
776
777udsaddress* udsaddress::new_instance() const {
778 udsaddress* ha = NULL;
779 catch_bad_alloc(ha = new udsaddress());
780 return ha;
781} // end new_instance
782
783udsaddress* udsaddress::copy() const {
784 udsaddress* ha = NULL;
785 catch_bad_alloc(ha = new udsaddress(*this));
786 return ha;
787} // end copy
788
789bool udsaddress::operator==(const address& ie) const {
790 const udsaddress* app = dynamic_cast<const udsaddress*>(&ie);
791 if (app) {
792 return (app->socknum == socknum) && (app->uds_socket == uds_socket);
793 } else return false;
794} // end operator==
795
796AddressList::AddrProperty *AddressList::LocalAddr_P;
797AddressList::AddrProperty *AddressList::ConfiguredAddr_P;
798AddressList::AddrProperty *AddressList::IgnoreAddr_P;
799AddressList::AddrProperty *AddressList::AnyAddr_P;
800
801AddressList::AddressList()
802{
803 if (LocalAddr_P == 0) {
804 LocalAddr_P = new AddrProperty("local");
805 ConfiguredAddr_P = new AddrProperty("configured");
806 IgnoreAddr_P = new AddrProperty("ignore");
807 AnyAddr_P = new AddrProperty("wildcard");
808 }
809 interfaces = 0;
810}
811
812AddressList::~AddressList()
813{
814 // Refcount AddressLists in order to GC properties?
815}
816
817AddressList::iflist_t *
818AddressList::get_interfaces()
819{
820 iflist_t *iflist;
821
822 if (interfaces != 0)
823 iflist = new iflist_t(*interfaces);
824 else {
825 iflist = new iflist_t();
826 getifaddrs_iflist(*iflist);
827 }
828
829 return iflist;
830}
831
832bool
833AddressList::by_interface(bool start_empty)
834{
835 if (interfaces != 0)
836 return false;
837
838 interfaces = new iflist_t();
839 if (!start_empty)
840 getifaddrs_iflist(*interfaces);
841
842 return true;
843}
844
845bool
846AddressList::add_interface(char *name)
847{
848 if (interfaces == 0)
849 return false;
850
851 return (interfaces->insert(name)).second;
852}
853
854bool
855AddressList::del_interface(char *name)
856{
857 if (interfaces == 0)
858 return false;
859
860 return (interfaces->erase(name) > 0);
861}
862
863bool
864AddressList::add_property(netaddress &na, AddrProperty *p, bool propagate)
865{
866 propmap_t *props, *lpfm_props;
867 propmap_t::iterator it;
868 addr2prop_t::node *node;
869
870 node = prop_trie.lookup_node(na, false, false);
871 if (node != NULL) {
872 props = node->data;
873 if (props == NULL) {
874 props = new propmap_t();
875 node->data = props;
876 }
877 props->insert(pair<AddrProperty *, bool>(p, propagate));
878
879 } else {
880 props = new propmap_t();
881 props->insert(pair<AddrProperty *, bool>(p, propagate));
882 node = prop_trie.insert(na, *props);
883 }
884
885 if (propagate)
886 bequeath(node, p, true);
887
888 // copy lpfm properties
889 lpfm_props = prop_trie.lookup(na, true);
890 if (lpfm_props == NULL)
891 return true;
892
893 for (it = lpfm_props->begin(); it != lpfm_props->end(); it++) {
894 if ((*it).second)
895 props->insert((*it));
896 }
897
898 return true;
899}
900
901bool
902AddressList::del_property(netaddress &na, AddrProperty *p, bool propagate)
903{
904 propmap_t *props, *lpfm_props;
905 propmap_t::iterator it;
906 addr2prop_t::node *node;
907
908 node = prop_trie.lookup_node(na, false, true);
909 if (node == NULL) {
910 // no exact match
911 if (!propagate) {
912 node = prop_trie.lookup_node(na, true, true);
913 if (node == NULL) {
914 // no lpfm either, we're done
915 return false;
916 }
917
918 props = node->data;
919 it = props->find(p);
920 if (it == props->end()) {
921 // lpfm doesn't have p set -> done
922 return false;
923 }
924 }
925 // insert an empty propmap
926 props = new propmap_t();
927 node = prop_trie.insert(na, *props);
928
929 // copy other lpfm properties
930 lpfm_props = prop_trie.lookup(na, true);
931 if (p != AnyAddr_P && lpfm_props != NULL) {
932 for (it = lpfm_props->begin(); it != lpfm_props->end();
933 it++) {
934 if ((*it).first != p && (*it).second)
935 props->insert((*it));
936 }
937 }
938 } else {
939 props = node->data;
940 if (p == AnyAddr_P) {
941 props->clear();
942 } else {
943 it = props->find(p);
944 if (it == props->end() && !propagate)
945 return false;
946
947 props->erase(it);
948 }
949 }
950
951 if (propagate)
952 bequeath(node, p, false);
953
954 return true;
955}
956
957bool
958AddressList::add_host_prop(const char *name, AddrProperty *p)
959{
960 netaddress na;
961 sockaddr_in *sin;
962 sockaddr_in6 *sin6;
963 struct addrinfo hints = {0}, *res, *cur;
964 int error;
965 char buf[1024];
966
967 if (name == NULL) {
968 name = buf;
969 if (gethostname(buf, sizeof(buf)) != 0)
970 return false;
971 buf[sizeof(buf) - 1] = '\0';
972 }
973 hints.ai_flags = AI_ADDRCONFIG | AI_CANONNAME;
974 hints.ai_family = AF_UNSPEC;
975 error = getaddrinfo(name, NULL, &hints, &res);
976 if (error != 0)
977 return false;
978
979 for(cur = res; cur != NULL && error == 0; cur = cur->ai_next) {
980 if (cur->ai_family == AF_INET) {
981 sin = (struct sockaddr_in *)cur->ai_addr;
982 na.set_ip(sin->sin_addr);
983 na.set_pref_len(32);
984 } else if (cur->ai_family == AF_INET6) {
985 sin6 = (struct sockaddr_in6 *)cur->ai_addr;
986 na.set_ip(sin6->sin6_addr);
987 na.set_pref_len(128);
988 } else
989 continue;
990
991 // cout << ++i << "XXMOB: " << na << endl;
992
993 error += add_property(na, p) ? 0 : 1;
994 // XXXMOB: for some reason we need a 'reset' here
995 // if we want to use /etc/hosts
996 na.set_ip("127.0.0.1");
997 }
998 freeaddrinfo(res);
999
1000 return (error == 0);
1001}
1002
1003bool
1004AddressList::del_host_prop(const char *name, AddrProperty *p)
1005{
1006 netaddress na;
1007 sockaddr_in *sin;
1008 sockaddr_in6 *sin6;
1009 struct addrinfo hints = {0}, *res, *cur;
1010 int error;
1011 char buf[1024];
1012
1013 if (name == NULL) {
1014 name = buf;
1015 if (gethostname(buf, sizeof(buf)) != 0)
1016 return false;
1017 buf[sizeof(buf) - 1] = '\0';
1018 }
1019 hints.ai_flags = AI_ADDRCONFIG;
1020 hints.ai_family = AF_UNSPEC;
1021 error = getaddrinfo(name, NULL, &hints, &res);
1022 if (error != 0)
1023 return false;
1024
1025 for(cur = res; cur != NULL && error == 0; cur = cur->ai_next) {
1026 if (cur->ai_family == AF_INET) {
1027 sin = (struct sockaddr_in *)cur->ai_addr;
1028 na.set_ip(sin->sin_addr);
1029 na.set_pref_len(32);
1030 } else if (cur->ai_family == AF_INET6) {
1031 sin6 = (struct sockaddr_in6 *)cur->ai_addr;
1032 na.set_ip(sin6->sin6_addr);
1033 na.set_pref_len(128);
1034 } else
1035 continue;
1036
1037 error += del_property(na, p) ? 0 : 1;
1038 }
1039 freeaddrinfo(res);
1040
1041 return (error == 0);
1042}
1043
1044bool
1045AddressList::ignore(netaddress &na, bool propagate)
1046{
1047 del_property(na, AnyAddr_P, propagate);
1048 return add_property(na, IgnoreAddr_P);
1049}
1050
1051bool
1052AddressList::unignore(netaddress &na, bool propagate)
1053{
1054 return del_property(na, IgnoreAddr_P, propagate);
1055}
1056
1057bool
1058AddressList::ignore_bogons(void)
1059{
1060 netaddress na;
1061
1062 // according to IANA Tue Apr 17 09:14:31 PDT 2007
1063 na.set_ip("0.0.0.0");na.set_pref_len(7);
1064 ignore(na);
1065 na.set_ip("2.0.0.0");na.set_pref_len(8);
1066 ignore(na);
1067 na.set_ip("5.0.0.0");na.set_pref_len(8);
1068 ignore(na);
1069 na.set_ip("7.0.0.0");na.set_pref_len(8);
1070 ignore(na);
1071 na.set_ip("23.0.0.0");na.set_pref_len(8);
1072 ignore(na);
1073 na.set_ip("27.0.0.0");na.set_pref_len(8);
1074 ignore(na);
1075 na.set_ip("31.0.0.0");na.set_pref_len(8);
1076 ignore(na);
1077 na.set_ip("36.0.0.0");na.set_pref_len(7);
1078 ignore(na);
1079 na.set_ip("39.0.0.0");na.set_pref_len(8);
1080 ignore(na);
1081 na.set_ip("42.0.0.0");na.set_pref_len(8);
1082 ignore(na);
1083 na.set_ip("49.0.0.0");na.set_pref_len(8);
1084 ignore(na);
1085 na.set_ip("50.0.0.0");na.set_pref_len(8);
1086 ignore(na);
1087 na.set_ip("94.0.0.0");na.set_pref_len(7);
1088 ignore(na);
1089 na.set_ip("100.0.0.0");na.set_pref_len(6);
1090 ignore(na);
1091 na.set_ip("104.0.0.0");na.set_pref_len(5);
1092 ignore(na);
1093 na.set_ip("112.0.0.0");na.set_pref_len(6);
1094 ignore(na);
1095 na.set_ip("169.254.0.0");na.set_pref_len(16);
1096 ignore(na);
1097 na.set_ip("173.0.0.0");na.set_pref_len(8);
1098 ignore(na);
1099 na.set_ip("174.0.0.0");na.set_pref_len(7);
1100 ignore(na);
1101 na.set_ip("176.0.0.0");na.set_pref_len(5);
1102 ignore(na);
1103 na.set_ip("184.0.0.0");na.set_pref_len(6);
1104 ignore(na);
1105 na.set_ip("191.0.0.0");na.set_pref_len(8);
1106 ignore(na);
1107 na.set_ip("192.0.2.0");na.set_pref_len(24);
1108 ignore(na);
1109 na.set_ip("197.0.0.0");na.set_pref_len(8);
1110 ignore(na);
1111 na.set_ip("198.18.0.0");na.set_pref_len(15);
1112 ignore(na);
1113 na.set_ip("223.0.0.0");na.set_pref_len(8);
1114 ignore(na);
1115 na.set_ip("240.0.0.0");na.set_pref_len(4);
1116 ignore(na);
1117 // according to http://www.cymru.com/Documents/bogonv6-list.html#agg
1118 na.set_ip("0000::");na.set_pref_len(8);
1119 ignore(na);
1120 na.set_ip("0100::");na.set_pref_len(8);
1121 ignore(na);
1122 na.set_ip("0200::");na.set_pref_len(7);
1123 ignore(na);
1124 na.set_ip("0400::");na.set_pref_len(7);
1125 ignore(na);
1126 na.set_ip("0600::");na.set_pref_len(7);
1127 ignore(na);
1128 na.set_ip("0800::");na.set_pref_len(5);
1129 ignore(na);
1130 na.set_ip("1000::");na.set_pref_len(4);
1131 ignore(na);
1132 na.set_ip("2000::");na.set_pref_len(16);
1133 ignore(na);
1134 na.set_ip("2001:1000::");na.set_pref_len(23);
1135 ignore(na);
1136 na.set_ip("2001:1600::");na.set_pref_len(23);
1137 ignore(na);
1138 na.set_ip("2001:2000::");na.set_pref_len(20);
1139 ignore(na);
1140 na.set_ip("2001:3000::");na.set_pref_len(20);
1141 ignore(na);
1142 na.set_ip("2001:4000::");na.set_pref_len(20);
1143 ignore(na);
1144 na.set_ip("2001:5000::");na.set_pref_len(20);
1145 ignore(na);
1146 na.set_ip("2001:6000::");na.set_pref_len(20);
1147 ignore(na);
1148 na.set_ip("2001:7000::");na.set_pref_len(20);
1149 ignore(na);
1150 na.set_ip("2001:8000::");na.set_pref_len(20);
1151 ignore(na);
1152 na.set_ip("2001:9000::");na.set_pref_len(20);
1153 ignore(na);
1154 na.set_ip("2001:A000::");na.set_pref_len(20);
1155 ignore(na);
1156 na.set_ip("2001:B000::");na.set_pref_len(20);
1157 ignore(na);
1158 na.set_ip("2001:C000::");na.set_pref_len(20);
1159 ignore(na);
1160 na.set_ip("2001:D000::");na.set_pref_len(20);
1161 ignore(na);
1162 na.set_ip("2001:E000::");na.set_pref_len(20);
1163 ignore(na);
1164 na.set_ip("2001:F000::");na.set_pref_len(20);
1165 ignore(na);
1166 na.set_ip("3FFF::");na.set_pref_len(16);
1167 ignore(na);
1168 na.set_ip("4000::");na.set_pref_len(3);
1169 ignore(na);
1170 na.set_ip("6000::");na.set_pref_len(3);
1171 ignore(na);
1172 na.set_ip("8000::");na.set_pref_len(3);
1173 ignore(na);
1174 na.set_ip("A000::");na.set_pref_len(3);
1175 ignore(na);
1176 na.set_ip("C000::");na.set_pref_len(3);
1177 ignore(na);
1178 na.set_ip("E000::");na.set_pref_len(4);
1179 ignore(na);
1180 na.set_ip("F000::");na.set_pref_len(5);
1181 ignore(na);
1182 na.set_ip("F800::");na.set_pref_len(6);
1183 ignore(na);
1184 na.set_ip("FC00::");na.set_pref_len(7);
1185 ignore(na);
1186 na.set_ip("FE00::");na.set_pref_len(9);
1187 ignore(na);
1188
1189 return true;
1190}
1191
1192bool
1193AddressList::ignore_locals(void)
1194{
1195 netaddress na;
1196
1197 na.set_ip("10.0.0.0");na.set_pref_len(8);
1198 ignore(na);
1199 na.set_ip("172.16.0.0");na.set_pref_len(12);
1200 ignore(na);
1201 na.set_ip("192.168.0.0");na.set_pref_len(16);
1202 ignore(na);
1203 na.set_ip("FE80::");na.set_pref_len(10);
1204 ignore(na);
1205 na.set_ip("FEC0::");na.set_pref_len(10);
1206 ignore(na);
1207
1208 return true;
1209}
1210
1211bool
1212AddressList::ignore_loopback(void)
1213{
1214 netaddress na;
1215
1216 na.set_ip("127.0.0.0");na.set_pref_len(8);
1217 ignore(na);
1218 na.set_ip("::1");na.set_pref_len(128);
1219 ignore(na);
1220
1221 return true;
1222}
1223
1224bool
1225AddressList::addr_is(netaddress &na, AddrProperty *prop)
1226{
1227 propmap_t *props;
1228 propmap_t::iterator it;
1229
1230 if (addr_is_in(na, IgnoreAddr_P))
1231 return false;
1232
1233 props = prop_trie.lookup(na, false);
1234 if (props != NULL) {
1235 it = props->find(prop);
1236 if (it != props->end()) {
1237 return true;
1238 }
1239 }
1240
1241 if (prop != LocalAddr_P)
1242 return false;
1243
1244 return getifaddrs_is_local(na);
1245}
1246
1247bool
1248AddressList::addr_is_in(netaddress &na, AddrProperty *prop)
1249{
1250 addr2prop_t::node *node;
1251 propmap_t *props;
1252 propmap_t::iterator it;
1253
1254 node = prop_trie.lookup_node(na, true, true);
1255 if (node == NULL)
1256 return false;
1257
1258 props = node->data;
1259 it = props->find(prop);
1260 if (it == props->end())
1261 return false;
1262
1263 if (!(*it).second && props != prop_trie.lookup(na, false))
1264 return false;
1265
1266 return true;
1267}
1268
1269AddressList::addrlist_t *
1270AddressList::get_addrs(AddrProperty *prop)
1271{
1272 addr2prop_t::node *node;
1273 netaddress na;
1274 addrlist_t *res = new addrlist_t();
1275
1276 if (res == 0)
1277 return res;
1278
1279 if (prop == LocalAddr_P || prop == AnyAddr_P)
1280 getifaddrs_get_addrs(*res);
1281
1282 na.set_ip("0.0.0.0");
1283 na.set_pref_len(0);
1284 node = prop_trie.lookup_node(na, true, false);
1285 collect(node, prop, *res);
1286
1287 na.set_ip("::");
1288 node = prop_trie.lookup_node(na, true, false);
1289 collect(node, prop, *res);
1290
1291 return res;
1292}
1293
1294netaddress *
1295AddressList::get_first(AddrProperty *p, bool IPv4)
1296{
1297 addr2prop_t::node *node;
1298 netaddress na;
1299 addrlist_t list;
1300 addrlist_t::iterator it;
1301
1302 if (IPv4) {
1303 na.set_ip("0.0.0.0");
1304 na.set_pref_len(0);
1305 } else {
1306 na.set_ip("::");
1307 na.set_pref_len(0);
1308 }
1309
1310 node = prop_trie.lookup_node(na, true, false);
1311 node = collect_first(node, p);
1312 if (node != NULL)
1313 return new netaddress(*node->key);
1314
1315 if (p == LocalAddr_P) {
1316 getifaddrs_get_addrs(list);
1317 for (it = list.begin(); it != list.end(); it++)
1318 if ((*it).is_ipv4() == IPv4)
1319 return new netaddress(*it);
1320 }
1321
1322 return NULL;
1323}
1324
1325netaddress *
1326AddressList::get_src_addr(const netaddress &dest, uint32_t *prefs)
1327{
1328 netaddress *res;
1329 int sfd;
1330
1331 sfd = socket(dest.is_ipv4()?AF_INET:AF_INET6, SOCK_DGRAM, 0);
1332 if (sfd == -1)
1333 return NULL;
1334
1335#ifdef IPV6_ADDR_PREFERENCES
1336 if (prefs != NULL && setsockopt(s, IPV6_ADDR_PREFERENCES,
1337 (void *)prefs, sizeof (*prefs)) == -1) {
1338 close(sfd);
1339 return NULL;
1340 }
1341#endif
1342 if (dest.is_ipv4()) {
1343 struct sockaddr_in sin = {0};
1344 socklen_t slen = sizeof(sin);
1345 sin.sin_family = AF_INET;
1346 sin.sin_port = htons(4);
1347 dest.get_ip(sin.sin_addr);
1348 if (connect(sfd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
1349 close(sfd);
1350 return NULL;
1351 }
1352 if (getsockname(sfd, (struct sockaddr *)&sin, &slen) == -1) {
1353 close(sfd);
1354 return NULL;
1355 }
1356 close(sfd);
1357 res = new netaddress();
1358 res->set_ip(sin.sin_addr);
1359 res->set_pref_len(32);
1360 return (res);
1361 } else {
1362 struct sockaddr_in6 sin6 = {0};
1363 socklen_t slen = sizeof(sin6);
1364 sin6.sin6_family = AF_INET6;
1365 sin6.sin6_port = htons(4);
1366 dest.get_ip(sin6.sin6_addr);
1367 if (connect(sfd, (struct sockaddr *)&sin6,
1368 sizeof(sin6)) == -1) {
1369 close(sfd);
1370 return NULL;
1371 }
1372 if (getsockname(sfd, (struct sockaddr *)&sin6, &slen) == -1) {
1373 close(sfd);
1374 return NULL;
1375 }
1376 close(sfd);
1377 res = new netaddress();
1378 res->set_ip(sin6.sin6_addr);
1379 res->set_pref_len(128);
1380 return (res);
1381 }
1382}
1383
1384void
1385AddressList::getifaddrs_iflist(iflist_t &list)
1386{
1387 struct ifaddrs *ifap, *cifa;
1388
1389 if (::getifaddrs(&ifap) != 0)
1390 return;
1391
1392 for (cifa = ifap; cifa != NULL; cifa = cifa->ifa_next) {
1393 list.insert(cifa->ifa_name);
1394 }
1395
1396 freeifaddrs(ifap);
1397}
1398
1399bool
1400AddressList::getifaddrs_is_local(netaddress &na)
1401{
1402 struct ifaddrs *ifap, *cifa;
1403
1404 if (::getifaddrs(&ifap) != 0)
1405 return false;
1406
1407 for (cifa = ifap; cifa != NULL; cifa = cifa->ifa_next) {
1408 hostaddress ha;
1409
1410 if (cifa->ifa_addr->sa_family == AF_INET) {
1411 ha.set_ip(
1412 ((struct sockaddr_in *)cifa->ifa_addr)->sin_addr);
1413 } else if (cifa->ifa_addr->sa_family == AF_INET6) {
1414 ha.set_ip(
1415 ((struct sockaddr_in6 *)cifa->ifa_addr)->sin6_addr);
1416 } else {
1417 continue;
1418 }
1419
1420 if (interfaces &&
1421 interfaces->find(cifa->ifa_name) == interfaces->end())
1422 continue;
1423
1424 if (ha.match_against(na) >= na.get_pref_len()) {
1425 freeifaddrs(ifap);
1426 return true;
1427 }
1428 }
1429
1430 freeifaddrs(ifap);
1431
1432 return false;
1433}
1434
1435void
1436AddressList::getifaddrs_get_addrs(addrlist_t &list)
1437{
1438 struct ifaddrs *ifap, *cifa;
1439
1440 if (::getifaddrs(&ifap) != 0)
1441 return;
1442
1443 for (cifa = ifap; cifa != NULL; cifa = cifa->ifa_next) {
1444 hostaddress *ha;
1445 netaddress na;
1446
1447 if (interfaces &&
1448 interfaces->find(cifa->ifa_name) == interfaces->end())
1449 continue;
1450
1451 if (cifa->ifa_addr->sa_family == AF_INET) {
1452 ha = new hostaddress;
1453 ha->set_ip(
1454 ((struct sockaddr_in *)cifa->ifa_addr)->sin_addr);
1455 na.set_pref_len(32);
1456 } else if (cifa->ifa_addr->sa_family == AF_INET6) {
1457 ha = new hostaddress;
1458 ha->set_ip(
1459 ((struct sockaddr_in6 *)cifa->ifa_addr)->sin6_addr);
1460 na.set_pref_len(128);
1461 } else {
1462 continue;
1463 }
1464
1465 na.set_ip(*ha);
1466 if (!addr_is_in(na, IgnoreAddr_P))
1467 list.insert(*ha);
1468 }
1469
1470 freeifaddrs(ifap);
1471}
1472
1473void
1474AddressList::bequeath(addr2prop_t::node *head, AddrProperty *p, bool add)
1475{
1476 propmap_t *props;
1477 propmap_t::iterator it;
1478
1479 if (p == AnyAddr_P && add)
1480 return;
1481
1482 props = head->data;
1483 if (props != NULL) {
1484 if (p == AnyAddr_P) {
1485 props->clear();
1486 } else {
1487 if (add) {
1488 props->insert(pair<AddrProperty *, bool>
1489 (p, true));
1490 } else {
1491 it = props->find(p);
1492 if (it != props->end())
1493 props->erase(it);
1494 }
1495 }
1496 }
1497
1498 if (head->left->index > head->index)
1499 bequeath(head->left, p, add);
1500 if (head->right->index > head->index)
1501 bequeath(head->right, p, add);
1502}
1503
1504void
1505AddressList::collect(addr2prop_t::node *head, AddrProperty *p,
1506 addrlist_t &list)
1507{
1508 propmap_t *props;
1509 propmap_t::iterator it;
1510
1511 props = head->data;
1512 if (props != NULL) {
1513 if (p == AnyAddr_P) {
1514 it = props->begin();
1515 } else {
1516 it = props->find(p);
1517 }
1518 if (it != props->end()) {
1519 list.insert(*(new netaddress(*head->key)));
1520 }
1521 }
1522
1523 if (head->left->index > head->index)
1524 collect(head->left, p, list);
1525 if (head->right->index > head->index)
1526 collect(head->right, p, list);
1527
1528}
1529
1530AddressList::addr2prop_t::node *
1531AddressList::collect_first(addr2prop_t::node *head, AddrProperty *p)
1532{
1533 addr2prop_t::node *res = NULL;
1534 propmap_t *props;
1535 propmap_t::iterator it;
1536
1537 props = head->data;
1538 if (props != NULL) {
1539 if (p == AnyAddr_P) {
1540 it = props->begin();
1541 } else {
1542 it = props->find(p);
1543 }
1544 if (it != props->end()) {
1545 return head;
1546 }
1547 }
1548
1549 if (head->left->index > head->index) {
1550 res = collect_first(head->left, p);
1551 if (res != NULL)
1552 return res;
1553 }
1554 if (head->right->index > head->index) {
1555 res = collect_first(head->right, p);
1556 if (res != NULL)
1557 return res;
1558 }
1559
1560 return NULL;
1561}
1562
1563
1564} // end namespace protlib
Note: See TracBrowser for help on using the repository browser.