#!/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, 2011, 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 tempfile

import time

import urllib

import urlparse

import uuid

from pkg.client import global_settings

from pkg.client.debugvalues import DebugValues

logger = global_settings.logger

import pkg.catalog

import pkg.client.api_errors as api_errors

import pkg.client.sigpolicy as sigpolicy

import pkg.misc as misc

import pkg.portable as portable

import pkg.server.catalog as old_catalog

import M2Crypto as m2

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

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

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

}

# This dictionary records the recognized values of extensions.

SUPPORTED_EXTENSION_VALUES = {

    "basicConstraints": ("CA:TRUE", "CA:FALSE", "PATHLEN:"),

    "keyUsage": ("DIGITAL SIGNATURE", "CERTIFICATE SIGN", "CRL SIGN")

}

# These dictionaries map uses into their extensions.

CODE_SIGNING_USE = {

    "keyUsage": ["DIGITAL SIGNATURE"]

}

CERT_SIGNING_USE = {

    "basicConstraints": ["CA:TRUE"],

    "keyUsage": ["CERTIFICATE SIGN"]

}

CRL_SIGNING_USE = {

    "keyUsage": ["CRL SIGN"]

}

POSSIBLE_USES = [CODE_SIGNING_USE, CERT_SIGNING_USE, CRL_SIGNING_USE]

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

        __proxy = 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):

                # Must set first.

                self.__trailing_slash = trailing_slash

                # 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

                self.proxy = proxy

                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, proxy=self.__proxy,

                    system=self.system)

                uri._source_object_id = id(self)

                return uri

        def __eq__(self, other):

                if isinstance(other, RepositoryURI):

                        return self.uri == other.uri and \

                            self.proxy == other.proxy

                if isinstance(other, str):

                        return self.proxy is None and self.uri == other

                return False

        def __ne__(self, other):

                if isinstance(other, RepositoryURI):

                        return self.uri != other.uri or \

                            self.proxy != other.proxy

                if isinstance(other, str):

                        return self.proxy is not None or self.uri != other

                return True

        def __cmp__(self, other):

                if not other:

                        return 1

                if not isinstance(other, RepositoryURI):

                        other = RepositoryURI(other)

                res = cmp(self.uri, other.uri)

                if res != 0:

                        return res

                return cmp(self.proxy, other.proxy)

        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 __set_proxy(self, proxy):

                if not proxy:

                        return

                self.__proxy = proxy

                assert not self.__ssl_cert

                assert not self.__ssl_key

        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, basestring):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "ssl_cert", value=filename)

                        filename = os.path.abspath(filename)

                        if not os.path.exists(filename):

                                raise api_errors.NoSuchCertificate(filename,

                                    uri=self.uri)

                if filename == "":

                        filename = None

                # XXX attempt certificate verification here?

                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, basestring):

                                raise api_errors.BadRepositoryAttributeValue(

                                    "ssl_key", value=filename)

                        filename = os.path.abspath(filename)

                        if not os.path.exists(filename):

                                raise api_errors.NoSuchKey(filename,

                                    uri=self.uri)

                if filename == "":

                        filename = None

                # XXX attempt key verification here?

                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)

                # Decompose URI to verify attributes.

                scheme, netloc, path, params, query = \

                    urlparse.urlsplit(uri, allow_fragments=0)

                # The set of currently supported protocol schemes.

                if scheme.lower() 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 (scheme.lower().startswith("http") and not netloc) or \

                    not misc.valid_pub_url(uri):

                        raise api_errors.BadRepositoryURI(uri)

                if scheme.lower() == "file" and netloc:

                        raise api_errors.BadRepositoryURI(uri)

                # Normalize URI scheme.

                uri = uri.replace(scheme, scheme.lower(), 1)

                if self.__trailing_slash:

                        uri = misc.url_affix_trailing_slash(uri)

                if scheme.lower() not in SSL_SCHEMES:

                        self.__ssl_cert = None

                        self.__ssl_key = None

                self.__uri = uri

        def __str__(self):

                if not self.__proxy:

                        return self.__uri

                return "proxy://%s" % self.__uri

        def change_scheme(self, new_scheme):

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

                assert self.__uri

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

                    urlparse.urlparse(self.__uri, allow_fragments=False)

                if new_scheme == scheme:

                        return

                self.uri = urlparse.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.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.urlparse(self.__uri, allow_fragments=0)

                if scheme == "file":

                        return urllib.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(lambda self: self.__proxy, __set_proxy, None, "The "

            "proxy to use to access this repository.")

        @property

        def scheme(self):

                """The URI scheme."""

                if not self.__uri:

                        return ""

                return urlparse.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 Repository(object):

        """Class representing a repository object.

        A repository object represents a location where clients can publish

        and retrieve package content and/or metadata.  It has the following

        characteristics:

                - may have one or more origins (URIs) for publication and

                  retrieval of package metadata and content.

                - may have zero or more mirrors (URIs) for retrieval of package

                  content."""

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

        __collection_type = None

        __legal_uris = []

        __mirrors = []

        __origins = []

        __refresh_seconds = None

        __registration_uri = None

        __related_uris = []

        __sort_policy = URI_SORT_PRIORITY

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

        # from during __copy__.

        _source_object_id = None

        name = None

        description = None

        registered = False

        def __init__(self, collection_type=REPO_CTYPE_CORE, description=None,

            legal_uris=None, mirrors=None, name=None, origins=None,

            refresh_seconds=None, registered=False, registration_uri=None,

            related_uris=None, sort_policy=URI_SORT_PRIORITY):

                """Initializes a repository object.

                'collection_type' is an optional constant value indicating the

                type of packages in the repository.

                'description' is an optional string value containing a

                descriptive paragraph for the repository.

                'legal_uris' should be a list of RepositoryURI objects or URI

                strings indicating where licensing, legal, and terms of service

                information for the repository can be found.

                'mirrors' is an optional list of RepositoryURI objects or URI

                strings indicating where package content can be retrieved.

                'name' is an optional, short, descriptive name for the

                repository.

                'origins' should be a list of RepositoryURI objects or URI

                strings indicating where package metadata can be retrieved.

                'refresh_seconds' is an optional integer value indicating the

                number of seconds clients should wait before refreshing cached

                repository catalog or repository metadata information.

                'registered' is an optional boolean value indicating whether

                a client has registered with the repository's publisher.

                'registration_uri' is an optional RepositoryURI object or a URI

                string indicating a location clients can use to register or

                obtain credentials needed to access the repository.

                'related_uris' is an optional list of RepositoryURI objects or a

                list of URI strings indicating the location of related

                repositories that a client may be interested in.

                'sort_policy' is an optional constant value indicating how

                legal_uris, mirrors, origins, and related_uris should be

                sorted."""

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

                # Must be set first so that it will apply to attributes set

                # afterwards.

                self.sort_policy = sort_policy

                self.collection_type = collection_type

                self.description = description

                self.legal_uris = legal_uris

                self.mirrors = mirrors

                self.name = name

                self.origins = origins

                self.refresh_seconds = refresh_seconds

                self.registered = registered

                self.registration_uri = registration_uri

                self.related_uris = related_uris

        def __add_uri(self, attr, uri, dup_check=None, priority=None,

            ssl_cert=None, ssl_key=None, trailing_slash=True):

                if not isinstance(uri, RepositoryURI):

                        uri = RepositoryURI(uri, priority=priority,

                            ssl_cert=ssl_cert, ssl_key=ssl_key,

                            trailing_slash=trailing_slash)

                if dup_check:

                        dup_check(uri)

                ulist = getattr(self, attr)

                ulist.append(uri)

                ulist.sort(key=URI_SORT_POLICIES[self.__sort_policy])

        def __copy__(self):

                cluris = [copy.copy(u) for u in self.legal_uris]

                cmirrors = [copy.copy(u) for u in self.mirrors]

                cruris = [copy.copy(u) for u in self.related_uris]

                corigins = [copy.copy(u) for u in self.origins]

                repo = Repository(collection_type=self.collection_type,

                    description=self.description,

                    legal_uris=cluris,

                    mirrors=cmirrors, name=self.name,

                    origins=corigins,

                    refresh_seconds=self.refresh_seconds,

                    registered=self.registered,

                    registration_uri=copy.copy(self.registration_uri),

                    related_uris=cruris)

                repo._source_object_id = id(self)

                return repo

        def __replace_uris(self, attr, value, trailing_slash=True):

                if value is None:

                        value = []

                if not isinstance(value, list):

                        raise api_errors.BadRepositoryAttributeValue(attr,

                            value=value)

                uris = []

                for u in value:

                        if not isinstance(u, RepositoryURI):

                                u = RepositoryURI(u,

                                    trailing_slash=trailing_slash)

                        elif trailing_slash:

                                u.uri = misc.url_affix_trailing_slash(u.uri)

                        uris.append(u)

                uris.sort(key=URI_SORT_POLICIES[self.__sort_policy])

                return uris

        def __set_collection_type(self, value):

                if value not in REPO_COLLECTION_TYPES:

                        raise api_errors.BadRepositoryCollectionType(value)

                self.__collection_type = value

        def __set_legal_uris(self, value):

                self.__legal_uris = self.__replace_uris("legal_uris", value,

                    trailing_slash=False)

        def __set_mirrors(self, value):

                self.__mirrors = self.__replace_uris("mirrors", value)

        def __set_origins(self, value):

                self.__origins = self.__replace_uris("origins", value)

        def __set_registration_uri(self, value):

                if value and not isinstance(value, RepositoryURI):

                        value = RepositoryURI(value, trailing_slash=False)

                self.__registration_uri = value

        def __set_related_uris(self, value):

                self.__related_uris = self.__replace_uris("related_uris",

                    value, trailing_slash=False)

        def __set_refresh_seconds(self, value):

                if value is not None: