/**
* Removes the {@code Provider} with the specified name form the collection
* of providers. If the the {@code Provider} with the specified name is
* removed, all provider at a greater position are shifted down one
* position.
* <p/>
* Returns silently if {@code name} is {@code null} or no provider with the
* specified name is installed.
* <p/>
* If a {@code SecurityManager} is installed, code calling this method needs
* the {@code SecurityPermission} {@code removeProvider.NAME} (where NAME is
* the provider name) to be granted, otherwise a {@code SecurityException}
* will be thrown.
*
* @param name
* the name of the provider to remove.
* @throws SecurityException
* if a {@code SecurityManager} is installed and the caller does
* not have permission to invoke this method.
*/
public static void removeProvider(String name)
{
lock (lockJ)
{
// It is not clear from spec.:
// 1. if name is null, should we checkSecurityAccess or not?
// throw SecurityException or not?
// 2. as 1 but provider is not installed
// 3. behavior if name is empty string?
Provider p;
if ((name == null) || (name.length() == 0))
{
return;
}
p = getProvider(name);
if (p == null)
{
return;
}
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkSecurityAccess("removeProvider." + name); //$NON-NLS-1$
}
Services.removeProvider(p.getProviderNumber());
renumProviders();
p.setProviderNumber(-1);
}
}
public void Test_SetSecurityManager()
{
java.lang.SecurityManager newSecurityManager = new java.lang.SecurityManager();
this.help_SetSecurityManager(newSecurityManager);
Assert.AreSame(newSecurityManager, java.lang.SystemJ.getSecurityManager(), "Object is not the same");
}
/*
* Creates a new URL instance using the given arguments. The URL uses the
* specified port instead of the default port for the given protocol.
*
* @param protocol
* the protocol of the new URL.
* @param host
* the host name or IP address of the new URL.
* @param port
* the specific port number of the URL. {@code -1} represents the
* default port of the protocol.
* @param file
* the name of the resource.
* @param handler
* the stream handler to be used by this URL.
* @throws MalformedURLException
* if the combination of all arguments do not represent a valid
* URL or the protocol is invalid.
* @throws SecurityException
* if {@code handler} is non-{@code null}, and a security
* manager is installed that disallows user-defined protocol
* handlers.
*/
public URL(String protocol, String host, int port, String file,
URLStreamHandler handler)
{// throws MalformedURLException {
if (port < -1)
{
throw new MalformedURLException("Port out of range: " + port); //$NON-NLS-1$
}
if (host != null && host.indexOf(":") != -1 && host.charAt(0) != '[')
{ //$NON-NLS-1$
host = "[" + host + "]"; //$NON-NLS-1$ //$NON-NLS-2$
}
if (protocol == null)
{
throw new java.lang.NullPointerException("Unknown protocol: " + "null"); //$NON-NLS-1$ //$NON-NLS-2$
}
this.protocol = protocol;
this.host = host;
this.port = port;
// Set the fields from the arguments. Handle the case where the
// passed in "file" includes both a file and a reference part.
int index = -1;
index = file.indexOf("#", file.lastIndexOf("/")); //$NON-NLS-1$ //$NON-NLS-2$
if (index >= 0)
{
this.file = file.substring(0, index);
refJ = file.substring(index + 1);
}
else
{
this.file = file;
}
fixURL(false);
// Set the stream handler for the URL either to the handler
// argument if it was specified, or to the default for the
// receiver's protocol if the handler was null.
if (handler == null)
{
setupStreamHandler();
if (strmHandler == null)
{
throw new MalformedURLException("Unknown protocol: " + protocol); //$NON-NLS-1$
}
}
else
{
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkPermission(specifyStreamHandlerPermission);
}
strmHandler = handler;
}
}
private static void checkSecurityPermission(SecurityPermission permission)
{
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkPermission(permission);
}
}
/**
* Invokes {@link SecurityManager#checkPermission(Permission)} with this
* permission as its argument. This method implements the {@link Guard}
* interface.
*
* @param obj
* as specified in {@link Guard#checkGuard(Object)} but ignored
* in this implementation.
* @throws SecurityException
* if this permission is not granted.
* @see Guard
* @see SecurityManager#checkPermission(Permission)
*/
public virtual void checkGuard(Object obj)
{//throws SecurityException {
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkPermission(this);
}
}
// check the RuntimePermission("preferences")
private static void checkSecurity()
{
java.lang.SecurityManager manager = java.lang.SystemJ.getSecurityManager();
if (null != manager)
{
manager.checkPermission(PREFS_PERM);
}
}
/*
* Method which checks to see if setting a logging stream is allowed by the
* Security manager
*/
private static void checkLogSecurity()
{
java.lang.SecurityManager securityManager = java.lang.SystemJ.getSecurityManager();
if (securityManager != null)
{
// Throws a SecurityException if setting the log is not permitted
securityManager.checkPermission(logPermission);
}
}
/**
* Sets the value of the specified security property.
* <p/>
* If a {@code SecurityManager} is installed, code calling this method needs
* the {@code SecurityPermission} {@code setProperty.KEY} (where KEY is the
* specified {@code key}) to be granted, otherwise a {@code
* SecurityException} will be thrown.
*
* @param key
* the name of the security property.
* @param datnum
* the value of the security property.
* @throws SecurityException
* if a {@code SecurityManager} is installed and the caller does
* not have permission to invoke this method.
*/
public static void setProperty(String key, String datnum)
{
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkSecurityAccess("setProperty." + key); //$NON-NLS-1$
}
secprops.put(key, datnum);
}
/**
* Returns the value of the security property named by the argument.
* <p/>
* If a {@code SecurityManager} is installed, code calling this method needs
* the {@code SecurityPermission} {@code getProperty.KEY} (where KEY is the
* specified {@code key}) to be granted, otherwise a {@code
* SecurityException} will be thrown.
*
* @param key
* the name of the requested security property.
* @return the value of the security property.
* @throws SecurityException
* if a {@code SecurityManager} is installed and the caller does
* not have permission to invoke this method.
*/
public static String getProperty(String key)
{
if (key == null)
{
throw new java.lang.NullPointerException("The key is null"); //$NON-NLS-1$
}
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkSecurityAccess("getProperty." + key); //$NON-NLS-1$
}
String property = secprops.getProperty(key);
if (property != null)
{
property = property.trim();
}
return(property);
}
/**
* Insert the given {@code Provider} at the specified {@code position}. The
* positions define the preference order in which providers are searched for
* requested algorithms.
* <p/>
* If a {@code SecurityManager} is installed, code calling this method needs
* the {@code SecurityPermission} {@code insertProvider.NAME} (where NAME is
* the provider name) to be granted, otherwise a {@code SecurityException}
* will be thrown.
*
* @param provider
* the provider to insert.
* @param position
* the position (starting from 1).
* @return the actual position or {@code -1} if the given {@code provider}
* was already in the list. The actual position may be different
* from the desired position.
* @throws SecurityException
* if a {@code SecurityManager} is installed and the caller does
* not have permission to invoke this method.
*/
public static int insertProviderAt(Provider provider,
int position)
{
lock (lockJ)
{
// check security access; check that provider is not already
// installed, else return -1; if (position <1) or (position > max
// position) position = max position + 1; insert provider, shift up
// one position for next providers; Note: The position is 1-based
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkSecurityAccess("insertProvider." + provider.getName()); //$NON-NLS-1$
}
if (getProvider(provider.getName()) != null)
{
return(-1);
}
int result = Services.insertProviderAt(provider, position);
renumProviders();
return(result);
}
}
/*
* Creates a new URL to the specified resource {@code spec}. This URL is
* relative to the given {@code context}. The {@code handler} will be used
* to parse the URL string representation. If this argument is {@code null}
* the default {@code URLStreamHandler} will be used. If the protocol of the
* parsed URL does not match with the protocol of the context URL, then the
* newly created URL is absolute and bases only on the given URL represented
* by {@code spec}. Otherwise the protocol is defined by the context URL.
*
* @param context
* the URL which is used as the context.
* @param spec
* the URL string representation which has to be parsed.
* @param handler
* the specific stream handler to be used by this URL.
* @throws MalformedURLException
* if the given string {@code spec} could not be parsed as a URL
* or an invalid protocol has been found.
*/
public URL(URL context, String spec, URLStreamHandler handler)
{//throws MalformedURLException {
if (handler != null)
{
java.lang.SecurityManager sm = java.lang.SystemJ.getSecurityManager();
if (sm != null)
{
sm.checkPermission(specifyStreamHandlerPermission);
}
strmHandler = handler;
}
if (spec == null)
{
throw new MalformedURLException();
}
spec = spec.trim();
// The spec includes a protocol if it includes a colon character
// before the first occurrence of a slash character. Note that,
// "protocol" is the field which holds this URLs protocol.
int index;
try
{
index = spec.indexOf(':');
}
catch (java.lang.NullPointerException e)
{
throw new MalformedURLException(e.toString());
}
int startIPv6Addr = spec.indexOf('[');
if (index >= 0)
{
if ((startIPv6Addr == -1) || (index < startIPv6Addr))
{
protocol = spec.substring(0, index);
// According to RFC 2396 scheme part should match
// the following expression:
// alpha *( alpha | digit | "+" | "-" | "." )
char c = protocol.charAt(0);
bool valid = ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
for (int i = 1; valid && (i < protocol.length()); i++)
{
c = protocol.charAt(i);
valid = ('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
('0' <= c && c <= '9') ||
(c == '+') ||
(c == '-') ||
(c == '.');
}
if (!valid)
{
protocol = null;
index = -1;
}
else
{
// Ignore case in protocol names.
// Scheme is defined by ASCII characters.
protocol = Util.toASCIILowerCase(protocol);
}
}
}
if (protocol != null)
{
// If the context was specified, and it had the same protocol
// as the spec, then fill in the receiver's slots from the values
// in the context but still allow them to be over-ridden later
// by the values in the spec.
if (context != null && protocol.equals(context.getProtocol()))
{
String cPath = context.getPath();
if (cPath != null && cPath.startsWith("/"))
{ //$NON-NLS-1$
set(protocol, context.getHost(), context.getPort(), context
.getAuthority(), context.getUserInfo(), cPath,
context.getQuery(), null);
}
if (strmHandler == null)
{
strmHandler = context.strmHandler;
}
}
}
else
{
// If the spec did not include a protocol, then the context
// *must* be specified. Fill in the receiver's slots from the
// values in the context, but still allow them to be over-ridden
// by the values in the ("relative") spec.
if (context == null)
{
throw new MalformedURLException("Protocol not found: " + spec); //$NON-NLS-1$
}
set(context.getProtocol(), context.getHost(), context.getPort(),
context.getAuthority(), context.getUserInfo(), context
.getPath(), context.getQuery(), null);
if (strmHandler == null)
{
strmHandler = context.strmHandler;
}
}
// If the stream handler has not been determined, set it
// to the default for the specified protocol.
if (strmHandler == null)
{
setupStreamHandler();
if (strmHandler == null)
{
throw new MalformedURLException("Unknown protocol: " + protocol); //$NON-NLS-1$
}
}
// Let the handler parse the URL. If the handler throws
// any exception, throw MalformedURLException instead.
//
// Note: We want "index" to be the index of the start of the scheme
// specific part of the URL. At this point, it will be either
// -1 or the index of the colon after the protocol, so we
// increment it to point at either character 0 or the character
// after the colon.
try
{
strmHandler.parseURL(this, spec, ++index, spec.length());
}
catch (Exception e)
{
throw new MalformedURLException(e.toString());
}
if (port < -1)
{
throw new MalformedURLException("Port out of range: " + port); //$NON-NLS-1$
}
}
internal void help_SetSecurityManager(java.lang.SecurityManager newSecurityManager)
{
java.lang.SystemJ.setSecurityManager(newSecurityManager);
}
