def find_from_tuple(cls, link):
     """
     Find link by providing a tuple with two ip addresses or two mac addresses
     :param link: tuple with two string elements indicating source and destination (ip or mac addresses)
     :returns: Link object
     """
     try:
         a = link[0]
         b = link[1]
     except IndexError:
         raise ValueError('Expecting tuple with source and destination')
     # find interfaces
     if (valid_ipv4(a) and valid_ipv4(b)) or (valid_ipv6(a) and valid_ipv6(b)):
         try:
             a = Ip.objects.get(address=a).interface
             b = Ip.objects.get(address=b).interface
         except Ip.DoesNotExist as e:
             raise LinkDataNotFound(e)
     elif valid_mac(a) and valid_mac(b):
         try:
             a = Interface.objects.get(mac=a)
             b = Interface.objects.get(mac=b)
         except Interface.DoesNotExist as e:
             raise LinkDataNotFound(e)
     else:
         raise ValueError('Expecting valid ipv4, ipv6 or mac address')
     # find link with interfaces
     # inverse order is also ok
     q = Q(interface_a=a, interface_b=b) | Q(interface_a=b, interface_b=a)
     link = Link.objects.filter(q).first()
     if link is None:
         raise LinkNotFound('Link matching query does not exist',
                            interface_a=a,
                            interface_b=b)
     return link

def main(args):
    '''
    Obtain necessary input to execute ping sweep:
    telnet-pingsweep [--version] [-v|--verbose] [-f|--file <file.yaml>]
                     <starting-address-range> <ending-address-range>
    '''
    parser = argparse.ArgumentParser(description='Connect to a specified router and run a '
            'command')
    parser.add_argument('--version', action='version', version=__version__)
    parser.add_argument('-v', '--verbose', action='store_true', help='display verbose output',
            default=False)
    parser.add_argument('-f', '--file', help='specify YAML file to read router info from',
            default=ROUTER_FILE)
    parser.add_argument('-o', '--output', help='specify output file to write results to')
    parser.add_argument('addr_start', help='starting address for sweep')
    parser.add_argument('addr_end', help='ending address for sweep')
    args = parser.parse_args()

    # Pre-flight checks
    myrouter_data = yaml_input(args.file, args.verbose)

    # Validate IP addresses
    if netaddr.valid_ipv4(args.addr_start):
        addr_start = netaddr.IPAddress(args.addr_start)
    else:
        sys.exit('Invalid IPv4 address:  {}'.format(args.start))
    if netaddr.valid_ipv4(args.addr_end):
        addr_end = netaddr.IPAddress(args.addr_end)
    else:
        sys.exit('Invalid IPv4 address:  {}'.format(args.start))
    if addr_end <= addr_start:
        sys.exit('Ending address must be after starting address.')
    if (addr_end - addr_start).value > 254:
        sys.exit('Largest range of addresses which may be swept is limited to 254.')
    addr_range = netaddr.IPRange(addr_start, addr_end)

    myrouter = Netinfnode(myrouter_data, TELNET_TIMEOUT)
    myrouter.connect(args.verbose)
    myrouter.nopaging(args.verbose)
    if args.output:
        output1 = open(args.output, 'w')
    for addr in addr_range:
        full_cmd = ROUTER_CMD + ' ' + str(addr)
        print 'Processing {}...'.format(full_cmd)
        output = myrouter.sendcmd(full_cmd, args.verbose)
        # output has extra carriage returns - remove
        new_output = output.replace('\r', '')
        result = 'Command ({}) output:\n{}\n'.format(full_cmd, new_output)
        if args.output:
            output1.write(result)
            output1.write('\n')
        else:
            print result

    # Cleanup
    myrouter.connection.close()
    if args.output:
        output1.close()

def validate_ip_addr(addr, version=None):
    """
    Validates that an IP address is valid. Returns true if valid, false if
    not. Version can be "4", "6", None for "IPv4", "IPv6", or "either"
    respectively.
    """
    if version == 4:
        return netaddr.valid_ipv4(addr)
    elif version == 6:
        return netaddr.valid_ipv6(addr)
    else:
        return netaddr.valid_ipv4(addr) or netaddr.valid_ipv6(addr)

 def _is_ip(self, domain):
     '''
     This extra parsing handles a variety of edge cases such as:
         - http://192.168.1.1
         - http://192.168.1.1:81
         - 192.168.1.1:81
     '''
     if valid_ipv4(domain):
         return True
     if urlparse(domain).scheme != '':
         domain = urlparse(domain).netloc
     if ':' in domain:
         domain = domain[:domain.rindex(':')]
     return valid_ipv4(domain)

    def get_common_server(self):
        data = {
            'public_address': None,
            'private_address': None,
            'service_net_name_or_ip': self.get_config_option(
                'service_net_name_or_ip'),
            'tenant_net_name_or_ip': self.get_config_option(
                'tenant_net_name_or_ip'),
        }

        data['instance'] = self.compute_api.server_get_by_name_or_id(
            self.admin_context,
            self.get_config_option('service_instance_name_or_id'))

        if netaddr.valid_ipv4(data['service_net_name_or_ip']):
            data['private_address'] = [data['service_net_name_or_ip']]
        else:
            data['private_address'] = self._get_addresses_by_network_name(
                data['service_net_name_or_ip'], data['instance'])

        if netaddr.valid_ipv4(data['tenant_net_name_or_ip']):
            data['public_address'] = [data['tenant_net_name_or_ip']]
        else:
            data['public_address'] = self._get_addresses_by_network_name(
                data['tenant_net_name_or_ip'], data['instance'])

        if not (data['public_address'] and data['private_address']):
            raise exception.ManilaException(
                "Can not find one of net addresses for service instance. "
                "Instance: %(instance)s, "
                "private_address: %(private_address)s, "
                "public_address: %(public_address)s." % data)

        share_server = {
            'username': self.get_config_option('service_instance_user'),
            'password': self.get_config_option('service_instance_password'),
            'pk_path': self.path_to_private_key,
            'instance_id': data['instance']['id'],
        }
        for key in ('private_address', 'public_address'):
            data[key + '_v4'] = None
            for address in data[key]:
                if netaddr.valid_ipv4(address):
                    data[key + '_v4'] = address
                    break
        share_server['ip'] = data['private_address_v4']
        share_server['public_address'] = data['public_address_v4']
        return {'backend_details': share_server}

    def is_ip(self, ip_addr=None):
        """
        Return true if valid IP address return false if invalid IP address
        :param ip_addr: optional IP to pass. Takes from root class if not specified
        >>> from ipinformation import IPInformation
        >>> print IPInformation(ip_address='8.8.8.8').is_ip()
            True
        >>> print IPInformation(ip_address='NotAnIP').is_ip()
            False
        """
        if not ip_addr:
            ip_addr = self.ip_address

        valid = True

        if netaddr.valid_ipv4(ip_addr):  # IPv4 Address
            if not re.match(valid_ip_regex, ip_addr):
                valid = False

        elif netaddr.valid_ipv6(ip_addr):
            pass

        else:
            # print '"%s" is not a valid IP Address.' %ip_addr
            valid = False

        return valid

    def _connect_tcp(self, peer_addr, conn_handler, time_out=None,
                     bind_address=None):
        """Creates a TCP connection to given peer address.

        Tries to create a socket for `timeout` number of seconds. If
        successful, uses the socket instance to start `client_factory`.
        The socket is bound to `bind_address` if specified.
        """
        LOG.debug('Connect TCP called for %s:%s' % (peer_addr[0],
                                                    peer_addr[1]))
        if netaddr.valid_ipv4(peer_addr[0]):
            family = socket.AF_INET
        else:
            family = socket.AF_INET6
        with Timeout(time_out, socket.error):
            sock = hub.connect(peer_addr, family=family, bind=bind_address)
            if sock:
                # Connection name for pro-active connection is made up
                # of local end address + remote end address
                conn_name = ('L: ' + str(sock.getsockname()) + ', R: ' +
                             str(sock.getpeername()))
                self._asso_socket_map[conn_name] = sock
                # If connection is established, we call connection handler
                # in a new thread.
                self._spawn(conn_name, conn_handler, sock)
        return sock

    def _get_address_groups(self, context, network_id, device_id, is_proxy):

        filters = {'network_id': [network_id],
                   'device_id': [device_id]}
        ports = self.nsxv_plugin.get_ports(context, filters=filters)

        subnets = self.nsxv_plugin.get_subnets(context, filters=filters)

        address_groups = []
        for subnet in subnets:
            address_group = {}
            net = netaddr.IPNetwork(subnet['cidr'])
            address_group['subnetMask'] = str(net.netmask)
            address_group['subnetPrefixLength'] = str(net.prefixlen)
            for port in ports:
                fixed_ips = port['fixed_ips']
                for fip in fixed_ips:
                    s_id = fip['subnet_id']
                    ip_addr = fip['ip_address']
                    if s_id == subnet['id'] and netaddr.valid_ipv4(ip_addr):
                        address_group['primaryAddress'] = ip_addr
                        break

            # For Edge appliances which aren't the metadata proxy Edge
            #  we add the metadata IP address
            if not is_proxy and network_id == self.internal_net:
                address_group['secondaryAddresses'] = {
                    'type': 'secondary_addresses',
                    'ipAddress': [METADATA_IP_ADDR]}

            address_groups.append(address_group)
        return address_groups

    def prefix_add(self, prefix, next_hop=None, route_dist=None):
        """ This method adds a new prefix to be advertized.

        ``prefix`` must be the string representation of an IP network
        (e.g., 10.1.1.0/24).

        ``next_hop`` specifies the next hop address for this
        prefix. This parameter is necessary for only VPNv4 and VPNv6
        address families.

        ``route_dist`` specifies a route distinguisher value. This
        parameter is necessary for only VPNv4 and VPNv6 address
        families.

        """
        func_name = 'network.add'
        networks = {}
        networks[PREFIX] = prefix
        if next_hop:
            networks[NEXT_HOP] = next_hop
        if route_dist:
            func_name = 'prefix.add_local'
            networks[ROUTE_DISTINGUISHER] = route_dist

            rf, p = self._check_rf_and_normalize(prefix)
            networks[ROUTE_FAMILY] = rf
            networks[PREFIX] = p

            if rf == vrfs.VRF_RF_IPV6 and netaddr.valid_ipv4(next_hop):
                # convert the next_hop to IPv4-Mapped IPv6 Address
                networks[NEXT_HOP] = \
                    str(netaddr.IPAddress(next_hop).ipv6())

        call(func_name, **networks)

    def add_to_global_table(self, prefix, nexthop=None,
                            is_withdraw=False):
        src_ver_num = 1
        peer = None
        # set mandatory path attributes
        origin = BGPPathAttributeOrigin(BGP_ATTR_ORIGIN_IGP)
        aspath = BGPPathAttributeAsPath([[]])

        pathattrs = OrderedDict()
        pathattrs[BGP_ATTR_TYPE_ORIGIN] = origin
        pathattrs[BGP_ATTR_TYPE_AS_PATH] = aspath

        net = netaddr.IPNetwork(prefix)
        ip = str(net.ip)
        masklen = net.prefixlen
        if netaddr.valid_ipv4(ip):
            _nlri = IPAddrPrefix(masklen, ip)
            if nexthop is None:
                nexthop = '0.0.0.0'
            p = Ipv4Path
        else:
            _nlri = IP6AddrPrefix(masklen, ip)
            if nexthop is None:
                nexthop = '::'
            p = Ipv6Path

        new_path = p(peer, _nlri, src_ver_num,
                     pattrs=pathattrs, nexthop=nexthop,
                     is_withdraw=is_withdraw)

        # add to global ipv4 table and propagates to neighbors
        self.learn_path(new_path)

def get_ipv6_addr_by_EUI64(prefix, mac):
    """Calculate IPv6 address using EUI-64 specification.

    This method calculates the IPv6 address using the EUI-64
    addressing scheme as explained in rfc2373.

    :param prefix: IPv6 prefix.
    :param mac: IEEE 802 48-bit MAC address.
    :returns: IPv6 address on success.
    :raises ValueError, TypeError: For any invalid input.

    .. versionadded:: 1.4
    """
    # Check if the prefix is an IPv4 address
    if netaddr.valid_ipv4(prefix):
        msg = _("Unable to generate IP address by EUI64 for IPv4 prefix")
        raise ValueError(msg)
    try:
        eui64 = int(netaddr.EUI(mac).eui64())
        prefix = netaddr.IPNetwork(prefix)
        return netaddr.IPAddress(prefix.first + eui64 ^ (1 << 57))
    except (ValueError, netaddr.AddrFormatError):
        raise ValueError(_('Bad prefix or mac format for generating IPv6 '
                           'address by EUI-64: %(prefix)s, %(mac)s:')
                         % {'prefix': prefix, 'mac': mac})
    except TypeError:
        raise TypeError(_('Bad prefix type for generating IPv6 address by '
                          'EUI-64: %s') % prefix)

    def _connect_tcp(self, peer_addr, conn_handler, time_out=None,
                     bind_address=None, password=None):
        """Creates a TCP connection to given peer address.

        Tries to create a socket for `timeout` number of seconds. If
        successful, uses the socket instance to start `client_factory`.
        The socket is bound to `bind_address` if specified.
        """
        LOG.debug('Connect TCP called for %s:%s', peer_addr[0], peer_addr[1])
        if netaddr.valid_ipv4(peer_addr[0]):
            family = socket.AF_INET
        else:
            family = socket.AF_INET6
        with Timeout(time_out, socket.error):
            sock = socket.socket(family)
            if bind_address:
                sock.bind(bind_address)
            if password:
                sockopt.set_tcp_md5sig(sock, peer_addr[0], password)
            sock.connect(peer_addr)
            # socket.error exception is raised in case of timeout and
            # the following code is executed only when the connection
            # is established.

        # Connection name for pro-active connection is made up of
        # local end address + remote end address
        local = self.get_localname(sock)[0]
        remote = self.get_remotename(sock)[0]
        conn_name = ('L: ' + local + ', R: ' + remote)
        self._asso_socket_map[conn_name] = sock
        # If connection is established, we call connection handler
        # in a new thread.
        self._spawn(conn_name, conn_handler, sock)
        return sock

def create_connection(address):
    """
    Wrapper for socket.create_connection() function.

    If *address* (a 2-tuple ``(host, port)``) contains a valid IPv4/v6
    address, passes *address* to socket.create_connection().
    If *host* is valid path to Unix Domain socket, tries to connect to
    the server listening on the given socket.

    :param address: IP address or path to Unix Domain socket.
    :return: Socket instance.
    """
    host, _port = address

    if (netaddr.valid_ipv4(host)
            or netaddr.valid_ipv6(host)):
        return socket.create_connection(address)
    elif os.path.exists(host):
        sock = None
        try:
            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            sock.connect(host)
        except socket.error as e:
            if sock is not None:
                sock.close()
            raise e
        return sock
    else:
        raise ValueError('Invalid IP address or Unix Socket: %s' % host)

    def neighbor_add(self, address, remote_as,
                     enable_ipv4=DEFAULT_CAP_MBGP_IPV4,
                     enable_vpnv4=DEFAULT_CAP_MBGP_VPNV4,
                     enable_vpnv6=DEFAULT_CAP_MBGP_VPNV6,
                     next_hop=None, password=None, multi_exit_disc=None):
        """ This method registers a new neighbor. The BGP speaker tries to
        establish a bgp session with the peer (accepts a connection
        from the peer and also tries to connect to it).

        ``address`` specifies the IP address of the peer. It must be
        the string representation of an IP address. Only IP v4 is
        supported now.

        ``remote_as`` specifies the AS number of the peer. It must be
        an integer between 1 and 65535.

        ``enable_ipv4`` enables IPv4 address family for this
        neighbor. The default is True.

        ``enable_vpnv4`` enables VPNv4 address family for this
        neighbor. The default is False.

        ``enable_vpnv6`` enables VPNv6 address family for this
        neighbor. The default is False.

        ``next_hop`` specifies the next hop IP address. If not
        specified, host's ip address to access to a peer is used.

        ``password`` is used for the MD5 authentication if it's
        specified. By default, the MD5 authenticaiton is disabled.

        ``multi_exit_disc`` specifies multi exit discriminator (MED) value.
        The default is None and if not specified, MED value is
        not sent to the neighbor. It must be an integer.

        """
        bgp_neighbor = {}
        bgp_neighbor[neighbors.IP_ADDRESS] = address
        bgp_neighbor[neighbors.REMOTE_AS] = remote_as
        bgp_neighbor[PEER_NEXT_HOP] = next_hop
        bgp_neighbor[PASSWORD] = password
        # v6 advertizement is available with only v6 peering
        if netaddr.valid_ipv4(address):
            bgp_neighbor[CAP_MBGP_IPV4] = enable_ipv4
            bgp_neighbor[CAP_MBGP_IPV6] = False
            bgp_neighbor[CAP_MBGP_VPNV4] = enable_vpnv4
            bgp_neighbor[CAP_MBGP_VPNV6] = enable_vpnv6
        elif netaddr.valid_ipv6(address):
            bgp_neighbor[CAP_MBGP_IPV4] = False
            bgp_neighbor[CAP_MBGP_IPV6] = True
            bgp_neighbor[CAP_MBGP_VPNV4] = False
            bgp_neighbor[CAP_MBGP_VPNV6] = False
        else:
            # FIXME: should raise an exception
            pass

        if multi_exit_disc:
            bgp_neighbor[MULTI_EXIT_DISC] = multi_exit_disc

        call('neighbor.create', **bgp_neighbor)

 def _handle_host_snat_ip(self, host_snat_ips):
     for hsi in host_snat_ips:
         LOG.debug(_("Auto-allocated host SNAT IP: %s"), hsi)
         es = hsi.get('external_segment_name')
         if not es:
             continue
         nh = self.ext_seg_next_hop.setdefault(es, ExtSegNextHopInfo(es))
         if nh.from_config:
             continue    # ignore auto-allocation if manually set
         ip = hsi.get('host_snat_ip')
         gw = ("%s/%s" % (hsi['gateway_ip'], hsi['prefixlen'])
             if (hsi.get('gateway_ip') and hsi.get('prefixlen')) else None)
         updated = False
         if netaddr.valid_ipv4(ip):
             if ip != nh.ip_start or gw != nh.ip_gateway:
                 nh.ip_start = ip
                 nh.ip_gateway = gw
                 updated = True
         elif netaddr.valid_ipv6(ip):
             if ip != nh.ip6_start or gw != nh.ip6_gateway:
                 nh.ip6_start = ip
                 nh.ip6_gateway = gw
                 updated = True
         else:
             LOG.info(_("Ignoring invalid auto-allocated SNAT IP %s"), ip)
         if updated:
             # Clear the interface so that SNAT iptables will be
             # re-created as required; leave MAC as is so that it will
             # be re-used
             nh.next_hop_iface = None
             LOG.info(_("Add/update SNAT info: %s"), nh)

 def create_bgp_peer(self, context, bgp_peer):
     bgp_peer = bgp_peer['bgp_peer']
     remote_ip = bgp_peer['peer_ip']
     if not netaddr.valid_ipv4(remote_ip):
         err_msg = _("NSXv BGP does not support for IPv6")
         raise n_exc.InvalidInput(error_message=err_msg)
     self._validate_bgp_configuration_on_peer_esg(bgp_peer)

    def take_action(self, args):
        configp = self.fetch_config(args)
        instance_root = configp.get('slapos','instance_root')
        master_url = urlparse(configp.get('slapos','master_url'))
        master_hostname = master_url.hostname

        # Check that we have IPv6 ready
        if configp.has_option('slapformat', 'ipv6_interface'):
            ipv6_interface = configp.get('slapformat', 'ipv6_interface')
        else:
            ipv6_interface = configp.get('slapformat', 'interface_name')
        _waitIpv6Ready(ipv6_interface)

        # Check that node can ping master
        if valid_ipv4(master_hostname):
          _test_ping(master_hostname)
        elif valid_ipv6(master_hostname):
          _test_ping6(master_hostname)
        else:
          # hostname
          _ping_hostname(master_hostname)

        app = SlapOSApp()
        # Make sure slapos node format returns ok
        while not _runFormat(app):
            print("[BOOT] [ERROR] Fail to format, try again in 15 seconds...")
            sleep(15)
       
        # Make sure slapos node bang returns ok
        while not _runBang(app):
            print("[BOOT] [ERROR] Fail to bang, try again in 15 seconds...")
            sleep(15)

        _removeTimestamp(instance_root)

	def __init__(self, ip):
		"""Use the avahi (zeroconfig) tools or dig to find a host name given an
		ip address.

		in: ip
		out: string w/ host name or 'unknown' if the host name couldn't be found
		"""
		# handle invalid ip address
		if not valid_ipv4(ip):
			print('Error: the IPv4 address {} is invalid'.format(ip))
			return

		# handle a localhost ip address
		if ip == '127.0.0.1':
			# self.name = platform.node()
			self.name = socket.gethostname()
			return

		# ok, now do more complex stuff
		name = 'unknown'
		if sys.platform == 'linux' or sys.platform == 'linux2':
			name = self.command("avahi-resolve-address {} | awk '{print $2}'".format(ip)).rstrip().rstrip('.')
		elif sys.platform == 'darwin':
			name = self.command('dig +short -x {} -p 5353 @224.0.0.251'.format(ip)).rstrip().rstrip('.')

		# detect any remaining errors
		if name.find('connection timed out') >= 0: name = 'unknown'
		if name == '': name = 'unknown'

		self.name = name

def validate_config(options):
    config = ConfigParser.ConfigParser()
    config.readfp(options.config)
    if not config.has_section(options.env):
        error("Environment {} does not exist in file {}".format(options.env, options.config.name))
    env = dict(config.items(options.env))

    if not valid_mac(env["fuel_mac"]):
        error("Wrong MAC address for Fuel node: {}".format(env["fuel_mac"]))

    for key in ["fuel_ip", "fuel_netmask", "fuel_gw", "fuel_control_ip"]:
        if not valid_ipv4(env[key]):
            error("Wrong IP address ({}) for {} parameter".format(env[key], key))

    ip = IPNetwork(env["fuel_ip"] + "/" + env["fuel_netmask"])
    gw = IPAddress(env["fuel_gw"])
    if gw not in ip:
        error("Gateway address is not within network range")

    for path in [
        env["image_mount_dir"],
        env["ks_files_dir"],
        env["ks_patch"],
        env["pxe_config_dir"],
        env["esxi_private_key_file"],
    ]:
        if not os.path.exists(path):
            error("Path {} does not exist or is not accessible".format(path))

    env["pxe_config_file"] = os.path.join(env["pxe_config_dir"], "01-{}".format(env["fuel_mac"].replace(":", "-")))
    return env

    def __init__(self, iface, mode, ip=None, netmask="255.255.255.0",
                 network=None,
                 broadcast=None, gateway=None, nameserver=None, options=None):
        """
        Creates a new interface object

        :param iface: The name of the interface (lo, br0, eth0, eth1)
        :param mode: can bee loopback, manual, dhcp, static
        :param ip: The IP Address of the interface
        :type ip: basestring
        :param netmask: The netmask of the interface
        :param network: The network of the interface. If omitted it will be
            calculated from IP and netmask
        :param broadcast: The broadcast of the interface. If omitted it will be
            calculated from UP and netmask
        :param gateway: The gateway
        :param nameserver: list of nameserver
        :type param: basestring
        :return: an interface object
        """
        self.options = options or []
        self.iface = iface
        self.mode = mode
        if self.mode not in ["auto", "manual", "dhcp", "static"]:
            raise Exception("No valid mode. Valid modes are 'auto', "
                            "'manual', 'dhcp' or 'static'.")
        self.ip = ip
        self.netmask = netmask
        self.network = network
        self.broadcast = broadcast
        self.gateway = gateway
        self.nameserver = (nameserver or "").split()
        if ip and netmask:
            if not netaddr.valid_ipv4(ip):
                raise Exception("IP no valid IPv4 address.")

            network_object = netaddr.IPNetwork("%s/%s" % (ip, netmask))
            self.ip = ip
            self.netmask = netmask
            self.broadcast = self.broadcast or str(network_object.broadcast)
            self.network = self.network or str(network_object.network)
            if self.gateway:
                if not netaddr.valid_ipv4(self.gateway):
                    raise Exception("Gateway no valid IPv4 address")
            for ns in self.nameserver:
                if not netaddr.valid_ipv4(ns):
                    raise Exception("Nameserver no valid IPv4 address")