An Overlay-based
Virtual Network Substrate
SpoVNet

source: trash/old-modules/transport/protlib/address.cpp @ 5641

Last change on this file since 5641 was 5641, checked in by Christoph Mayer, 10 years ago
File size: 37.6 KB
Line 
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)) {
433                    if (proto!=app->proto) cout << "protocols not matching" << endl;
434                    if (port !=app->port) cout << "ports not matching" << endl;
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        const char* i = NULL;
533        char* errptr = NULL;
534        char ipstr[INET6_ADDRSTRLEN] = {0};
535        // look for /
536        i = strchr(str,'/');
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.