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 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 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 _format_address_for_dnsmasq(address): # (dzyu) Check if it is legal ipv6 address, if so, need wrap # it with '[]' to let dnsmasq to distinguish MAC address from # IPv6 address. if netaddr.valid_ipv6(address): return '[%s]' % address return address
def getAddress(self, allow_tap=False): """ Return a list of the interface address not attributed to any partition, (which are therefore free for the computer itself). Returns: False if the interface isn't available, else the list of the free addresses. """ if self.interface is None: return dict(addr=self.address, netmask=self.netmask) computer_partition_address_list = [] for partition in self.partition_list: for address in partition.address_list: if netaddr.valid_ipv6(address['addr']): computer_partition_address_list.append(address['addr']) # Going through addresses of the computer's interface for address_dict in self.interface.getGlobalScopeAddressList(): # Comparing with computer's partition addresses if address_dict['addr'] not in computer_partition_address_list: return address_dict if allow_tap: # all addresses on interface are for partition, so lets add new one computer_tap = Tap('compdummy') computer_tap.createWithOwner(User('root'), attach_to_tap=True) self.interface.addTap(computer_tap) return self.interface.addAddr() # Can't find address raise NoAddressOnInterface('No valid IPv6 found on %s.' % self.interface.name)
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 _is_pingable(self, mgmt_ip="", count=5, timeout=1, interval='0.2', **kwargs): """Checks whether an IP address is reachable by pinging. Use linux utils to execute the ping (ICMP ECHO) command. Sends 5 packets with an interval of 0.2 seconds and timeout of 1 seconds. Runtime error implies unreachability else IP is pingable. :param ip: IP to check :return: bool - True or string 'failure' depending on pingability. """ cmd_ping = 'ping' if netaddr.valid_ipv6(mgmt_ip): cmd_ping = 'ping6' ping_cmd = [cmd_ping, '-c', count, '-W', timeout, '-i', interval, mgmt_ip] try: linux_utils.execute(ping_cmd, check_exit_code=True) return True except RuntimeError: LOG.warning("Cannot ping ip address: %s", mgmt_ip) return 'failure'
def _build_base_url(self, scheme): proto_str = "%s://" % scheme host_str = ("[%s]" % self._host if netaddr.valid_ipv6(self._host) else self._host) port_str = ":%d" % (self._api_ssl_port if scheme == "https" else self._api_port) return proto_str + host_str + port_str
def run(args): # minimal web server. serves files relative to the # current directory. logging.basicConfig(format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", filename=args['log-file'] ,level=logging.INFO) port = args['port'] host = args['host'] os.chdir(args['cwd']) Handler = ServerHandler Handler.document_path = args['root-dir'] Handler.restrict_root_folder = (args['root-dir'] != args['cwd']) if valid_ipv6(host): server = HTTPServerV6 else: server = HTTPServer httpd = server((host, port), Handler) scheme = 'http' if args.has_key('cert-file') and args.has_key('key-file') and \ os.path.exists(args['cert-file']) and os.path.exists(args['key-file']): scheme = 'https' httpd.socket = ssl.wrap_socket (httpd.socket, server_side=True, certfile=args['cert-file'], keyfile=args['key-file']) logging.info("Starting simple http server at %s://%s:%s" % (scheme, host, port)) httpd.serve_forever()
def _process_networks(osutils, network_details): reboot_required = False ipv4_ns, ipv6_ns = NetworkConfigPlugin._get_default_dns_nameservers( network_details) for net in network_details.networks: ip_address, prefix_len = net.address_cidr.split("/") gateway = None default_gw_route = [ r for r in net.routes if netaddr.IPNetwork(r.network_cidr).prefixlen == 0] if default_gw_route: gateway = default_gw_route[0].gateway nameservers = net.dns_nameservers if not nameservers: if netaddr.valid_ipv6(ip_address): nameservers = ipv6_ns else: nameservers = ipv4_ns LOG.info( "Setting static IP configuration on network adapter " "\"%(name)s\". IP: %(ip)s, prefix length: %(prefix_len)s, " "gateway: %(gateway)s, dns: %(dns)s", {"name": net.link, "ip": ip_address, "prefix_len": prefix_len, "gateway": gateway, "dns": nameservers}) reboot = osutils.set_static_network_config( net.link, ip_address, prefix_len, gateway, nameservers) reboot_required = reboot or reboot_required return reboot_required
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 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 request(self, url, method='GET', body=None, headers=None, ssl_verify=True, stream=False): _headers = {'Content-Type': 'application/json'} _headers.update(headers or {}) parsed_url = urlparse.urlparse(url) port = parsed_url.port hostname = parsed_url.hostname scheme = parsed_url.scheme if netaddr.valid_ipv6(hostname): hostname = "[%s]" % hostname relative_url = parsed_url.path if parsed_url.query: relative_url = relative_url + "?" + parsed_url.query LOG.info(_("Doing %(method)s on %(relative_url)s"), {'method': method, 'relative_url': relative_url}) if body: LOG.info(_("Body: %s") % body) if port: _url = "%s://%s:%d%s" % (scheme, hostname, int(port), relative_url) else: _url = "%s://%s%s" % (scheme, hostname, relative_url) response = requests.request(method, _url, data=body, headers=_headers, verify=ssl_verify, stream=stream) return response
def parse_server_string(server_str): """Parses the given server_string and returns a tuple of host and port. If it's not a combination of host part and port, the port element is an empty string. If the input is invalid expression, return a tuple of two empty strings. """ try: # First of all, exclude pure IPv6 address (w/o port). if netaddr.valid_ipv6(server_str): return (server_str, "") # Next, check if this is IPv6 address with a port number combination. if server_str.find("]:") != -1: (address, port) = server_str.replace("[", "", 1).split("]:") return (address, port) # Third, check if this is a combination of an address and a port if server_str.find(":") == -1: return (server_str, "") # This must be a combination of an address and a port (address, port) = server_str.split(":") return (address, port) except (ValueError, netaddr.AddrFormatError): LOG.error(_LE("Invalid server_string: %s"), server_str) return ("", "")
def parse_server_string(server_str): """ Parses the given server_string and returns a list of host and port. If it's not a combination of host part and port, the port element is a null string. If the input is invalid expression, return a null list. """ try: # First of all, exclude pure IPv6 address (w/o port). if netaddr.valid_ipv6(server_str): return (server_str, '') # Next, check if this is IPv6 address with a port number combination. if server_str.find("]:") != -1: (address, port) = server_str.replace('[', '', 1).split(']:') return (address, port) # Third, check if this is a combination of an address and a port if server_str.find(':') == -1: return (server_str, '') # This must be a combination of an address and a port (address, port) = server_str.split(':') return (address, port) except Exception: LOG.error(_('Invalid server_string: %s'), server_str) return ('', '')
def prefix_del(self, prefix, route_dist=None): """ This method deletes a advertized prefix. ``prefix`` must be the string representation of an IP network (e.g., 10.1.1.0/24). ``route_dist`` specifies a route distinguisher value. This parameter is necessary for only VPNv4 and VPNv6 address families. """ func_name = 'network.del' networks = {} networks[PREFIX] = prefix if route_dist: func_name = 'prefix.delete_local' networks[ROUTE_DISTINGUISHER] = route_dist ip, masklen = prefix.split('/') if netaddr.valid_ipv6(ip): networks[ROUTE_FAMILY] = vrfs.VRF_RF_IPV6 # normalize IPv6 address expression networks[PREFIX] = \ str(netaddr.IPAddress(ip)) + '/' + masklen else: networks[ROUTE_FAMILY] = vrfs.VRF_RF_IPV4 call(func_name, **networks)
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 _output_hosts_file(self): """Writes a dnsmasq compatible hosts file.""" r = re.compile('[:.]') buf = six.StringIO() for port in self.network.ports: for alloc in port.fixed_ips: name = 'host-%s.%s' % (r.sub('-', alloc.ip_address), self.conf.dhcp_domain) set_tag = '' # (dzyu) Check if it is legal ipv6 address, if so, need wrap # it with '[]' to let dnsmasq to distinguish MAC address from # IPv6 address. ip_address = alloc.ip_address if netaddr.valid_ipv6(ip_address): ip_address = '[%s]' % ip_address if getattr(port, 'extra_dhcp_opts', False): if self.version >= self.MINIMUM_VERSION: set_tag = 'set:' buf.write('%s,%s,%s,%s%s\n' % (port.mac_address, name, ip_address, set_tag, port.id)) else: buf.write('%s,%s,%s\n' % (port.mac_address, name, ip_address)) name = self.get_conf_file_name('host') utils.replace_file(name, buf.getvalue()) return name
def is_connective(self, ping_timeout=20.0): """ Check if host network is connective via ping command :param ping_timeout: time to wait for response :type ping_timeout: float :return: True if address is connective via ping command, False otherwise :rtype: bool """ host_address = self.host.ip # Leave it for future support of IPV6 ping_cmd = "ping6" if netaddr.valid_ipv6(self.host.ip) else "ping" self.logger.info( "Check if address is connective via ping in given timeout %s", ping_timeout ) command = [ ping_cmd, "-c", "1", "-w", str(ping_timeout), host_address ] p = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE ) out, _ = p.communicate() if p.returncode: self.logger.debug( "Failed to ping address %s: %s", host_address, out ) return False return True
def validate_ip_addr(ip_addr): if netaddr.valid_ipv4(ip_addr): return lib_consts.IP_VERSION_4 elif netaddr.valid_ipv6(ip_addr): return lib_consts.IP_VERSION_6 else: raise bgp_driver_exc.InvalidParamType(param=ip_addr, param_type='ip-address')
def is_valid_ip_address(ip_address, ip_version): if int(ip_version) == 4: return netaddr.valid_ipv4(ip_address) elif int(ip_version) == 6: return netaddr.valid_ipv6(ip_address) else: raise exception.ManilaException( _("Provided improper IP version '%s'.") % ip_version)
def isIP(ip): try: if netaddr.valid_ipv4(ip,flags=netaddr.INET_PTON) or netaddr.valid_ipv6(ip,flags=netaddr.INET_PTON): return True else: return False except: return False
def __init__(self, buildout, name, options): slap = slapos.slap.slap() slap.initializeConnection( options['url'], options.get('key'), options.get('cert'), ) computer_partition = slap.registerComputerPartition( options['computer'], options['partition'], ) parameter_dict = computer_partition.getInstanceParameterDict() options['instance-state'] = computer_partition.getState() # XXX: those are not partition parameters, strictly speaking. # Make them available as individual section keys. for his_key in ( 'slap_software_type', 'slap_computer_partition_id', 'slap_computer_id', 'slap_software_release_url', 'slave_instance_list', 'timestamp', ): try: value = parameter_dict.pop(his_key) except KeyError: pass else: options[his_key.replace('_', '-')] = value ipv4_set = set() v4_add = ipv4_set.add ipv6_set = set() v6_add = ipv6_set.add tap_set = set() tap_add = tap_set.add for tap, ip in parameter_dict.pop('ip_list'): tap_add(tap) if valid_ipv4(ip): v4_add(ip) elif valid_ipv6(ip): v6_add(ip) # XXX: emit warning on unknown address type ? options['ipv4'] = ipv4_set options['ipv6'] = ipv6_set # also export single ip values for those recipes that don't support sets. if ipv4_set: options['ipv4-random'] = list(ipv4_set)[0].encode('UTF-8') if ipv6_set: options['ipv6-random'] = list(ipv6_set)[0].encode('UTF-8') options['tap'] = tap_set parameter_dict = self._expandParameterDict(options, parameter_dict) match = self.OPTCRE_match for key, value in parameter_dict.iteritems(): if match(key) is not None: continue options['configuration.' + key] = value
def general_info(self): """ Return IP in bits, ip_type (ie: private, multicast, loopback,etc..), time updated/returned and version for an IP Address >>> from ipinformation import IPInformation >>> from pprint import pprint >>> pprint( IPInformation(ip_address='8.8.8.8').general_info() ) {'general': {'bits': '00001000000010000000100000001000', 'type': 'public', 'updated': datetime.datetime(2016, 1, 16, 18, 7, 4, 288512), 'version': '4'}} >>> pprint( IPInformation(ip_address='127.0.0.1').general_info() ) {'general': {'bits': '01111111000000000000000000000001', 'type': 'loopback', 'updated': datetime.datetime(2016, 1, 16, 18, 10, 6, 729149), 'version': '4'}} """ data = {"general": {"bits": None, "type": None, "updated": None, "version": None}} if not self.ISIP: # print '"%s" is not a valid IP Address.' %self.ip_address # logging_file.error( '"{0}" is not a valid IP Address.'.format(self.ip_address) ) return data if netaddr.valid_ipv4(self.ip_address): # IPv4 Address ip_version = "4" data["general"].update({"version": ip_version}) ip_bits = ( netaddr.IPAddress(self.ip_address).bits().replace(".", "") ) # Set the IP bits for searching by subnet data["general"].update({"bits": ip_bits}) ip_addr = netaddr.IPAddress(self.ip_address) if ip_addr.is_private(): ip_type = "private" elif ip_addr.is_multicast(): ip_type = "multicast" elif ip_addr.is_loopback(): ip_type = "loopback" elif ip_addr.is_netmask(): ip_type = "netmask" elif ip_addr.is_reserved(): ip_type = "reserved" elif ip_addr.is_link_local(): ip_type = "link_local" elif ip_addr.is_unicast(): ip_type = "public" else: # Unknown Type ip_type = "unknown" logging_file.error('"{0}" is an unknown IP Address.'.format(self.ip_address)) elif netaddr.valid_ipv6(self.ip_address): # IPv6 Address#TODO:Finish IPv6 ip_version = "6" print "Is IPv6" return False data["general"].update({"type": ip_type}) data["general"].update({"updated": datetime.utcnow()}) return data
def detect_address_family(host): if netaddr.valid_ipv4(host): return socket.AF_INET elif netaddr.valid_ipv6(host): return socket.AF_INET6 elif os.path.isdir(os.path.dirname(host)): return socket.AF_UNIX else: return None
def _parse_hosts(self, hosts): """Parses the list of hosts and creates corresponding objects.""" ip_list = [str(ip) for ip in list(netaddr.IPNetwork(hosts))] if netaddr.valid_ipv4(ip_list[0]): self.inet = socket.AF_INET elif netaddr.valid_ipv6(ip_list[0]): self.inet = socket.AF_INET6 return [Host(ip, self.ports) for ip in ip_list]
def valid_ipv6_url(host, port): """Given a host and a port returns a valid URL RFC2732 https://tools.ietf.org/html/rfc2732 square brackets always required in ipv6 URI. """ if netaddr.valid_ipv6(host): uri = '[%s]:%s' % (host, port) else: uri = '%s:%s' % (host, port) return uri
def is_ip(string): try: if netaddr.valid_ipv4(string): return True if netaddr.valid_ipv6(string): return True return False except: traceback.print_exc() return False
def is_ip(string): try: if netaddr.valid_ipv4(string): return True if netaddr.valid_ipv6(string): return True return False except: if logger.debug: traceback.print_exc() return False
def _get_link_interface(self, string_id): if valid_ipv4(string_id) or valid_ipv6(string_id): try: return Ip.objects.get(address=string_id).interface except Ip.DoesNotExist as e: return None else: try: return Interface.objects.get(mac=string_id) except Interface.DoesNotExist as e: return None
def _get_default_dns_nameservers(network_details): ipv4_nameservers = [] ipv6_nameservers = [] for s in network_details.services: if isinstance(s, network_model.NameServerService): for nameserver in s.addresses: if netaddr.valid_ipv6(nameserver): ipv6_nameservers.append(nameserver) else: ipv4_nameservers.append(nameserver) return (ipv4_nameservers, ipv6_nameservers)
def is_single_ipv6(ip): """ to check a value if its IPv6 address Args: ip: the value to check if its IPv6 Returns: True if it's IPv6 otherwise False """ return netaddr.valid_ipv6(str(ip))
def addrstr(x): """ helper for mapping IP addresses to zebra config statements """ addr = x.split("/")[0] if netaddr.valid_ipv4(addr): return "ip address %s" % x elif netaddr.valid_ipv6(addr): return "ipv6 address %s" % x else: raise ValueError("invalid address: %s", x)
def is_valid_ipv6(address): """Verify that address represents a valid IPv6 address. :param address: Value to verify :type address: string :returns: bool """ try: return netaddr.valid_ipv6(address) except Exception: return False
def addrstr(ip: netaddr.IPNetwork) -> str: """ helper for mapping IP addresses to zebra config statements """ address = str(ip.ip) if netaddr.valid_ipv4(address): return "ip address %s" % ip elif netaddr.valid_ipv6(address): return "ipv6 address %s" % ip else: raise ValueError("invalid address: %s", ip)
def is_ip(ip): """Checks if an IP is a valid IPv4 or IPv6 address. Args: ip (str): The IP to be checked. Returns: True, if it's a valid IPv4 or IPv6 address """ return valid_ipv4(ip) or valid_ipv6(ip)
def routestr(ip: netaddr.IPNetwork) -> str: address = str(ip.ip) if netaddr.valid_ipv6(address): dst = "3ffe:4::/64" else: dst = "10.9.8.0/24" if ip[-2] == ip[1]: return "" else: rtcmd = "#/sbin/ip route add %s via" % dst return "%s %s" % (rtcmd, ip[1])
def _output_hosts_file(self): """Writes a dnsmasq compatible dhcp hosts file. The generated file is sent to the --dhcp-hostsfile option of dnsmasq, and lists the hosts on the network which should receive a dhcp lease. Each line in this file is in the form:: 'mac_address,FQDN,ip_address' IMPORTANT NOTE: a dnsmasq instance does not resolve hosts defined in this file if it did not give a lease to a host listed in it (e.g.: multiple dnsmasq instances on the same network if this network is on multiple network nodes). This file is only defining hosts which should receive a dhcp lease, the hosts resolution in itself is defined by the `_output_addn_hosts_file` method. """ buf = six.StringIO() filename = self.get_conf_file_name('host') LOG.debug('Building host file: %s', filename) dhcp_enabled_subnet_ids = [ s.id for s in self.network.subnets if s.enable_dhcp ] # NOTE(ihrachyshka): the loop should not log anything inside it, to # avoid potential performance drop when lots of hosts are dumped for (port, alloc, hostname, name) in self._iter_hosts(): if not alloc: if getattr(port, 'extra_dhcp_opts', False): buf.write('%s,%s%s\n' % (port.mac_address, 'set:', port.id)) continue # don't write ip address which belongs to a dhcp disabled subnet. if alloc.subnet_id not in dhcp_enabled_subnet_ids: continue # (dzyu) Check if it is legal ipv6 address, if so, need wrap # it with '[]' to let dnsmasq to distinguish MAC address from # IPv6 address. ip_address = alloc.ip_address if netaddr.valid_ipv6(ip_address): ip_address = '[%s]' % ip_address if getattr(port, 'extra_dhcp_opts', False): buf.write( '%s,%s,%s,%s%s\n' % (port.mac_address, name, ip_address, 'set:', port.id)) else: buf.write('%s,%s,%s\n' % (port.mac_address, name, ip_address)) utils.replace_file(filename, buf.getvalue()) LOG.debug('Done building host file %s with contents:\n%s', filename, buf.getvalue()) return filename
def get_soap_url(protocol, host, path='sdk'): """Return URL to SOAP services for ESX/VC server. :param protocol: https or http :param host: ESX/VC server host IP :param path: path part of the SOAP URL :return: URL to SOAP services for ESX/VC server """ if netaddr.valid_ipv6(host): return '%s://[%s]/%s' % (protocol, host, path) return '%s://%s/%s' % (protocol, host, path)
def wbmanage(action, ruleset, address, direction='inbound', account='@.'): # python /opt/iredapd/tools/wblist_admin.py --delete --blacklist 172.16.1.10 # --add --blacklist [email protected] array = address.split(' ') for i in range(len(array)): if netaddr.valid_ipv4(array[i]) or netaddr.valid_ipv6(array[i]): True elif '@' not in array[i]: array[i] = '@'+array[i] address = ' '.join(array) return __salt__['cmd.run']('python /opt/iredapd/tools/wblist_admin.py --'+direction+' --'+account+' --'+action+' --'+ruleset+' '+address)
def is_valid_ip(address): if python_version(3, 3): import ipaddress try: ipaddress.ip_address(address) return True except ValueError: return False else: import netaddr return netaddr.valid_ipv4(address) or netaddr.valid_ipv6(address)
def _output_hosts_file(self): """Writes a dnsmasq compatible dhcp hosts file. The generated file is sent to the --dhcp-hostsfile option of dnsmasq, and lists the hosts on the network which should receive a dhcp lease. Each line in this file is in the form:: 'mac_address,FQDN,ip_address' IMPORTANT NOTE: a dnsmasq instance does not resolve hosts defined in this file if it did not give a lease to a host listed in it (e.g.: multiple dnsmasq instances on the same network if this network is on multiple network nodes). This file is only defining hosts which should receive a dhcp lease, the hosts resolution in itself is defined by the `_output_addn_hosts_file` method. """ buf = six.StringIO() filename = self.get_conf_file_name('host') LOG.debug('Building host file: %s', filename) dhcp_enabled_subnet_ids = [s.id for s in self.network.subnets if s.enable_dhcp] # NOTE(ihrachyshka): the loop should not log anything inside it, to # avoid potential performance drop when lots of hosts are dumped for (port, alloc, hostname, name) in self._iter_hosts(): if not alloc: if getattr(port, 'extra_dhcp_opts', False): buf.write('%s,%s%s\n' % (port.mac_address, 'set:', port.id)) continue # don't write ip address which belongs to a dhcp disabled subnet. if alloc.subnet_id not in dhcp_enabled_subnet_ids: continue # (dzyu) Check if it is legal ipv6 address, if so, need wrap # it with '[]' to let dnsmasq to distinguish MAC address from # IPv6 address. ip_address = alloc.ip_address if netaddr.valid_ipv6(ip_address): ip_address = '[%s]' % ip_address if getattr(port, 'extra_dhcp_opts', False): buf.write('%s,%s,%s,%s%s\n' % (port.mac_address, name, ip_address, 'set:', port.id)) else: buf.write('%s,%s,%s\n' % (port.mac_address, name, ip_address)) utils.replace_file(filename, buf.getvalue()) LOG.debug('Done building host file %s with contents:\n%s', filename, buf.getvalue()) return filename
def attach_container(self, container_name, br_name, veth_name, ip, tag=0, gw=False, txoff=False): logger.debug("Configure for container: {}".format(container_name)) nspid = self.docker.nspid(container_name) self._create_veth(container_name, br_name, veth_name, tag) logger.debug("Container {}: add ip address {} for {}.\n".format(container_name, ip, veth_name)) self._config_ip(nspid, veth_name, ip, txoff) if gw and netaddr.valid_ipv4(gw) or netaddr.valid_ipv6(gw): self._config_add_route(container_name, gw)
def _parse_subnets(self, subnets, link_name): networks = [] if not subnets or not isinstance(subnets, list): LOG.warning("Subnets '%s' is empty or not a list.", subnets) return networks for subnet in subnets: if not isinstance(subnet, dict): LOG.warning("Subnet '%s' is not a dictionary", subnet) continue if subnet.get("type") in ["dhcp", "dhcp6"]: continue routes = [] for route_data in subnet.get("routes", []): route_netmask = route_data.get("netmask") route_network = route_data.get("network") route_network_cidr = network_utils.ip_netmask_to_cidr( route_network, route_netmask) route_gateway = route_data.get("gateway") route = network_model.Route(network_cidr=route_network_cidr, gateway=route_gateway) routes.append(route) address_cidr = subnet.get("address") netmask = subnet.get("netmask") if netmask: address_cidr = network_utils.ip_netmask_to_cidr( address_cidr, netmask) gateway = subnet.get("gateway") if gateway: # Map the gateway as a default route, depending on the # IP family / version (4 or 6) gateway_net_cidr = "0.0.0.0/0" if netaddr.valid_ipv6(gateway): gateway_net_cidr = "::/0" routes.append( network_model.Route(network_cidr=gateway_net_cidr, gateway=gateway)) networks.append( network_model.Network( link=link_name, address_cidr=address_cidr, dns_nameservers=subnet.get("dns_nameservers"), routes=routes)) return networks
def is_valid_ipv6(address): """ Helper to determine if we need the to add brackets. is_valid_ipv6('fd00::1') -> True is_valid_ipv6('[fd00::1]') -> False is_valid_ipv6('192.168.1.1') -> False """ try: return netaddr.valid_ipv6(address) except Exception: return False
def get_server_cls(host): """Return an appropriate WSGI server class base on provided host :param host: The listen host for the ceilometer API server. """ server_cls = simple_server.WSGIServer if netaddr.valid_ipv6(host): # NOTE(dzyu) make sure use IPv6 sockets if host is in IPv6 pattern if getattr(server_cls, 'address_family') == socket.AF_INET: class server_cls(server_cls): address_family = socket.AF_INET6 return server_cls
def data(self) -> Dict[str, Any]: routes = [] for iface in self.node.get_ifaces(control=False): for ip in iface.ips(): address = str(ip.ip) if netaddr.valid_ipv6(address): dst = "3ffe:4::/64" else: dst = "10.9.8.0/24" if ip[-2] != ip[1]: routes.append((dst, ip[1])) return dict(routes=routes)
def __init__(self, Direccion): self.__id self.__direccion = netaddr.IPAddress(Direccion) if netaddr.valid_ipv4(Direccion): self.__familia = 4 if netaddr.valid_ipv6(Direccion): self.__familia = 6 self.__vrf self.__id_interfaz self.__fecha_creacion = datetime.datetime.now() self.__fecha_actualizacion self.__nat_interno self.__descripcion
def get_server_cls(host): """Return an appropriate WSGI server class base on provided host :param host: The listen host for the entropy API server. """ server_cls = simple_server.WSGIServer if netaddr.valid_ipv6(host): if getattr(server_cls, 'address_family') == socket.AF_INET: class server_cls(server_cls): address_family = socket.AF_INET6 return server_cls
def get_link(cls, source, target, topology=None): """ Find link between source and target, (or vice versa, order is irrelevant). :param source: ip or mac addresses :param target: ip or mac addresses :param topology: optional topology relation :returns: Link object :raises: LinkNotFound """ a = source b = target # ensure parameters are coherent if not (valid_ipv4(a) and valid_ipv4(b)) and not (valid_ipv6(a) and valid_ipv6(b)) and not (valid_mac(a) and valid_mac(b)): raise ValueError('Expecting valid ipv4, ipv6 or mac address') # get interfaces a = cls._get_link_interface(a) b = cls._get_link_interface(b) # raise LinkDataNotFound if an interface is not found not_found = [] if a is None: not_found.append(source) if b is None: not_found.append(target) if not_found: msg = 'the following interfaces could not be found: {0}'.format(', '.join(not_found)) raise LinkDataNotFound(msg) # find link with interfaces # inverse order is also ok q = (Q(interface_a=a, interface_b=b) | Q(interface_a=b, interface_b=a)) # add topology to lookup if topology: q = q & Q(topology=topology) link = Link.objects.filter(q).first() if link is None: raise LinkNotFound('Link matching query does not exist', interface_a=a, interface_b=b, topology=topology) return link
def netlist(nets): v4nets = [] v6nets = [] for net in nets: ipNetwork = netaddr.IPNetwork(net) parts = str(ipNetwork).split("/") ip = parts[0] mask = parts[1] if netaddr.valid_ipv4(ip) and int(mask) <= 32: v4nets.append(ipNetwork) elif netaddr.valid_ipv6(ip) and int(mask) <= 128: v6nets.append(ipNetwork) return v4nets, v6nets
def isIP6(IP): """ to check a value if its IPv6 address Args: IP: the value to check if its IPv6 Returns: True if it's IPv6 otherwise False """ IP = str(IP) ip_flag = netaddr.valid_ipv6(IP) return ip_flag
def is_valid_ipv6(address): """Verify that address represents a valid IPv6 address. :param address: Value to verify :type address: string :returns: bool .. versionadded:: 1.1 """ try: return netaddr.valid_ipv6(address) except netaddr.AddrFormatError: return False
def _check_rf_and_normalize(prefix): """ check prefix's route_family and if the address is IPv6 address, return IPv6 route_family and normalized IPv6 address. If the address is IPv4 address, return IPv4 route_family and the prefix itself. """ ip, masklen = prefix.split('/') if netaddr.valid_ipv6(ip): # normalize IPv6 address ipv6_prefix = str(netaddr.IPAddress(ip)) + '/' + masklen return vrfs.VRF_RF_IPV6, ipv6_prefix else: return vrfs.VRF_RF_IPV4, prefix
def serialize(self): # fixup if (netaddr.valid_ipv4(self.peer_ip) and netaddr.valid_ipv4(self.local_ip)): self.afi = self.AFI_IPv4 elif (netaddr.valid_ipv6(self.peer_ip) and netaddr.valid_ipv6(self.local_ip)): self.afi = self.AFI_IPv6 else: raise ValueError( 'peer_ip and local_ip must be the same address family: ' 'peer_ip=%s, local_ip=%s' % (self.peer_ip, self.local_ip)) buf = struct.pack(self._HEADER_FMT, self.peer_as, self.local_as, self.if_index, self.afi) buf += ip.text_to_bin(self.peer_ip) buf += ip.text_to_bin(self.local_ip) buf += self.bgp_message.serialize() return buf
def validate_ip(ip_addr, version): """ Validate that ip_addr is a valid IPv4 or IPv6 address :param ip_addr: IP address to be validated :param version: 4 or 6 :return: Boolean: True if valid, False if invalid. """ assert version in (4, 6) if version == 4: return netaddr.valid_ipv4(ip_addr) if version == 6: return netaddr.valid_ipv6(ip_addr)
def get_transport_function(ip, port): if '%' in ip: ip, interface = ip.split('%', 1) if not re.match('[a-z][a-z0-9]+$', interface): logging.warn("Invalid IP Address") return None else: return Udp6TransportTarget((ip, port)) elif netaddr.valid_ipv4(ip): return cmdgen.UdpTransportTarget((ip, port)) elif netaddr.valid_ipv6(ip): return Udp6TransportTarget((ip, port))
def find_default_gwv6(self): """ Find host default ipv6 gateway Returns: str: Default gateway """ out = self._cmd(["ip", "-6", "route"]).splitlines() for i in out: if re.search("default", i): default_gw = re.findall(r'(?<=\s)[0-9a-fA-F:]{3,}(?=\s)', i) if netaddr.valid_ipv6(default_gw[0]): return default_gw[0] return None
def data(self) -> Dict[str, Any]: interfaces = [] for ifc in self.node.netifs(): if getattr(ifc, "control", False): continue prefixes = [] for x in ifc.addrlist: addr = x.split("/")[0] if netaddr.valid_ipv6(addr): prefixes.append(x) if not prefixes: continue interfaces.append((ifc.name, prefixes)) return dict(interfaces=interfaces)