#!/usr/bin/python

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

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

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

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

#

#

# NOTE: Any changes to this file are considered a change in client api

# interfaces and must be fully documented in doc/client_api_versions.txt

# if they are visible changes to the public interfaces provided.

#

# This also means that changes to the interfaces here must be reflected in

# the client version number and compatible_versions specifier found in

# modules/client/api.py:__init__.

#

import calendar

import collections

import copy

import cStringIO

import datetime as dt

import errno

import hashlib

import os

import pycurl

import shutil

import six

import tempfile

import time

import uuid

from six.moves.urllib.parse import quote, urlsplit, urlparse, urlunparse, \

    ParseResult

from six.moves.urllib.request import url2pathname

import pkg.catalog

import pkg.client.api_errors as api_errors

import pkg.client.sigpolicy as sigpolicy

import pkg.client.pkgdefs as pkgdefs

import pkg.digest as digest

import pkg.misc as misc

import pkg.portable as portable

import pkg.server.catalog as old_catalog

from pkg.client import global_settings

from pkg.client.debugvalues import DebugValues

logger = global_settings.logger

from pkg.misc import EmptyDict, EmptyI, SIGNATURE_POLICY, DictProperty, \

    PKG_RO_FILE_MODE

# The "core" type indicates that a repository contains all of the dependencies

# declared by packages in the repository.  It is primarily used for operating

# system repositories.

REPO_CTYPE_CORE = "core"

# The "supplemental" type indicates that a repository contains packages that

# rely on or are intended to be used with packages located in another

# repository.

REPO_CTYPE_SUPPLEMENTAL = "supplemental"

# Mapping of constant values to names (in the event these ever get changed to

# numeric values or it is decided they need "prettier" or different labels).

REPO_COLLECTION_TYPES = {

    REPO_CTYPE_CORE: "core",

    REPO_CTYPE_SUPPLEMENTAL: "supplemental",

}

# Supported Protocol Schemes

SUPPORTED_SCHEMES = set(("file", "http", "https"))

SUPPORTED_PROXY_SCHEMES = ("http")

# SSL Protocol Schemes

SSL_SCHEMES = set(("https",))

# Supported RepositoryURI sorting policies.

URI_SORT_PRIORITY = "priority"

# Sort policy mapping.

URI_SORT_POLICIES = {

    URI_SORT_PRIORITY: lambda obj: (obj.priority, obj.uri),

}

SUPPORTED_EXTENSION_VALUES = {

}

# These dictionaries map uses into their extensions.

CODE_SIGNING_USE = {

}

CERT_SIGNING_USE = {

}

CRL_SIGNING_USE = {

}

POSSIBLE_USES = [CODE_SIGNING_USE, CERT_SIGNING_USE, CRL_SIGNING_USE]

# A special token used in place of the system repository URL which is

# replaced at runtime by the actual address and port of the

# system-repository.

SYSREPO_PROXY = "<sysrepo>"

class RepositoryURI(object):

        """Class representing a repository URI and any transport-related

        information."""

        # These properties are declared here so that they show up in the pydoc

        # documentation as private, and for clarity in the property declarations

        # found near the end of the class definition.

        __priority = None

        __proxies = None

        __ssl_cert = None

        __ssl_key = None

        __trailing_slash = None

        __uri = None

        # Used to store the id of the original object this one was copied

        # from during __copy__.

        _source_object_id = None

        def __init__(self, uri, priority=None, ssl_cert=None, ssl_key=None,

            trailing_slash=True, proxy=None, system=False, proxies=None):

                # Must set first.

                self.__trailing_slash = trailing_slash

                self.__scheme = None

                self.__netloc = None

                self.__proxies = []

                # Note that the properties set here are intentionally lacking

                # the '__' prefix which means assignment will occur using the

                # get/set methods declared for the property near the end of

                # the class definition.

                self.priority = priority

                self.uri = uri

                self.ssl_cert = ssl_cert

                self.ssl_key = ssl_key

                # The proxy parameter is deprecated and remains for backwards

                # compatibity, for now.  If we get given both, then we must

                # complain - this error is for internal use only.

                if proxy and proxies:

                        raise api_errors.PublisherError("Both 'proxies' and "

                            "'proxy' values were used to create a "

                            "RepositoryURI object.")

                if proxy:

                        self.proxies = [ProxyURI(proxy)]

                if proxies:

                        self.proxies = proxies

                self.system = system

        def __copy__(self):

                uri = RepositoryURI(self.__uri, priority=self.__priority,

                    ssl_cert=self.__ssl_cert, ssl_key=self.__ssl_key,

                    trailing_slash=self.__trailing_slash,

                    proxies=self.__proxies, system=self.system)

                uri._source_object_id = id(self)

                return uri

        def __eq__(self, other):

                if isinstance(other, RepositoryURI):

                        return self.uri == other.uri

                if isinstance(other, str):

                        return self.uri == other

                return False

        def __ne__(self, other):

                if isinstance(other, RepositoryURI):

                        return self.uri != other.uri

                if isinstance(other, str):

                        return self.uri != other

                return True

        __hash__ = object.__hash__

        def __lt__(self, other):

                if not other:

                        return False

                if not isinstance(other, RepositoryURI):

                        other = RepositoryURI(other)

                return self.uri < other.uri

        def __gt__(self, other):

                if not other:

                        return True

                if not isinstance(other, RepositoryURI):

                        other = RepositoryURI(other)

                return self.uri > other.uri

        def __le__(self, other):

                return self == other or self < other

        def __ge__(self, other):

                return self == other or self > other

        def __set_priority(self, value):

                if value is not None:

                        try:

                                value = int(value)

                        except (TypeError, ValueError):

                                raise api_errors.BadRepositoryURIPriority(value)

                self.__priority = value

        def __get_proxy(self):

                if not self.__proxies:

                        return None

                else:

                        return self.__proxies[0].uri

        def __set_proxy(self, proxy):

                if not proxy:

                        return

                if not isinstance(proxy, ProxyURI):

                        p = ProxyURI(proxy)

                else:

                        p = proxy

                self.__proxies = [p]

        def __set_proxies(self, proxies):

                for proxy in proxies:

                        if not isinstance(proxy, ProxyURI):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "proxies", value=proxy)

                if proxies and self.scheme == "file":

                        raise api_errors.UnsupportedRepositoryURIAttribute(

                            "proxies", scheme=self.scheme)

                if not (isinstance(proxies, list) or

                    isinstance(proxies, tuple)):

                        raise api_errors.BadRepositoryAttributeValue(

                            "proxies", value=proxies)

                # for now, we only support a single proxy per RepositoryURI

                if len(proxies) > 1:

                        raise api_errors.BadRepositoryAttributeValue(

                            "proxies", value=proxies)

                if proxies:

                        self.__proxies = proxies

                else:

                        self.__proxies = []

        def __set_ssl_cert(self, filename):

                if self.scheme not in SSL_SCHEMES and filename:

                        raise api_errors.UnsupportedRepositoryURIAttribute(

                            "ssl_cert", scheme=self.scheme)

                if filename:

                        if not isinstance(filename, six.string_types):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "ssl_cert", value=filename)

                        filename = os.path.normpath(filename)

                if filename == "":

                        filename = None

                self.__ssl_cert = filename

        def __set_ssl_key(self, filename):

                if self.scheme not in SSL_SCHEMES and filename:

                        raise api_errors.UnsupportedRepositoryURIAttribute(

                            "ssl_key", scheme=self.scheme)

                if filename:

                        if not isinstance(filename, six.string_types):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "ssl_key", value=filename)

                        filename = os.path.normpath(filename)

                if filename == "":

                        filename = None

                self.__ssl_key = filename

        def __set_trailing_slash(self, value):

                if value not in (True, False):

                        raise api_errors.BadRepositoryAttributeValue(

                            "trailing_slash", value=value)

                self.__trailing_slash = value

        def __set_uri(self, uri):

                if uri is None:

                        raise api_errors.BadRepositoryURI(uri)

                # if we're setting the URI to an existing value, do nothing.

                if uri == self.__uri:

                        return

                # This is not ideal, but determining whether we're operating

                # on a ProxyURI saves us duplicating code in that class,

                # which we would otherwise need, due to __protected members

                # here.

                if isinstance(self, ProxyURI):

                        is_proxy = True

                else:

                        is_proxy = False

                # Decompose URI to verify attributes.

                scheme, netloc, path, params, query = \

                    urlsplit(uri, allow_fragments=0)

                self.__scheme = scheme.lower()

                self.__netloc = netloc

                # The set of currently supported protocol schemes.

                if is_proxy and self.__scheme not in \

                    SUPPORTED_PROXY_SCHEMES:

                        raise api_errors.UnsupportedProxyURI(uri)

                else:

                        if self.__scheme not in SUPPORTED_SCHEMES:

                                raise api_errors.UnsupportedRepositoryURI(uri)

                # XXX valid_pub_url's check isn't quite right and could prevent

                # usage of IDNs (international domain names).

                if (self.__scheme.startswith("http") and not netloc) or \

                    not misc.valid_pub_url(uri, proxy=is_proxy):

                        raise api_errors.BadRepositoryURI(uri)

                if self.__scheme == "file" and netloc:

                        raise api_errors.BadRepositoryURI(uri)

                # Normalize URI scheme.

                uri = uri.replace(scheme, self.__scheme, 1)

                if self.__trailing_slash:

                        uri = uri.rstrip("/")

                        uri = misc.url_affix_trailing_slash(uri)

                if self.__scheme not in SSL_SCHEMES:

                        self.__ssl_cert = None

                        self.__ssl_key = None

                self.__uri = uri

        def _override_uri(self, uri):

                """Allow the __uri field of the object to be overridden in

                special cases."""

                if uri not in [None, SYSREPO_PROXY]:

                        raise api_errors.BadRepositoryURI(uri)

                self.__uri = uri

        def __str__(self):

                return str(self.__uri)

        def change_scheme(self, new_scheme):

                """Change the scheme of this uri."""

                assert self.__uri

                scheme, netloc, path, params, query, fragment = \

                    urlparse(self.__uri, allow_fragments=False)

                if new_scheme == scheme:

                        return

                self.uri = urlunparse(

                    (new_scheme, netloc, path, params, query, fragment))

        def get_host(self):

                """Get the host and port of this URI if it's a http uri."""

                scheme, netloc, path, params, query, fragment = \

                    urlparse(self.__uri, allow_fragments=0)

                if scheme != "file":

                        return netloc

                return ""

        def get_pathname(self):

                """Returns the URI path as a pathname if the URI is a file

                URI or '' otherwise."""

                scheme, netloc, path, params, query, fragment = \

                    urlparse(self.__uri, allow_fragments=0)

                if scheme == "file":

                        return url2pathname(path)

                return ""

        ssl_cert = property(lambda self: self.__ssl_cert, __set_ssl_cert, None,

            "The absolute pathname of a PEM-encoded SSL certificate file.")

        ssl_key = property(lambda self: self.__ssl_key, __set_ssl_key, None,

            "The absolute pathname of a PEM-encoded SSL key file.")

        uri = property(lambda self: self.__uri, __set_uri, None,

            "The URI used to access a repository.")

        priority = property(lambda self: self.__priority, __set_priority, None,

            "An integer value representing the importance of this repository "

            "URI relative to others.")

        proxy = property(__get_proxy, __set_proxy, None, "The proxy to use to "

            "access this repository.")

        proxies = property(lambda self: self.__proxies, __set_proxies, None,

            "A list of proxies that can be used to access this repository."

            "At runtime, a $http_proxy environment variable might override this."

            )

        @property

        def scheme(self):

                """The URI scheme."""

                if not self.__uri:

                        return ""

                return urlsplit(self.__uri, allow_fragments=0)[0]

        trailing_slash = property(lambda self: self.__trailing_slash,

            __set_trailing_slash, None,

            "A boolean value indicating whether any URI provided for this "

            "object should have a trailing slash appended when setting the "

            "URI property.")

class ProxyURI(RepositoryURI):

        """A class to represent the URI of a proxy. The 'uri' value can be

        'None' if 'system' is set to True."""

        def __init__(self, uri, system=False):

                self.__system = None

                self.system = system

                if not system:

                        self.uri = uri

        def __set_system(self, value):

                """A property to specify whether we should use the system

                publisher as the proxy.  Note that this method modifies the

                'uri' property when set or cleared."""

                if value not in (True, False):

                        raise api_errors.BadRepositoryAttributeValue(

                            "system", value=value)

                self.__system = value

                if value:

                        # Set a special value for the uri, intentionally an

                        # invalid URI which should get caught by any consumers

                        # using it by mistake.  This also allows us to reuse

                        # the __eq__, __cmp__, etc. methods from the parent

                        # (where there is no public way of setting the URI to

                        # SYSREPO_PROXY, '<sysrepo>')

                        self._override_uri(SYSREPO_PROXY)

                else:

                        self._override_uri(None)

        def __unsupported(self, value):

                """A method used to prevent certain properties defined in the

                parent class from being set on ProxyURI objects."""

                # We don't expect this string to be exposed to users.

                raise ValueError("This property cannot be set to {0} on a "

                    "ProxyURI object.".format(value))

        system = property(lambda self: self.__system, __set_system, None,

            "True, if we should use the system publisher as a proxy.")

        # Ensure we can't set any of the following properties.

        proxies = property(lambda self: None, __unsupported, None,

            "proxies is an invalid property for ProxyURI properties")

        ssl_cert = property(lambda self:  None, __unsupported, None,

            "ssl_cert is an invalid property for ProxyURI properties")