Connection.java, [...]: Moved to gnu/java/net/protocol.

2003-10-08  Michael Koch  <konqueror@gmx.de>

	* gnu/gcj/protocol/core/Connection.java,
	gnu/gcj/protocol/core/CoreInputStream.java,
	gnu/gcj/protocol/core/Handler.java,
	gnu/gcj/protocol/core/natCoreInputStream.cc,
	gnu/gcj/protocol/file/Connection.java,
	gnu/gcj/protocol/file/Handler.java,
	gnu/gcj/protocol/gcjlib/Connection.java,
	gnu/gcj/protocol/gcjlib/Handler.java,
	gnu/gcj/protocol/http/Connection.java,
	gnu/gcj/protocol/http/Handler.java,
	gnu/gcj/protocol/jar/Connection.java,
	gnu/gcj/protocol/jar/Handler.java: Moved to gnu/java/net/protocol.
	* gnu/java/net/protocol/core/Connection.java,
	gnu/java/net/protocol/core/CoreInputStream.java,
	gnu/java/net/protocol/core/Handler.java,
	gnu/java/net/protocol/core/natCoreInputStream.cc,
	gnu/java/net/protocol/file/Connection.java,
	gnu/java/net/protocol/file/Handler.java,
	gnu/java/net/protocol/gcjlib/Connection.java,
	gnu/java/net/protocol/gcjlib/Handler.java,
	gnu/java/net/protocol/http/Connection.java,
	gnu/java/net/protocol/http/Handler.java,
	gnu/java/net/protocol/jar/Connection.java,
	gnu/java/net/protocol/jar/Handler.java: Moved from gnu/gcj/protocol.
	* gnu/gcj/runtime/FirstThread.java,
	java/net/URL.java: Use moved protocol handlers.
	* Makefile.am
	(ordinary_java_source_files): Moved files.
	(nat_source_files): Likewise.
	* Makefile.in: Regenerated.

From-SVN: r72233

12 files changed, 1189 insertions, 0 deletions

diff --git a/libjava/gnu/java/net/protocol/core/Connection.java b/libjava/gnu/java/net/protocol/core/Connection.java
new file mode 100644
index 0000000..2319c0b
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/core/Connection.java
@@ -0,0 +1,172 @@
+// Connection.java - Implementation of URLConnection for core protocol.
+
+/* Copyright (C) 2001, 2003  Free Software Foundation
+
+   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 gnu.java.net.protocol.core;
+
+import gnu.gcj.Core;
+import java.io.InputStream;
+import java.io.IOException;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Map;
+import java.util.Vector;
+import java.util.Hashtable;
+import java.util.Enumeration;
+
+/**
+ * @author Anthony Green <green@redhat.com>
+ * @date August 13, 2001
+ */
+
+class Connection extends URLConnection
+{
+  private Hashtable hdrHash = new Hashtable();
+  private Vector hdrVec = new Vector();
+  private boolean gotHeaders = false;
+
+  private Core core;
+
+  public Connection (URL url)
+  {
+    super(url);
+  }
+
+  // Implementation of abstract method.
+  public void connect() throws IOException
+  {
+    // Call is ignored if already connected.
+    if (connected)
+      return;
+
+    // If not connected, then file needs to be opened.
+    core = Core.create (url.getFile());
+    connected = true;
+  }
+
+  public InputStream getInputStream() throws IOException
+  {
+    if (!connected)
+      connect();
+
+    if (! doInput)
+      throw new ProtocolException("Can't open InputStream if doInput is false");
+    return new CoreInputStream (core);
+  }
+
+  // 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 = core.length;
+    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/gnu/java/net/protocol/core/CoreInputStream.java b/libjava/gnu/java/net/protocol/core/CoreInputStream.java
new file mode 100644
index 0000000..421bb1c
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/core/CoreInputStream.java
@@ -0,0 +1,90 @@
+// Handler.java - URLStreamHandler for core protocol.
+
+/* Copyright (C) 2001  Free Software Foundation
+
+   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 gnu.java.net.protocol.core;
+
+import gnu.gcj.Core;
+import gnu.gcj.RawData;
+import java.io.InputStream;
+import java.io.IOException;
+
+public class CoreInputStream extends InputStream
+{
+  /* A pointer to the object in memory.  */
+  protected RawData ptr;
+
+  /* Position of the next byte in core to be read. */
+  protected int pos;
+
+  /* The currently marked position in the stream. */
+  protected int mark;
+
+  /* The index in core one greater than the last valid character. */
+  protected int count;
+
+  private native int unsafeGetByte (long offset);
+  private native int copyIntoByteArray (byte[] dest, int offset, int numBytes);
+
+  public CoreInputStream (Core core)
+  {
+    ptr = core.ptr;
+    count = core.length;
+  }
+
+  public synchronized int available()
+  {
+    return count - pos;
+  }
+
+  public synchronized void mark(int readAheadLimit)
+  {
+    // readAheadLimit is ignored per Java Class Lib. book, p.220.
+    mark = pos;
+  }
+
+  public boolean markSupported()
+  {
+    return true;
+  }
+
+  public synchronized int read()
+  {
+    if (pos < count)
+      return ((int) unsafeGetByte(pos++)) & 0xFF;
+    return -1;
+  }
+
+  public synchronized int read(byte[] b, int off, int len)
+  {
+    if (pos >= count)
+      return -1;
+
+    int numBytes = Math.min(count - pos, len);
+    copyIntoByteArray (b, off, numBytes);
+    pos += numBytes;
+    return numBytes;
+  }
+
+  public synchronized void reset()
+  {
+    pos = mark;
+  }
+
+  public synchronized long skip(long n)
+  {
+    // Even though the var numBytes is a long, in reality it can never
+    // be larger than an int since the result of subtracting 2 positive
+    // ints will always fit in an int.  Since we have to return a long
+    // anyway, numBytes might as well just be a long.
+    long numBytes = Math.min ((long) (count - pos), n < 0 ? 0L : n);
+    pos += numBytes;
+    return numBytes;
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/core/Handler.java b/libjava/gnu/java/net/protocol/core/Handler.java
new file mode 100644
index 0000000..8726172
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/core/Handler.java
@@ -0,0 +1,28 @@
+// Handler.java - URLStreamHandler for core protocol.
+
+/* Copyright (C) 2001  Free Software Foundation
+
+   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 gnu.java.net.protocol.core;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+
+/**
+ * @author Anthony Green <green@redhat.com>
+ * @date August 13, 2001.
+ */
+public class Handler extends URLStreamHandler
+{
+  protected URLConnection openConnection(URL url) throws IOException
+  {
+    return new Connection(url);
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/core/natCoreInputStream.cc b/libjava/gnu/java/net/protocol/core/natCoreInputStream.cc
new file mode 100644
index 0000000..4053efc
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/core/natCoreInputStream.cc
@@ -0,0 +1,51 @@
+// natCoreInputStream.cc -- C++ side of CoreInputStream
+
+/* Copyright (C) 2001  Free Software Foundation
+
+   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.  */
+
+/* Author: Anthony Green <green@redhat.com>.  */
+
+#include <config.h>
+
+#include <gcj/cni.h>
+#include <jvm.h>
+#include <string.h>
+
+#include <java/lang/NullPointerException.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
+#include <gnu/java/net/protocol/core/CoreInputStream.h>
+
+jint
+gnu::java::net::protocol::core::CoreInputStream::unsafeGetByte (jlong offset)
+{
+  return ((char*) ptr) [offset];
+}
+
+jint
+gnu::java::net::protocol::core::CoreInputStream::copyIntoByteArray (jbyteArray dest,
+							            jint offset,
+							            jint numBytes)
+{
+  if (!dest)
+    throw new ::java::lang::NullPointerException;
+  
+  jsize destSize = JvGetArrayLength (dest);
+  
+  if (offset < 0 || numBytes < 0 || offset + numBytes < 0
+      || offset + numBytes > destSize
+      || pos + numBytes > count)
+    throw new ::java::lang::ArrayIndexOutOfBoundsException;
+
+  void *pcore = (void *) &((char*) ptr) [pos];
+  void *pdest = (void *) (elements (dest) + offset);
+
+  memcpy (pdest, pcore, numBytes);
+
+  return 0;
+}
+
diff --git a/libjava/gnu/java/net/protocol/file/Connection.java b/libjava/gnu/java/net/protocol/file/Connection.java
new file mode 100644
index 0000000..3bddd0f
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/file/Connection.java
@@ -0,0 +1,201 @@
+// Connection.java - Implementation of URLConnection for file protocol.
+
+/* Copyright (C) 1999  Free Software Foundation
+
+   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 gnu.java.net.protocol.file;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Map;
+import java.util.Vector;
+import java.util.Hashtable;
+import java.util.Enumeration;
+
+/**
+ * @author Warren Levy <warrenl@cygnus.com>
+ * @date April 13, 1999.
+ */
+
+/**
+ * Written using on-line Java Platform 1.2 API Specification, as well
+ * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
+ * Status:  Minimal subset of functionality.
+ */
+
+class Connection extends URLConnection
+{
+  private Hashtable hdrHash = new Hashtable();
+  private Vector hdrVec = new Vector();
+  private boolean gotHeaders = false;
+  private File fileIn;
+  private InputStream inputStream;
+  private OutputStream outputStream;
+
+  public Connection(URL url)
+  {
+    super(url);
+  }
+
+  // Implementation of abstract method.
+  public void connect() throws IOException
+  {
+    // Call is ignored if already connected.
+    if (connected)
+      return;
+
+    // If not connected, then file needs to be openned.
+    String fname = url.getFile();
+    fileIn = new File(fname);
+    if (doInput)
+      inputStream = new BufferedInputStream(new FileInputStream(fileIn));
+    if (doOutput)
+      outputStream = new BufferedOutputStream(new FileOutputStream(fileIn));
+    connected = true;
+  }
+
+  public InputStream getInputStream() throws IOException
+  {
+    if (! doInput)
+      throw new ProtocolException("Can't open InputStream if doInput is false");
+    if (!connected)
+      connect();
+
+    return inputStream;
+  }
+
+  // Override default method in URLConnection.
+  public OutputStream getOutputStream() throws IOException
+  {
+    if (! doOutput)
+      throw new
+	ProtocolException("Can't open OutputStream if doOutput is false");
+
+    if (!connected)
+      connect();
+
+    return outputStream;
+  }
+
+  // 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 = fileIn.length();
+    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/gnu/java/net/protocol/file/Handler.java b/libjava/gnu/java/net/protocol/file/Handler.java
new file mode 100644
index 0000000..f85db44
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/file/Handler.java
@@ -0,0 +1,53 @@
+// Handler.java - URLStreamHandler for file protocol.
+
+/* Copyright (C) 1999, 2000  Free Software Foundation
+
+   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 gnu.java.net.protocol.file;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+
+/**
+ * @author Warren Levy <warrenl@cygnus.com>
+ * @date April 13, 1999.
+ */
+
+/**
+ * Written using on-line Java Platform 1.2 API Specification, as well
+ * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
+ * Status:  Minimal functionality.
+ */
+
+public class Handler extends URLStreamHandler
+{
+  protected URLConnection openConnection(URL url) throws IOException
+  {
+    // If a hostname is set, then we need to switch protocols to ftp
+    // in order to transfer this from the remote host.
+    String host = url.getHost();
+    if ((host != null) && (! host.equals("")))
+      {
+        throw new IOException("ftp protocol handler not yet implemented.");
+        /*
+	// Reset the protocol (and implicitly the handler) for this URL.
+	// Then have the URL attempt the connection again, as it will
+	// get the changed handler the next time around.
+	setURL (url, "ftp", url.getHost(), url.getPort(), url.getFile(),
+		url.getRef());
+	// Until the ftp protocol handler is written, this will cause
+	// a NullPointerException.
+	return url.openConnection();
+	*/
+      }
+
+    return new Connection(url);
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/gcjlib/Connection.java b/libjava/gnu/java/net/protocol/gcjlib/Connection.java
new file mode 100644
index 0000000..b31db56
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/gcjlib/Connection.java
@@ -0,0 +1,64 @@
+// Connection.java - Implementation of URLConnection for gcjlib
+// protocol.
+
+/* Copyright (C) 2003  Free Software Foundation
+
+   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 gnu.java.net.protocol.gcjlib;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import gnu.gcj.Core;
+import gnu.gcj.runtime.SharedLibHelper;
+import gnu.java.net.protocol.core.CoreInputStream;
+
+/**
+ * @author Tom Tromey <tromey@redhat.com>
+ * @date January 10, 2003
+ */
+class Connection extends URLConnection
+{
+  String solib;
+  String name;
+  Core core;
+
+  public Connection (URL url) throws MalformedURLException
+  {
+    super (url);
+    int index = url.getFile().indexOf ("!/");
+    
+    if (index == -1)
+      throw new MalformedURLException ("couldn't find !/ in gcjlib URL");
+
+    name = url.getFile().substring (index + 2);
+    solib = url.getFile().substring (0, index);
+  }
+
+  public void connect() throws IOException
+  {
+    if (core != null)
+      return;
+    // We can't create a new SharedLibHelper here, since we don't know
+    // what parent class loader to use.
+    SharedLibHelper helper = SharedLibHelper.findHelper(solib);
+    if (helper == null)
+      throw new IOException("library not loaded: " + solib);
+    core = helper.findCore(name);
+    if (core == null)
+      throw new IOException("couldn't find core object: " + name);
+  }
+
+  public InputStream getInputStream() throws IOException
+  {
+    connect();
+    return new CoreInputStream(core);
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/gcjlib/Handler.java b/libjava/gnu/java/net/protocol/gcjlib/Handler.java
new file mode 100644
index 0000000..60f5bcc
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/gcjlib/Handler.java
@@ -0,0 +1,24 @@
+// Handler.java - URLStreamHandler for gcjlib protocol.
+
+/* Copyright (C) 2003  Free Software Foundation
+
+   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 gnu.java.net.protocol.gcjlib;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+
+public class Handler extends URLStreamHandler
+{
+  protected URLConnection openConnection (URL url) throws IOException
+  {
+    return new Connection (url);
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/http/Connection.java b/libjava/gnu/java/net/protocol/http/Connection.java
new file mode 100644
index 0000000..990287d
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/http/Connection.java
@@ -0,0 +1,348 @@
+// Connection.java - Implementation of HttpURLConnection for http protocol.
+
+/* Copyright (C) 1999, 2000, 2003  Free Software Foundation
+
+   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 gnu.java.net.protocol.http;
+
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.net.HttpURLConnection;
+import java.net.InetAddress;
+import java.net.ProtocolException;
+import java.net.Socket;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Map;
+import java.util.Vector;
+import java.util.Hashtable;
+import java.util.Enumeration;
+
+/**
+ * Written using on-line Java Platform 1.2 API Specification, as well
+ * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
+ * Status: Minimal subset of functionality.  Proxies only partially
+ * handled; Redirects not yet handled.  FileNameMap handling needs to
+ * be considered.  useCaches, ifModifiedSince, and
+ * allowUserInteraction need consideration as well as doInput and
+ * doOutput.
+ */
+
+/**
+ * @author Warren Levy <warrenl@cygnus.com>
+ * @date March 29, 1999.
+ */
+class Connection extends HttpURLConnection
+{
+  protected Socket sock = null;
+  private static Hashtable defRequestProperties = new Hashtable();
+  private Hashtable requestProperties;
+  private Hashtable hdrHash = new Hashtable();
+  private Vector hdrVec = new Vector();
+  private BufferedInputStream bufferedIn;
+
+  private static int proxyPort = 80;
+  private static boolean proxyInUse = false;
+  private static String proxyHost = null;
+
+  static 
+  {
+    // Recognize some networking properties listed at
+    // http://java.sun.com/j2se/1.4/docs/guide/net/properties.html.
+    String port = null;
+    proxyHost = System.getProperty("http.proxyHost");
+    if (proxyHost != null)
+      {
+	proxyInUse = true;
+	if ((port = System.getProperty("http.proxyPort")) != null)
+	  {
+	    try
+	      {
+		proxyPort = Integer.parseInt(port);
+	      }
+	    catch (Throwable t)
+	      {
+		// Nothing.  
+	      }
+	  }
+      }
+  }
+
+  public Connection(URL url)
+  {
+    super(url);
+    requestProperties = (Hashtable) defRequestProperties.clone();
+  }
+
+  // Override method in URLConnection.
+  public static void setDefaultRequestProperty(String key, String value)
+  {
+    defRequestProperties.put(key, value);
+  }
+
+  // Override method in URLConnection.
+  public static String getDefaultRequestProperty(String key)
+  {
+    return (String) defRequestProperties.get(key);
+  }
+
+  // Override method in URLConnection.
+  public void setRequestProperty(String key, String value)
+  {
+    if (connected)
+      throw new IllegalAccessError("Connection already established.");
+
+    requestProperties.put(key, value);
+  }
+
+  // Override method in URLConnection.
+  public String getRequestProperty(String key)
+  {
+    if (connected)
+      throw new IllegalAccessError("Connection already established.");
+
+    return (String) requestProperties.get(key);
+  }
+
+  // Implementation of abstract method.
+  public void connect() throws IOException
+  {
+    // Call is ignored if already connected.
+    if (connected)
+      return;
+
+    // Get address and port number.
+    int port;
+    if (proxyInUse)
+      {
+	port = proxyPort;
+	sock = new Socket(proxyHost, port);
+      }
+    else
+      {
+	InetAddress destAddr = InetAddress.getByName(url.getHost());
+	if ((port = url.getPort()) == -1)
+	  port = 80;
+	// Open socket and output stream.
+	sock = new Socket(destAddr, port);
+      }
+
+    PrintWriter out = new PrintWriter(sock.getOutputStream());
+
+    // Send request including any request properties that were set.
+    out.print(getRequestMethod() + " " + url.getFile() + " HTTP/1.0\n");
+    out.print("Host: " + url.getHost() + ":" + port + "\n");
+    Enumeration reqKeys = requestProperties.keys();
+    Enumeration reqVals = requestProperties.elements();
+    while (reqKeys.hasMoreElements())
+      out.print(reqKeys.nextElement() + ": " + reqVals.nextElement() + "\n");
+    out.print("\n");
+    out.flush();    
+    getHttpHeaders();
+    connected = true;
+  }
+
+  // Implementation of abstract method.
+  public void disconnect()
+  {
+    if (sock != null)
+      {
+	try
+	  {
+	    sock.close();
+	  }
+	catch (IOException ex)
+	  {
+	    ; // Ignore errors in closing socket.
+	  }
+	sock = null;
+      }
+  }
+
+  public boolean usingProxy()
+  {
+    return proxyInUse;
+  }
+
+  // Override default method in URLConnection.
+  public InputStream getInputStream() throws IOException
+  {
+    if (!connected)
+      connect();
+
+    if (!doInput)
+      throw new ProtocolException("Can't open InputStream if doInput is false");
+    return bufferedIn;
+  }
+
+  // Override default method in URLConnection.
+  public OutputStream getOutputStream() throws IOException
+  {
+    if (!connected)
+      connect();
+
+    if (! doOutput)
+      throw new
+	ProtocolException("Can't open OutputStream if doOutput is false");
+    return sock.getOutputStream();
+  }
+
+  // Override default method in URLConnection.
+  public String getHeaderField(String name)
+  {
+    if (!connected)
+      try
+        {
+	  connect();
+	}
+      catch (IOException x)
+        {
+	  return null;
+	}
+
+    return (String) hdrHash.get(name.toLowerCase());
+  }
+
+  // Override default method in URLConnection.
+  public Map getHeaderFields()
+  {
+    if (!connected)
+      try
+        {
+	  connect();
+	}
+      catch (IOException x)
+        {
+	  return null;
+	}
+
+    return hdrHash;
+  }
+
+  // Override default method in URLConnection.
+  public String getHeaderField(int n)
+  {
+    if (!connected)
+      try
+        {
+	  connect();
+	}
+      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)
+  {
+    if (!connected)
+      try
+        {
+	  connect();
+	}
+      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 getHttpHeaders() throws IOException
+  {
+    // Originally tried using a BufferedReader here to take advantage of
+    // the readLine method and avoid the following, but the buffer read
+    // past the end of the headers so the first part of the content was lost.
+    // It is probably more robust than it needs to be, e.g. the byte[]
+    // is unlikely to overflow and a '\r' should always be followed by a '\n',
+    // but it is better to be safe just in case.
+    bufferedIn = new BufferedInputStream(sock.getInputStream());
+
+    int buflen = 100;
+    byte[] buf = new byte[buflen];
+    String line = "";
+    boolean gotnl = false;
+    byte[] ch = new byte[1];
+    ch[0] = (byte) '\n';
+
+    while (true)
+      {
+	// Check for leftover byte from non-'\n' after a '\r'.
+	if (ch[0] != '\n')
+	  line = line + '\r' + new String(ch, 0, 1);
+
+	int i;
+	// FIXME: This is rather inefficient.
+	for (i = 0; i < buflen; i++)
+	  {
+	    buf[i] = (byte) bufferedIn.read();
+	    if (buf[i] == -1)
+	      throw new IOException("Malformed HTTP header");
+	    if (buf[i] == '\r')
+	      {
+	        bufferedIn.read(ch, 0, 1);
+		if (ch[0] == '\n')
+		  gotnl = true;
+		break;
+	      }
+	  }
+	line = line + new String(buf, 0, i);
+
+	// A '\r' '\n' combo indicates the end of the header entry.
+	// If it wasn't found, cycle back through the loop and append
+	// to 'line' until one is found.
+	if (gotnl)
+	  {
+	    // A zero length entry signals the end of the headers.
+	    if (line.length() == 0)
+	      break;
+
+	    // Store the header and reinitialize for next cycle.
+	    hdrVec.addElement(line);
+	    String key = getKey(line);
+	    if (key != null)
+	      hdrHash.put(key.toLowerCase(), getField(line));
+	    line = "";
+	    ch[0] = (byte) '\n';
+	    gotnl = false;
+	  }
+      }
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/http/Handler.java b/libjava/gnu/java/net/protocol/http/Handler.java
new file mode 100644
index 0000000..e1184bb
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/http/Handler.java
@@ -0,0 +1,40 @@
+// Handler.java - URLStreamHandler for http protocol.
+
+/* Copyright (C) 1999, 2003  Free Software Foundation
+
+   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 gnu.java.net.protocol.http;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+
+/**
+ * Written using on-line Java Platform 1.2 API Specification, as well
+ * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
+ * Status:  Minimal functionality.
+ */
+
+/**
+ * @author Warren Levy
+ * @author Anthony Green <green@redhat.com>
+ * @date March 26, 1999.
+ */
+public class Handler extends URLStreamHandler
+{
+  protected URLConnection openConnection (URL url) throws IOException
+  {
+    return new Connection (url);
+  }
+
+  protected int getDefaultPort()
+  {
+    return 80;
+  }
+}
diff --git a/libjava/gnu/java/net/protocol/jar/Connection.java b/libjava/gnu/java/net/protocol/jar/Connection.java
new file mode 100644
index 0000000..19e8ab7
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/jar/Connection.java
@@ -0,0 +1,90 @@
+/* Copyright (C) 1999, 2002  Free Software Foundation
+
+   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 gnu.java.net.protocol.jar;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.net.JarURLConnection;
+import java.net.MalformedURLException;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.util.Hashtable;
+import java.util.jar.JarFile;
+import java.util.zip.ZipFile;
+
+/**
+ * Written using on-line Java Platform 1.2 API Specification.
+ *
+ * @author Kresten Krab Thorup <krab@gnu.org>
+ * @date Aug 10, 1999.
+ */
+public class Connection extends JarURLConnection 
+{
+  static Hashtable file_cache = new Hashtable();
+  private JarFile jarfile;
+
+  public Connection(URL url)
+    throws MalformedURLException
+  {
+    super(url);
+  }
+
+  public synchronized JarFile getJarFile() throws java.io.IOException
+  {
+    if (!connected)
+      connect();
+
+    if (! doInput)
+      throw new ProtocolException("Can't open JarFile if doInput is false");
+
+    if (jarfile != null)
+      return jarfile;
+
+    URL jarFileURL = getJarFileURL();
+
+    if (jarFileURL.getProtocol().equals ("file")
+	&& jarFileURL.getHost().equals (""))
+      {
+	if (getUseCaches())
+	  {
+	    jarfile = (JarFile) file_cache.get(jarFileURL);
+	    if (jarfile == null)
+	      {
+		jarfile = new JarFile (jarFileURL.getFile());
+		file_cache.put (jarFileURL, jarfile);
+	      }
+	  }
+	else
+	  jarfile = new JarFile (jarFileURL.getFile());
+      }
+    else
+      {
+	URLConnection urlconn = jarFileURL.openConnection();
+	InputStream is = urlconn.getInputStream();
+	byte[] buf = new byte[4*1024];
+	File f = File.createTempFile("cache", "jar");
+	FileOutputStream fos = new FileOutputStream(f);
+	int len = 0;
+	while ((len = is.read(buf)) != -1)
+	  fos.write(buf, 0, len);
+        fos.close();
+	// Always verify the Manifest, open read only and delete when done.
+	// XXX ZipFile.OPEN_DELETE not yet implemented.
+	// jf = new JarFile(f, true, ZipFile.OPEN_READ | ZipFile.OPEN_DELETE);
+	jarfile = new JarFile(f, true, ZipFile.OPEN_READ);
+      }
+
+    return jarfile;
+  }
+
+}
diff --git a/libjava/gnu/java/net/protocol/jar/Handler.java b/libjava/gnu/java/net/protocol/jar/Handler.java
new file mode 100644
index 0000000..e19a5cf
--- /dev/null
+++ b/libjava/gnu/java/net/protocol/jar/Handler.java
@@ -0,0 +1,28 @@
+// Handler.java - URLStreamHandler for file protocol.
+
+/* Copyright (C) 1999  Free Software Foundation
+
+   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 gnu.java.net.protocol.jar;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+
+/**
+ * @author Kresten Krab Thorup <krab@gnu.org>
+ * @date August 13, 1999.
+ */
+public class Handler extends URLStreamHandler
+{
+  protected URLConnection openConnection(URL url) throws IOException
+  {
+    return new Connection(url);
+  }
+}