# Copyright (C) 2017 Canonical Ltd.

#

# Author: Chad Smith <chad.smith@canonical.com>

#

# This file is part of cloud-init. See LICENSE file for license information.

import configobj

import logging

import os

import re

import signal

import time

from io import StringIO

from cloudinit.net import (

    EphemeralIPv4Network, find_fallback_nic, get_devicelist,

    has_url_connectivity)

from cloudinit.net.network_state import mask_and_ipv4_to_bcast_addr as bcip

from cloudinit import temp_utils

from cloudinit import subp

from cloudinit import util

LOG = logging.getLogger(__name__)

NETWORKD_LEASES_DIR = '/run/systemd/netif/leases'

class InvalidDHCPLeaseFileError(Exception):

    """Raised when parsing an empty or invalid dhcp.leases file.

    Current uses are DataSourceAzure and DataSourceEc2 during ephemeral

    boot to scrape metadata.

    """

class NoDHCPLeaseError(Exception):

    """Raised when unable to get a DHCP lease."""

class EphemeralDHCPv4(object):

    def __init__(self, iface=None, connectivity_url=None, dhcp_log_func=None):

        self.iface = iface

        self._ephipv4 = None

        self.lease = None

        self.dhcp_log_func = dhcp_log_func

        self.connectivity_url = connectivity_url

    def __enter__(self):

        """Setup sandboxed dhcp context, unless connectivity_url can already be

        reached."""

        if self.connectivity_url:

            if has_url_connectivity(self.connectivity_url):

                LOG.debug(

                    'Skip ephemeral DHCP setup, instance has connectivity'

                    ' to %s', self.connectivity_url)

                return

        return self.obtain_lease()

    def __exit__(self, excp_type, excp_value, excp_traceback):

        """Teardown sandboxed dhcp context."""

        self.clean_network()

    def clean_network(self):

        """Exit _ephipv4 context to teardown of ip configuration performed."""

        if self.lease:

            self.lease = None

        if not self._ephipv4:

            return

        self._ephipv4.__exit__(None, None, None)

    def obtain_lease(self):

        """Perform dhcp discovery in a sandboxed environment if possible.

        @return: A dict representing dhcp options on the most recent lease

            obtained from the dhclient discovery if run, otherwise an error

            is raised.

        @raises: NoDHCPLeaseError if no leases could be obtained.

        """

        if self.lease:

            return self.lease

        try:

            leases = maybe_perform_dhcp_discovery(

                self.iface, self.dhcp_log_func)

        except InvalidDHCPLeaseFileError as e:

            raise NoDHCPLeaseError() from e

        if not leases:

            raise NoDHCPLeaseError()

        self.lease = leases[-1]

        LOG.debug("Received dhcp lease on %s for %s/%s",

                  self.lease['interface'], self.lease['fixed-address'],

                  self.lease['subnet-mask'])

        nmap = {'interface': 'interface', 'ip': 'fixed-address',

                'prefix_or_mask': 'subnet-mask',

                'broadcast': 'broadcast-address',

                'static_routes': [

                    'rfc3442-classless-static-routes',

                    'classless-static-routes'

                ],

                'router': 'routers'}

        kwargs = self.extract_dhcp_options_mapping(nmap)

        if not kwargs['broadcast']:

            kwargs['broadcast'] = bcip(kwargs['prefix_or_mask'], kwargs['ip'])

        if kwargs['static_routes']:

            kwargs['static_routes'] = (

                parse_static_routes(kwargs['static_routes']))

        if self.connectivity_url:

            kwargs['connectivity_url'] = self.connectivity_url

        ephipv4 = EphemeralIPv4Network(**kwargs)

        ephipv4.__enter__()

        self._ephipv4 = ephipv4

        return self.lease

    def extract_dhcp_options_mapping(self, nmap):

        result = {}

        for internal_reference, lease_option_names in nmap.items():

            if isinstance(lease_option_names, list):

                self.get_first_option_value(

                    internal_reference,

                    lease_option_names,

                    result

                )

            else:

                result[internal_reference] = self.lease.get(lease_option_names)

        return result

    def get_first_option_value(self, internal_mapping,

                               lease_option_names, result):

        for different_names in lease_option_names:

            if not result.get(internal_mapping):

                result[internal_mapping] = self.lease.get(different_names)

def maybe_perform_dhcp_discovery(nic=None, dhcp_log_func=None):

    """Perform dhcp discovery if nic valid and dhclient command exists.

    If the nic is invalid or undiscoverable or dhclient command is not found,

    skip dhcp_discovery and return an empty dict.

    @param nic: Name of the network interface we want to run dhclient on.

    @param dhcp_log_func: A callable accepting the dhclient output and error

        streams.

    @return: A list of dicts representing dhcp options for each lease obtained

        from the dhclient discovery if run, otherwise an empty list is

        returned.

    """

    if nic is None:

        nic = find_fallback_nic()

        if nic is None:

            LOG.debug('Skip dhcp_discovery: Unable to find fallback nic.')

            return []

    elif nic not in get_devicelist():

        LOG.debug(

            'Skip dhcp_discovery: nic %s not found in get_devicelist.', nic)

        return []

    dhclient_path = subp.which('dhclient')

    if not dhclient_path:

        LOG.debug('Skip dhclient configuration: No dhclient command found.')

        return []

    with temp_utils.tempdir(rmtree_ignore_errors=True,

                            prefix='cloud-init-dhcp-',

                            needs_exe=True) as tdir:

        # Use /var/tmp because /run/cloud-init/tmp is mounted noexec

        return dhcp_discovery(dhclient_path, nic, tdir, dhcp_log_func)

def parse_dhcp_lease_file(lease_file):

    """Parse the given dhcp lease file for the most recent lease.

    Return a list of dicts of dhcp options. Each dict contains key value pairs

    a specific lease in order from oldest to newest.

    @raises: InvalidDHCPLeaseFileError on empty of unparseable leasefile

        content.

    """

    lease_regex = re.compile(r"lease {(?P<lease>[^}]*)}\n")

    dhcp_leases = []

    lease_content = util.load_file(lease_file)

    if len(lease_content) == 0:

        raise InvalidDHCPLeaseFileError(

            'Cannot parse empty dhcp lease file {0}'.format(lease_file))

    for lease in lease_regex.findall(lease_content):

        lease_options = []

        for line in lease.split(';'):

            # Strip newlines, double-quotes and option prefix

            line = line.strip().replace('"', '').replace('option ', '')

            if not line:

                continue

            lease_options.append(line.split(' ', 1))

        dhcp_leases.append(dict(lease_options))

    if not dhcp_leases:

        raise InvalidDHCPLeaseFileError(

            'Cannot parse dhcp lease file {0}. No leases found'.format(

                lease_file))

    return dhcp_leases

def dhcp_discovery(dhclient_cmd_path, interface, cleandir, dhcp_log_func=None):

    """Run dhclient on the interface without scripts or filesystem artifacts.

    @param dhclient_cmd_path: Full path to the dhclient used.

    @param interface: Name of the network inteface on which to dhclient.

    @param cleandir: The directory from which to run dhclient as well as store

        dhcp leases.

    @param dhcp_log_func: A callable accepting the dhclient output and error

        streams.

    @return: A list of dicts of representing the dhcp leases parsed from the

        dhcp.leases file or empty list.

    """

    LOG.debug('Performing a dhcp discovery on %s', interface)

    # XXX We copy dhclient out of /sbin/dhclient to avoid dealing with strict

    # app armor profiles which disallow running dhclient -sf <our-script-file>.

    # We want to avoid running /sbin/dhclient-script because of side-effects in

    # /etc/resolv.conf any any other vendor specific scripts in

    # /etc/dhcp/dhclient*hooks.d.

    sandbox_dhclient_cmd = os.path.join(cleandir, 'dhclient')

    util.copy(dhclient_cmd_path, sandbox_dhclient_cmd)

    pid_file = os.path.join(cleandir, 'dhclient.pid')

    lease_file = os.path.join(cleandir, 'dhcp.leases')

    # In some cases files in /var/tmp may not be executable, launching dhclient

    # from there will certainly raise 'Permission denied' error. Try launching

    # the original dhclient instead.

    if not os.access(sandbox_dhclient_cmd, os.X_OK):

        sandbox_dhclient_cmd = dhclient_cmd_path

    # ISC dhclient needs the interface up to send initial discovery packets.

    # Generally dhclient relies on dhclient-script PREINIT action to bring the

    # link up before attempting discovery. Since we are using -sf /bin/true,

    # we need to do that "link up" ourselves first.

    subp.subp(['ip', 'link', 'set', 'dev', interface, 'up'], capture=True)

    cmd = [sandbox_dhclient_cmd, '-1', '-v', '-lf', lease_file,

           '-pf', pid_file, interface, '-sf', '/bin/true']

    out, err = subp.subp(cmd, capture=True)

    # Wait for pid file and lease file to appear, and for the process

    # named by the pid file to daemonize (have pid 1 as its parent). If we

    # try to read the lease file before daemonization happens, we might try

    # to read it before the dhclient has actually written it. We also have

    # to wait until the dhclient has become a daemon so we can be sure to

    # kill the correct process, thus freeing cleandir to be deleted back

    # up the callstack.

    missing = util.wait_for_files(

        [pid_file, lease_file], maxwait=5, naplen=0.01)

    if missing:

        LOG.warning("dhclient did not produce expected files: %s",

                    ', '.join(os.path.basename(f) for f in missing))

        return []

    ppid = 'unknown'

    daemonized = False

    for _ in range(0, 1000):

        pid_content = util.load_file(pid_file).strip()

        try:

            pid = int(pid_content)

        except ValueError:

            pass

        else:

            ppid = util.get_proc_ppid(pid)

            if ppid == 1:

                LOG.debug('killing dhclient with pid=%s', pid)

                os.kill(pid, signal.SIGKILL)

                daemonized = True

                break

        time.sleep(0.01)

    if not daemonized:

        LOG.error(

            'dhclient(pid=%s, parentpid=%s) failed to daemonize after %s '

            'seconds', pid_content, ppid, 0.01 * 1000

        )

    if dhcp_log_func is not None:

        dhcp_log_func(out, err)

    return parse_dhcp_lease_file(lease_file)

def networkd_parse_lease(content):

    """Parse a systemd lease file content as in /run/systemd/netif/leases/

    Parse this (almost) ini style file even though it says:

      # This is private data. Do not parse.

    Simply return a dictionary of key/values."""

    return dict(configobj.ConfigObj(StringIO(content), list_values=False))

def networkd_load_leases(leases_d=None):

    """Return a dictionary of dictionaries representing each lease

    found in lease_d.i

    The top level key will be the filename, which is typically the ifindex."""

    if leases_d is None:

        leases_d = NETWORKD_LEASES_DIR

    ret = {}

    if not os.path.isdir(leases_d):

        return ret

    for lfile in os.listdir(leases_d):

        ret[lfile] = networkd_parse_lease(

            util.load_file(os.path.join(leases_d, lfile)))

    return ret

def networkd_get_option_from_leases(keyname, leases_d=None):

    if leases_d is None:

        leases_d = NETWORKD_LEASES_DIR

    leases = networkd_load_leases(leases_d=leases_d)

    for _ifindex, data in sorted(leases.items()):

        if data.get(keyname):

            return data[keyname]

    return None

def parse_static_routes(rfc3442):

    """ parse rfc3442 format and return a list containing tuple of strings.

    The tuple is composed of the network_address (including net length) and

    gateway for a parsed static route.  It can parse two formats of rfc3442,

    one from dhcpcd and one from dhclient (isc).

    @param rfc3442: string in rfc3442 format (isc or dhcpd)

    @returns: list of tuple(str, str) for all valid parsed routes until the

              first parsing error.

    E.g.

    sr=parse_static_routes("32,169,254,169,254,130,56,248,255,0,130,56,240,1")

    sr=[

        ("169.254.169.254/32", "130.56.248.255"), ("0.0.0.0/0", "130.56.240.1")

    ]

    sr2 = parse_static_routes("24.191.168.128 192.168.128.1,0 192.168.128.1")

    sr2 = [

        ("191.168.128.0/24", "192.168.128.1"), ("0.0.0.0/0", "192.168.128.1")

    ]

    Python version of isc-dhclient's hooks:

       /etc/dhcp/dhclient-exit-hooks.d/rfc3442-classless-routes

    """

    # raw strings from dhcp lease may end in semi-colon

    rfc3442 = rfc3442.rstrip(";")

    tokens = [tok for tok in re.split(r"[, .]", rfc3442) if tok]

    static_routes = []

    def _trunc_error(cidr, required, remain):

        msg = ("RFC3442 string malformed.  Current route has CIDR of %s "

               "and requires %s significant octets, but only %s remain. "

               "Verify DHCP rfc3442-classless-static-routes value: %s"

               % (cidr, required, remain, rfc3442))

        LOG.error(msg)

    current_idx = 0

    for idx, tok in enumerate(tokens):

        if idx < current_idx:

            continue

        net_length = int(tok)

        if net_length in range(25, 33):

            req_toks = 9

            if len(tokens[idx:]) < req_toks:

                _trunc_error(net_length, req_toks, len(tokens[idx:]))

                return static_routes

            net_address = ".".join(tokens[idx+1:idx+5])

            gateway = ".".join(tokens[idx+5:idx+req_toks])

            current_idx = idx + req_toks

        elif net_length in range(17, 25):

            req_toks = 8

            if len(tokens[idx:]) < req_toks:

                _trunc_error(net_length, req_toks, len(tokens[idx:]))

                return static_routes

            net_address = ".".join(tokens[idx+1:idx+4] + ["0"])

            gateway = ".".join(tokens[idx+4:idx+req_toks])

            current_idx = idx + req_toks

        elif net_length in range(9, 17):

            req_toks = 7

            if len(tokens[idx:]) < req_toks:

                _trunc_error(net_length, req_toks, len(tokens[idx:]))

                return static_routes

            net_address = ".".join(tokens[idx+1:idx+3] + ["0", "0"])

            gateway = ".".join(tokens[idx+3:idx+req_toks])

            current_idx = idx + req_toks

        elif net_length in range(1, 9):

            req_toks = 6

            if len(tokens[idx:]) < req_toks:

                _trunc_error(net_length, req_toks, len(tokens[idx:]))

                return static_routes

            net_address = ".".join(tokens[idx+1:idx+2] + ["0", "0", "0"])

            gateway = ".".join(tokens[idx+2:idx+req_toks])

            current_idx = idx + req_toks

        elif net_length == 0:

            req_toks = 5

            if len(tokens[idx:]) < req_toks:

                _trunc_error(net_length, req_toks, len(tokens[idx:]))

                return static_routes

            net_address = "0.0.0.0"

            gateway = ".".join(tokens[idx+1:idx+req_toks])

            current_idx = idx + req_toks

        else:

            LOG.error('Parsed invalid net length "%s".  Verify DHCP '

                      'rfc3442-classless-static-routes value.', net_length)

            return static_routes

        static_routes.append(("%s/%s" % (net_address, net_length), gateway))

    return static_routes

# vi: ts=4 expandtab