Interim refactoring commit

1 files changed, 0 insertions, 1267 deletions

diff --git a/cobbler/IPy.py b/cobbler/IPy.py
deleted file mode 100644
index f0d2bcb..0000000
--- a/cobbler/IPy.py
+++ /dev/null
@@ -1,1267 +0,0 @@
-""" IPy - class and tools for handling of IPv4 and IPv6 Addresses and Networks.
-
-$HeadURL: http://svn.23.nu/svn/repos/IPy/trunk/IPy.py $
-
-$Id: IPy.py 671 2004-08-22 21:02:29Z md $
-
-The IP class allows a comfortable parsing and handling for most
-notations in use for IPv4 and IPv6 Addresses and Networks. It was
-greatly inspired bei RIPE's Perl module NET::IP's interface but
-doesn't share the Implementation. It doesn't share non-CIDR netmasks,
-so funky stuff lixe a netmask 0xffffff0f can't be done here.
-
-    >>> ip = IP('127.0.0.0/30')
-    >>> for x in ip:
-    ...  print x
-    ...
-    127.0.0.0
-    127.0.0.1
-    127.0.0.2
-    127.0.0.3
-    >>> ip2 = IP('0x7f000000/30')
-    >>> ip == ip2
-    1
-    >>> ip.reverseNames()
-    ['0.0.0.127.in-addr.arpa.', '1.0.0.127.in-addr.arpa.', '2.0.0.127.in-addr.arpa.', '3.0.0.127.in-addr.arpa.']
-    >>> ip.reverseName()
-    '0-3.0.0.127.in-addr.arpa.'
-    >>> ip.iptype()
-    'PRIVATE'
-
-It can detect about a dozen different ways of expressing IP addresses
-and networks, parse them and distinguish between IPv4 and IPv6 addresses.
-
-    >>> IP('10.0.0.0/8').version()
-    4
-    >>> IP('::1').version()
-    6
-    >>> print IP(0x7f000001)
-    127.0.0.1
-    >>> print IP('0x7f000001')
-    127.0.0.1
-    >>> print IP('127.0.0.1')
-    127.0.0.1
-    >>> print IP('10')
-    10.0.0.0
-    >>> print IP('1080:0:0:0:8:800:200C:417A')
-    1080:0000:0000:0000:0008:0800:200c:417a
-    >>> print IP('1080::8:800:200C:417A')
-    1080:0000:0000:0000:0008:0800:200c:417a
-    >>> print IP('::1')
-    0000:0000:0000:0000:0000:0000:0000:0001
-    >>> print IP('::13.1.68.3')
-    0000:0000:0000:0000:0000:0000:0d01:4403
-    >>> print IP('127.0.0.0/8')
-    127.0.0.0/8
-    >>> print IP('127.0.0.0/255.0.0.0')
-    127.0.0.0/8
-    >>> print IP('127.0.0.0-127.255.255.255')
-    127.0.0.0/8
-
-Nearly all class methods which return a string have an optional
-parameter 'wantprefixlen' which controlles if the prefixlen or netmask
-is printed. Per default the prefilen is always shown if the net
-contains more than one address.
-
-wantprefixlen == 0 / None        don't return anything    1.2.3.0
-wantprefixlen == 1               /prefix                  1.2.3.0/24
-wantprefixlen == 2               /netmask                 1.2.3.0/255.255.255.0
-wantprefixlen == 3               -lastip                  1.2.3.0-1.2.3.255
-
-You can also change the defaults on an per-object basis by fiddeling with the class members
-
-NoPrefixForSingleIp
-WantPrefixLen
-
-    >>> IP('10.0.0.0/32').strNormal()
-    '10.0.0.0'
-    >>> IP('10.0.0.0/24').strNormal()
-    '10.0.0.0/24'
-    >>> IP('10.0.0.0/24').strNormal(0)
-    '10.0.0.0'
-    >>> IP('10.0.0.0/24').strNormal(1)
-    '10.0.0.0/24'
-    >>> IP('10.0.0.0/24').strNormal(2)
-    '10.0.0.0/255.255.255.0'
-    >>> IP('10.0.0.0/24').strNormal(3)
-    '10.0.0.0-10.0.0.255'
-    >>> ip = IP('10.0.0.0')
-    >>> print ip
-    10.0.0.0
-    >>> ip.NoPrefixForSingleIp = None
-    >>> print ip
-    10.0.0.0/32
-    >>> ip.WantPrefixLen = 3
-    >>> print ip
-    10.0.0.0-10.0.0.0
-
-
-Further Information might be available at http://c0re.jp/c0de/IPy/
-
-Hacked 2001 by drt@un.bewaff.net
-
-TODO:
-      * better comparison (__cmp__ and friends)
-      * tests for __cmp__
-      * always write hex values lowercase
-      * interpret 2001:1234:5678:1234/64 as 2001:1234:5678:1234::/64
-      * move size in bits into class variables to get rid of some "if self._ipversion ..."
-      * support for base85 encoding
-      * support for output of IPv6 encoded IPv4 Addresses
-      * update address type tables
-      * first-last notation should be allowed for IPv6
-      * add IPv6 docstring examples
-      * check better for negative parameters
-      * add addition / aggregation
-      * move reverse name stuff out of the classes and refactor it
-      * support for aggregation of more than two nets at once
-      * support for aggregation with "holes"
-      * support for finding common prefix
-      * '>>' and '<<' for prefix manipulation
-      * add our own exceptions instead ValueError all the time
-      * rename checkPrefix to checkPrefixOk
-      * add more documentation and doctests
-      * refactor
-"""
-
-__rcsid__ = '$Id: IPy.py 671 2004-08-22 21:02:29Z md $'
-__version__ = '0.42'
-
-import types
-
-# Definition of the Ranges for IPv4 IPs
-# this should include www.iana.org/assignments/ipv4-address-space
-# and www.iana.org/assignments/multicast-addresses
-IPv4ranges = {
-    '0'	   	        : 'PUBLIC',   # fall back
-    '00000000'		: 'PRIVATE',  # 0/8
-    '00001010'		: 'PRIVATE',  # 10/8
-    '01111111'		: 'PRIVATE',  # 127.0/8
-    '1'		        : 'PUBLIC',   # fall back
-    '101011000001'      : 'PRIVATE',  # 172.16/12
-    '1100000010101000'	: 'PRIVATE',  # 192.168/16
-    '11011111'		: 'RESERVED', # 223/8
-    '111'	        : 'RESERVED'  # 224/3
-    }
-
-# Definition of the Ranges for IPv6 IPs
-# see also www.iana.org/assignments/ipv6-address-space,
-# www.iana.org/assignments/ipv6-tla-assignments,
-# www.iana.org/assignments/ipv6-multicast-addresses,
-# www.iana.org/assignments/ipv6-anycast-addresses
-IPv6ranges = {
-    '00000000'              : 'RESERVED',       # ::/8
-    '00000001'              : 'UNASSIGNED',     # 100::/8
-    '0000001'               : 'NSAP',           # 200::/7
-    '0000010'               : 'IPX',            # 400::/7
-    '0000011'               : 'UNASSIGNED',     # 600::/7
-    '00001'                 : 'UNASSIGNED',     # 800::/5
-    '0001'                  : 'UNASSIGNED',     # 1000::/4
-    '0010000000000000'      : 'RESERVED',       # 2000::/16 Reserved
-    '0010000000000001'      : 'ASSIGNABLE',     # 2001::/16 Sub-TLA Assignments [RFC2450]
-    '00100000000000010000000': 'ASSIGNABLE IANA',  # 2001:0000::/29 - 2001:01F8::/29 IANA
-    '00100000000000010000001': 'ASSIGNABLE APNIC', # 2001:0200::/29 - 2001:03F8::/29 APNIC
-    '00100000000000010000010': 'ASSIGNABLE ARIN',  # 2001:0400::/29 - 2001:05F8::/29 ARIN
-    '00100000000000010000011': 'ASSIGNABLE RIPE',  # 2001:0600::/29 - 2001:07F8::/29 RIPE NCC
-    '0010000000000010'      : '6TO4',           # 2002::/16 "6to4" [RFC3056]
-    '0011111111111110'      : '6BONE',          # 3FFE::/16 6bone Testing [RFC2471]
-    '0011111111111111'      : 'RESERVED',       # 3FFF::/16 Reserved
-    '010'                   : 'GLOBAL-UNICAST', # 4000::/3
-    '011'                   : 'UNASSIGNED',     # 6000::/3
-    '100'                   : 'GEO-UNICAST',    # 8000::/3
-    '101'                   : 'UNASSIGNED',     # A000::/3
-    '110'                   : 'UNASSIGNED',     # C000::/3
-    '1110'                  : 'UNASSIGNED',     # E000::/4
-    '11110'                 : 'UNASSIGNED',     # F000::/5
-    '111110'                : 'UNASSIGNED',     # F800::/6
-    '1111110'               : 'UNASSIGNED',     # FC00::/7
-    '111111100'             : 'UNASSIGNED',     # FE00::/9
-    '1111111010'            : 'LINKLOCAL',      # FE80::/10
-    '1111111011'            : 'SITELOCAL',      # FEC0::/10
-    '11111111'              : 'MULTICAST',      # FF00::/8
-    '0' * 96                : 'IPV4COMP',       # ::/96
-    '0' * 80 + '1' * 16     : 'IPV4MAP',        # ::FFFF:0:0/96
-    '0' * 128               : 'UNSPECIFIED',    # ::/128
-    '0' * 127 + '1'         : 'LOOPBACK'        # ::1/128
-    }
-
-
-class IPint:
-    """Handling of IP addresses returning integers.
-
-    Use class IP instead because some features are not implemented for
-    IPint."""
-
-    def __init__(self, data, ipversion = 0):
-        """Create an instance of an IP object.
-
-        Data can be a network specification or a single IP. IP
-        Addresses can be specified in all forms understood by
-        parseAddress.() the size of a network can be specified as
-
-        /prefixlen        a.b.c.0/24               2001:658:22a:cafe::/64
-        -lastIP           a.b.c.0-a.b.c.255        2001:658:22a:cafe::-2001:658:22a:cafe:ffff:ffff:ffff:ffff
-        /decimal netmask  a.b.c.d/255.255.255.0    not supported for IPv6
-
-        If no size specification is given a size of 1 address (/32 for
-        IPv4 and /128 for IPv6) is assumed.
-
-        >>> print IP('127.0.0.0/8')
-        127.0.0.0/8
-        >>> print IP('127.0.0.0/255.0.0.0')
-        127.0.0.0/8
-        >>> print IP('127.0.0.0-127.255.255.255')
-        127.0.0.0/8
-
-        See module documentation for more examples.
-        """
-
-        self.NoPrefixForSingleIp = 1  # Print no Prefixlen for /32 and /128
-        self.WantPrefixLen = None     # Do we want prefix printed by default? see _printPrefix()
-
-        netbits = 0
-        prefixlen = -1
-
-        # handling of non string values in constructor
-        if type(data) == types.IntType or type(data) == types.LongType:
-            self.ip = long(data)
-            if ipversion == 0:
-                if self.ip < 0x100000000L:
-                    ipversion = 4
-                else:
-                    ipversion = 6
-            if ipversion == 4:
-                prefixlen = 32
-            elif ipversion == 6:
-                prefixlen = 128
-            else:
-                raise ValueError, "only IPv4 and IPv6 supported"
-            self._ipversion = ipversion
-            self._prefixlen = prefixlen
-        # handle IP instance as an parameter
-        elif isinstance(data, IPint):
-            self._ipversion = data._ipversion
-            self._prefixlen = data._prefixlen
-            self.ip = data.ip
-        else:
-            # TODO: refactor me!
-            # splitting of a string into IP and prefixlen et. al.
-            x = data.split('-')
-            if len(x) == 2:
-                # a.b.c.0-a.b.c.255 specification ?
-                (ip, last) = x
-                (self.ip, parsedVersion) = parseAddress(ip)
-                if parsedVersion != 4:
-                    raise ValueError, "first-last notation only allowed for IPv4"
-                (last, lastversion) = parseAddress(last)
-                if lastversion != 4:
-                    raise ValueError, "last address should be IPv4, too"
-                if last < self.ip:
-                    raise ValueError, "last address should be larger than first"
-                size = last - self.ip
-                netbits = _count1Bits(size)
-            elif len(x) == 1:
-                x = data.split('/')
-                # if no prefix is given use defaults
-                if len(x) == 1:
-                    ip = x[0]
-                    prefixlen = -1
-                elif len(x) > 2:
-                    raise ValueError, "only one '/' allowed in IP Address"
-                else:
-                    (ip, prefixlen) = x
-                    if prefixlen.find('.') != -1:
-                        # check if the user might have used a netmask like
-                        # a.b.c.d/255.255.255.0
-                        (netmask, vers) = parseAddress(prefixlen)
-                        if vers != 4:
-                            raise ValueError, "netmask must be IPv4"
-                        prefixlen = _netmaskToPrefixlen(netmask)
-            elif len(x) > 2:
-                raise ValueError, "only one '-' allowed in IP Address"
-            else:
-                raise ValueError, "can't parse"
-
-            (self.ip, parsedVersion) = parseAddress(ip)
-            if ipversion == 0:
-                ipversion = parsedVersion
-            if prefixlen == -1:
-                if ipversion == 4:
-                    prefixlen = 32 - netbits
-                elif ipversion == 6:
-                    prefixlen = 128 - netbits
-                else:
-                    raise ValueError, "only IPv4 and IPv6 supported"
-            self._ipversion = ipversion
-            self._prefixlen = int(prefixlen)
-
-            if not _checkNetaddrWorksWithPrefixlen(self.ip, self._prefixlen, self._ipversion):
-                raise ValueError, "%s goes not well with prefixlen %d" % (hex(self.ip), self._prefixlen)
-
-
-    def int(self):
-        """Return the first / base / network addess as an (long) integer.
-
-        The same as IP[0].
-
-        >>> hex(IP('10.0.0.0/8').int())
-        '0xA000000L'
-        """
-        return self.ip
-
-    def version(self):
-        """Return the IP version of this Object.
-
-        >>> IP('10.0.0.0/8').version()
-        4
-        >>> IP('::1').version()
-        6
-        """
-        return self._ipversion
-
-    def prefixlen(self):
-        """Returns Network Prefixlen.
-
-        >>> IP('10.0.0.0/8').prefixlen()
-        8
-        """
-        return self._prefixlen
-
-    def net(self):
-        """Return the base (first) address of a network as an (long) integer."""
-
-        return self.int()
-
-    def broadcast(self):
-        """Return the broadcast (last) address of a network as an (long) integer.
-
-        The same as IP[-1]."""
-        return self.int() + self.len() - 1
-
-    def _printPrefix(self, want):
-        """Prints Prefixlen/Netmask.
-
-        Not really. In fact it is our universal Netmask/Prefixlen printer.
-        This is considered an internel function.
-
-        want == 0 / None        don't return anything    1.2.3.0
-        want == 1               /prefix                  1.2.3.0/24
-        want == 2               /netmask                 1.2.3.0/255.255.255.0
-        want == 3               -lastip                  1.2.3.0-1.2.3.255
-        """
-
-        if (self._ipversion == 4 and self._prefixlen == 32) or \
-           (self._ipversion == 6 and self._prefixlen == 128):
-            if self.NoPrefixForSingleIp:
-                want = 0
-        if want == None:
-            want = self.WantPrefixLen
-            if want == None:
-                want = 1
-        if want:
-            if want == 2:
-                # this should work wit IP and IPint
-                netmask = self.netmask()
-                if type(netmask) != types.IntType and type(netmask) != types.LongType:
-                    netmask = netmask.int()
-                return "/%s" % (intToIp(netmask, self._ipversion))
-            elif want == 3:
-                return "-%s" % (intToIp(self.ip + self.len() - 1, self._ipversion))
-            else:
-                # default
-                return "/%d" % (self._prefixlen)
-        else:
-            return ''
-
-        # We have different Favours to convert to:
-        # strFullsize   127.0.0.1    2001:0658:022a:cafe:0200:c0ff:fe8d:08fa
-        # strNormal     127.0.0.1    2001:658:22a:cafe:200:c0ff:fe8d:08fa
-        # strCompressed 127.0.0.1    2001:658:22a:cafe::1
-        # strHex        0x7F000001L  0x20010658022ACAFE0200C0FFFE8D08FA
-        # strDec        2130706433   42540616829182469433547974687817795834
-
-    def strBin(self, wantprefixlen = None):
-        """Return a string representation as a binary value.
-
-        >>> print IP('127.0.0.1').strBin()
-        01111111000000000000000000000001
-        """
-
-
-        if self._ipversion == 4:
-            bits = 32
-        elif self._ipversion == 6:
-            bits = 128
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-        if self.WantPrefixLen == None and wantprefixlen == None:
-            wantprefixlen = 0
-        ret = _intToBin(self.ip)
-        return  '0' * (bits - len(ret)) + ret + self._printPrefix(wantprefixlen)
-
-    def strCompressed(self, wantprefixlen = None):
-        """Return a string representation in compressed format using '::' Notation.
-
-        >>> print IP('127.0.0.1').strCompressed()
-        127.0.0.1
-        >>> print IP('2001:0658:022a:cafe:0200::1').strCompressed()
-        2001:658:22a:cafe:200::1
-        """
-
-        if self.WantPrefixLen == None and wantprefixlen == None:
-            wantprefixlen = 1
-
-        if self._ipversion == 4:
-            return self.strFullsize(wantprefixlen)
-        else:
-            # find the longest sequence of '0'
-            hextets = [int(x, 16) for x in self.strFullsize(0).split(':')]
-            # every element of followingzeros will contain the number of zeros
-            # following the corrospondending element of hextetes
-            followingzeros = [0] * 8
-            for i in range(len(hextets)):
-                followingzeros[i] = _countFollowingZeros(hextets[i:])
-            # compressionpos is the position where we can start removing zeros
-            compressionpos = followingzeros.index(max(followingzeros))
-            if max(followingzeros) > 1:
-                # genererate string with the longest number of zeros cut out
-                # now we need hextets as strings
-                hextets = [x for x in self.strNormal(0).split(':')]
-                while compressionpos < len(hextets) and hextets[compressionpos] == '0':
-                    del(hextets[compressionpos])
-                hextets.insert(compressionpos, '')
-                if compressionpos + 1 >= len(hextets):
-                    hextets.append('')
-                if compressionpos == 0:
-                    hextets = [''] + hextets
-                return ':'.join(hextets) + self._printPrefix(wantprefixlen)
-            else:
-                return self.strNormal() + self._printPrefix(wantprefixlen)
-
-    def strNormal(self, wantprefixlen = None):
-        """Return a string representation in the usual format.
-
-        >>> print IP('127.0.0.1').strNormal()
-        127.0.0.1
-        >>> print IP('2001:0658:022a:cafe:0200::1').strNormal()
-        2001:658:22a:cafe:200:0:0:1
-        """
-
-        if self.WantPrefixLen == None and wantprefixlen == None:
-            wantprefixlen = 1
-
-        if self._ipversion == 4:
-            ret = self.strFullsize(0)
-        elif self._ipversion == 6:
-            ret = ':'.join([hex(x)[2:] for x in [int(x, 16) for x in self.strFullsize(0).split(':')]])
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-
-
-        return ret + self._printPrefix(wantprefixlen)
-
-    def strFullsize(self, wantprefixlen = None):
-        """Return a string representation in the non mangled format.
-
-        >>> print IP('127.0.0.1').strFullsize()
-        127.0.0.1
-        >>> print IP('2001:0658:022a:cafe:0200::1').strFullsize()
-        2001:0658:022a:cafe:0200:0000:0000:0001
-        """
-
-        if self.WantPrefixLen == None and wantprefixlen == None:
-            wantprefixlen = 1
-
-        return intToIp(self.ip, self._ipversion).lower() + self._printPrefix(wantprefixlen)
-
-    def strHex(self, wantprefixlen = None):
-        """Return a string representation in hex format.
-
-        >>> print IP('127.0.0.1').strHex()
-        0x7F000001
-        >>> print IP('2001:0658:022a:cafe:0200::1').strHex()
-        0x20010658022ACAFE0200000000000001
-        """
-
-        if self.WantPrefixLen == None and wantprefixlen == None:
-            wantprefixlen = 0
-
-        x = hex(self.ip)
-        if x[-1] == 'L':
-            x = x[:-1]
-        return x + self._printPrefix(wantprefixlen)
-
-    def strDec(self, wantprefixlen = None):
-        """Return a string representation in decimal format.
-
-        >>> print IP('127.0.0.1').strDec()
-        2130706433
-        >>> print IP('2001:0658:022a:cafe:0200::1').strDec()
-        42540616829182469433547762482097946625
-        """
-
-        if self.WantPrefixLen == None and wantprefixlen == None:
-            wantprefixlen = 0
-
-        x =  str(self.ip)
-        if x[-1] == 'L':
-            x = x[:-1]
-        return x + self._printPrefix(wantprefixlen)
-
-    def iptype(self):
-        """Return a description of the IP type ('PRIVATE', 'RESERVERD', etc).
-
-        >>> print IP('127.0.0.1').iptype()
-        PRIVATE
-        >>> print IP('192.168.1.1').iptype()
-        PRIVATE
-        >>> print IP('195.185.1.2').iptype()
-        PUBLIC
-        >>> print IP('::1').iptype()
-        LOOPBACK
-        >>> print IP('2001:0658:022a:cafe:0200::1').iptype()
-        ASSIGNABLE RIPE
-
-        The type information for IPv6 is out of sync with reality.
-        """
-
-        # this could be greatly improved
-
-        if self._ipversion == 4:
-            iprange = IPv4ranges
-        elif self._ipversion == 6:
-            iprange = IPv6ranges
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-        bits = self.strBin()
-        for i in range(len(bits), 0, -1):
-            if iprange.has_key(bits[:i]):
-                return iprange[bits[:i]]
-        return "unknown"
-
-
-    def netmask(self):
-        """Return netmask as an integer.
-
-        >>> print hex(IP('195.185.0.0/16').netmask().int())
-        0xFFFF0000L
-        """
-
-        # TODO: unify with prefixlenToNetmask?
-        if self._ipversion == 4:
-            locallen = 32 - self._prefixlen
-        elif self._ipversion == 6:
-            locallen = 128 - self._prefixlen
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-        return ((2L ** self._prefixlen) - 1) << locallen
-
-
-    def strNetmask(self):
-        """Return netmask as an string. Mostly useful for IPv6.
-
-        >>> print IP('195.185.0.0/16').strNetmask()
-        255.255.0.0
-        >>> print IP('2001:0658:022a:cafe::0/64').strNetmask()
-        /64
-        """
-
-        # TODO: unify with prefixlenToNetmask?
-        if self._ipversion == 4:
-            locallen = 32 - self._prefixlen
-            return intToIp(((2L ** self._prefixlen) - 1) << locallen, 4)
-        elif self._ipversion == 6:
-            locallen = 128 - self._prefixlen
-            return "/%d" % self._prefixlen
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-    def len(self):
-        """Return the length of an subnet.
-
-        >>> print IP('195.185.1.0/28').len()
-        16
-        >>> print IP('195.185.1.0/24').len()
-        256
-        """
-
-        if self._ipversion == 4:
-            locallen = 32 - self._prefixlen
-        elif self._ipversion == 6:
-            locallen = 128 - self._prefixlen
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-        return 2L ** locallen
-
-
-    def __len__(self):
-        """Return the length of an subnet.
-
-        Called to implement the built-in function len().
-        It breaks with IPv6 Networks. Anybody knows how to fix this."""
-
-        # Python < 2.2 has this silly restriction which breaks IPv6
-        # how about Python >= 2.2 ... ouch - it presists!
-
-        return int(self.len())
-
-
-    def __getitem__(self, key):
-        """Called to implement evaluation of self[key].
-
-        >>> ip=IP('127.0.0.0/30')
-        >>> for x in ip:
-        ...  print hex(x.int())
-        ...
-        0x7F000000L
-        0x7F000001L
-        0x7F000002L
-        0x7F000003L
-        >>> hex(ip[2].int())
-        '0x7F000002L'
-        >>> hex(ip[-1].int())
-        '0x7F000003L'
-        """
-
-        if type(key) != types.IntType and type(key) != types.LongType:
-            raise TypeError
-        if abs(key) >= self.len():
-            raise IndexError
-        if key < 0:
-            key = self.len() - abs(key)
-
-        return self.ip + long(key)
-
-
-
-    def __contains__(self, item):
-        """Called to implement membership test operators.
-
-        Should return true if item is in self, false otherwise. Item
-        can be other IP-objects, strings or ints.
-
-        >>> print IP('195.185.1.1').strHex()
-        0xC3B90101
-        >>> 0xC3B90101L in IP('195.185.1.0/24')
-        1
-        >>> '127.0.0.1' in IP('127.0.0.0/24')
-        1
-        >>> IP('127.0.0.0/24') in IP('127.0.0.0/25')
-        0
-        """
-
-        item = IP(item)
-        if item.ip >= self.ip and item.ip < self.ip + self.len() - item.len() + 1:
-            return 1
-        else:
-            return 0
-
-
-    def overlaps(self, item):
-        """Check if two IP address ranges overlap.
-
-        Returns 0 if the two ranged don't overlap, 1 if the given
-        range overlaps at the end and -1 if it does at the beginning.
-
-        >>> IP('192.168.0.0/23').overlaps('192.168.1.0/24')
-        1
-        >>> IP('192.168.0.0/23').overlaps('192.168.1.255')
-        1
-        >>> IP('192.168.0.0/23').overlaps('192.168.2.0')
-        0
-        >>> IP('192.168.1.0/24').overlaps('192.168.0.0/23')
-        -1
-        """
-
-        item = IP(item)
-        if item.ip >= self.ip and item.ip < self.ip + self.len():
-            return 1
-        elif self.ip >= item.ip and self.ip < item.ip + item.len():
-            return -1
-        else:
-            return 0
-
-
-    def __str__(self):
-        """Dispatch to the prefered String Representation.
-
-        Used to implement str(IP)."""
-
-        return self.strFullsize()
-
-
-    def __repr__(self):
-        """Print a representation of the Object.
-
-        Used to implement repr(IP). Returns a string which evaluates
-        to an identical Object (without the wnatprefixlen stuff - see
-        module docstring.
-
-        >>> print repr(IP('10.0.0.0/24'))
-        IP('10.0.0.0/24')
-        """
-
-        return("IPint('%s')" % (self.strCompressed(1)))
-
-
-    def __cmp__(self, other):
-        """Called by comparison operations.
-
-        Should return a negative integer if self < other, zero if self
-        == other, a positive integer if self > other.
-
-        Networks with different prefixlen are considered non-equal.
-        Networks with the same prefixlen and differing addresses are
-        considered non equal but are compared by thair base address
-        integer value to aid sorting of IP objects.
-
-        The Version of Objects is not put into consideration.
-
-        >>> IP('10.0.0.0/24') > IP('10.0.0.0')
-        1
-        >>> IP('10.0.0.0/24') < IP('10.0.0.0')
-        0
-        >>> IP('10.0.0.0/24') < IP('12.0.0.0/24')
-        1
-        >>> IP('10.0.0.0/24') > IP('12.0.0.0/24')
-        0
-
-        """
-
-        # Im not really sure if this is "the right thing to do"
-        if self._prefixlen < other.prefixlen():
-            return (other.prefixlen() - self._prefixlen)
-        elif self._prefixlen > other.prefixlen():
-
-            # Fixed bySamuel Krempp <krempp@crans.ens-cachan.fr>:
-
-            # The bug is quite obvious really (as 99% bugs are once
-            # spotted, isn't it ? ;-) Because of precedence of
-            # multiplication by -1 over the substraction, prefixlen
-            # differences were causing the __cmp__ function to always
-            # return positive numbers, thus the function was failing
-            # the basic assumptions for a __cmp__ function.
-
-            # Namely we could have (a > b AND b > a), when the
-            # prefixlen of a and b are different.  (eg let
-            # a=IP("1.0.0.0/24"); b=IP("2.0.0.0/16");) thus, anything
-            # could happen when launching a sort algorithm..
-            # everything's in order with the trivial, attached patch.
-
-            return (self._prefixlen - other.prefixlen()) * -1
-        else:
-            if self.ip < other.ip:
-                return -1
-            elif self.ip > other.ip:
-                return 1
-            else:
-                return 0
-
-
-    def __hash__(self):
-        """Called for the key object for dictionary operations, and by
-        the built-in function hash()  Should return a 32-bit integer
-        usable as a hash value for dictionary operations. The only
-        required property is that objects which compare equal have the
-        same hash value
-
-        >>> hex(IP('10.0.0.0/24').__hash__())
-        '0xf5ffffe7'
-        """
-
-        thehash = int(-1)
-        ip = self.ip
-        while ip > 0:
-            thehash = (thehash & 0xffffffff) ^ (ip & 0x7fffffff)
-            ip = ip >> 32
-        thehash = thehash ^ self._prefixlen
-        return int(thehash)
-
-
-class IP(IPint):
-    """Class for handling IP Addresses and Networks."""
-
-    def net(self):
-        """Return the base (first) address of a network as an IP object.
-
-        The same as IP[0].
-
-        >>> IP('10.0.0.0/8').net()
-        IP('10.0.0.0')
-        """
-        return IP(IPint.net(self))
-
-    def broadcast(self):
-        """Return the broadcast (last) address of a network as an IP object.
-
-        The same as IP[-1].
-
-        >>> IP('10.0.0.0/8').broadcast()
-        IP('10.255.255.255')
-        """
-        return IP(IPint.broadcast(self))
-
-    def netmask(self):
-        """Return netmask as an IP object.
-
-        >>> IP('10.0.0.0/8').netmask()
-        IP('255.0.0.0')
-         """
-        return IP(IPint.netmask(self))
-
-
-    def reverseNames(self):
-        """Return a list with values forming the reverse lookup.
-
-        >>> IP('213.221.113.87/32').reverseNames()
-        ['87.113.221.213.in-addr.arpa.']
-        >>> IP('213.221.112.224/30').reverseNames()
-        ['224.112.221.213.in-addr.arpa.', '225.112.221.213.in-addr.arpa.', '226.112.221.213.in-addr.arpa.', '227.112.221.213.in-addr.arpa.']
-        >>> IP('127.0.0.0/24').reverseNames()
-        ['0.0.127.in-addr.arpa.']
-        >>> IP('127.0.0.0/23').reverseNames()
-        ['0.0.127.in-addr.arpa.', '1.0.127.in-addr.arpa.']
-        >>> IP('127.0.0.0/16').reverseNames()
-        ['0.127.in-addr.arpa.']
-        >>> IP('127.0.0.0/15').reverseNames()
-        ['0.127.in-addr.arpa.', '1.127.in-addr.arpa.']
-        >>> IP('128.0.0.0/8').reverseNames()
-        ['128.in-addr.arpa.']
-        >>> IP('128.0.0.0/7').reverseNames()
-        ['128.in-addr.arpa.', '129.in-addr.arpa.']
-
-        """
-
-        if self._ipversion == 4:
-            ret =[]
-            # TODO: Refactor. Add support for IPint objects
-            if self.len() < 2**8:
-                for x in self:
-                    ret.append(x.reverseName())
-            elif self.len() < 2**16L:
-                for i in range(0, self.len(), 2**8):
-                    ret.append(self[i].reverseName()[2:])
-            elif self.len() < 2**24L:
-                for i in range(0, self.len(), 2**16):
-                    ret.append(self[i].reverseName()[4:])
-            else:
-                for i in range(0, self.len(), 2**24):
-                    ret.append(self[i].reverseName()[6:])
-            return ret
-        elif self._ipversion == 6:
-            s = hex(self.ip)[2:].lower()
-            if s[-1] == 'l':
-                s = s[:-1]
-            if self._prefixlen % 4 != 0:
-                raise NotImplementedError, "can't create IPv6 reverse names at sub nibble level"
-            s = list(s)
-            s.reverse()
-            s = '.'.join(s)
-            first_nibble_index = int(32 - (self._prefixlen / 4)) * 2
-            return ["%s.ip6.int." % s[first_nibble_index:]]
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-
-
-    def reverseName(self):
-        """Return the value for reverse lookup/PTR records as RfC 2317 look alike.
-
-        RfC 2317 is an ugly hack which only works for sub-/24 e.g. not
-        for /23. Do not use it. Better set up a Zone for every
-        address. See reverseName for a way to arcive that.
-
-        >>> print IP('195.185.1.1').reverseName()
-        1.1.185.195.in-addr.arpa.
-        >>> print IP('195.185.1.0/28').reverseName()
-        0-15.1.185.195.in-addr.arpa.
-        """
-
-        if self._ipversion == 4:
-            s = self.strFullsize(0)
-            s = s.split('.')
-            s.reverse()
-            first_byte_index = int(4 - (self._prefixlen / 8))
-            if self._prefixlen % 8 != 0:
-                nibblepart = "%s-%s" % (s[3-(self._prefixlen / 8)], intToIp(self.ip + self.len() - 1, 4).split('.')[-1])
-                if nibblepart[-1] == 'l':
-                    nibblepart = nibblepart[:-1]
-                nibblepart += '.'
-            else:
-                nibblepart = ""
-
-            s = '.'.join(s[first_byte_index:])
-            return "%s%s.in-addr.arpa." % (nibblepart, s)
-
-        elif self._ipversion == 6:
-            s = hex(self.ip)[2:].lower()
-            if s[-1] == 'l':
-                s = s[:-1]
-            if self._prefixlen % 4 != 0:
-                nibblepart = "%s-%s" % (s[self._prefixlen:], hex(self.ip + self.len() - 1)[2:].lower())
-                if nibblepart[-1] == 'l':
-                    nibblepart = nibblepart[:-1]
-                nibblepart += '.'
-            else:
-                nibblepart = ""
-            s = list(s)
-            s.reverse()
-            s = '.'.join(s)
-            first_nibble_index = int(32 - (self._prefixlen / 4)) * 2
-            return "%s%s.ip6.int." % (nibblepart, s[first_nibble_index:])
-        else:
-            raise ValueError, "only IPv4 and IPv6 supported"
-
-    def __getitem__(self, key):
-        """Called to implement evaluation of self[key].
-
-        >>> ip=IP('127.0.0.0/30')
-        >>> for x in ip:
-        ...  print str(x)
-        ...
-        127.0.0.0
-        127.0.0.1
-        127.0.0.2
-        127.0.0.3
-        >>> print str(ip[2])
-        127.0.0.2
-        >>> print str(ip[-1])
-        127.0.0.3
-        """
-        return IP(IPint.__getitem__(self, key))
-
-    def __repr__(self):
-        """Print a representation of the Object.
-
-        >>> IP('10.0.0.0/8')
-        IP('10.0.0.0/8')
-        """
-
-        return("IP('%s')" % (self.strCompressed(1)))
-
-    def __add__(self, other):
-        """Emulate numeric objects through network aggregation"""
-        if self.prefixlen() != other.prefixlen():
-            raise ValueError, "Only networks with the same prefixlen can be added."
-        if self.prefixlen < 1:
-            raise ValueError, "Networks with a prefixlen longer than /1 can't be added."
-        if self.version() != other.version():
-            raise ValueError, "Only networks with the same IP version can be added."
-        if self > other:
-            # fixed by Skinny Puppy <skin_pup-IPy@happypoo.com>
-            return other.__add__(self)
-        else:
-            ret = IP(self.int())
-            ret._prefixlen = self.prefixlen() - 1
-            return ret
-
-def parseAddress(ipstr):
-    """Parse a string and return the corrospondending IPaddress and the a guess of the IP version.
-
-    Following Forms ar recorgnized:
-    0x0123456789abcdef           # IPv4 if <= 0xffffffff else IPv6
-    123.123.123.123              # IPv4
-    123.123                      # 0-padded IPv4
-    1080:0000:0000:0000:0008:0800:200C:417A
-    1080:0:0:0:8:800:200C:417A
-    1080:0::8:800:200C:417A
-    ::1
-    ::
-    0:0:0:0:0:FFFF:129.144.52.38
-    ::13.1.68.3
-    ::FFFF:129.144.52.38
-    """
-
-    # TODO: refactor me!
-    if ipstr.startswith('0x'):
-        ret = long(ipstr[2:], 16)
-        if ret > 0xffffffffffffffffffffffffffffffffL:
-            raise ValueError, "%r: IP Address can't be bigger than 2^128" % (ipstr)
-        if ret < 0x100000000L:
-            return (ret, 4)
-        else:
-            return (ret, 6)
-
-    if ipstr.find(':') != -1:
-        # assume IPv6
-        if ipstr.find(':::') != -1:
-            raise ValueError, "%r: IPv6 Address can't contain ':::'" % (ipstr)
-        hextets = ipstr.split(':')
-        if ipstr.find('.') != -1:
-            # this might be a mixed address like '0:0:0:0:0:0:13.1.68.3'
-            (v4, foo) = parseAddress(hextets[-1])
-            assert foo == 4
-            del(hextets[-1])
-            hextets.append(hex(v4 >> 16)[2:-1])
-            hextets.append(hex(v4 & 0xffff)[2:-1])
-        if len(hextets) > 8:
-            raise ValueError, "%r: IPv6 Address with more than 8 hexletts" % (ipstr)
-        if len(hextets) < 8:
-            if '' not in hextets:
-                raise ValueError, "%r IPv6 Address with less than 8 hexletts and without '::'" % (ipstr)
-            # catch :: at the beginning or end
-            if hextets.index('') < len(hextets) - 1 and hextets[hextets.index('')+1] == '':
-                hextets.remove('')
-            # catch '::'
-            if hextets.index('') < len(hextets) - 1 and hextets[hextets.index('')+1] == '':
-                hextets.remove('')
-
-            for foo in range(9-len(hextets)):
-                hextets.insert(hextets.index(''), '0')
-            hextets.remove('')
-            if '' in hextets:
-                raise ValueError, "%r IPv6 Address may contain '::' only once" % (ipstr)
-        if '' in hextets:
-            raise ValueError, "%r IPv6 Address may contain '::' only if it has less than 8 hextets" % (ipstr)
-        num = ''
-        for x in hextets:
-            if len(x) < 4:
-                x = ((4 - len(x)) * '0') + x
-            if int(x, 16) < 0 or int(x, 16) > 0xffff:
-                raise ValueError, "%r: single hextet must be 0 <= hextet <= 0xffff which isn't true for %s" % (ipstr, x)
-            num += x
-        return (long(num, 16), 6)
-
-    elif len(ipstr) == 32:
-        # assume IPv6 in pure hexadecimal notation
-        return (long(ipstr, 16), 6)
-
-    elif  ipstr.find('.') != -1 or (len(ipstr) < 4 and int(ipstr) < 256):
-        # assume IPv4  ('127' gets interpreted as '127.0.0.0')
-        bytes = ipstr.split('.')
-        if len(bytes) > 4:
-            raise ValueError, "IPv4 Address with more than 4 bytes"
-        bytes += ['0'] * (4 - len(bytes))
-        bytes = [long(x) for x in bytes]
-        for x in bytes:
-            if x > 255 or x < 0:
-                raise ValueError, "%r: single byte must be 0 <= byte < 256" % (ipstr)
-        return ((bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3], 4)
-
-    else:
-        # we try to interprete it as a decimal digit -
-        # this ony works for numbers > 255 ... others
-        # will be interpreted as IPv4 first byte
-        ret = long(ipstr)
-        if ret > 0xffffffffffffffffffffffffffffffffL:
-            raise ValueError, "IP Address cant be bigger than 2^128"
-        if ret <= 0xffffffffL:
-            return (ret, 4)
-        else:
-            return (ret, 6)
-
-
-def intToIp(ip, version):
-    """Transform an integer string into an IP address."""
-
-    # just to be sure and hoping for Python 2.22
-    ip = long(ip)
-
-    if ip < 0:
-        raise ValueError, "IPs can't be negative: %d" % (ip)
-
-    ret = ''
-    if version == 4:
-        if ip > 0xffffffffL:
-            raise ValueError, "IPv4 Addresses can't be larger than 0xffffffff: %s" % (hex(ip))
-        for l in range(4):
-            ret = str(ip & 0xffL) + '.' + ret
-            ip = ip >> 8;
-        ret = ret[:-1]
-    elif version == 6:
-        if ip > 0xffffffffffffffffffffffffffffffffL:
-            raise ValueError, "IPv6 Addresses can't be larger than 0xffffffffffffffffffffffffffffffff: %s" % (hex(ip))
-        l = '0' * 32 + hex(ip)[2:-1]
-        for x in range(1,33):
-            ret = l[-x] + ret
-            if x % 4 == 0:
-                ret = ':' + ret
-        ret = ret[1:]
-    else:
-        raise ValueError, "only IPv4 and IPv6 supported"
-
-    return ret;
-
-def _ipVersionToLen(version):
-    """Return number of bits in address for a certain IP version.
-
-    >>> _ipVersionToLen(4)
-    32
-    >>> _ipVersionToLen(6)
-    128
-    >>> _ipVersionToLen(5)
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in ?
-      File "IPy.py", line 1076, in _ipVersionToLen
-        raise ValueError, "only IPv4 and IPv6 supported"
-    ValueError: only IPv4 and IPv6 supported
-    """
-
-    if version == 4:
-        return 32
-    elif version == 6:
-        return 128
-    else:
-        raise ValueError, "only IPv4 and IPv6 supported"
-
-
-def _countFollowingZeros(l):
-    """Return Nr. of elements containing 0 at the beginning th the list."""
-    if len(l) == 0:
-        return 0
-    elif l[0] != 0:
-        return 0
-    else:
-        return 1 + _countFollowingZeros(l[1:])
-
-
-_BitTable = {'0': '0000', '1': '0001', '2': '0010', '3': '0011',
-            '4': '0100', '5': '0101', '6': '0110', '7': '0111',
-            '8': '1000', '9': '1001', 'a': '1010', 'b': '1011',
-            'c': '1100', 'd': '1101', 'e': '1110', 'f': '1111'}
-
-def _intToBin(val):
-    """Return the binary representation of an integer as string."""
-
-    if val < 0:
-        raise ValueError, "Only positive Values allowed"
-    s = hex(val).lower()
-    ret = ''
-    if s[-1] == 'l':
-        s = s[:-1]
-    for x in s[2:]:
-        if __debug__:
-            if not _BitTable.has_key(x):
-                raise AssertionError, "hex() returned strange result"
-        ret += _BitTable[x]
-    # remove leading zeros
-    while ret[0] == '0' and len(ret) > 1:
-        ret = ret[1:]
-    return ret
-
-def _count1Bits(num):
-    """Find the highest bit set to 1 in an integer."""
-    ret = 0
-    while num > 0:
-        num = num >> 1
-        ret += 1
-    return ret
-
-def _count0Bits(num):
-    """Find the highest bit set to 0 in an integer."""
-
-    # this could be so easy if _count1Bits(~long(num)) would work as excepted
-    num = long(num)
-    if num < 0:
-        raise ValueError, "Only positive Numbers please: %s" % (num)
-    ret = 0
-    while num > 0:
-        if num & 1 == 1:
-            break
-        num = num >> 1
-        ret += 1
-    return ret
-
-
-def _checkPrefix(ip, prefixlen, version):
-    """Check the validity of a prefix
-
-    Checks if the variant part of a prefix only has 0s, and the length is
-    correct.
-
-    >>> _checkPrefix(0x7f000000L, 24, 4)
-    1
-    >>> _checkPrefix(0x7f000001L, 24, 4)
-    0
-    >>> repr(_checkPrefix(0x7f000001L, -1, 4))
-    'None'
-    >>> repr(_checkPrefix(0x7f000001L, 33, 4))
-    'None'
-    """
-
-    # TODO: unify this v4/v6/invalid code in a function
-    bits = _ipVersionToLen(version)
-
-    if prefixlen < 0 or prefixlen > bits:
-        return None
-
-    if ip == 0:
-        zbits = bits + 1
-    else:
-        zbits = _count0Bits(ip)
-    if zbits <  bits - prefixlen:
-        return 0
-    else:
-        return 1
-
-
-def _checkNetmask(netmask, masklen):
-    """Checks if a netmask is expressable as e prefixlen."""
-
-    num = long(netmask)
-    bits = masklen
-
-    # remove zero bits at the end
-    while (num & 1) == 0:
-        num = num >> 1
-        bits -= 1
-        if bits == 0:
-            break
-    # now check if the rest consists only of ones
-    while bits > 0:
-        if (num & 1) == 0:
-            raise ValueError, "Netmask %s can't be expressed as an prefix." % (hex(netmask))
-        num = num >> 1
-        bits -= 1
-
-
-def _checkNetaddrWorksWithPrefixlen(net, prefixlen, version):
-    """Check if a base addess of e network is compatible with a prefixlen"""
-    if net & _prefixlenToNetmask(prefixlen, version) == net:
-        return 1
-    else:
-        return 0
-
-
-def _netmaskToPrefixlen(netmask):
-    """Convert an Integer reprsenting a Netmask to an prefixlen.
-
-    E.g. 0xffffff00 (255.255.255.0) returns 24
-    """
-
-    netlen = _count0Bits(netmask)
-    masklen = _count1Bits(netmask)
-    _checkNetmask(netmask, masklen)
-    return masklen - netlen
-
-
-def _prefixlenToNetmask(prefixlen, version):
-    """Return a mask of n bits as a long integer.
-
-    From 'IP address conversion functions with the builtin socket module' by Alex Martelli
-    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66517
-    """
-    if prefixlen == 0:
-        return 0
-    elif prefixlen < 0:
-        raise ValueError, "Prefixlen must be > 0"
-    return ((2L<<prefixlen-1)-1) << (_ipVersionToLen(version) - prefixlen)
-
-
-def _test():
-    import doctest, IPy
-    return doctest.testmod(IPy)
-
-if __name__ == "__main__":
-    _test()
-
-    t = [0xf0, 0xf00, 0xff00, 0xffff00, 0xffffff00L]
-    o = []
-    for x in t:
-        pass
-    x = 0L