# 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 os

import re

import shutil

import socket

import sys

import uuid

import netaddr

from oslo.config import cfg

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

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

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

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."""

    @classmethod

    def check_version(cls):

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

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

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

        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'

    @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)

        except (OSError, RuntimeError, IndexError, ValueError):

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

                          'Please ensure that its version is %s '

                          'or above!'), cls.MINIMUM_VERSION)

        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(),

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

            '--leasefile-ro',

        ]

        possible_leases = 0

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

            # 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()

                # IANA assigned ID for Oracle

                enterprise_id = '111'

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

            cidr = netaddr.IPNetwork(subnet.cidr)

        # 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.dhcp_domain:

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

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

        utils.execute(cmd, self.root_helper)

        """Release a DHCP lease."""

    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._output_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)

        for port in self.network.ports:

            for alloc in port.fixed_ips: