def slaac(value, query=""):
""" Get the SLAAC address within given network """
try:
vtype = ipaddr(value, "type")
if vtype == "address":
v = ipaddr(value, "cidr")
elif vtype == "network":
v = ipaddr(value, "subnet")
if ipaddr(value, "version") != 6:
return False
value = netaddr.IPNetwork(v)
except Exception:
return False
if not query:
return False
try:
mac = hwaddr(query, alias="slaac")
eui = netaddr.EUI(mac)
except Exception:
return False
return str(eui.ipv6(value.network))
def nthhost(value, query=""):
""" Returns the nth host within a network described by value. """
try:
vtype = ipaddr(value, "type")
if vtype == "address":
v = ipaddr(value, "cidr")
elif vtype == "network":
v = ipaddr(value, "subnet")
value = netaddr.IPNetwork(v)
except Exception:
return False
if not query:
return False
try:
nth = int(query)
if value.size > nth:
return str(value[nth])
except ValueError:
return False
return False
def ipwrap(value, query=""):
try:
if isinstance(value, (list, tuple, types.GeneratorType)):
_ret = []
for element in value:
if ipaddr(element, query, version=False, alias="ipwrap"):
_ret.append(ipaddr(element, "wrap"))
else:
_ret.append(element)
return _ret
else:
_ret = ipaddr(value, query, version=False, alias="ipwrap")
if _ret:
return ipaddr(_ret, "wrap")
else:
return value
except Exception:
return value
def _ipaddr(*args, **kwargs):
"""This filter is designed to return the input value if a query is True, and False if a query is False"""
keys = ["value", "query", "version", "alias"]
data = dict(zip(keys, args[1:]))
data.update(kwargs)
aav = AnsibleArgSpecValidator(data=data,
schema=DOCUMENTATION,
name="ipaddr")
valid, errors, updated_data = aav.validate()
if not valid:
raise AnsibleFilterError(errors)
return ipaddr(**updated_data)
def next_nth_usable(value, offset):
"""
Returns the next nth usable ip within a network described by value.
"""
try:
vtype = ipaddr(value, "type")
if vtype == "address":
v = ipaddr(value, "cidr")
elif vtype == "network":
v = ipaddr(value, "subnet")
v = netaddr.IPNetwork(v)
except Exception:
return False
if type(offset) != int:
raise AnsibleFilterError("Must pass in an integer")
if v.size > 1:
first_usable, last_usable = _first_last(v)
nth_ip = int(netaddr.IPAddress(int(v.ip) + offset))
if first_usable <= nth_ip <= last_usable:
return str(netaddr.IPAddress(int(v.ip) + offset))
def network_in_network(value, test):
"""
Checks whether the 'test' address or addresses are in 'value', including broadcast and network
:param: value: The network address or range to test against.
:param test: The address or network to validate if it is within the range of 'value'.
:return: bool
"""
# normalize value and test variables into an ipaddr
v = _address_normalizer(value)
w = _address_normalizer(test)
# get first and last addresses as integers to compare value and test; or cathes value when case is /32
v_first = ipaddr(ipaddr(v, "network") or ipaddr(v, "address"), "int")
v_last = ipaddr(ipaddr(v, "broadcast") or ipaddr(v, "address"), "int")
w_first = ipaddr(ipaddr(w, "network") or ipaddr(w, "address"), "int")
w_last = ipaddr(ipaddr(w, "broadcast") or ipaddr(w, "address"), "int")
if _range_checker(w_first, v_first, v_last) and _range_checker(
w_last, v_first, v_last):
return True
else:
return False
def reduce_on_network(value, network):
"""
Reduces a list of addresses to only the addresses that match a given network.
:param: value: The list of addresses to filter on.
:param: network: The network to validate against.
:return: The reduced list of addresses.
"""
# normalize network variable into an ipaddr
n = _address_normalizer(network)
# get first and last addresses as integers to compare value and test; or cathes value when case is /32
n_first = ipaddr(ipaddr(n, "network") or ipaddr(n, "address"), "int")
n_last = ipaddr(ipaddr(n, "broadcast") or ipaddr(n, "address"), "int")
# create an empty list to fill and return
r = []
for address in value:
# normalize address variables into an ipaddr
a = _address_normalizer(address)
# get first and last addresses as integers to compare value and test; or cathes value when case is /32
a_first = ipaddr(ipaddr(a, "network") or ipaddr(a, "address"), "int")
a_last = ipaddr(ipaddr(a, "broadcast") or ipaddr(a, "address"), "int")
if _range_checker(a_first, n_first, n_last) and _range_checker(
a_last, n_first, n_last
):
r.append(address)
return r
def ipv4(value, query=""):
return ipaddr(value, query, version=4, alias="ipv4")
def ipv6(value, query=""):
return ipaddr(value, query, version=6, alias="ipv6")
def ipsubnet(value, query="", index="x"):
""" Manipulate IPv4/IPv6 subnets """
try:
vtype = ipaddr(value, "type")
if vtype == "address":
v = ipaddr(value, "cidr")
elif vtype == "network":
v = ipaddr(value, "subnet")
value = netaddr.IPNetwork(v)
except Exception:
return False
query_string = str(query)
if not query:
return str(value)
elif query_string.isdigit():
vsize = ipaddr(v, "size")
query = int(query)
try:
float(index)
index = int(index)
if vsize > 1:
try:
return str(list(value.subnet(query))[index])
except Exception:
return False
elif vsize == 1:
try:
return str(value.supernet(query)[index])
except Exception:
return False
except Exception:
if vsize > 1:
try:
return str(len(list(value.subnet(query))))
except Exception:
return False
elif vsize == 1:
try:
return str(value.supernet(query)[0])
except Exception:
return False
elif query_string:
vtype = ipaddr(query, "type")
if vtype == "address":
v = ipaddr(query, "cidr")
elif vtype == "network":
v = ipaddr(query, "subnet")
else:
msg = "You must pass a valid subnet or IP address; {0} is invalid".format(
query_string)
raise AnsibleFilterError(msg)
query = netaddr.IPNetwork(v)
for i, subnet in enumerate(query.subnet(value.prefixlen), 1):
if subnet == value:
return str(i)
msg = "{0} is not in the subnet {1}".format(value.cidr, query.cidr)
raise AnsibleFilterError(msg)
return False
def network_in_usable(value, test):
"""
Checks whether 'test' is a usable address or addresses in 'value'
:param: value: The string representation of an address or network to test against.
:param test: The string representation of an address or network to validate if it is within the range of 'value'.
:return: bool
"""
# normalize value and test variables into an ipaddr
v = _address_normalizer(value)
w = _address_normalizer(test)
# get first and last addresses as integers to compare value and test; or cathes value when case is /32
v_first = ipaddr(ipaddr(v, "first_usable") or ipaddr(v, "address"), "int")
v_last = ipaddr(ipaddr(v, "last_usable") or ipaddr(v, "address"), "int")
w_first = ipaddr(ipaddr(w, "network") or ipaddr(w, "address"), "int")
w_last = ipaddr(ipaddr(w, "broadcast") or ipaddr(w, "address"), "int")
if _range_checker(w_first, v_first, v_last) and _range_checker(
w_last, v_first, v_last):
return True
else:
return False