import ipaddress import logging import re import socket ## import netaddr from pyroute2 import IPRoute ## from . import ra from . import utils # TODO: more logging logger = logging.getLogger() class IP(object): type = None version = None _ip = ipaddress.ip_address _net = ipaddress.ip_network _net_ip = netaddr.IPAddress _net_net = netaddr.IPNetwork def __init__(self, ip, prefix, *args, **kwargs): self.str = ip self.prefix = int(prefix) self.net_ip = self._net_ip(self.str) self.net_net = self._net_net('{0}/{1}'.format(self.str, self.prefix)) def _ext_init(self): self.ip = self._ip(self.str) self.net = self._net('{0}/{1}'.format(self.str, self.prefix), strict = False) return(None) class IP4(IP): type = 'IPv4' version = 4 _ip = ipaddress.IPv4Address _net = ipaddress.IPv4Network def __init__(self, ip, prefix, *args, **kwargs): super().__init__(ip, prefix, *args, **kwargs) self._ext_init() class IP6(IP): type = 'IPv6' version = 6 _ip = ipaddress.IPv6Address _net = ipaddress.IPv6Network def __init__(self, ip, prefix, *args, **kwargs): super().__init__(ip, prefix, *args, **kwargs) self._ext_init() self.alloc_block = netaddr.SubnetSplitter(self.net_net) class Assignment(object): def __init__(self, assign_xml, ra_dns = False, ra_dhcp = False, ra_other = False, ra_tag = None, ra_domains = None): self.xml = assign_xml self.ra_dns = ra_dns self.ra_tag = ra_tag self.ra_other = ra_other self.ra_dhcp = ra_dhcp for a in ('dns', 'tag', 'other', 'dhcp'): k = 'ra_{0}'.format(a) v = getattr(self, k) logger.debug('{0}: {1}'.format(k, v)) self.ra_domains = set() if isinstance(ra_domains, list): self.ra_domains.update(ra_domains) elif isinstance(ra_domains, str): self.ra_domains.update([i.lower().strip() for i in ra_domains if i.strip() != '']) logger.debug('ra_domains: {0}'.format(', '.join(self.ra_domains))) self.iface = None self.iface_ll = None self.iface_idx = None self.iface_blocks = [] self.dhcp6_ranges = [] self.alloc = None # This must be set externally to a mapped Allocation instance self.alloc_id = None self.prefix = None self.alloc_block = None self.parse() def _alloc(self): self.alloc_id = int(self.xml.attrib['alloc'].strip()) return(None) def _iface(self): _iface_txt = self.xml.attrib['iface'].strip() self.iface = _iface_txt.strip() ipr = IPRoute() logger.debug('Looking for iface {0}'.format(self.iface)) self.iface_idx = ipr.link_lookup(ifname = self.iface)[0] logger.debug('Found iface {0} at idx {1}'.format(self.iface, self.iface_idx)) # Link-Local address ll = ipr.get_addr(index = self.iface_idx, family = socket.AF_INET6, scope = 253)[0]['attrs'] addrs = dict(ll)['IFA_ADDRESS'] logger.debug('Link-Local address for {0}: {1}'.format(self.iface, addrs)) if isinstance(addrs, (list, tuple)): addr = addrs[0] else: addr = addrs self.iface_ll = addr ipr.close() return(None) def _prefix(self): self.prefix = int(self.xml.attrib.get('prefix', 64).strip()) return(None) def parse(self): self._iface() self._alloc() self._prefix() return(None) def parse_alloc(self): self.alloc_block = self.alloc.ip.alloc_block self.iface_blocks = self.alloc_block.extract_subnet(self.prefix, count = 1) logger.debug('Allocation blocks for {0}: {1}'.format(self.iface, ','.join([str(i) for i in self.iface_blocks]))) for idx, i in enumerate(self.iface_blocks): if i.prefixlen > 64: raise ValueError('Allocation block must be a /64 or larger') # DHCPv6 range. # We need to do some funky things here. Netaddr doesn't have an .exploded(). _base = ipaddress.IPv6Address(str(i.ip)) _base = ipaddress.IPv6Address(re.sub(r'(:0000){4}$', r':dead:beef:cafe::', str(_base.exploded))) _base = re.sub(r':0$', r'', str(_base)) logger.debug('Base prefix for {0}: {1}'.format(str(i), _base)) start = '{0}:0'.format(_base) stop = '{0}:ffff'.format(_base) d_range = (start, stop) self.dhcp6_ranges.append(d_range) logger.debug('Added range {0} to block {1} for iface {2}'.format(d_range, str(i.ip), self.iface)) return(None) class Allocation(object): def __init__(self, alloc_net): _ip, _prefix = alloc_net.split('/') self.id = int(_prefix.strip()) self.prefix = self.id self.ip = IP6(_ip.strip(), self.prefix) class Tunnel(object): def __init__(self, tun_xml, he_tunnel, creds): self.xml = tun_xml self.creds = creds self.he = he_tunnel self.update_key = self.he.creds.password self.id = None self.client = None self.server = None self.endpoint = None self.ra = None self.ra_provider = None self.allocations = {} # This is a dict of {}[alloc.id] = Allocation obj (as provided by HE) self.assignments = [] # This is a list of Assignment objs self.parse() def _allocations(self): self.allocations = self.he.allocations return(None) def _assignments(self): _assigns_xml = self.xml.find('assignments') self.ra_provider = _assigns_xml.attrib.get('raProvider') for _assign_xml in _assigns_xml.findall('assign'): do_dns = False domains = [] do_dhcp = False ra_other = False tag = None _ra_xml = _assign_xml.find('ra') if _ra_xml is not None and self.ra_provider: tag = _ra_xml.attrib.get('tag', None) _dns_xml = _ra_xml.find('dns') _dhcp_xml = _ra_xml.find('dhcpv6') if _dns_xml is not None: do_dns = utils.xml2bool(_dns_xml.text.strip()) domains = [i.strip() for i in _dns_xml.attrib.get('domains', '').split() if i.strip() != ''] if _dhcp_xml is not None: do_dhcp = utils.xml2bool(_dhcp_xml.text.strip()) ra_other = utils.xml2bool(_dhcp_xml.attrib.get('advOther', 'false').strip()) assign = Assignment(_assign_xml, ra_dns = do_dns, ra_dhcp = do_dhcp, ra_other = ra_other, ra_tag = tag, ra_domains = domains) assign.alloc = self.allocations[assign.alloc_id] assign.parse_alloc() self.assignments.append(assign) return(None) def _client(self): self.client = self.he.client return(None) def _creds(self): self.creds_id = self.xml.attrib['creds'].strip() return(None) def _endpoint(self): self.endpoint = self.he.endpoint return(None) def _id(self): self.id = int(self.xml.attrib['id'].strip()) return(None) def _ra(self): # TODO: support conf path override via config XML? if self.ra_provider.strip().lower() == 'dnsmasq': self.ra = ra.DNSMasq() elif self.ra_provider.strip().lower() == 'radvd': self.ra = ra.RADVD() self.ra.conf.generate(self.assignments) return(None) def _server(self): self.server = self.he.server return(None) def parse(self): self._id() self._creds() self._client() self._server() self._endpoint() self._allocations() self._assignments() self._ra() return(None)