/*

 * Copyright (c) 1996, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.security;

import java.io.*;

import java.util.*;

import static java.util.Locale.ENGLISH;

import java.lang.ref.*;

import java.lang.reflect.*;

import java.util.function.BiConsumer;

import java.util.function.BiFunction;

import java.util.function.Function;

import java.util.concurrent.ConcurrentHashMap;

/**

 * This class represents a "provider" for the

 * Java Security API, where a provider implements some or all parts of

 * Java Security. Services that a provider may implement include:

 *

 * <ul>

 *

 * <li>Algorithms (such as DSA, RSA, or SHA-256).

 *

 * <li>Key generation, conversion, and management facilities (such as for

 * algorithm-specific keys).

 *

 * </ul>

 *

 * <p>Some provider implementations may encounter unrecoverable internal

 * errors during their operation, for example a failure to communicate with a

 * security token. A {@link ProviderException} should be used to indicate

 * such errors.

 *

 * <p>Please note that a provider can be used to implement any security

 * service in Java that uses a pluggable architecture with a choice

 * of implementations that fit underneath.

 *

 * <p>The service type {@code Provider} is reserved for use by the

 * security framework. Services of this type cannot be added, removed,

 * or modified by applications.

 * The following attributes are automatically placed in each Provider object:

 * <table class="striped">

 * <caption><b>Attributes Automatically Placed in a Provider Object</b></caption>

 * <thead>

 * <tr><th scope="col">Name</th><th scope="col">Value</th>

 * </thead>

 * <tbody style="text-align:left">

 * <tr><th scope="row">{@code Provider.id name}</th>

 *     <td>{@code String.valueOf(provider.getName())}</td>

 * <tr><th scope="row">{@code Provider.id version}</th>

 *     <td>{@code String.valueOf(provider.getVersionStr())}</td>

 * <tr><th scope="row">{@code Provider.id info}</th>

 *     <td>{@code String.valueOf(provider.getInfo())}</td>

 * <tr><th scope="row">{@code Provider.id className}</th>

 *     <td>{@code provider.getClass().getName()}</td>

 * </tbody>

 * </table>

 *

 * <p>Each provider has a name and a version string. A provider normally

 * identifies itself with a file named {@code java.security.Provider}

 * in the resource directory {@code META-INF/services}.

 * Security providers are looked up via the {@link ServiceLoader} mechanism

 * using the {@link ClassLoader#getSystemClassLoader application class loader}.

 *

 * <p>Providers may be configured such that they are automatically

 * installed and made available at runtime via the

 * {@link Security#getProviders() Security.getProviders()} method.

 * The mechanism for configuring and installing security providers is

 * implementation-specific.

 *

 * @implNote

 * The JDK implementation supports static registration of the security

 * providers via the {@code conf/security/java.security} file in the Java

 * installation directory. These providers are automatically installed by

 * the JDK runtime, see {@extLink security_guide_jca_provider

 * The Provider Class}

 * in the Java Cryptography Architecture (JCA) Reference Guide

 * for information about how a particular type of provider, the cryptographic

 * service provider, works and is installed.

 *

 * @author Benjamin Renaud

 * @author Andreas Sterbenz

 * @since 1.1

 */

public abstract class Provider extends Properties {

    // Declare serialVersionUID to be compatible with JDK1.1

    @java.io.Serial

    private static final long serialVersionUID = -4298000515446427739L;

    private static final sun.security.util.Debug debug =

        sun.security.util.Debug.getInstance("provider", "Provider");

    /**

     * The provider name.

     *

     * @serial

     */

    private String name;

    /**

     * A description of the provider and its services.

     *

     * @serial

     */

    private String info;

    /**

     * The provider version number.

     *

     * @serial

     */

    private double version;

    /**

     * The provider version string.

     *

     * @serial

     */

    private String versionStr;

    private transient Set<Map.Entry<Object,Object>> entrySet = null;

    private transient int entrySetCallCount = 0;

    private transient boolean initialized;

    private static Object newInstanceUtil(final Class<?> clazz,

        final Class<?> ctrParamClz, final Object ctorParamObj)

        throws Exception {

        if (ctrParamClz == null) {

            Constructor<?> con = clazz.getConstructor();

            return con.newInstance();

        } else {

            // Looking for the constructor with a params first and fallback

            // to one without if not found. This is to support the enhanced

            // SecureRandom where both styles of constructors are supported.

            // Before jdk9, there was no params support (only getInstance(alg))

            // and an impl only had the params-less constructor. Since jdk9,

            // there is getInstance(alg,params) and an impl can contain

            // an Impl(params) constructor.

            try {

                Constructor<?> con = clazz.getConstructor(ctrParamClz);

                return con.newInstance(ctorParamObj);

            } catch (NoSuchMethodException nsme) {

                // For pre-jdk9 SecureRandom implementations, they only

                // have params-less constructors which still works when

                // the input ctorParamObj is null.

                //

                // For other primitives using params, ctorParamObj should not

                // be null and nsme is thrown, just like before.

                if (ctorParamObj == null) {

                    try {

                        Constructor<?> con = clazz.getConstructor();

                        return con.newInstance();

                    } catch (NoSuchMethodException nsme2) {

                        nsme.addSuppressed(nsme2);

                        throw nsme;

                    }

                } else {

                    throw nsme;

                }

            }

        }

    }

    private static double parseVersionStr(String s) {

        try {

            int firstDotIdx = s.indexOf('.');

            int nextDotIdx = s.indexOf('.', firstDotIdx + 1);

            if (nextDotIdx != -1) {

                s = s.substring(0, nextDotIdx);

            }

            int endIdx = s.indexOf('-');

            if (endIdx > 0) {

                s = s.substring(0, endIdx);

            }

            endIdx = s.indexOf('+');

            if (endIdx > 0) {

                s = s.substring(0, endIdx);

            }

            return Double.parseDouble(s);

        } catch (NullPointerException | NumberFormatException e) {

            return 0d;

        }

    }

    /**

     * Constructs a provider with the specified name, version number,

     * and information. Calling this constructor is equivalent to call the

     * {@link #Provider(String, String, String)} with {@code name}

     * name, {@code Double.toString(version)}, and {@code info}.

     *

     * @param name the provider name.

     *

     * @param version the provider version number.

     *

     * @param info a description of the provider and its services.

     *

     * @deprecated use {@link #Provider(String, String, String)} instead.

     */

    @Deprecated(since="9")

    protected Provider(String name, double version, String info) {

        this.name = name;

        this.version = version;

        this.versionStr = Double.toString(version);

        this.info = info;

        this.serviceMap = new ConcurrentHashMap<>();

        putId();

        initialized = true;

    }

    /**

     * Constructs a provider with the specified name, version string,

     * and information.

     *

     * <p>The version string contains a version number optionally followed

     * by other information separated by one of the characters of '+', '-'.

     *

     * The format for the version number is:

     *

     * <blockquote><pre>

     *     ^[0-9]+(\.[0-9]+)*

     * </pre></blockquote>

     *

     * <p>In order to return the version number in a double, when there are

     * more than two components (separated by '.' as defined above), only

     * the first two components are retained. The resulting string is then

     * passed to {@link Double#valueOf(String)} to generate version number,

     * i.e. {@link #getVersion}.

     * <p>If the conversion failed, value 0 will be used.

     *

     * @param name the provider name.

     *

     * @param versionStr the provider version string.

     *

     * @param info a description of the provider and its services.

     *

     * @since 9

     */

    protected Provider(String name, String versionStr, String info) {

        this.name = name;

        this.versionStr = versionStr;

        this.version = parseVersionStr(versionStr);

        this.info = info;

        this.serviceMap = new ConcurrentHashMap<>();

        putId();

        initialized = true;

    }

    /**

     * Apply the supplied configuration argument to this provider instance

     * and return the configured provider. Note that if this provider cannot

     * be configured in-place, a new provider will be created and returned.

     * Therefore, callers should always use the returned provider.

     *

     * @implSpec

     * The default implementation throws {@code UnsupportedOperationException}.

     * Subclasses should override this method only if a configuration argument

     * is supported.

     *

     * @param configArg the configuration information for configuring this

     *         provider.

     *

     * @throws UnsupportedOperationException if a configuration argument is

     *         not supported.

     * @throws NullPointerException if the supplied configuration argument is

               null.

     * @throws InvalidParameterException if the supplied configuration argument

     *         is invalid.

     * @return a provider configured with the supplied configuration argument.

     *

     * @since 9

     */

    public Provider configure(String configArg) {

        throw new UnsupportedOperationException("configure is not supported");

    }

    /**

     * Check if this provider instance has been configured.

     *

     * @implSpec

     * The default implementation returns true.

     * Subclasses should override this method if the provider instance requires

     * an explicit {@code configure} call after being constructed.

     *

     * @return true if no further configuration is needed, false otherwise.

     *

     * @since 9

     */

    public boolean isConfigured() {

        return true;

    }

    /**

     * Returns the name of this provider.

     *

     * @return the name of this provider.

     */

    public String getName() {

        return name;

    }

    /**

     * Returns the version number for this provider.

     *

     * @return the version number for this provider.

     *

     * @deprecated use {@link #getVersionStr} instead.

     */

    @Deprecated(since="9")

    public double getVersion() {

        return version;

    }

    /**

     * Returns the version string for this provider.

     *

     * @return the version string for this provider.

     *

     * @since 9

     */

    public String getVersionStr() {

        return versionStr;

    }

    /**

     * Returns a human-readable description of the provider and its

     * services.  This may return an HTML page, with relevant links.

     *

     * @return a description of the provider and its services.

     */

    public String getInfo() {

        return info;

    }

    /**

     * Returns a string with the name and the version string

     * of this provider.

     *

     * @return the string with the name and the version string

     * for this provider.

     */

    public String toString() {

        return name + " version " + versionStr;

    }

    /*

     * override the following methods to ensure that provider

     * information can only be changed if the caller has the appropriate

     * permissions.

     */

    /**

     * Clears this provider so that it no longer contains the properties

     * used to look up facilities implemented by the provider.

     *

     * <p>If a security manager is enabled, its {@code checkSecurityAccess}

     * method is called with the string {@code "clearProviderProperties."+name}

     * (where {@code name} is the provider name) to see if it's ok to clear

     * this provider.

     *

     * @throws  SecurityException

     *          if a security manager exists and its {@link

     *          java.lang.SecurityManager#checkSecurityAccess} method

     *          denies access to clear this provider

     *

     * @since 1.2

     */

    @Override

    public synchronized void clear() {

        check("clearProviderProperties."+name);

        if (debug != null) {

            debug.println("Remove " + name + " provider properties");

        }

        implClear();

    }

    /**

     * Reads a property list (key and element pairs) from the input stream.

     *

     * @param inStream the input stream.

     * @throws    IOException if an error occurred when reading from the

     *               input stream.

     * @see java.util.Properties#load

     */

    @Override

    public synchronized void load(InputStream inStream) throws IOException {

        check("putProviderProperty."+name);

        if (debug != null) {

            debug.println("Load " + name + " provider properties");

        }

        Properties tempProperties = new Properties();

        tempProperties.load(inStream);

        implPutAll(tempProperties);

    }

    /**

     * Copies all of the mappings from the specified Map to this provider.

     * These mappings will replace any properties that this provider had

     * for any of the keys currently in the specified Map.

     *

     * @since 1.2

     */

    @Override

    public synchronized void putAll(Map<?,?> t) {

        check("putProviderProperty."+name);

        if (debug != null) {

            debug.println("Put all " + name + " provider properties");

        }

        implPutAll(t);

    }

    /**

     * Returns an unmodifiable Set view of the property entries contained

     * in this Provider.

     *

     * @see   java.util.Map.Entry

     * @since 1.2

     */

    @Override

    public synchronized Set<Map.Entry<Object,Object>> entrySet() {

        checkInitialized();

        if (entrySet == null) {

            if (entrySetCallCount++ == 0)  // Initial call

                entrySet = Collections.unmodifiableMap(this).entrySet();

            else

                return super.entrySet();   // Recursive call

        }

        // This exception will be thrown if the implementation of

        // Collections.unmodifiableMap.entrySet() is changed such that it

        // no longer calls entrySet() on the backing Map.  (Provider's

        // entrySet implementation depends on this "implementation detail",

        // which is unlikely to change.

        if (entrySetCallCount != 2)

            throw new RuntimeException("Internal error.");

        return entrySet;

    }

    /**

     * Returns an unmodifiable Set view of the property keys contained in

     * this provider.

     *

     * @since 1.2

     */

    @Override

    public Set<Object> keySet() {

        checkInitialized();

        return Collections.unmodifiableSet(super.keySet());

    }

    /**

     * Returns an unmodifiable Collection view of the property values

     * contained in this provider.

     *

     * @since 1.2

     */

    @Override

    public Collection<Object> values() {

        checkInitialized();

        return Collections.unmodifiableCollection(super.values());

    }

    /**

     * Sets the {@code key} property to have the specified

     * {@code value}.

     *

     * <p>If a security manager is enabled, its {@code checkSecurityAccess}

     * method is called with the string {@code "putProviderProperty."+name},

     * where {@code name} is the provider name, to see if it's ok to set this

     * provider's property values.

     *

     * @throws  SecurityException

     *          if a security manager exists and its {@link

     *          java.lang.SecurityManager#checkSecurityAccess} method

     *          denies access to set property values.

     *

     * @since 1.2

     */