def connect_line_bridge(line_component, bridge_component, addressing_scheme=None):
    """ Connects a ring to a bridge.

    :param line_component: ring component that will be connected to the bridge. Needs at least two free interfaces
    :param bridge_component: bridge component that will be connected to the ring. Will add new interfaces to the bridge.
    """
    link_id = used_resources.get_new_link_id()

    line_container = line_component.connection_points.pop()

    # create new interface for container in line
    line_interface_id = "%s.%03d" % (line_container.container_id, line_container.get_next_interface() )
    line_interface = NetworkInterface(line_interface_id, link_id)
    if addressing_scheme is not None:
        ip = addressing_scheme['bridge_links'].pop()
        line_interface.address = "%s/%s" % (ip, addressing_scheme['bridge_prefix'])

    # get bridge and interface for bridge
    br = bridge_component.connection_points[0]
    bridge_interface_id = "%s.%03d" % (br.bridge_id, br.get_next_interface())

    bridge_interface = NetworkInterface(bridge_interface_id, link_id)

    # summary
    if addressing_scheme is not None:
        containers = len(line_component.topology['containers'])
        print("amount of containers: %s " % containers)
        other_container = None
        if len(line_component.connection_points) > 0:
            other_container = line_component.connection_points[0]
            line_component.addresses = sorted(line_component.addresses)

        if other_container is not None and netaddr.IPNetwork(line_container.interfaces[0].address) > netaddr.IPNetwork(
                other_container.interfaces[0].address):
            summary = netaddr.cidr_merge(line_component.addresses[(containers - 1):len(line_component.addresses)])
            line_component.addresses = line_component.addresses[0: containers - 2]
            print("2: ", )
            for address in line_component.addresses:
                print(address, )
        else:
            summary = netaddr.cidr_merge(line_component.addresses[0:containers - 2])
            line_component.addresses = line_component.addresses[containers - 1:len(line_component.addresses)]

        line_interface.summarizes = summary

    print("link %s has %s and %s" % (link_id, line_interface.interface_id, bridge_interface.interface_id))

    br.add_interface(bridge_interface)
    line_container.add_interface(line_interface)
    line_container.gateway = line_interface.interface_id

def main():

	parser = argparse.ArgumentParser(description='IP Blacklist Generator')

	parser.add_argument('-if', type=lambda x: open_file(parser, x), dest='input_file', metavar='INPUT_FILE', required=True, help='Input file with blacklist URLs')
	parser.add_argument('-of', type=str, dest='output_file', metavar='OUTPUT_FILE', required=True, help='Output file')

	args = parser.parse_args()

	output_filename = args.output_file
	input_file = args.input_file


	#Create master list that will ultimately get written to file
	master_list = []

	#Read in URLs from file and build list
	urls = get_urls(input_file)

	#Download lists, parse, and append to master list
	for url in urls:
		raw_list = download_list(url)
		if raw_list is not None:
			formatted_list = parse_list(raw_list)
			for address_block in formatted_list:
				master_list.append(address_block)

	#aggregate and remove duplicates
	master_list = cidr_merge(master_list)

	#sort the list of IP objects
	master_list.sort()

	#Export list to file
	export_list(master_list, output_filename)

def set_summaries(configured_host):
    logging.getLogger(__name__).info("Setting summaries")
    for interface_id, interface in configured_host['interfaces'].items():
        container_id = configured_host['mappings'][interface_id]
        container = configured_host['containers'][container_id]
        if interface.address is not None:
            logging.getLogger(__name__).info(interface_id)
            for summary, via in configured_host["mappings_summaries"].items():
                #print " checking for:  %s, via %s" % (summary, via)

                # via must be in same subnet as address in this interface
                same_subnet_via = (netaddr.IPNetwork(via) == netaddr.IPNetwork(interface.address))

                # check if summary is in same subnet or not
                existing_summaries = []
                for route in container.routing['routes']:
                    existing_summaries.append(netaddr.IPNetwork(route.address))
                existing_summaries = netaddr.cidr_merge(existing_summaries)
                route_exists = False
                for route in existing_summaries:
                    if route.network == netaddr.IPNetwork(summary).network:
                        route_exists = True

                if same_subnet_via and not route_exists:
                    network = netaddr.IPNetwork(summary)
                    address = "%s/%s" % (network.network, network.prefixlen)
                    summary_route = emulator.elements.Route(address, interface.veth)
                    summary_route.via = str(netaddr.IPNetwork(via).ip)
                    container.routing["routes"].append(summary_route)
                    logging.getLogger(__name__).info("Adding %s to %s", summary_route.address, container.container_id)

def test_ip_range():
    ip_list = list(iter_iprange('192.0.2.1', '192.0.2.14'))

    assert len(ip_list) == 14

    assert ip_list == [
        IPAddress('192.0.2.1'),
        IPAddress('192.0.2.2'),
        IPAddress('192.0.2.3'),
        IPAddress('192.0.2.4'),
        IPAddress('192.0.2.5'),
        IPAddress('192.0.2.6'),
        IPAddress('192.0.2.7'),
        IPAddress('192.0.2.8'),
        IPAddress('192.0.2.9'),
        IPAddress('192.0.2.10'),
        IPAddress('192.0.2.11'),
        IPAddress('192.0.2.12'),
        IPAddress('192.0.2.13'),
        IPAddress('192.0.2.14'),
    ]

    assert cidr_merge(ip_list) == [
        IPNetwork('192.0.2.1/32'),
        IPNetwork('192.0.2.2/31'),
        IPNetwork('192.0.2.4/30'),
        IPNetwork('192.0.2.8/30'),
        IPNetwork('192.0.2.12/31'),
        IPNetwork('192.0.2.14/32'),
    ]

def ip_range_diff(source_ip_range, remove_ip_range):
    """Return source_ip_range after excluding remove_ip_range."""
    # Convert IP ranges to CIDR.
    source_ip_range = ip_range_to_cidr(source_ip_range)
    remove_ip_range = ip_range_to_cidr(remove_ip_range)
    logging.debug('source_ip_range = %s' % (source_ip_range))
    logging.debug('remove_ip_range = %s' % (remove_ip_range))
    # Expand each range.
    source_ip_range_expanded = ip_range_expand(source_ip_range)
    remove_ip_range_expanded = ip_range_expand(remove_ip_range)
#    logging.debug('remove_ip_range_expanded = %s' % (remove_ip_range_expanded))
    # Remove each matching source IP address individually.
    for i in remove_ip_range_expanded:
        try:
            source_ip_range_expanded.remove(i)
        except ValueError:
            # Value not in source_ip_range
            continue
    # Convert remaining range to CIDR.
#    logging.debug('source_ip_range_expanded = %s' % (source_ip_range_expanded))
    source_ip_range = netaddr.cidr_merge(source_ip_range_expanded)
    logging.debug('source_ip_range = %s' % (source_ip_range))
    # Convert each CIDR block to string.
    result_cidr = []
    for cidr_object in source_ip_range:
        result_cidr.append(str(cidr_object))
    # Convert entire list to a string.
    result_cidr = ','.join(result_cidr)
    logging.debug('result_cidr = %s' % (result_cidr))
    # Remove '/32' (single IP) and return diff'd range.
    return result_cidr.replace('/32', '')

def ip_range_to_cidr(ip_network_string):
    """Convert ip_network_string into CIDR notation."""
    # Split string into list by ', ' delimiter.
    ip_network_cidr = []
    ip_network_list = ip_network_string.split(',')
    for ip_object in ip_network_list:
        # For every ip range ('10.182.71.0-10.182.75.255'), convert to individual slash notation, 10.182.71.0/24, 10.182.72.0/22.
        if '-' in ip_object:
            # The object is a range.
            dash = ip_object.find('-')
            # First part of ip range.
            ip_start = ip_object[:dash]
            # Last part of ip range.
            ip_end = ip_object[dash + 1:]
            # Generate lists of IP addresses in range.
            ip_range = list(netaddr.iter_iprange(ip_start, ip_end))
            # Convert start & finish range to CIDR.
            ip_range = netaddr.cidr_merge(ip_range)
            # May be one or more objects in list.
            # Example 1:  '10.182.71.0-10.182.75.255' ==> ['10.182.71.0/24, 10.182.72.0/22']
            # Example 2:  '10.182.90.0-10.182.91.255' ==> ['10.182.90.0/23']
            # Add each CIDR to ip_network.
            for ip_object in ip_range:
                 ip_network_cidr.append(str(ip_object))
        else:
            # The object is not a range, just add it.
            logging.debug('ip_object = %s' % (ip_object))
            ip_network_cidr.append(str(netaddr.IPNetwork(ip_object).cidr))
    # Return as a string with delimiter ', '
    return ip_network_cidr

def report(domains, asns=None, networks=None, addresses=None, rdns=None):
    """
    Prints the sets of given domains, autonomous system numbers, networks, PTRs, and IP addresses if user wants it.
    Args:
        domains: set of domains gathered.
        asns: set of autonomous system numbers gathered.
        networks: set of network ranges gathered.
        addresses: set of IP addresses gathered.
        rdns: set of PTR records
    """
    if domains is not None:
        print_border("DOMAINS ({})".format(len(domains)))
        print("{}".format("\n".join(str(x) for x in domains)))

    if asns is not None:
        print_border("AUTONOMOUS SYSTEM NUMBERS ({})".format(len(asns)))
        print(*asns, sep="\n")

    if networks is not None:
        networks = netaddr.cidr_merge(list(networks))
        print_border("NETWORK RANGES ({})".format(len(networks)))
        print(*networks, sep="\n")

    if addresses is not None:
        print_border("IP ADDRESSES ({})".format(len(addresses)))
        print(*addresses, sep="\n")

    if rdns is not None:
        print_border("RDNS RECORDS ({})".format(len(rdns)))
        print(*rdns, sep="\n")

def iana_rir_gen_ip_list(user_rir_list):

    # generates a list of networks that can be blocked by RIR

    # we use a SortedList so that elements are inserted in order. This allows cidr_merge to work
    rir_slash_eight_list = SortedList()

    with open('iana') as iana_file:

        iana_csv = csv.reader(iana_file)

        for line in iana_csv:

            for rir in user_rir_list:

                # case in which the whois line from our csv contains the RIR
                if rir in line[3]:

                    network = line[0].lstrip('0')
                    rir_slash_eight_list.add(netaddr.IPNetwork(network))

                    # if we find a match, there is no reason to see if the other RIRs are on the same line
                    break

        # run cidr_merge to summarize
        rir_slash_eight_list = netaddr.cidr_merge(rir_slash_eight_list)

    return rir_slash_eight_list

def manual_ipv6_infrastructure_allocation(anm):
    """Applies manual IPv6 allocation"""

    import netaddr

    g_ipv6 = anm["ipv6"]
    log.info("Using specified IPv6 infrastructure allocation")

    for node in g_ipv6.l3devices():
        for interface in node.physical_interfaces:
            if not interface["input"].is_bound:
                continue  # unbound interface
            ip_address = netaddr.IPAddress(interface["input"].ipv6_address)
            prefixlen = interface["input"].ipv6_prefixlen
            interface.ip_address = ip_address
            interface.prefixlen = prefixlen
            cidr_string = "%s/%s" % (ip_address, prefixlen)
            interface.subnet = netaddr.IPNetwork(cidr_string)

    broadcast_domains = [d for d in g_ipv6 if d.broadcast_domain]

    # TODO: allow this to work with specified ip_address/subnet as well as ip_address/prefixlen

    from netaddr import IPNetwork

    for coll_dom in broadcast_domains:
        connected_interfaces = [edge.dst_int for edge in coll_dom.edges()]
        cd_subnets = [IPNetwork("%s/%s" % (i.subnet.network, i.prefixlen)) for i in connected_interfaces]

        if len(cd_subnets) == 0:
            log.warning("Collision domain %s is not connected to any nodes" % coll_dom)
            continue

        try:
            assert len(set(cd_subnets)) == 1
        except AssertionError:
            mismatch_subnets = "; ".join("%s: %s/%s" % (i, i.subnet.network, i.prefixlen) for i in connected_interfaces)
            log.warning("Non matching subnets from collision domain %s: %s" % (coll_dom, mismatch_subnets))
        else:
            coll_dom.subnet = cd_subnets[0]  # take first entry

        # apply to remote interfaces

        for edge in coll_dom.edges():
            edge.dst_int.subnet = coll_dom.subnet

    # also need to form aggregated IP blocks (used for e.g. routing prefix
    # advertisement)
    # import autonetkit
    # autonetkit.update_http(anm)

    infra_blocks = {}
    for (asn, devices) in g_ipv6.groupby("asn").items():
        broadcast_domains = [d for d in devices if d.broadcast_domain]
        subnets = [cd.subnet for cd in broadcast_domains if cd.subnet is not None]  # only if subnet is set
        infra_blocks[asn] = netaddr.cidr_merge(subnets)

    g_ipv6.data.infra_blocks = infra_blocks

def read_rirs(country_list, permit, rir_list=RIR_NAMES):

    # list containing our file objects
    file_list = []

    # we use a SortedList so that elements are inserted in order. This allows cidr_merge to work
    rir_ips = SortedList()

    # Open the files we downloaded earlier and store the file object
    for rir in rir_list:
        file_list.append(open(rir))

    for f in file_list:

        for line in f:

            curr_line = line.split('|')

            try:

                # we want only the ipv4 lines that are for a specific country
                # also only want countries that we are going to block
                if (curr_line[2] == "ipv4" and curr_line[1] != "*") and \
                    ((permit and curr_line[1] not in country_list) or
                     (not permit and curr_line[1] in country_list)):

                    country_code = curr_line[1]
                    network_id = curr_line[3]
                    wildcard = int(curr_line[4])-1

                    try:

                        # Add network to list, if the number of IPs was not a
                        # power of 2 (wildcard is not valid).
                        # AddrFormatError is thrown
                        rir_ips.add(netaddr.IPNetwork(network_id + "/" + str(netaddr.IPAddress(wildcard))))

                    # Handle case in where our mask is invalid by rounding DOWN
                    except netaddr.AddrFormatError:

                        print "rounded network " + network_id + " with " + str(wildcard) + \
                              " hosts up to nearest power of 2"
                        wildcard = next_power_of_2(wildcard) - 1
                        print wildcard + 1
                        rir_ips.add(netaddr.IPNetwork(network_id + "/" + str(netaddr.IPAddress(wildcard))))

            # IndexErrors only occur when parsing columns we don't need
            except IndexError:

                pass

        f.close()

    # cidr_merge takes our list of IPs and summarizes subnets where possible
    # this greatly decreases the number of ACL entries
    rir_ips = netaddr.cidr_merge(rir_ips)

    return rir_ips

 def _setup_routes(self, if_dev, ver, ip_start, ip_end, gw_ip):
     gw_ip_net = netaddr.IPNetwork(gw_ip)
     if_dev.addr.add(ver, "%s/%s" % (ip_start, gw_ip_net.prefixlen), gw_ip_net.broadcast)
     if_dev.route.add_gateway(str(gw_ip_net.ip))
     if ip_start != ip_end:
         local_nets = netaddr.cidr_merge(netaddr.iter_iprange(ip_start, ip_end))
         max_pfx_len = ver == 4 and 32 or 128
         for l in local_nets:
             if l.prefixlen < max_pfx_len or str(l.ip) != ip_start:
                 if_dev.route._as_root("add", "local", str(l), "dev", if_dev.name, options=[ver])

def manual_ipv4_allocation(anm):
    """Applies manual IPv4 allocation"""
    import netaddr
    g_in_directed = anm['input_directed']
    g_ipv4 = anm['ipv4']

    for l3_device in g_ipv4.nodes("is_l3device"):
        directed_node = g_in_directed.node(l3_device)
        l3_device.loopback = directed_node.ipv4loopback
        for edge in l3_device.edges():
            # find edge in g_in_directed
            directed_edge = g_in_directed.edge(edge)
            edge.ip_address = netaddr.IPAddress(directed_edge.ipv4)

            # set subnet onto collision domain (can come from either
            # direction)
            collision_domain = edge.dst
            if not collision_domain.subnet:
                # TODO: see if direct method in netaddr to deduce network
                prefixlen = directed_edge.netPrefixLenV4
                cidr_string = "%s/%s" % (edge.ip_address, prefixlen)

                intermediate_subnet = netaddr.IPNetwork(cidr_string)
                cidr_string = "%s/%s" % (
                    intermediate_subnet.network, prefixlen)
                subnet = netaddr.IPNetwork(cidr_string)
                collision_domain.subnet = subnet

    # also need to form aggregated IP blocks (used for e.g. routing prefix
    # advertisement)
    loopback_blocks = {}
    infra_blocks = {}
    for asn, devices in g_ipv4.groupby("asn").items():
        routers = [d for d in devices if d.is_router]
        loopbacks = [r.loopback for r in routers]
        loopback_blocks[asn] = netaddr.cidr_merge(loopbacks)

        collision_domains = [d for d in devices if d.collision_domain]
        subnets = [cd.subnet for cd in collision_domains]
        infra_blocks[asn] = netaddr.cidr_merge(subnets)

    g_ipv4.data.loopback_blocks = loopback_blocks
    g_ipv4.data.infra_blocks = infra_blocks

def cidr_subtract(supernet_cidr, subnet_cidr):
    supernet = netaddr.IPNetwork(supernet_cidr)
    subnet = netaddr.IPNetwork(subnet_cidr)

    if subnet not in supernet:
        return [supernet]

    supernet_subnets = list(supernet.subnet(subnet.prefixlen))
    supernet_subnets.remove(subnet)

    return netaddr.cidr_merge(supernet_subnets)

 def _validate_range_with_network(self):
     ip_networks = []
     if self.range:
         start, end = self.range.split('-')
         ip_addresses = list(netapi.iter_iprange(start, end))
         ip_networks.extend(netapi.cidr_merge(ip_addresses))
     else:
         ip_addresses = get_ips_from_cidr(self.cidr)
         ip_networks.extend(netapi.cidr_merge(ip_addresses))
     address_lst = []
     net = netapi.IPNetwork(self.cidr)
     for network in ip_networks:
         for address in network:
             address_lst.append(str(address))
             if address not in net:
                 excep_msg = 'given dhcp range:%s not a subset of network:%s' % (self.range, net)
                 LOGGER.error(excep_msg)
                 raise Exception(excep_msg)
                 
     self.iplist = address_lst

def main():
	if len(sys.argv) < 2:
		usage()
		sys.exit()
	
	ipFile = open(sys.argv[1])
	ipAddresses = [i for i in ipFile.readlines()]
	ipAddresses = sorted(ipAddresses)
	cidrs = netaddr.cidr_merge(ipAddresses)
	for cidr in cidrs:
		print cidr

 def get_utilization(self):
     """
     Determine the utilization rate of the aggregate prefix and return it as a percentage.
     """
     child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))
     # Remove overlapping prefixes from list of children
     networks = cidr_merge([c.prefix for c in child_prefixes])
     children_size = float(0)
     for p in networks:
         children_size += p.size
     return int(children_size / self.prefix.size * 100)

def combine_it(iplist):
    try:
        fipl = []
        for ip in cidr_merge(iplist):
            if '/' in str(ip) and str(ip).split('/', 1)[1] == '32':
                fipl.append(str(ip).split('/', 1)[0])
            else:
                fipl.append(str(ip))
        return fipl
    except (ValueError, TypeError):
        print "{}[!]{} Ensure that all IPs are in CIDR notation.".format(colors.red, colors.normal)

    def _merge_cidrs(cls):
        """
        We learned about CIDRs from the following functions:
        -   _load_elasticips()
        -   _load_vpcs()
        -   _load_vpces()
        -   _load_natgateways()
        -   _load_network_whitelist()

        These cidr's are stored in the OBJECT_STORE in a way that is not optimal:

            OBJECT_STORE['cidr']['54.0.0.1'] = set(['123456789012'])
            OBJECT_STORE['cidr']['54.0.0.0'] = set(['123456789012'])
            ...
            OBJECT_STORE['cidr']['54.0.0.255/32'] = set(['123456789012'])

        The above example is attempting to illustrate that account `123456789012`
        contains `54.0.0.0/24`, maybe from 256 elastic IPs.

        If a resource policy were attempting to ingress this range as a `/24` instead
        of as individual IPs, it would not work.  We need to use the `cidr_merge`
        method from the `netaddr` library.  We need to preserve the account identifiers
        that are associated with each cidr as well.

        # Using:
        # https://netaddr.readthedocs.io/en/latest/tutorial_01.html?highlight=summarize#summarizing-list-of-addresses-and-subnets
        # import netaddr
        # netaddr.cidr_merge(ip_list)

        Step 1: Group CIDRs by account:
        #   ['123456789012'] = ['IP', 'IP']

        Step 2:
        Merge each account's cidr's separately and repalce the OBJECT_STORE['cidr'] entry.

        Return:
            `None`.  Mutates the cls.OBJECT_STORE['cidr'] datastructure.
        """
        if not 'cidr' in cls.OBJECT_STORE:
            return

        # step 1
        merged = defaultdict(set)
        for cidr, accounts in cls.OBJECT_STORE['cidr'].items():
            for account in accounts:
                merged[account].add(cidr)

        del cls.OBJECT_STORE['cidr']

        # step 2
        for account, cidrs in merged.items():
            merged_cidrs = netaddr.cidr_merge(cidrs)
            for cidr in merged_cidrs:
                add(cls.OBJECT_STORE['cidr'], str(cidr), account)

def test_cidr_merge_v4():
    assert cidr_merge(['192.0.128.0/24', '192.0.129.0/24']) == [IPNetwork('192.0.128.0/23')]
    assert cidr_merge(['192.0.129.0/24', '192.0.130.0/24']) == [IPNetwork('192.0.129.0/24'), IPNetwork('192.0.130.0/24')]
    assert cidr_merge(['192.0.2.112/30', '192.0.2.116/31', '192.0.2.118/31']) == [IPNetwork('192.0.2.112/29')]
    assert cidr_merge(['192.0.2.112/30', '192.0.2.116/32', '192.0.2.118/31']) == [IPNetwork('192.0.2.112/30'), IPNetwork('192.0.2.116/32'), IPNetwork('192.0.2.118/31')]
    assert cidr_merge(['192.0.2.112/31', '192.0.2.116/31', '192.0.2.118/31']) == [IPNetwork('192.0.2.112/31'), IPNetwork('192.0.2.116/30')]

    assert cidr_merge([
        '192.0.1.254/31',
        '192.0.2.0/28',
        '192.0.2.16/28',
        '192.0.2.32/28',
        '192.0.2.48/28',
        '192.0.2.64/28',
        '192.0.2.80/28',
        '192.0.2.96/28',
        '192.0.2.112/28',
        '192.0.2.128/28',
        '192.0.2.144/28',
        '192.0.2.160/28',
        '192.0.2.176/28',
        '192.0.2.192/28',
        '192.0.2.208/28',
        '192.0.2.224/28',
        '192.0.2.240/28',
        '192.0.3.0/28']) == [
        IPNetwork('192.0.1.254/31'),
        IPNetwork('192.0.2.0/24'),
        IPNetwork('192.0.3.0/28'),
    ]

def make_iplist(l):
    """
    Expect the input to be well-formatted.
    :param l: list. ip ranges(or single ip) e.g. [('192.0.2.1', '192.0.2.15'), '192.0.3.1']
    :return: list. CIRD notation of ips in the range
    """
    re = []
    for ip in l:
        if type(ip) == types.TupleType:
            r = IPRange(ip[0], ip[1])
            re.extend(r.cidrs())
        else: # ip is a str. e.g. '192.0.3.1'
            re.append(IPAddress(ip))
    return cidr_merge(re)