/*
* 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);
}
}
/*
* 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$
}
}
