/*

* Copyright (c) 1996, 2014, 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;

/**

* 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, MD5 or SHA-1).

*

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

* algorithm-specific keys).

*

*</ul>

*

* <p>Each provider has a name and a version number, and is configured

* in each runtime it is installed in.

*

* <p>See <a href =

* "../../../technotes/guides/security/crypto/CryptoSpec.html#Provider">The Provider Class</a>

* in the "Java Cryptography Architecture API Specification &amp; Reference"

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

* cryptographic service provider, works and is installed. However,

* 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>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>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 cellspacing=4>

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

* <tr><th>Name</th><th>Value</th>

* <tr><td>{@code Provider.id name}</td>

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

* <tr><td>{@code Provider.id version}</td>

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

* <tr><td>{@code Provider.id info}</td>

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

* <tr><td>{@code Provider.id className}</td>

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

* </table>

*

* @author Benjamin Renaud

* @author Andreas Sterbenz

*/

public abstract class Provider extends Properties {

// Declare serialVersionUID to be compatible with JDK1.1

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;

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

private transient int entrySetCallCount = 0;

private transient boolean initialized;

/**

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

* and information.

*

* @param name the provider name.

*

* @param version the provider version number.

*

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

*/

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

this.name = name;

this.version = version;

this.info = info;

putId();

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

*/

public double getVersion() {

return version;

}

/**

* 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 number

* of this provider.

*

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

* for this provider.

*/

public String toString() {

return name + " version " + version;

}

/*

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

* @exception 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

*/

@Override

public synchronized Object put(Object key, Object value) {

check("putProviderProperty."+name);

if (debug != null) {

debug.println("Set " + name + " provider property [" +

key + "/" + value +"]");

}

return implPut(key, value);

}

/**

* If the specified key is not already associated with a value (or is mapped

* to {@code null}) associates it with the given value and returns

* {@code null}, else returns the current 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.8

*/

@Override

public synchronized Object putIfAbsent(Object key, Object value) {

check("putProviderProperty."+name);

if (debug != null) {

debug.println("Set " + name + " provider property [" +

key + "/" + value +"]");

}

return implPutIfAbsent(key, value);

}

/**

* Removes the {@code key} property (and its corresponding

* {@code value}).

*

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

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

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

* provider's properties.

*

* @throws SecurityException

* if a security manager exists and its {@link

* java.lang.SecurityManager#checkSecurityAccess} method

* denies access to remove this provider's properties.

*

* @since 1.2

*/

@Override

public synchronized Object remove(Object key) {

check("removeProviderProperty."+name);

if (debug != null) {

debug.println("Remove " + name + " provider property " + key);

}

return implRemove(key);

}

/**

* Removes the entry for the specified key only if it is currently

* mapped to the specified value.

*

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

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

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

* provider's properties.

*

* @throws SecurityException

* if a security manager exists and its {@link

* java.lang.SecurityManager#checkSecurityAccess} method

* denies access to remove this provider's properties.

*

* @since 1.8

*/

@Override

public synchronized boolean remove(Object key, Object value) {

check("removeProviderProperty."+name);

if (debug != null) {

debug.println("Remove " + name + " provider property " + key);

}

return implRemove(key, value);

}

/**

* Replaces the entry for the specified key only if currently

* mapped to the specified 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.8

*/

@Override

public synchronized boolean replace(Object key, Object oldValue,

Object newValue) {

check("putProviderProperty." + name);

if (debug != null) {

debug.println("Replace " + name + " provider property " + key);

}

return implReplace(key, oldValue, newValue);

}

/**

* Replaces the entry for the specified key only if it is

* currently mapped to some 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.8

*/

@Override

public synchronized Object replace(Object key, Object value) {

check("putProviderProperty." + name);

if (debug != null) {

debug.println("Replace " + name + " provider property " + key);

}

return implReplace(key, value);

}

/**

* Replaces each entry's value with the result of invoking the given

* function on that entry, in the order entries are returned by an entry

* set iterator, until all entries have been processed or the function

* throws an exception.

*

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

*/

@Override

public synchronized void replaceAll(BiFunction<? super Object, ? super Object, ? extends Object> function) {

check("putProviderProperty." + name);

if (debug != null) {

debug.println("ReplaceAll " + name + " provider property ");

}

implReplaceAll(function);

}

/**

* Attempts to compute a mapping for the specified key and its

* current mapped value (or {@code null} if there is no current

* mapping).

*

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

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

* and {@code "removeProviderProperty."+name}, where {@code name} is the

* provider name, to see if it's ok to set this provider's property values

* and remove this provider's properties.

*

* @throws SecurityException

* if a security manager exists and its {@link

* java.lang.SecurityManager#checkSecurityAccess} method

* denies access to set property values or remove properties.

*

* @since 1.8

*/

@Override

public synchronized Object compute(Object key,

BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

check("putProviderProperty." + name);

check("removeProviderProperty" + name);

if (debug != null) {

debug.println("Compute " + name + " provider property " + key);

}

return implCompute(key, remappingFunction);

}

/**

* If the specified key is not already associated with a value (or

* is mapped to {@code null}), attempts to compute its value using

* the given mapping function and enters it into this map unless

* {@code null}.

*

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

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

* and {@code "removeProviderProperty."+name}, where {@code name} is the

* provider name, to see if it's ok to set this provider's property values

* and remove this provider's properties.

*

* @throws SecurityException

* if a security manager exists and its {@link

* java.lang.SecurityManager#checkSecurityAccess} method

* denies access to set property values and remove properties.

*

* @since 1.8

*/

@Override

public synchronized Object computeIfAbsent(Object key, Function<? super Object, ? extends Object> mappingFunction) {

check("putProviderProperty." + name);

check("removeProviderProperty" + name);

if (debug != null) {

debug.println("ComputeIfAbsent " + name + " provider property " +

key);

}

return implComputeIfAbsent(key, mappingFunction);

}

/**

* If the value for the specified key is present and non-null, attempts to

* compute a new mapping given the key and its current mapped value.

*

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

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

* and {@code "removeProviderProperty."+name}, where {@code name} is the

* provider name, to see if it's ok to set this provider's property values

* and remove this provider's properties.

*

* @throws SecurityException

* if a security manager exists and its {@link

* java.lang.SecurityManager#checkSecurityAccess} method

* denies access to set property values or remove properties.

*

* @since 1.8

*/

@Override

public synchronized Object computeIfPresent(Object key, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

check("putProviderProperty." + name);

check("removeProviderProperty" + name);

if (debug != null) {

debug.println("ComputeIfPresent " + name + " provider property " +

key);

}

return implComputeIfPresent(key, remappingFunction);

}

/**

* If the specified key is not already associated with a value or is

* associated with null, associates it with the given value. Otherwise,

* replaces the value with the results of the given remapping function,

* or removes if the result is null. This method may be of use when

* combining multiple mapped values for a key.

*

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

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

* and {@code "removeProviderProperty."+name}, where {@code name} is the

* provider name, to see if it's ok to set this provider's property values

* and remove this provider's properties.

*

* @throws SecurityException

* if a security manager exists and its {@link

* java.lang.SecurityManager#checkSecurityAccess} method

* denies access to set property values or remove properties.

*

* @since 1.8

*/

@Override

public synchronized Object merge(Object key, Object value, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

check("putProviderProperty." + name);

check("removeProviderProperty" + name);

if (debug != null) {

debug.println("Merge " + name + " provider property " + key);

}

return implMerge(key, value, remappingFunction);

}

// let javadoc show doc from superclass

@Override

public Object get(Object key) {

checkInitialized();

return super.get(key);

}

/**

* @since 1.8

*/

@Override

public synchronized Object getOrDefault(Object key, Object defaultValue) {

checkInitialized();

return super.getOrDefault(key, defaultValue);

}

/**

* @since 1.8

*/

@Override

public synchronized void forEach(BiConsumer<? super Object, ? super Object> action) {

checkInitialized();

super.forEach(action);

}

// let javadoc show doc from superclass

@Override

public Enumeration<Object> keys() {

checkInitialized();

return super.keys();

}

// let javadoc show doc from superclass

@Override

public Enumeration<Object> elements() {

checkInitialized();

return super.elements();

}

// let javadoc show doc from superclass

public String getProperty(String key) {

checkInitialized();

return super.getProperty(key);

}

private void checkInitialized() {

if (!initialized) {

throw new IllegalStateException();

}

}

private void check(String directive) {

checkInitialized();

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkSecurityAccess(directive);

}

}

// legacy properties changed since last call to any services method?

private transient boolean legacyChanged;

// serviceMap changed since last call to getServices()

private transient boolean servicesChanged;

// Map<String,String>

private transient Map<String,String> legacyStrings;

// Map<ServiceKey,Service>

// used for services added via putService(), initialized on demand

private transient Map<ServiceKey,Service> serviceMap;

// Map<ServiceKey,Service>

// used for services added via legacy methods, init on demand

private transient Map<ServiceKey,Service> legacyMap;

// Set<Service>

// Unmodifiable set of all services. Initialized on demand.

private transient Set<Service> serviceSet;

// register the id attributes for this provider

// this is to ensure that equals() and hashCode() do not incorrectly

// report to different provider objects as the same

private void putId() {

// note: name and info may be null

super.put("Provider.id name", String.valueOf(name));

super.put("Provider.id version", String.valueOf(version));

super.put("Provider.id info", String.valueOf(info));

super.put("Provider.id className", this.getClass().getName());

}

private void readObject(ObjectInputStream in)

throws IOException, ClassNotFoundException {

Map<Object,Object> copy = new HashMap<>();

for (Map.Entry<Object,Object> entry : super.entrySet()) {

copy.put(entry.getKey(), entry.getValue());

}

defaults = null;

in.defaultReadObject();

implClear();

initialized = true;

putAll(copy);

}

private boolean checkLegacy(Object key) {

String keyString = (String)key;

if (keyString.startsWith("Provider.")) {

return false;

}

legacyChanged = true;

if (legacyStrings == null) {

legacyStrings = new LinkedHashMap<String,String>();

}

return true;

}

/**

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

* Internal method to be called AFTER the security check has been

* performed.

*/

private void implPutAll(Map<?,?> t) {

for (Map.Entry<?,?> e : t.entrySet()) {

implPut(e.getKey(), e.getValue());

}

}

private Object implRemove(Object key) {

if (key instanceof String) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.remove((String)key);

}

return super.remove(key);

}

private boolean implRemove(Object key, Object value) {

if (key instanceof String && value instanceof String) {

if (!checkLegacy(key)) {

return false;

}

legacyStrings.remove((String)key, value);

}

return super.remove(key, value);

}

private boolean implReplace(Object key, Object oldValue, Object newValue) {

if ((key instanceof String) && (oldValue instanceof String) &&

(newValue instanceof String)) {

if (!checkLegacy(key)) {

return false;

}

legacyStrings.replace((String)key, (String)oldValue,

(String)newValue);

}

return super.replace(key, oldValue, newValue);

}

private Object implReplace(Object key, Object value) {

if ((key instanceof String) && (value instanceof String)) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.replace((String)key, (String)value);

}

return super.replace(key, value);

}

private void implReplaceAll(BiFunction<? super Object, ? super Object, ? extends Object> function) {

legacyChanged = true;

if (legacyStrings == null) {

legacyStrings = new LinkedHashMap<String,String>();

} else {

legacyStrings.replaceAll((BiFunction<? super String, ? super String, ? extends String>) function);

}

super.replaceAll(function);

}

private Object implMerge(Object key, Object value, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

if ((key instanceof String) && (value instanceof String)) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.merge((String)key, (String)value,

(BiFunction<? super String, ? super String, ? extends String>) remappingFunction);

}

return super.merge(key, value, remappingFunction);

}

private Object implCompute(Object key, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

if (key instanceof String) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.computeIfAbsent((String) key,

(Function<? super String, ? extends String>) remappingFunction);

}

return super.compute(key, remappingFunction);

}

private Object implComputeIfAbsent(Object key, Function<? super Object, ? extends Object> mappingFunction) {

if (key instanceof String) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.computeIfAbsent((String) key,

(Function<? super String, ? extends String>) mappingFunction);

}

return super.computeIfAbsent(key, mappingFunction);

}

private Object implComputeIfPresent(Object key, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

if (key instanceof String) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.computeIfPresent((String) key,

(BiFunction<? super String, ? super String, ? extends String>) remappingFunction);

}

return super.computeIfPresent(key, remappingFunction);

}

private Object implPut(Object key, Object value) {

if ((key instanceof String) && (value instanceof String)) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.put((String)key, (String)value);

}

return super.put(key, value);

}

private Object implPutIfAbsent(Object key, Object value) {

if ((key instanceof String) && (value instanceof String)) {

if (!checkLegacy(key)) {

return null;

}

legacyStrings.putIfAbsent((String)key, (String)value);

}

return super.putIfAbsent(key, value);

}

private void implClear() {

if (legacyStrings != null) {

legacyStrings.clear();

}

if (legacyMap != null) {

legacyMap.clear();

}

if (serviceMap != null) {

serviceMap.clear();

}

legacyChanged = false;

servicesChanged = false;

serviceSet = null;

super.clear();

putId();

}

// used as key in the serviceMap and legacyMap HashMaps

private static class ServiceKey {

private final String type;

private final String algorithm;

private final String originalAlgorithm;

private ServiceKey(String type, String algorithm, boolean intern) {

this.type = type;

this.originalAlgorithm = algorithm;

algorithm = algorithm.toUpperCase(ENGLISH);

this.algorithm = intern ? algorithm.intern() : algorithm;

}

public int hashCode() {

return type.hashCode() + algorithm.hashCode();

}

public boolean equals(Object obj) {

if (this == obj) {

return true;

}

if (obj instanceof ServiceKey == false) {

return false;

}

ServiceKey other = (ServiceKey)obj;

return this.type.equals(other.type)

&& this.algorithm.equals(other.algorithm);

}

boolean matches(String type, String algorithm) {

return (this.type == type) && (this.originalAlgorithm == algorithm);

}

}

/**

* Ensure all the legacy String properties are fully parsed into

* service objects.

*/

private void ensureLegacyParsed() {

if ((legacyChanged == false) || (legacyStrings == null)) {

return;

}

serviceSet = null;

if (legacyMap == null) {

legacyMap = new LinkedHashMap<ServiceKey,Service>();

} else {

legacyMap.clear();

}

for (Map.Entry<String,String> entry : legacyStrings.entrySet()) {

parseLegacyPut(entry.getKey(), entry.getValue());

}

removeInvalidServices(legacyMap);

legacyChanged = false;

}

/**

* Remove all invalid services from the Map. Invalid services can only

* occur if the legacy properties are inconsistent or incomplete.

*/

private void removeInvalidServices(Map<ServiceKey,Service> map) {

for (Iterator<Map.Entry<ServiceKey, Service>> t =

map.entrySet().iterator(); t.hasNext(); ) {

Service s = t.next().getValue();

if (s.isValid() == false) {

t.remove();

}

}

}

private String[] getTypeAndAlgorithm(String key) {

int i = key.indexOf(".");

if (i < 1) {

if (debug != null) {

debug.println("Ignoring invalid entry in provider "

+ name + ":" + key);

}

return null;

}

String type = key.substring(0, i);

String alg = key.substring(i + 1);

return new String[] {type, alg};

}

private final static String ALIAS_PREFIX = "Alg.Alias.";

private final static String ALIAS_PREFIX_LOWER = "alg.alias.";

private final static int ALIAS_LENGTH = ALIAS_PREFIX.length();

private void parseLegacyPut(String name, String value) {

if (name.toLowerCase(ENGLISH).startsWith(ALIAS_PREFIX_LOWER)) {

// e.g. put("Alg.Alias.MessageDigest.SHA", "SHA-1");

// aliasKey ~ MessageDigest.SHA

String stdAlg = value;

String aliasKey = name.substring(ALIAS_LENGTH);

String[] typeAndAlg = getTypeAndAlgorithm(aliasKey);

if (typeAndAlg == null) {

return;

}

String type = getEngineName(typeAndAlg[0]);

String aliasAlg = typeAndAlg[1].intern();

ServiceKey key = new ServiceKey(type, stdAlg, true);

Service s = legacyMap.get(key);

if (s == null) {

s = new Service(this);

s.type = type;

s.algorithm = stdAlg;

legacyMap.put(key, s);

}

legacyMap.put(new ServiceKey(type, aliasAlg, true), s);

s.addAlias(aliasAlg);

} else {

String[] typeAndAlg = getTypeAndAlgorithm(name);

if (typeAndAlg == null) {

return;

}

int i = typeAndAlg[1].indexOf(' ');

if (i == -1) {

// e.g. put("MessageDigest.SHA-1", "sun.security.provider.SHA");

String type = getEngineName(typeAndAlg[0]);

String stdAlg = typeAndAlg[1].intern();

String className = value;

ServiceKey key = new ServiceKey(type, stdAlg, true);

Service s = legacyMap.get(key);

if (s == null) {

s = new Service(this);

s.type = type;

s.algorithm = stdAlg;

legacyMap.put(key, s);

}

s.className = className;

} else { // attribute

// e.g. put("MessageDigest.SHA-1 ImplementedIn", "Software");

String attributeValue = value;

String type = getEngineName(typeAndAlg[0]);

String attributeString = typeAndAlg[1];

String stdAlg = attributeString.substring(0, i).intern();

String attributeName = attributeString.substring(i + 1);

// kill additional spaces

while (attributeName.startsWith(" ")) {

attributeName = attributeName.substring(1);

}

attributeName = attributeName.intern();