def isWhitelisted(self,conn,indicatorType,indicator):
        """Return whether or not the indicator of type indicatorType is whitelisted by this whitelist.
        If the indicator is a single address, it is whitelisted if it is included in any CIDR.
        If the indicator is a network spec, it is whitelisted if all of the addresses it represents are included in any CIDR
        """
        sn=IPNetwork(indicator)
        minip=sn.first
        maxip=sn.last

        c=conn.cursor()
        c.execute("select cidr,minip,maxip from ipv4sn where ? between minip and maxip or ? between minip and maxip order by minip",(minip,maxip))
        ipset=None
        rec=c.fetchone()
        # create a set of all ips contained network specs that contain the min and max ip specified by the indicator
        while (rec != None):
            if(ipset==None):
                ipset = IPSet(IPNetwork(rec[0]))
            else:
                ipset = ipset | IPSet(IPNetwork(rec[0]))
            rec=c.fetchone()
        # if the resulting set is empty, the indicator is not whitelisted
        if(ipset == None):
            return False
        # if the set of IPs represented by the indicator is a subset of the IPs set created above, then it is whitelisted
        ips=IPSet(sn)
        if(ips.issubset(ipset)):
            rv=True
        else:
            rv=False
        c.close()
        return rv

def test_ipset_basic_api():
    range1 = IPRange('192.0.2.1', '192.0.2.15')

    ip_list = [
        IPAddress('192.0.2.1'),
        '192.0.2.2/31',
        IPNetwork('192.0.2.4/31'),
        IPAddress('192.0.2.6'),
        IPAddress('192.0.2.7'),
        '192.0.2.8',
        '192.0.2.9',
        IPAddress('192.0.2.10'),
        IPAddress('192.0.2.11'),
        IPNetwork('192.0.2.12/30'),
    ]

    set1 = IPSet(range1.cidrs())

    set2 = IPSet(ip_list)

    assert set2 == IPSet([
        '192.0.2.1/32',
        '192.0.2.2/31',
        '192.0.2.4/30',
        '192.0.2.8/29',
    ])

    assert set1 == set2
    assert set2.pop() in set1
    assert set1 != set2

def test_ipset_converts_to_cidr_networks_v4():
    s1 = IPSet(IPNetwork('10.1.2.3/8'))
    s1.add(IPNetwork('192.168.1.2/16'))
    assert list(s1.iter_cidrs()) == [
        IPNetwork('10.0.0.0/8'),
        IPNetwork('192.168.0.0/16'),
    ]

def test_ipset_converts_to_cidr_networks_v6():
    s1 = IPSet(IPNetwork('fe80::4242/64'))
    s1.add(IPNetwork('fe90::4343/64'))
    assert list(s1.iter_cidrs()) == [
        IPNetwork('fe80::/64'),
        IPNetwork('fe90::/64'),
    ]

def test_ipset_clear():
    ipset = IPSet(['10.0.0.0/16'])
    ipset.update(IPRange('10.1.0.0', '10.1.255.255'))
    assert ipset == IPSet(['10.0.0.0/15'])

    ipset.clear()
    assert ipset == IPSet([])

def ipranges(ip_input):
    ips = []
    ip_input = ip_input.replace(" ", "")
    if '/' in ip_input:
        if ',' in ip_input:
            ip_input_ranges = ip_input.split(',')
            for ip_range in ip_input_ranges:
                for ip in IPSet([ip_range]):
                    ips.append(ip)
        else:
            ips = IPSet([ip_input])
    elif '-' in ip_input:
        if ',' in ip_input:
            ip_input_ranges = ip_input.split(',')
            for ip_range in ip_input_ranges:
                ip_split = ip_range.split("-")
                ip_range_temp = IPRange(ip_split[0], ip_split[1])
                for idx, ip in enumerate(ip_range_temp):
                    ips.append(ip_range_temp[idx])
        else:
            ip_split = ip_input.split("-")
            ips = IPRange(ip_split[0], ip_split[1])
    else:
        ips = IPAddress(ip_input)
    return ips

def assign_ips(_upper_ref, _from_key, lower_refs, to_key,
               ip_start='192.168.0.1', ip_end='192.168.0.254',
               **_kwargs):
    """Assign ips to hosts' configurations."""
    if not ip_start or not ip_end:
        return {}
    host_ips = {}
    unassigned_hosts = []
    ips = IPSet(IPRange(ip_start, ip_end))
    for lower_key, lower_ref in lower_refs.items():
        ip_addr = lower_ref.get(to_key, '')
        if ip_addr:
            host_ips[lower_key] = ip_addr
            ips.remove(ip_addr)
        else:
            unassigned_hosts.append(lower_key)

    for ip_addr in ips:
        if not unassigned_hosts:
            break

        host = unassigned_hosts.pop(0)
        host_ips[host] = str(ip_addr)

    logging.debug('assign %s: %s', to_key, host_ips)
    return host_ips

def test_ipset_updates():
    s1 = IPSet(['192.0.2.0/25'])
    s2 = IPSet(['192.0.2.128/25'])

    s1.update(s2)
    assert s1 == IPSet(['192.0.2.0/24'])

    s1.update(['192.0.0.0/24', '192.0.1.0/24', '192.0.3.0/24'])
    assert s1 == IPSet(['192.0.0.0/22'])

    def generateIP(self):
        network = IPSet(IPNetwork(self.cidr))
        network.remove(min(network))
        network.remove(max(network))
        hostlist = IPSet([ h.ip for h in self.hosts.all() ])
        available = network - hostlist
        return min(available)

        '''

def test_ipset_exceptions():
    s1 = IPSet(['10.0.0.1'])

    #   IPSet objects are not hashable.
    with pytest.raises(TypeError):
        hash(s1)

    #   Bad update argument type.
    with pytest.raises(TypeError):
        s1.update(42)

def test_disjointed_ipsets():
    s1 = IPSet(['192.0.2.0', '192.0.2.1', '192.0.2.2'])
    s2 = IPSet(['192.0.2.2', '192.0.2.3', '192.0.2.4'])

    assert s1 & s2 == IPSet(['192.0.2.2/32'])
    assert not s1.isdisjoint(s2)

    s3 = IPSet(['192.0.2.0', '192.0.2.1'])
    s4 = IPSet(['192.0.2.3', '192.0.2.4'])

    assert s3 & s4 == IPSet([])
    assert s3.isdisjoint(s4)

def optimize_network_range(ipstr, threshold=0.9, verbose=DEBUG):
    """
    Parses the input string and then calculates the subnet usage percentage. If over
    the threshold it will return a loose result, otherwise it returns strict.

    :param ipstr:
        IP string to be parsed.

    :param threshold:
        The percentage of the network usage required to return a loose result.

    :param verbose:
        Toggle verbosity.

    Example of default behavior using 0.9 (90% usage) threshold:
        >>> import cidrize
        >>> cidrize.optimize_network_range('10.20.30.40-50', verbose=True)
        Subnet usage ratio: 0.34375; Threshold: 0.9
        Under threshold, IP Parse Mode: STRICT
        [IPNetwork('10.20.30.40/29'), IPNetwork('10.20.30.48/31'), IPNetwork('10.20.30.50/32')]

    Example using a 0.3 (30% threshold):
        >>> import cidrize
        >>> cidrize.optimize_network_range('10.20.30.40-50', threshold=0.3, verbose=True)
        Subnet usage ratio: 0.34375; Threshold: 0.3
        Over threshold, IP Parse Mode: LOOSE
        [IPNetwork('10.20.30.32/27')]

    """
    if threshold > 1 or threshold < 0:
        raise CidrizeError('Threshold must be from 0.0 to 1.0')

    # Can't optimize 0.0.0.0/0!
    if ipstr in EVERYTHING:
        return cidrize(ipstr)

    loose = IPSet(cidrize(ipstr))
    strict = IPSet(cidrize(ipstr, strict=True))
    ratio = float(len(strict)) / float(len(loose))

    if verbose:
        print 'Subnet usage ratio: %s; Threshold: %s' % (ratio, threshold)

    if ratio >= threshold:
        if verbose:
            print 'Over threshold, IP Parse Mode: LOOSE'
        result = loose.iter_cidrs()
    else:
        if verbose:
            print 'Under threshold, IP Parse Mode: STRICT'
        result = strict.iter_cidrs()

    return result

    def parse(self, data):
        mynets = IPSet()

        for line in data.split("\n"):
            if not line or line[0] == ";":
                continue

            ip, sbl = line.split(";")
            ip = IPNetwork(ip.strip())
            mynets.add(ip)

        return mynets

def concat_networks(context, pool_1, pool_2):
    if pool_1.is_free and pool_2.is_free:
        network_1 = pool_to_network(pool_1)
        network_2 = pool_to_network(pool_2)
        if network_1.size == network_2.size:
            ipset = IPSet([network_1, network_2])
            cidr = ipset.iter_cidrs()[0]
            pool_1.ip = cidr.first
            pool_1.netmask = cidr.netmask.value
            count = len(pool_to_network(pool_1))
            pool_1.count = count
            pool_delete(context, pool_2.pool_id)
            concat_pool(context, pool_1)

def add_available_prefixes(parent, prefix_list):
    """
    Create fake Prefix objects for all unallocated space within a prefix.
    """

    # Find all unallocated space
    available_prefixes = IPSet(parent) ^ IPSet([p.prefix for p in prefix_list])
    available_prefixes = [Prefix(prefix=p) for p in available_prefixes.iter_cidrs()]

    # Concatenate and sort complete list of children
    prefix_list = list(prefix_list) + available_prefixes
    prefix_list.sort(key=lambda p: p.prefix)

    return prefix_list

def summarizeIPs(inFile, outFile):
    netSet = IPSet()
    with open(inFile, 'r') as f:
        for line in f.readlines():
            net = IPSet()
            try:
                net.add(line.strip())
            except AddrFormatError:
                continue
            else:
                netSet = netSet | net
    netMin = netSet.iter_cidrs()
    with open(outFile, 'w') as f:
        for net in netMin:
            f.write('{}\n'.format(net))

def test_ipset_member_insertion_and_deletion():
    s1 = IPSet()
    s1.add('192.0.2.0')
    assert s1 == IPSet(['192.0.2.0/32'])

    s1.remove('192.0.2.0')
    assert s1 == IPSet([])

    s1.add(IPRange("10.0.0.0", "10.0.0.255"))
    assert s1 == IPSet(['10.0.0.0/24'])

    s1.remove(IPRange("10.0.0.128", "10.10.10.10"))
    assert s1 == IPSet(['10.0.0.0/25'])

def write_file(scope: str, content: IPSet, prefix=''):
    if len(prefix)>0 and not prefix.endswith('-'):
        prefix = prefix + '-'
    filename = 'output/' + prefix + scope + '.txt'
    cidrs = content.iter_cidrs()
    log.info(f"Writing output file: {filename}")
    log.info(f"There are {len(cidrs)} CIDR blocks in {filename}.")
    with open(filename, 'w') as f:
        f.writelines(f"{cidr}\n" for cidr in cidrs)

def choose_ip(routable_cidrs, excluded_cidrs=[], client_addr=''):
    """Find available IP addresses for both sides of a VPN Tunnel.

    This method iterates over the settings.ALLOWED_CIDRS list in order to
    allocate available IP address to both the client and server side of a
    VPN tunnel. CIDRs that belong to the lists of settings.RESERVED_CIDRS,
    `routable_cidrs`, and `excluded_cidrs` are excluded from the allocation
    process.

    :param routable_cidrs: the CIDRs that are to be routed over a VPN tunnel
    :param excluded_cidrs: an optional list of CIDRs to be excluded from the
                           address allocation process
    :param client_addr:    the `client_addr` is used to attempt to pick an
                           adjacent IP address for the server side

    :return: a private IP address

    """
    exc_nets = routable_cidrs + excluded_cidrs + settings.RESERVED_CIDRS
    # make sure the exc_nets list does not contain any empty strings
    exc_nets = [exc_net for exc_net in exc_nets if exc_net]
    # a list of unique, non-overlapping supernets (to be excluded)
    exc_nets = IPSet(exc_nets).iter_cidrs()
    for network in settings.ALLOWED_CIDRS:
        available_cidrs = IPSet(IPNetwork(network))
        for exc_net in exc_nets:
            available_cidrs.remove(exc_net)
        if not available_cidrs:
            continue
        for cidr in available_cidrs.iter_cidrs():
            first, last = cidr.first, cidr.last
            if client_addr:
                address = IPAddress(client_addr) + 1
            else:
                address = IPAddress(random.randrange(first + 1, last))
            for _ in xrange(first + 1, last):
                if address not in cidr or address == cidr.broadcast:
                    address = cidr.network + 1
                try:
                    Tunnel.objects.get(Q(client=str(address)) |
                                       Q(server=str(address)))
                    address += 1
                except Tunnel.DoesNotExist:
                    return str(address)

    def derive_outwall(self):
        """
        This would not only inverse the set with the "big one", it would also exclude
        See: http://www.tcpipguide.com/free/t_IPReservedPrivateandLoopbackAddresses-3.htm
        """

        self.ipset_outwall = IPSet(['0.0.0.0/0']) ^ self.ipset_inwall ^ self.ipset_reserved
        self.cidrs_outwall = list(self.ipset_outwall.iter_cidrs())

        logging.info("Finished deriving out-wall IP table(s). Total: %i CIDR blocks.", len(self.cidrs_outwall), )