# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2012 OpenStack Foundation

# All Rights Reserved.

#

# Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.

#

#    Licensed under the Apache License, Version 2.0 (the "License"); you may

#    not use this file except in compliance with the License. You may obtain

#    a copy of the License at

#

#         http://www.apache.org/licenses/LICENSE-2.0

#

#    Unless required by applicable law or agreed to in writing, software

#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

#    License for the specific language governing permissions and limitations

#    under the License.

#

# @author: Girish Moodalbail, Oracle, Inc.

import abc

import collections

import os

import re

import shutil

import socket

import sys

import uuid

import netaddr

from oslo.config import cfg

import six

from neutron.agent.linux import utils

from neutron.agent.solaris import net_lib

from neutron.common import constants

from neutron.common import exceptions

from neutron.openstack.common import importutils

from neutron.openstack.common import jsonutils

from neutron.openstack.common import log as logging

from neutron.openstack.common import uuidutils

LOG = logging.getLogger(__name__)

OPTS = [

    cfg.StrOpt('dhcp_confs',

               default='$state_path/dhcp',

               help=_('Location to store DHCP server config files')),

    cfg.StrOpt('dhcp_domain',

               default='openstacklocal',

               help=_('Domain to use for building the hostnames')),

    cfg.StrOpt('dnsmasq_config_file',

               default='',

               help=_('Override the default dnsmasq settings with this file')),

    cfg.ListOpt('dnsmasq_dns_servers',

                help=_('Comma-separated list of the DNS servers which will be '

                       'used as forwarders.'),

                deprecated_name='dnsmasq_dns_server'),

    cfg.BoolOpt('dhcp_delete_namespaces', default=False,

                help=_("Delete namespace after removing a dhcp server.")),

    cfg.IntOpt(

        'dnsmasq_lease_max',

        default=(2 ** 24),

        help=_('Limit number of leases to prevent a denial-of-service.')),

]

IPV4 = 4

IPV6 = 6

UDP = 'udp'

TCP = 'tcp'

DNS_PORT = 53

DHCPV4_PORT = 67

DHCPV6_PORT = 547

METADATA_DEFAULT_PREFIX = 16

METADATA_DEFAULT_IP = '169.254.169.254'

METADATA_DEFAULT_CIDR = '%s/%d' % (METADATA_DEFAULT_IP,

                                   METADATA_DEFAULT_PREFIX)

METADATA_PORT = 80

WIN2k3_STATIC_DNS = 249

class DictModel(dict):

    """Convert dict into an object that provides attribute access to values."""

    def __init__(self, *args, **kwargs):

        """Convert dict values to DictModel values."""

        super(DictModel, self).__init__(*args, **kwargs)

        def needs_upgrade(item):

            """Check if `item` is a dict and needs to be changed to DictModel.

            """

            return isinstance(item, dict) and not isinstance(item, DictModel)

        def upgrade(item):

            """Upgrade item if it needs to be upgraded."""

            if needs_upgrade(item):

                return DictModel(item)

            else:

                return item

        for key, value in self.iteritems():

            if isinstance(value, (list, tuple)):

                # Keep the same type but convert dicts to DictModels

                self[key] = type(value)(

                    (upgrade(item) for item in value)

                )

            elif needs_upgrade(value):

                # Change dict instance values to DictModel instance values

                self[key] = DictModel(value)

    def __getattr__(self, name):

        try:

            return self[name]

        except KeyError as e:

            raise AttributeError(e)

    def __setattr__(self, name, value):

        self[name] = value

    def __delattr__(self, name):

        del self[name]

class NetModel(DictModel):

    def __init__(self, use_namespaces, d):

        super(NetModel, self).__init__(d)

        self._ns_name = None

    @property

    def namespace(self):

        return self._ns_name

@six.add_metaclass(abc.ABCMeta)

class DhcpBase(object):

    def __init__(self, conf, network, root_helper='sudo',

                 version=None, plugin=None):

        self.conf = conf

        self.network = network

        self.root_helper = None

        self.device_manager = DeviceManager(self.conf,

                                            self.root_helper, plugin)

        self.version = version

    @abc.abstractmethod

    def enable(self):

        """Enables DHCP for this network."""

    @abc.abstractmethod

    def disable(self, retain_port=False):

        """Disable dhcp for this network."""

    def restart(self):

        """Restart the dhcp service for the network."""

        self.disable(retain_port=True)

        self.enable()

    @abc.abstractproperty

    def active(self):

        """Boolean representing the running state of the DHCP server."""

    @abc.abstractmethod

    def reload_allocations(self):

        """Force the DHCP server to reload the assignment database."""

    @classmethod

    def existing_dhcp_networks(cls, conf, root_helper):

        """Return a list of existing networks ids that we have configs for."""

        raise NotImplementedError()

    @classmethod

    def check_version(cls):

        """Execute version checks on DHCP server."""

        raise NotImplementedError()

    @classmethod

    def get_isolated_subnets(cls, network):

        """Returns a dict indicating whether or not a subnet is isolated"""

        raise NotImplementedError()

    @classmethod

    def should_enable_metadata(cls, conf, network):

        """True if the metadata-proxy should be enabled for the network."""

        raise NotImplementedError()

class DhcpLocalProcess(DhcpBase):

    PORTS = []

    def _enable_dhcp(self):

        """check if there is a subnet within the network with dhcp enabled."""

        for subnet in self.network.subnets:

            if subnet.enable_dhcp:

                return True

        return False

    def enable(self):

        """Enables DHCP for this network by spawning a local process."""

        if self.active:

            self.restart()

        elif self._enable_dhcp():

            interface_name = self.device_manager.setup(self.network)

            self.interface_name = interface_name

            self.spawn_process()

    def disable(self, retain_port=False):

        """Disable DHCP for this network by killing the local process."""

        pid = self.pid

        if pid:

            if self.active:

                cmd = ['kill', '-9', pid]

                utils.execute(cmd, self.root_helper)

            else:

                LOG.debug(_('DHCP for %(net_id)s is stale, pid %(pid)d '

                            'does not exist, performing cleanup'),

                          {'net_id': self.network.id, 'pid': pid})

            if not retain_port:

                self.device_manager.destroy(self.network,

                                            self.interface_name)

        else:

            LOG.debug(_('No DHCP started for %s'), self.network.id)

        self._remove_config_files()

    def _remove_config_files(self):

        confs_dir = os.path.abspath(os.path.normpath(self.conf.dhcp_confs))

        conf_dir = os.path.join(confs_dir, self.network.id)

        shutil.rmtree(conf_dir, ignore_errors=True)

    def get_conf_file_name(self, kind, ensure_conf_dir=False):

        """Returns the file name for a given kind of config file."""

        confs_dir = os.path.abspath(os.path.normpath(self.conf.dhcp_confs))

        conf_dir = os.path.join(confs_dir, self.network.id)

        if ensure_conf_dir:

            if not os.path.isdir(conf_dir):

                os.makedirs(conf_dir, 0o755)

        return os.path.join(conf_dir, kind)

    def _get_value_from_conf_file(self, kind, converter=None):

        """A helper function to read a value from one of the state files."""

        file_name = self.get_conf_file_name(kind)

        msg = _('Error while reading %s')

        try:

            with open(file_name, 'r') as f:

                try:

                    return converter and converter(f.read()) or f.read()

                except ValueError:

                    msg = _('Unable to convert value in %s')

        except IOError:

            msg = _('Unable to access %s')

        LOG.debug(msg % file_name)

        return None

    @property

    def pid(self):

        """Last known pid for the DHCP process spawned for this network."""

        return self._get_value_from_conf_file('pid', int)

    @property

    def active(self):

        pid = self.pid

        if pid is None:

            return False

        cmd = ['/usr/bin/pargs', pid]

        try:

            return self.network.id in utils.execute(cmd)

        except RuntimeError:

            return False

    @property

    def interface_name(self):

        return self._get_value_from_conf_file('interface')

    @interface_name.setter

    def interface_name(self, value):

        interface_file_path = self.get_conf_file_name('interface',

                                                      ensure_conf_dir=True)

        utils.replace_file(interface_file_path, value)

    @abc.abstractmethod

    def spawn_process(self):

        pass

class Dnsmasq(DhcpLocalProcess):

    # The ports that need to be opened when security policies are active

    # on the Neutron port used for DHCP.  These are provided as a convenience

    # for users of this class.

    PORTS = {IPV4: [(UDP, DNS_PORT), (TCP, DNS_PORT), (UDP, DHCPV4_PORT)],

             IPV6: [(UDP, DNS_PORT), (TCP, DNS_PORT), (UDP, DHCPV6_PORT)],

             }

    _TAG_PREFIX = 'tag%d'

    NEUTRON_NETWORK_ID_KEY = 'NEUTRON_NETWORK_ID'

    NEUTRON_RELAY_SOCKET_PATH_KEY = 'NEUTRON_RELAY_SOCKET_PATH'

    MINIMUM_VERSION = 2.63

    MINIMUM_IPV6_VERSION = 2.67

    @classmethod

    def check_version(cls):

        ver = 0

        try:

            cmd = ['/usr/lib/inet/dnsmasq', '--version']

            out = utils.execute(cmd)

            ver = re.findall("\d+.\d+", out)[0]

            is_valid_version = float(ver) >= cls.MINIMUM_VERSION

            # For Solaris, we rely on the packaging system to ensure a

            # matching/supported version of dnsmasq.

            if not is_valid_version:

                LOG.warning(_('FAILED VERSION REQUIREMENT FOR DNSMASQ. '

                              'DHCP AGENT MAY NOT RUN CORRECTLY! '

                              'Please ensure that its version is %s '

                              'or above!'), cls.MINIMUM_VERSION)

                raise SystemExit(1)

            is_valid_version = float(ver) >= cls.MINIMUM_IPV6_VERSION

            if not is_valid_version:

                LOG.warning(_('FAILED VERSION REQUIREMENT FOR DNSMASQ. '

                              'DHCP AGENT MAY NOT RUN CORRECTLY WHEN '

                              'SERVING IPV6 STATEFUL SUBNETS! '

                              'Please ensure that its version is %s '

                              'or above!'), cls.MINIMUM_IPV6_VERSION)

        except (OSError, RuntimeError, IndexError, ValueError):

            LOG.warning(_('Unable to determine dnsmasq version. '

                          'Please ensure that its version is %s '

                          'or above!'), cls.MINIMUM_VERSION)

            raise SystemExit(1)

        return float(ver)

    @classmethod

    def existing_dhcp_networks(cls, conf, root_helper):

        """Return a list of existing networks ids that we have configs for."""

        confs_dir = os.path.abspath(os.path.normpath(conf.dhcp_confs))

        return [

            c for c in os.listdir(confs_dir)

            if uuidutils.is_uuid_like(c)

        ]

    def spawn_process(self):

        """Spawns a Dnsmasq process for the network."""

        env = {

            self.NEUTRON_NETWORK_ID_KEY: self.network.id,

        }

        cmd = [

            '/usr/lib/inet/dnsmasq',

            '--no-hosts',

            '--no-resolv',

            '--strict-order',

            '--bind-interfaces',

            '--interface=%s' % self.interface_name,

            '--except-interface=lo0',

            '--pid-file=%s' % self.get_conf_file_name(

                'pid', ensure_conf_dir=True),

            '--dhcp-hostsfile=%s' % self._output_hosts_file(),

            '--addn-hosts=%s' % self._output_addn_hosts_file(),

            '--dhcp-optsfile=%s' % self._output_opts_file(),

            '--leasefile-ro',

        ]

        possible_leases = 0

        for i, subnet in enumerate(self.network.subnets):

            mode = None

            # if a subnet is specified to have dhcp disabled

            if not subnet.enable_dhcp:

                continue

            if subnet.ip_version == 4:

                mode = 'static'

            else:

                # We need to also set the DUID for the DHCPv6 server to use

                macaddr_cmd = ['/usr/sbin/dladm', 'show-linkprop',

                               '-co', 'value', '-p', 'mac-address',

                               self.interface_name]

                stdout = utils.execute(macaddr_cmd)

                uid = stdout.splitlines()[0].strip()

                # format the MAC address

                uid = ':'.join(['%.2x' % w for w in netaddr.EUI(uid).words])

                # IANA assigned ID for Oracle

                enterprise_id = '111'

                cmd.append('--dhcp-duid=%s,%s' % (enterprise_id, uid))

                # Note(scollins) If the IPv6 attributes are not set, set it as

                # static to preserve previous behavior

                addr_mode = getattr(subnet, 'ipv6_address_mode', None)

                ra_mode = getattr(subnet, 'ipv6_ra_mode', None)

                if (addr_mode in [constants.DHCPV6_STATEFUL,

                                  constants.DHCPV6_STATELESS] or

                        not addr_mode and not ra_mode):

                    mode = 'static'

            cidr = netaddr.IPNetwork(subnet.cidr)

            if self.conf.dhcp_lease_duration == -1:

                lease = 'infinite'

            else:

                lease = '%ss' % self.conf.dhcp_lease_duration

            # mode is optional and is not set - skip it

            if mode:

                if subnet.ip_version == 4:

                    cmd.append('--dhcp-range=%s%s,%s,%s,%s' %

                               ('set:', self._TAG_PREFIX % i,

                                cidr.network, mode, lease))

                else:

                    cmd.append('--dhcp-range=%s%s,%s,%s,%d,%s' %

                               ('set:', self._TAG_PREFIX % i,

                                cidr.network, mode,

                                cidr.prefixlen, lease))

                possible_leases += cidr.size

        # Cap the limit because creating lots of subnets can inflate

        # this possible lease cap.

        cmd.append('--dhcp-lease-max=%d' %

                   min(possible_leases, self.conf.dnsmasq_lease_max))

        cmd.append('--conf-file=%s' % self.conf.dnsmasq_config_file)

        if self.conf.dnsmasq_dns_servers:

            cmd.extend(

                '--server=%s' % server

                for server in self.conf.dnsmasq_dns_servers)

        if self.conf.dhcp_domain:

            cmd.append('--domain=%s' % self.conf.dhcp_domain)

        # TODO(gmoodalb): prepend the env vars before command

        utils.execute(cmd, self.root_helper)

    def _release_lease(self, mac_address, ip):

        """Release a DHCP lease."""

        cmd = ['/usr/lib/inet/dhcp_release', self.interface_name,

               ip, mac_address]

        utils.execute(cmd, self.root_helper)

    def reload_allocations(self):

        """Rebuild the dnsmasq config and signal the dnsmasq to reload."""

        # If all subnets turn off dhcp, kill the process.

        if not self._enable_dhcp():

            self.disable()

            LOG.debug(_('Killing dhcpmasq for network since all subnets have '

                        'turned off DHCP: %s'), self.network.id)

            return

        self._release_unused_leases()

        self._output_hosts_file()

        self._output_addn_hosts_file()

        self._output_opts_file()

        if self.active:

            cmd = ['kill', '-HUP', self.pid]

            utils.execute(cmd, self.root_helper)

        else:

            LOG.debug(_('Pid %d is stale, relaunching dnsmasq'), self.pid)

        LOG.debug(_('Reloading allocations for network: %s'), self.network.id)

        self.device_manager.update(self.network, self.interface_name)

    def _iter_hosts(self):

        """Iterate over hosts.

        For each host on the network we yield a tuple containing:

        (

            port,  # a DictModel instance representing the port.

            alloc,  # a DictModel instance of the allocated ip and subnet.

            host_name,  # Host name.

            name,  # Canonical hostname in the format 'hostname[.domain]'.

        )

        """

        v6_nets = dict((subnet.id, subnet) for subnet in

                       self.network.subnets if subnet.ip_version == 6)

        for port in self.network.ports:

            for alloc in port.fixed_ips:

                # Note(scollins) Only create entries that are

                # associated with the subnet being managed by this

                # dhcp agent

                if alloc.subnet_id in v6_nets:

                    addr_mode = v6_nets[alloc.subnet_id].ipv6_address_mode

                    if addr_mode != constants.DHCPV6_STATEFUL:

                        continue

                hostname = 'host-%s' % alloc.ip_address.replace(

                    '.', '-').replace(':', '-')

                fqdn = hostname

                if self.conf.dhcp_domain:

                    fqdn = '%s.%s' % (fqdn, self.conf.dhcp_domain)

                yield (port, alloc, hostname, fqdn)

    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::