/* ----------------------------------------------------------------------------
   The Kiwi Toolkit - A Java Class Library
   Copyright (C) 1998-2004 Mark A. Lindner

   This library 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 of the
   License, or (at your option) any later version.

   This library 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 this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.
 
   The author may be contacted at: mark_a_lindner@yahoo.com
   ----------------------------------------------------------------------------
   $Log: HTTPRequest.java,v $
   Revision 1.7  2004/05/05 21:36:35  markl
   comment block updates

   Revision 1.6  2003/11/07 19:06:05  markl
   bug fix

   Revision 1.5  2003/01/19 09:37:12  markl
   Javadoc & comment header updates.

   Revision 1.4  2001/03/12 06:01:18  markl
   Javadoc cleanup.

   Revision 1.3  2001/03/12 01:58:42  markl
   Source code cleanup.

   Revision 1.2  2000/08/07 07:56:52  markl
   *** empty log message ***

   Revision 1.1  1999/06/03 08:07:22  markl
   Initial revision
   ----------------------------------------------------------------------------
*/

package kiwi.io;

import java.io.*;
import java.net.*;
import java.util.*;

/** This class represents an HTTP request, e.g., a single transaction with an
 * HTTP server. It may be used to send arbitrary requests to an HTTP server.
 * This class extends the abstract class
 * <code>java.net.HttpURLConnection</code>; see the documentation on that class
 * for more information.
 * 
 * @author Mark Lindner
 */

public class HTTPRequest extends HttpURLConnection
  {
  private Socket socket = null;
  private static final char keySeparator = ':';
  private Hashtable keys = new Hashtable();
  private Vector headers = new Vector(), keyList = new Vector();
  private boolean gotHeaders = false;
  private static final String CRLF = "\r\n";

  /** Construct a new <code>HTTPRequest</code> for the given URL.
   *
   * @param url The URL identifying the destination of the transaction.
   */
  
  public HTTPRequest(URL url)
    {
    super(url);
    }

  /** Connect to the HTTP server.
   *
   * @exception java.io.IOException If the connection failed.
   */

  public void connect() throws IOException
    {
    if(connected) return;

    InetAddress dest = InetAddress.getByName(getURL().getHost());
    int port = getURL().getPort();
    if(port < 0)
      port = 80;

    socket = new Socket(dest, port);
    OutputStream out = socket.getOutputStream();

    send(out, getRequestMethod() + " " + url.getFile() + " HTTP/1.0" + CRLF);
    send(out, "Host: " + getURL().getHost() + CRLF);
    send(out, CRLF);

    InputStream in = socket.getInputStream();
    
    String status = recv(in);

    StringTokenizer st = new StringTokenizer(status);

    if(st.hasMoreTokens())
      {
      st.nextToken();

      if(st.hasMoreTokens())
        {
        responseCode = Integer.parseInt(st.nextToken());
        responseMessage = st.nextToken("");
        }
      }

    connected = true;
    }

  /** Disconnect from the HTTP server. */
  
  public void disconnect()
    {
    if(socket != null)
      {
      try
        {
        socket.close();
        }
      catch(IOException ex) { /* ignore */ }
      socket = null;
      }
    
    connected = false;
    }

  /** Determine if this implementation uses a proxy.
   *
   * @return This implementation returns <code>false</code>.
   */

  public boolean usingProxy()
    {
    return(false);
    }

  /** Get the input stream associated with the request. If no connection has
   * been established yet, an attempt is made to make one.
   */
  
  public InputStream getInputStream() throws IOException
    {
    if(!connected)
      connect();

    return(socket.getInputStream());
    }

  /** Get the output stream associated with the request. If no connection has
   * been established yet, an attempt is made to make one.
   */
  
  public OutputStream getOutputStream() throws IOException
    {
    if(!connected)
      connect();

    return(socket.getOutputStream());
    }

  /** Get the header field value for the specified key.
   *
   * @param key The key.
   * @return The value of the field.
   */

  public String getHeaderField(String key)
    {
    getHeaders();
    return((String)keys.get(key.toLowerCase()));
    }

  /** Get the header field key for the specified position.
   *
   * @param n The position.
   * @return The key of the header at the specified position.
   */
  
  public String getHeaderFieldKey(int n)
    {
    getHeaders();
    if(n >= headers.size())
      return(null);

    return((String)keyList.elementAt(n));
    }

  /* send a line on a stream */
  
  private void send(OutputStream out, String s) throws IOException
    {
    //System.out.println("SEND: " + s);
    
    for(int i = 0; i < s.length(); i++)
      out.write((byte)s.charAt(i));
    
    out.flush();
    }

  /* receive a line on a stream */
  
  private String recv(InputStream in) throws IOException
    {
    StringBuffer result = new StringBuffer();

    for(;;)
      {
      int c = in.read();

      if((c < 0) || (c == '\n'))
        break;

      if(c != '\r')
        result.append((char)c);
      }

    String s = result.toString();
    
    //System.out.println("RECV: " + s);
    
    return(s);
    }

  /** Retrieve header key/value pairs. */
  
  public void getHeaders()
    {
    if(gotHeaders)
      return;

    gotHeaders = true;

    try
      {
      InputStream in = getInputStream();
      for(;;)
        {
        String header = recv(in);
        if(header.length() == 0)
          break;

        // break out key & value

        String key, value;
        int i = header.indexOf(keySeparator);
        if(i < 0)
          {
          key = header;
          value = "";
          }
        else
          {
          key = header.substring(0, i).toLowerCase();
          value = header.substring(++i).trim();
          }

        keys.put(key, value);
        keyList.addElement(key);
        headers.addElement(header);
        }
      }
    catch(IOException ex)
      {
      ex.printStackTrace();
      }
    }
  
  }

/* end of source file */