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

	* gnu/java/net/protocol/file/FileURLConnection.java,
	gnu/java/net/protocol/http/HttpURLConnection.java,
	gnu/java/net/protocol/jar/JarURLConnection.java:
	Removed.
	* gnu/java/net/protocol/file/Connection.java,
	gnu/java/net/protocol/http/Connection.java,
	gnu/java/net/protocol/jar/Connection.java:
	New files.
	* gnu/java/net/protocol/jar/Handler.java,
	gnu/java/net/protocol/http/Handler.java,
	gnu/java/net/protocol/file/Handler.java,
	gnu/java/lang/SystemClassLoader.java:
	Use new files.

1 files changed, 404 insertions, 0 deletions

diff --git a/gnu/java/net/protocol/http/Connection.java b/gnu/java/net/protocol/http/Connection.java
new file mode 100644
index 000000000..61a5715bf
--- /dev/null
+++ b/gnu/java/net/protocol/http/Connection.java
@@ -0,0 +1,404 @@
+/* HttpURLConnection.java -- URLConnection class for HTTP protocol
+   Copyright (C) 1998, 2002, 2003 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.net.protocol.http;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.net.HttpURLConnection;
+import java.net.ProtocolException;
+import java.net.Socket;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Iterator;
+import java.util.Map;
+import gnu.java.net.HeaderFieldHelper;
+
+/**
+ * This subclass of java.net.URLConnection models a URLConnection via
+ * the HTTP protocol.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+public class Connection extends HttpURLConnection
+{
+  /**
+   * The socket we are connected to
+   */
+  private Socket socket;
+
+  /**
+   * The InputStream for this connection
+   */
+  private DataInputStream in_stream;
+
+  /**
+   * The OutputStream for this connection
+   */
+  private OutputStream out_stream;
+
+  /**
+   * buffered_out_stream is a buffer to contain content of the HTTP request,
+   * and will be written to out_stream all at once
+   */
+  private ByteArrayOutputStream buffered_out_stream;
+
+  /**
+   * The PrintWriter for this connection (used internally)
+   */
+  private PrintWriter out_writer;
+
+  /**
+   * This is the object that holds the header field information
+   */
+  private HeaderFieldHelper headers = new HeaderFieldHelper();
+
+  /**
+   * Calls superclass constructor to initialize
+   */
+  protected Connection (URL url)
+  {
+    super (url);
+
+    /* Set up some variables */
+    doOutput = false;
+  }
+
+  /**
+   * Connects to the remote host, sends the request, and parses the reply
+   * code and header information returned
+   */
+  public void connect() throws IOException
+  {
+    // Connect up
+    if (url.getPort() == -1)
+      socket = new Socket(url.getHost(), 80);
+    else
+      socket = new Socket(url.getHost(), url.getPort());
+
+    out_stream = new BufferedOutputStream(socket.getOutputStream());
+    out_writer = new PrintWriter(new OutputStreamWriter(out_stream, "8859_1")); 
+
+    connected = true;
+  }
+
+  /**
+   * write HTTP request header and content to out_writer
+   */
+  void SendRequest() throws IOException
+  {
+    // Send the request
+    out_writer.print(getRequestMethod() + " " + getURL().getFile()
+                     + " HTTP/1.1\r\n");
+
+    if (getRequestProperty ("host") == null)
+      {
+        setRequestProperty ("Host", getURL().getHost());
+      }
+    
+    if (getRequestProperty ("Connection") == null)
+      {
+        setRequestProperty ("Connection", "Close");
+      }
+    
+    if (getRequestProperty ("user-agent") == null)
+      {
+        setRequestProperty ("user-agent", "gnu-classpath/"
+                            + System.getProperty ("classpath.version"));
+      }
+    
+    if (getRequestProperty ("accept") == null)
+      {
+        setRequestProperty ("accept", "*/*");
+      }
+    
+    if (getRequestProperty ("Content-type") == null)
+      {
+        setRequestProperty ("Content-type", "application/x-www-form-urlencoded");
+      }
+
+    // Write all req_props name-value pairs to the output writer
+    Iterator itr = getRequestProperties().entrySet().iterator();
+
+    while (itr.hasNext())
+      {
+        Map.Entry e = (Map.Entry) itr.next();
+        out_writer.print (e.getKey() + ": " + e.getValue() + "\r\n");
+      }
+
+    // Write Content-type and length
+    if (buffered_out_stream != null)
+      {
+        out_writer.print ("Content-type: application/x-www-form-urlencoded\r\n");
+        out_writer.print ("Content-length: "
+                          + String.valueOf (buffered_out_stream.size()) + "\r\n");
+      }
+
+    // One more CR-LF indicates end of header
+    out_writer.print ("\r\n");
+    out_writer.flush();
+
+    // Write content
+    if (buffered_out_stream != null)
+      {
+        buffered_out_stream.writeTo (out_stream);
+        out_stream.flush();
+      }
+  }
+
+  /**
+   * Read HTTP reply from in_stream
+   */
+  void ReceiveReply() throws IOException
+  {
+    // Parse the reply
+    String line = in_stream.readLine();
+    String saveline = line;
+    int idx = line.indexOf (" ");
+    
+    if ((idx == -1)
+        || (line.length() < (idx + 6)))
+      throw new IOException("Server reply was unparseable: " + saveline);
+
+    line = line.substring (idx + 1);
+    String code = line.substring (0, 3);
+    
+    try
+      {
+        responseCode = Integer.parseInt (code);
+      }
+    catch (NumberFormatException e)
+      {
+        throw new IOException ("Server reply was unparseable: " + saveline);
+      }
+    
+    responseMessage = line.substring (4);
+
+    // Now read the header lines
+    String key = null, value = null;
+    
+    for (;;)
+      {
+        line = in_stream.readLine();
+        
+        if (line.equals(""))
+          break;
+
+        // Check for folded lines
+        if (line.startsWith (" ")
+            || line.startsWith("\t"))
+          {
+            // Trim off leading space
+            do
+              {
+                if (line.length() == 1)
+                  throw new IOException("Server header lines were unparseable: "
+                                        + line);
+
+                line = line.substring (1);
+              }
+            while (line.startsWith(" ")
+                   || line.startsWith("\t"));
+
+            value = value + " " + line;
+          }
+        else 
+          {
+            if (key != null)
+              {
+                headers.addHeaderField (key, value);
+                key = null;
+                value = null;
+              }
+
+            // Parse out key and value
+            idx = line.indexOf (":");
+            if ((idx == -1)
+                || (line.length() < (idx + 2)))
+              throw new IOException ("Server header lines were unparseable: "
+                                     + line);
+
+            key = line.substring (0, idx);
+            value = line.substring (idx + 1);
+
+            // Trim off leading space
+            while (value.startsWith (" ")
+                   || value.startsWith ("\t"))
+              {
+                if (value.length() == 1)
+                  throw new IOException ("Server header lines were unparseable: "
+                                         + line);
+
+                value = value.substring (1);
+              }
+          }
+      }
+    
+    if (key != null)
+      {
+        headers.addHeaderField (key, value);
+      }
+  }
+
+  /**
+   * Disconnects from the remote server
+   */
+  public void disconnect()
+  {
+    try
+      {
+        if (socket != null)
+          socket.close();
+      }
+    catch (IOException e)
+      {
+      }
+  }
+
+  /**
+   * Overrides java.net.HttpURLConnection.setRequestMethod() in order to
+   * restrict the available methods to only those we support.
+   *
+   * @param method The RequestMethod to use
+   *
+   * @exception ProtocolException If the specified method is not valid
+   */
+  public void setRequestMethod (String method) throws ProtocolException
+  {
+    method = method.toUpperCase();
+    
+    if (method.equals("GET")
+        || method.equals("HEAD")
+        || method.equals("POST"))
+      super.setRequestMethod (method);
+    else
+      throw new ProtocolException ("Unsupported or unknown request method " +
+                                   method);
+  }
+
+  /**
+   * Return a boolean indicating whether or not this connection is
+   * going through a proxy
+   *
+   * @return true if using a proxy, false otherwise
+   */
+  public boolean usingProxy()
+  {
+    return false;
+  }
+
+  /**
+   * This method returns the header field key at the specified numeric
+   * index.
+   *
+   * @param n The index into the header field array
+   *
+   * @return The name of the header field key, or <code>null</code> if the
+   * specified index is not valid.
+   */
+  public String getHeaderFieldKey (int n)
+  {
+    return headers.getHeaderFieldKeyByIndex (n);
+  }
+
+  /**
+   * This method returns the header field value at the specified numeric
+   * index.
+   *
+   * @param n The index into the header field array
+   *
+   * @return The value of the specified header field, or <code>null</code>
+   * if the specified index is not valid.
+   */
+  public String getHeaderField (int n)
+  {
+    return headers.getHeaderFieldValueByIndex (n);
+  }
+
+  /**
+   * Returns an InputStream for reading from this connection.  This stream
+   * will be "queued up" for reading just the contents of the requested file.
+   * Overrides URLConnection.getInputStream()
+   *
+   * @return An InputStream for this connection.
+   *
+   * @exception IOException If an error occurs
+   */
+  public InputStream getInputStream() throws IOException
+  {
+    if(in_stream != null)
+      return in_stream;
+
+    if (!connected)
+      connect();
+
+    in_stream
+      = new DataInputStream (new BufferedInputStream (socket.getInputStream()));
+  
+    SendRequest();
+    ReceiveReply();
+
+    return in_stream;
+  }
+
+  public OutputStream getOutputStream() throws IOException
+  {
+    if (!doOutput)
+      throw new ProtocolException
+        ("Want output stream while haven't setDoOutput(true)");
+    
+    if (!method.equals ("POST")) //But we might support "PUT" in future
+      setRequestMethod ("POST");
+  
+    if (!connected)
+      connect();
+  
+    if(buffered_out_stream == null)
+      buffered_out_stream = new ByteArrayOutputStream (256); //default is too small
+    
+    return buffered_out_stream;
+  }
+
+} // class HttpURLConnection