2003-12-20 Michael Koch <konqueror@gmx.de>

	* gnu/java/net/protocol/jar/Connection.java
	(connectionCache): New field.
	(connect): New method.
	(getInputStream): New method.
	(hdrHash): New field.
	(hdrVec): New field.
	(gotHeaders): New field.
	(getHeaderField): New method.
	(getHeaderFields): New method.
	(getHeaderFieldKey): New method.
	(getKey): New method.
	(getField): New method.
	(getHeaders): New method.
	* java/net/JarURLConnection.java
	(connectionCache): Removed.
	(connect): Removed.
	(getInputStream): Removed.
	(hdrHash): Removed.
	(hdrVec): Removed.
	(gotHeaders): Removed.
	(getHeaderField): Removed.
	(getHeaderFields): Removed.
	(getHeaderFieldKey): Removed.
	(getKey): Removed.
	(getField): Removed.
	(getHeaders): Removed.

From-SVN: r74895

1 files changed, 229 insertions, 0 deletions

diff --git a/libjava/gnu/java/net/protocol/jar/Connection.java b/libjava/gnu/java/net/protocol/jar/Connection.java
index 573f7f1..af4903d 100644
--- a/libjava/gnu/java/net/protocol/jar/Connection.java
+++ b/libjava/gnu/java/net/protocol/jar/Connection.java
@@ -38,6 +38,8 @@ exception statement from your version. */
 
 package gnu.java.net.protocol.jar;
 
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.InputStream;
@@ -47,9 +49,15 @@ import java.net.MalformedURLException;
 import java.net.ProtocolException;
 import java.net.URL;
 import java.net.URLConnection;
+import java.util.Map;
+import java.util.Vector;
+import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.jar.JarFile;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
 import java.util.zip.ZipFile;
+import java.util.zip.ZipEntry;
 
 /**
  * This subclass of java.net.JarURLConnection models a URLConnection via
@@ -62,12 +70,109 @@ public final class Connection extends JarURLConnection
   private static Hashtable file_cache = new Hashtable();
   private JarFile jar_file;
 
+  /**
+   * Cached JarURLConnection objects .
+   */
+  static HashMap connectionCache = new HashMap();
+
   protected Connection(URL url)
     throws MalformedURLException
   {
     super(url);
   }
 
+  public synchronized void connect() throws IOException
+  {
+    // Call is ignored if already connected.
+    if (connected)
+      return;
+
+    if (getUseCaches())
+      {
+	jarFileURLConnection =
+          (URLConnection) connectionCache.get(getJarFileURL());
+
+	if (jarFileURLConnection == null)
+	  {
+	    jarFileURLConnection = getJarFileURL().openConnection();
+	    jarFileURLConnection.setUseCaches(true);
+	    jarFileURLConnection.connect();
+	    connectionCache.put(getJarFileURL(), jarFileURLConnection);
+	  }
+      }
+    else
+      {
+	jarFileURLConnection = getJarFileURL().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 (getEntryName() == null)
+      {
+	// This is a JarURLConnection for the entire jar file.  
+
+	InputStream in = new BufferedInputStream
+	  (jarFileURLConnection.getInputStream());
+	return new JarInputStream(in);
+      }
+
+    // Reaching this point, we're looking for an entry of a jar file.
+
+    JarFile jarfile = null;
+
+    try
+      {
+	jarfile = getJarFile ();
+      }
+    catch (IOException x)
+      {
+	/* ignore */
+      }
+    
+    if (jarfile != null)
+      {
+	// this is the easy way...
+	ZipEntry entry = jarfile.getEntry(getEntryName());
+        
+	if (entry != null)
+	  return jarfile.getInputStream (entry);
+	else
+	  return null;
+      }
+    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 entry = zis.getNextEntry(); 
+	     entry != null; 
+	     entry = zis.getNextEntry())
+	  {
+	    if (getEntryName().equals(entry.getName()))
+	      {
+		int size = (int) entry.getSize();
+		byte[] data = new byte[size];
+		zis.read (data, 0, size);
+		return new ByteArrayInputStream (data);
+	      }
+	  }
+      }
+
+    return null;
+  }
+
   public synchronized JarFile getJarFile() throws IOException
   {
     if (!connected)
@@ -116,4 +221,128 @@ public final class Connection extends JarURLConnection
     return jar_file;
   }
 
+  // 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 Map getHeaderFields()
+  {
+    try
+      {
+        getHeaders();
+      }
+    catch (IOException x)
+      {
+        return null;
+      }
+    return hdrHash;
+  }
+
+  // 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 = -1;
+
+    if (getEntryName() == null)
+      if (jarFileURLConnection != null)
+	len = jarFileURLConnection.getContentLength ();
+    else
+      {
+	JarEntry entry = getJarEntry();
+	if (entry != null)
+	  len = entry.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));
+  }
 }