aboutsummaryrefslogtreecommitdiff
path: root/libjava/java/net
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/java/net')
-rw-r--r--libjava/java/net/JarURLConnection.java301
-rw-r--r--libjava/java/net/URLClassLoader.java221
2 files changed, 522 insertions, 0 deletions
diff --git a/libjava/java/net/JarURLConnection.java b/libjava/java/net/JarURLConnection.java
new file mode 100644
index 0000000..8eb4b7d
--- /dev/null
+++ b/libjava/java/net/JarURLConnection.java
@@ -0,0 +1,301 @@
+/* Copyright (C) 1999 Cygnus Solutions
+
+ This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
+details. */
+
+package java.net;
+
+import java.net.*;
+import java.io.*;
+import java.util.jar.*;
+import java.util.zip.*;
+import java.util.Vector;
+import java.util.Hashtable;
+
+/**
+ * @author Kresten Krab Thorup <krab@gnu.org>
+ * @date Aug 10, 1999.
+ */
+
+
+public abstract class JarURLConnection extends URLConnection
+{
+ // three different ways to say the same thing
+ private final URL jarFileURL;
+
+ /** The connection to the jar file itself. A JarURLConnection
+ * can represent an entry in a jar file or an entire jar file. In
+ * either case this describes just the jar file itself. */
+ protected URLConnection jarFileURLConnection;
+
+ // If this is a connection to a jar file element this is set, otherwose null.
+ private final String element;
+
+ // Cached JarURLConnection's
+ static Hashtable conn_cache = new Hashtable();
+
+ public URL getJarFileURL ()
+ {
+ return jarFileURL;
+ }
+
+ public String getEntryName ()
+ {
+ return element;
+ }
+
+ public JarURLConnection(URL url)
+ throws MalformedURLException
+ {
+ super(url);
+
+ String spec = url.getFile();
+ int bang = spec.indexOf ("!/", 0);
+ if (bang == -1)
+ throw new MalformedURLException (url + ": No `!/' in spec.");
+
+ // Extact the url for the jar itself.
+ jarFileURL = new URL(spec.substring (0, bang));
+
+ // Get the name of the element, if any.
+ element = (bang+2==spec.length() ? null : spec.substring (bang+2));
+ }
+
+ public synchronized void connect() throws IOException
+ {
+ // Call is ignored if already connected.
+ if (connected)
+ return;
+
+ if (getUseCaches())
+ {
+ jarFileURLConnection = (URLConnection) conn_cache.get (jarFileURL);
+
+ if (jarFileURLConnection == null)
+ {
+ jarFileURLConnection = jarFileURL.openConnection ();
+ jarFileURLConnection.setUseCaches (true);
+ jarFileURLConnection.connect ();
+ conn_cache.put (jarFileURL, jarFileURLConnection);
+ }
+ }
+ else
+ {
+ jarFileURLConnection = jarFileURL.openConnection ();
+ jarFileURLConnection.connect ();
+ }
+
+ connected = true;
+ }
+
+ public InputStream getInputStream() throws IOException
+ {
+ if (!connected)
+ connect();
+
+ if (! doInput)
+ throw new ProtocolException("Can't open InputStream if doInput is false");
+
+ if (element == null)
+ {
+ // This is a JarURLConnection for the entire jar file.
+
+ InputStream jar_is = new BufferedInputStream(jarFileURLConnection.getInputStream ());
+ return new JarInputStream(jar_is);
+ }
+
+ // Reaching this point, we're looking for an element of a jar file.
+
+ JarFile jarfile = null;
+
+ try
+ {
+ jarfile = getJarFile ();
+ }
+ catch (java.io.IOException x)
+ {
+ /* ignore */
+ }
+
+ if (jarfile != null)
+ {
+ // this is the easy way...
+ return jarfile.getInputStream (jarfile.getEntry (element));
+ }
+ else
+ {
+ // If the jar file is not local, ...
+ JarInputStream zis = new JarInputStream(jarFileURLConnection.getInputStream ());
+
+ // This is hideous, we're doing a linear search...
+ for (ZipEntry ent = zis.getNextEntry ();
+ ent != null;
+ ent = zis.getNextEntry ())
+ {
+ if (element.equals (ent.getName ()))
+ {
+ int size = (int)ent.getSize();
+ byte[] data = new byte[size];
+ zis.read (data, 0, size);
+ return new ByteArrayInputStream (data);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public JarEntry getJarEntry (String name)
+ throws java.io.IOException
+ {
+ JarFile jarfile = null;
+
+ if (! doInput)
+ throw new ProtocolException("Can't open JarEntry if doInput is false");
+
+ try
+ {
+ jarfile = getJarFile ();
+ }
+ catch (java.io.IOException x)
+ {
+ /* ignore */
+ }
+
+ if (jarfile == null)
+ {
+ JarInputStream zis = new JarInputStream(jarFileURLConnection.getInputStream ());
+
+ // This is hideous, we're doing a linear search for the thing...
+ for (ZipEntry ent = zis.getNextEntry ();
+ ent != null;
+ ent = zis.getNextEntry ())
+ {
+ if (element.equals (ent.getName ()))
+ {
+ return new JarEntry (ent);
+ }
+ }
+ }
+
+ else
+ {
+ return jarfile.getJarEntry (element);
+ }
+
+ return null;
+ }
+
+ public abstract JarFile getJarFile() throws java.io.IOException;
+
+
+ // Steal and borrow from protocol/file/Connection.java
+
+ private Hashtable hdrHash = new Hashtable();
+ private Vector hdrVec = new Vector();
+ private boolean gotHeaders = false;
+
+ // Override default method in URLConnection.
+ public String getHeaderField(String name)
+ {
+ try
+ {
+ getHeaders();
+ }
+ catch (IOException x)
+ {
+ return null;
+ }
+ return (String) hdrHash.get(name.toLowerCase());
+ }
+
+ // Override default method in URLConnection.
+ public String getHeaderField(int n)
+ {
+ try
+ {
+ getHeaders();
+ }
+ catch (IOException x)
+ {
+ return null;
+ }
+ if (n < hdrVec.size())
+ return getField((String) hdrVec.elementAt(n));
+
+ return null;
+ }
+
+ // Override default method in URLConnection.
+ public String getHeaderFieldKey(int n)
+ {
+ try
+ {
+ getHeaders();
+ }
+ catch (IOException x)
+ {
+ return null;
+ }
+ if (n < hdrVec.size())
+ return getKey((String) hdrVec.elementAt(n));
+
+ return null;
+ }
+
+ private String getKey(String str)
+ {
+ if (str == null)
+ return null;
+ int index = str.indexOf(':');
+ if (index >= 0)
+ return str.substring(0, index);
+ else
+ return null;
+ }
+
+ private String getField(String str)
+ {
+ if (str == null)
+ return null;
+ int index = str.indexOf(':');
+ if (index >= 0)
+ return str.substring(index + 1).trim();
+ else
+ return str;
+ }
+
+ private void getHeaders() throws IOException
+ {
+ if (gotHeaders)
+ return;
+ gotHeaders = true;
+
+ connect();
+
+ // Yes, it is overkill to use the hash table and vector here since
+ // we're only putting one header in the file, but in case we need
+ // to add others later and for consistency, we'll implement it this way.
+
+ // Add the only header we know about right now: Content-length.
+ long len;
+
+ if (element == null)
+ len = jarFileURLConnection.getContentLength ();
+ else
+ len = getJarEntry (element).getSize ();
+
+ String line = "Content-length: " + len;
+ hdrVec.addElement(line);
+
+ // The key will never be null in this scenario since we build up the
+ // headers ourselves. If we ever rely on getting a header from somewhere
+ // else, then we may have to check if the result of getKey() is null.
+ String key = getKey(line);
+ hdrHash.put(key.toLowerCase(), Long.toString(len));
+ }
+
+}
diff --git a/libjava/java/net/URLClassLoader.java b/libjava/java/net/URLClassLoader.java
new file mode 100644
index 0000000..df34306
--- /dev/null
+++ b/libjava/java/net/URLClassLoader.java
@@ -0,0 +1,221 @@
+/* Copyright (C) 1999 Cygnus Solutions
+
+ This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
+details. */
+
+package java.net;
+
+import java.io.*;
+import java.util.jar.*;
+import java.util.Vector;
+
+public class URLClassLoader extends ClassLoader
+{
+ // The URLStreamHandlerFactory
+ URLStreamHandlerFactory factory = null;
+
+ // `path' contains simply the URL's we're using for the searching.
+ private Vector path;
+
+ // If path[n] is a zip/jar, then this holds a JarURLConnection for that thing,
+ // otherwise, path[n] is null.
+ private Vector info;
+
+ private URLStreamHandler getHandler0 (String protocol)
+ {
+ if (factory != null)
+ return factory.createURLStreamHandler(protocol);
+ else
+ return null;
+ }
+
+ public URLClassLoader (URL[] urls)
+ {
+ this (urls, null, null);
+ }
+
+ public URLClassLoader (URL[] urls, ClassLoader parent)
+ {
+ this (urls, parent, null);
+ }
+
+ public URLClassLoader (URL[] urls, ClassLoader parent,
+ URLStreamHandlerFactory fac)
+ {
+ super (parent);
+
+ factory = fac;
+
+ if (urls == null || urls.length == 0)
+ {
+ path = new Vector (1);
+ info = new Vector (1);
+ return;
+ }
+
+ path = new Vector (urls.length);
+ info = new Vector (urls.length);
+
+ for (int i = 0; i < urls.length; i++)
+ {
+ URL u = urls[i];
+
+ // If it is a jar url, then we'll search it as is.
+ if (! u.getProtocol ().equals ("jar"))
+ {
+ String f = u.getFile ();
+
+ // If it ends with '/' we'll take it for a directory,
+ // otherwise it's a jar file. This is how JDK 1.2 defines
+ // it, so we will not try to be smart here.
+ if (f.charAt (f.length ()-1) != '/')
+ {
+ try
+ {
+ u = new URL ("jar", "", -1, (u.toExternalForm ())+"!/",
+ getHandler0 ("jar"));
+ }
+ catch (MalformedURLException x)
+ {
+ /* ignore */
+ }
+ }
+ }
+
+ path.insertElementAt (u, i);
+
+ if (u.getProtocol ().equals ("jar"))
+ {
+ JarURLConnection conn = null;
+ try
+ {
+ conn = (JarURLConnection) u.openConnection ();
+ }
+ catch (java.io.IOException x)
+ {
+ /* ignore */
+ }
+ info.insertElementAt (conn, i);
+ }
+ else
+ {
+ info.insertElementAt (null, i);
+ }
+ }
+ }
+
+ public URL getResource (String name)
+ {
+ for (int i = 0; i < path.size(); i++)
+ {
+ URL u = (URL)path.elementAt (i);
+
+ try {
+ JarURLConnection conn = (JarURLConnection) info.elementAt (i);
+
+ if (conn != null)
+ {
+ if (conn.getJarEntry (name) != null)
+ return new URL(u, name, getHandler0 (u.getProtocol()));
+ }
+ else
+ {
+ URL p = new URL (u, name, getHandler0 (u.getProtocol()));
+
+ InputStream is = p.openStream();
+ if (is != null)
+ {
+ is.close();
+ return p;
+ }
+ }
+
+ // if we get an exception ... try the next path element
+ } catch (IOException x) {
+ continue;
+ }
+ }
+
+ return null;
+ }
+
+ /** IN jdk 1.2 this method is not overridden, but we gain performance
+ by doing so.
+ */
+
+ public InputStream getResourceAsStream (String name)
+ {
+ for (int i = 0; i < path.size(); i++)
+ {
+ URL u = (URL)path.elementAt (i);
+
+ try {
+ JarURLConnection conn = (JarURLConnection) info.elementAt (i);
+
+ if (conn != null)
+ {
+ JarFile file = conn.getJarFile ();
+ JarEntry ent = file.getJarEntry (name);
+ if (ent != null)
+ return file.getInputStream(ent);
+ }
+ else
+ {
+ InputStream is = new URL(u, name, getHandler0 (u.getProtocol())).openStream();
+ if (is != null)
+ return is;
+ }
+
+ // if we get an exception ... try the next path element
+ } catch (IOException x) {
+ continue;
+ }
+ }
+
+ return null;
+ }
+
+ // and finally, we can implement our class loader functionality.
+ protected Class findClass (String name)
+ throws ClassNotFoundException
+ {
+ if (name == null)
+ throw new ClassNotFoundException ("null");
+
+ try
+ {
+ InputStream is = getResourceAsStream (name.replace ('.', '/') + ".class");
+
+ if (is == null)
+ throw new ClassNotFoundException (name);
+
+ // Here we have to rely on available() to provide the length of
+ // the class; which might not be exactly right in some cases...
+
+ int len = is.available ();
+ byte[] data = new byte[len];
+
+ int left = len;
+ int off = 0;
+ while (left > 0)
+ {
+ int c = is.read (data, off, len-off);
+ if (c == -1 || c == 0)
+ throw new InternalError ("premature end of file");
+ left -= c;
+ off += c;
+ }
+
+ return defineClass (name, data, 0, len);
+ }
+ catch (java.io.IOException x)
+ {
+ throw new ClassNotFoundException(name);
+ }
+ }
+
+}
+
generated by cgit v1.1 at 2025-04-08 20:10:51 +0000