def _subnet_of(network_a, network_b):
""" Test if a network is a subnet of another network """
params = {"network_a": network_a, "network_b": network_b}
_validate_args("subnet_of", DOCUMENTATION, params)
try:
return _is_subnet_of(ip_network(network_a), ip_network(network_b))
except Exception:
return False
def _in_one_network(ip, networks):
"""Test if an IP or network is in one network"""
params = {"ip": ip, "networks": networks}
_validate_args("in_one_network", DOCUMENTATION, params)
bools = [_in_network(ip, network) for network in networks]
if bools.count(True) == 1:
return True
return False
def _private(ip):
""" Test if an IP address is private """
params = {"ip": ip}
_validate_args("private", DOCUMENTATION, params)
try:
return ip_address(ip).is_private
except Exception:
return False
def _ipv6_address(ip):
"""Test if something in an IPv6 address"""
params = {"ip": ip}
_validate_args("ipv6_address", DOCUMENTATION, params)
try:
return ip_address(ip).version == 6
except Exception:
return False
def _in_any_network(ip, networks):
"""Test if an IP or network is in any network"""
params = {"ip": ip, "networks": networks}
_validate_args("in_any_network", DOCUMENTATION, params)
bools = [_in_network(ip, network) for network in networks]
if True in bools:
return True
return False
def _ipv4(ip):
"""Test if something in an IPv4 address or network"""
params = {"ip": ip}
_validate_args("ipv4", DOCUMENTATION, params)
try:
return ip_network(ip).version == 4
except Exception:
return False
def _loopback(ip):
""" Test if an IP address is a loopback """
params = {"ip": ip}
_validate_args("loopback", DOCUMENTATION, params)
try:
return ip_address(ip).is_loopback
except Exception:
return False
def _unspecified(ip):
""" Test for an unspecified IP address """
params = {"ip": ip}
_validate_args("unspecified", DOCUMENTATION, params)
try:
return ip_address(ip).is_unspecified
except Exception:
return False
def _public(ip):
""" Test if an IP address is public """
params = {"ip": ip}
_validate_args("public", DOCUMENTATION, params)
try:
return ip_address(ip).is_global
except Exception:
return False
def _in_network(ip, network):
"""Test if an address or network is in a network"""
params = {"ip": ip, "network": network}
_validate_args("in_network", DOCUMENTATION, params)
try:
return _is_subnet_of(ip_network(ip), ip_network(network))
except Exception:
return False
def _multicast(ip):
""" Test for a multicast IP address """
params = {"ip": ip}
_validate_args("multicast", DOCUMENTATION, params)
try:
return ip_address(ip).is_multicast
except Exception:
return False
def _ipv4_netmask(mask):
""" Test for a valid IPv4 netmask"""
params = {"mask": mask}
_validate_args("ipv4_netmask", DOCUMENTATION, params)
try:
network = ip_network("10.0.0.0/{mask}".format(mask=mask))
return str(network.netmask) == mask
except Exception:
return False
def _ip_address(ip):
"""Test if something in an IP address"""
params = {"ip": ip}
_validate_args("ip_address", DOCUMENTATION, params)
try:
ip_address(ip)
return True
except Exception:
return False
def _ipv4_hostmask(ip):
"""Test if an address is a hostmask"""
params = {"ip": ip}
_validate_args("ipv4_hostmask", DOCUMENTATION, params)
try:
ipaddr = ip_network("10.0.0.0/{ip}".format(ip=ip))
return str(ipaddr.hostmask) == ip
except Exception:
return False
def _ipv6_ipv4_mapped(ip):
""" Test if something appears to be a mapped IPv6 to IPv4 mapped address """
params = {"ip": ip}
_validate_args("ipv6_ipv4_mapped", DOCUMENTATION, params)
try:
if ip_address(ip).ipv4_mapped is None:
return False
return True
except Exception:
return False
def _ipv6_teredo(ip):
""" Test if something is an IPv6 teredo address """
params = {"ip": ip}
_validate_args("ipv6_teredo", DOCUMENTATION, params)
try:
if ip_address(ip).teredo is None:
return False
return True
except Exception:
return False
def _ipv6_sixtofour(ip):
""" Test if something appears to be a 6to4 address """
params = {"ip": ip}
_validate_args("ipv6_sixtofour", DOCUMENTATION, params)
try:
if ip_address(ip).sixtofour is None:
return False
return True
except Exception:
return False
def _mac(mac):
""" Test if something appears to be a valid mac address """
params = {"mac": mac}
_validate_args("mac", DOCUMENTATION, params)
# IEEE EUI-48 upper and lower, commom unix
re1 = r"^(?i)([0-9a-f]{2}[:-]){5}[0-9a-f]{2}$"
# Cisco triple hextex
re2 = r"^(?i)([0-9a-f]{4}\.[0-9a-f]{4}\.[0-9a-f]{4})$"
# Bare
re3 = r"^(?i)[0-9a-f]{12}$"
regex = "{re1}|{re2}|{re3}".format(re1=re1, re2=re2, re3=re3)
return bool(re.match(regex, mac))
def _resolvable(host):
""" Test if an IP or name can be resolved via /etc/hosts or DNS """
params = {"host": host}
_validate_args("resolvable", DOCUMENTATION, params)
try:
ipaddress.ip_address(host)
ip = True
except Exception:
ip = False
if ip:
try:
socket.gethostbyaddr(host)
return True
except Exception:
return False
else:
try:
socket.getaddrinfo(host, None)
return True
except Exception:
return False
