HTTP & Web Servers

import java.io.IOException;
import java.net.ServerSocket;
import java.util.Date;

/**
 * Java HTTP Server
 *
 * This is a very simple HTTP server.
 *
 */
public class HttpServer
{

  public static boolean VERBOSE = false;

  /**
   * Usage
   */
  private static void usage()
  {
    //print instructions to standard out
    String instructions
            = "usage: java HttpServer [-options] [port-number]\n\n"
            + "where options include:\n"
            + "    -? -help\t print out this message\n"
            + "    -v -verbose\t turn on verbose mode\n\n"
            + "  and port-number is the port number to listen on";

    System.out.println(instructions);
    System.out.flush();
  }

  /**
   * Extract command line arguments
   */
  private static void extractArguments(String[] args)
  {
    if (args.length > 0)
    {
      int arg = 0;
      if (args[arg].equals("-?") || args[arg].equals("-help"))
      {
        usage();
        arg++;
      }

      if (args.length >= arg)
      {
        if (args[arg].equals("-v") || args[arg].equals("-verbose"))
        {
          VERBOSE = true;
          arg++;
        }
      }

      if (args.length >= arg)
      {
        try
        {
          m_port = Integer.parseInt(args[arg]);
        }
        catch (java.lang.NumberFormatException nfe)
        {
          System.err.println("Invalid port number specified: " + args[arg]);
          System.err.println("  Defaulting to: " + m_port);
        }
      }
    }
  }
  
  /**
   * Main method
   *
   * @param args [-options] [port-number]
   */
  public static void main(String[] args)
  {
    extractArguments(args);

    ServerSocket serverConnect = null;
    try
    {
      System.out.println("\nConnecting to port " + m_port + "...\n");
      serverConnect = new ServerSocket(m_port); //listen on port
      System.out.println("Listening for connections on port " + m_port + "...\n");
      while (true) //listen until user halts execution
      {
        RequestHandler handler = new RequestHandler(serverConnect.accept());
        if (VERBOSE)
        {
          System.out.println("Connection opened. (" + new Date() + ")");
        }
        handler.start(); // Start the request handler thread
      }
    }
    catch (IOException e)
    {
      System.err.println("Server error: " + e);
    }
  }

  ///// Private data /////
  private static int m_port = 8080; //default port value
}

import java.io.BufferedReader;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.StringTokenizer;
import java.util.Date;

/**
 * HTTP Request Handler
 *
 * This class handles a single request received by the HTTP server. It currently
 * supports only the GET method.
 *
 */
public class RequestHandler extends Thread
{
  // Constructor
  public RequestHandler(Socket connect)
  {
    m_connect = connect;
  }

  /**
   * Services each request in a separate thread
   */
  public void run()
  {
    BufferedReader in = null;
    PrintWriter out = null;
    BufferedOutputStream dataOut = null;
    try
    {
      // Get character input stream from the client
      in = new BufferedReader(new InputStreamReader(m_connect.getInputStream()));
      // Get output stream to client
      OutputStream clientOut = m_connect.getOutputStream();
      // Get character output stream to client (for headers)
      if (HttpServer.VERBOSE)
      {
        // Insert a TeeWriter to capture the response header
        // output by the rest of the program.
        out = new PrintWriter(
                new TeeWriter(
                        new OutputStreamWriter(clientOut),
                        new OutputStreamWriter(System.out)
                )
        );

      }
      else
      {
        out = new PrintWriter(m_connect.getOutputStream());
      }
      // Get binary output stream to client (for requested data)
      dataOut = new BufferedOutputStream(clientOut);

      // Get first line of request from client
      String input = in.readLine();
      // Save the header for this request
      m_requestHeader = input;
      while (true)
      {
        String line = in.readLine();
        // Read until end of stream, or blank line
        if (line == null || line.length() == 0)
        {
          break;
        }
        m_requestHeader += ("\n<br>" + line);
      }

      // Use StringTokenizer to parse request's first line, which is of the form:
      //    method file-requested HTTP/version-number
      // where:
      //    method is GET, HEAD, POST, etc.
      //    version-number is 1.0, 1.1, etc.
      //
      StringTokenizer parse = new StringTokenizer(input);
      String method = parse.nextToken().toUpperCase();// Parse out method
      String fileRequested = parse.nextToken().toLowerCase();// file

      if (HttpServer.VERBOSE)
      {
        System.out.println("--------Begin Request-----");
        System.out.println(m_requestHeader);
        System.out.println("--------End Request-------");
        System.out.flush();
      }

      // Dispatch, based on method type
      if (method.equals("GET"))
      {
        processGetRequest(fileRequested, in, out, dataOut);
      }
      else
      {
        // Other HTTP methods are not yet implemented in this HTTP server
        unsupportedRequest(method, in, out);
      }
    }
    catch (IOException e)
    {
      System.err.println("Server Error: " + e);
    } finally
    {
      // Ensure all streams are closed
      try
      {
        if (in != null)
        {
          in.close();
        }
        if (out != null)
        {
          out.close();
        }
        if (dataOut != null)
        {
          dataOut.close();
        }

        // Ensure the connection is closed
        m_connect.close();
        if (HttpServer.VERBOSE)
        {
          System.out.println("Connection closed.\n");
        }
      }
      catch (IOException ioe)
      {
        // Do nothing -- no recovery possible.
      }
    }
  }

  /**
   * Process a GET request
   */
  private void processGetRequest(String fileRequested,
          BufferedReader in,
          PrintWriter out,
          BufferedOutputStream dataOut)
          throws IOException
  {
    // Handle "special" requests
    int index = fileRequested.indexOf("special/");
    if (index != -1)
    {
      processSpecialGetRequest(fileRequested, in, out);
      return;
    }

    if (fileRequested.endsWith("/"))
    {
      //append default file name to request
      fileRequested += DEFAULT_FILE;
    }

    FileInputStream fileIn = null;
    try
    {
      File file = new File(WEB_ROOT, fileRequested);
      if (!file.exists())
      {
        throw new FileNotFoundException();
      }

      // Get the file's MIME content type
      String content = MIMETypes.getType(fileRequested);

      // Generate HTTP response header
      out.println("HTTP/1.0 200 OK");
      out.println("Server: HttpServer 1.0");
      out.println("Date: " + new Date());
      out.println("Content-type: " + content);
      out.println("Content-length: " + file.length());
      out.println(); // Blank line between headers and content
      out.flush(); // Flush character output stream buffer

      // Now the content...
      // Open input stream on the file
      fileIn = new FileInputStream(file);
      // Create a byte array to store the file contents
      byte[] fileData = new byte[(int) file.length()];
      // Read file into byte array
      fileIn.read(fileData);
      // Write file to stream
      dataOut.write(fileData, 0, (int) file.length());
      dataOut.flush(); //flush binary output stream buffer
      if (HttpServer.VERBOSE)
      {
        System.out.println("File " + fileRequested
                + " of type " + content + " returned.");
      }
    }
    catch (IOException e)
    {
      // Tell client that file doesn't exist
      fileNotFound(fileRequested, out);
    } finally
    {
      // Ensure that the fileIn is closed.
      if (fileIn != null)
      {
        fileIn.close();
      }
    }
  }

  /**
   * Process a "special" GET request. Currently, the only implementation of this
   * is where the user specifies a "special/" directory in the request. In this
   * case, the special GET request simply returns the contents of the request
   * header in a displayable form on the browser.
   */
  private void processSpecialGetRequest(String fileRequested,
          BufferedReader in,
          PrintWriter out)
          throws IOException
  {
    String page
            = "<HTML>\n"
            + "<HEAD><TITLE>Request Header Echo</TITLE></HEAD>\n"
            + "<BODY>\n"
            + "<H2>The Header from this Request was:</H2>\n"
            + m_requestHeader + "\n"
            + "</BODY>\n"
            + "</HTML>";

    // Generate HTTP response header
    out.println("HTTP/1.0 200 OK");
    out.println("Server: HttpServer 1.0");
    out.println("Date: " + new Date());
    out.println("Content-type: " + "text/html");
    out.println("Content-length: " + page.length());
    out.println(); // Blank line between headers and content
    out.println(page);
    out.flush(); // Flush character output stream buffer
  }

  /**
   * Process unsupported requests
   */
  private void unsupportedRequest(String method, BufferedReader in, PrintWriter out)
  {
    if (HttpServer.VERBOSE)
    {
      System.out.println("501 Not Implemented: " + method + " method.");
    }

    // Send Not Implemented message to client
    out.println("HTTP/1.0 501 Not Implemented");
    out.println("Server: HttpServer 1.0");
    out.println("Date: " + new Date());
    out.println("Content-Type: text/html");
    out.println(); // Blank line between headers and content
    out.println("<HTML>");
    out.println("<HEAD><TITLE>Not Implemented</TITLE></HEAD>");
    out.println("<BODY>");
    out.println("<H2>501 Not Implemented: " + method + " method.</H2>");
    out.println("</BODY>");
    out.println("</HTML>");
    out.flush(); // Flush character output stream buffer
  }

  /**
   * Informs client that requested file does not exist.
   */
  private void fileNotFound(String fileRequested, PrintWriter out)
          throws IOException
  {
    if (HttpServer.VERBOSE)
    {
      System.out.println("404 File Not Found: " + fileRequested);
    }

    out.println("HTTP/1.0 404 File Not Found");
    out.println("Server: HttpServer 1.0");
    out.println("Date: " + new Date());
    out.println("Content-Type: text/html");
    out.println();  // Blank line between headers and content
    out.println("<HTML>");
    out.println("<HEAD><TITLE>File Not Found</TITLE></HEAD>");
    out.println("<BODY>");
    out.println("<H2>404 File Not Found: " + fileRequested + "</H2>");
    out.println("</BODY>");
    out.println("</HTML>");
    out.flush(); // Flush character output stream buffer
  }

  ///// Private data /////
  // HttpServer root is the current directory
  private static final File WEB_ROOT = new File(".");
  // Default file name for unspecified request filename
  private static final String DEFAULT_FILE = "index.html";

  private Socket m_connect;

  private String m_requestHeader;
}

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * This class provides a mapping from filetype to MIME type.
 */
public class MIMETypes
{

  /**
   * Returns the MIME type, given a filename
   */
  public static String getType(String fileName)
  {
    String type = null;
    // Extract the filetype from the filename
    int dotIndex = fileName.lastIndexOf('.');
    if (dotIndex != -1)
    {
      String fileType = fileName.substring(dotIndex);
      // Now, look up the filetype to get the MIME type
      type = (String) m_map.get(fileType);
    }
    if (type == null)
    {
      type = UNKNOWN_MIME_TYPE;
    }
    return type;
  }

  /**
   * Adds a file type/MIME type mapping.
   */
  public static void add(String fileType, String MIMEType)
  {
    m_map.put(fileType, MIMEType);
  }

  /**
   * Removes a file type/MIME type mapping
   */
  public static void remove(String fileType)
  {
    m_map.remove(fileType);
  }

  /**
   * Suppress the constructor, since all methods in this class are static.
   */
  private MIMETypes()
  {
  }

  /////// Private data ///////
  // The HashMap used to store the relationships between filetype and MIME type
  private static HashMap m_map = new HashMap();

  // The MIME types this web server is initially aware of
  private static final String[][] m_initialValues =
  {
    {
      ".class", "application/x-java-vm"
    },
    {
      ".css", "text/css"
    },
    {
      ".doc", "application/msword"
    },
    {
      ".gif", "image/gif"
    },
    {
      ".htm", "text/html"
    },
    {
      ".html", "text/html"
    },
    {
      ".jar", "application/x-java-archive"
    },
    {
      ".jpg", "image/jpeg"
    },
    {
      ".jpeg", "image/jpeg"
    },
    {
      ".mpg", "video/mpeg"
    },
    {
      ".mpeg", "video/mpeg"
    },
    {
      ".pdf", "application/pdf"
    },
    {
      ".png", "image/png"
    },
    {
      ".ppt", "application/vnd.ms-powerpoint"
    },
    {
      ".ps", "application/postscript"
    },
    {
      ".ser", "application/x-java-serialized-object"
    },
    {
      ".tiff", "image/tiff"
    },
    {
      ".txt", "text/plain"
    },
    {
      ".xls", "application/vnd.ms-excel"
    },
    {
      ".zip", "application/zip"
    },
  };

  // Populate the HashMap on class load.
  static
  {
    for (int i = 0; i < m_initialValues.length; i++)
    {
      String key = m_initialValues[i][0];
      String value = m_initialValues[i][1];
      m_map.put(key, value);
    }
  }

  /**
   * Main entry point, for testing
   */
  public static void main(String[] args)
  {
    System.out.println("----BEGIN-----");
    for (Iterator iter = m_map.entrySet().iterator(); iter.hasNext();)
    {
      Map.Entry entry = (Map.Entry) iter.next();
      String key = (String) entry.getKey();
      String value = (String) entry.getValue();
      System.out.println(key + " : " + value);
    }
    System.out.println("-----END-----");

    String type = null;
    type = getType("bar");
    System.out.println("foo type is: " + type);
    type = getType(".foo");
    System.out.println(".foo type is: " + type);
    type = getType(".css");
    System.out.println(".css type is: " + type);
    type = getType("fromage.pdf");
    System.out.println("fromage.pdf type is: " + type);
  }
  
    private static final String UNKNOWN_MIME_TYPE = "application/octet-stream";
}

import java.io.FileWriter;
import java.io.FilterWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;

/**
 * This class provides a "Tee" so that anything written to it is sent to both
 * its Writers. This can be quite useful for logging everything written to a
 * stream.
 */
public class TeeWriter extends FilterWriter
{
  /**
   * Constructor
   */
  public TeeWriter(Writer out1, Writer out2)
  {
    super(out1);
    m_out = out2;
  }

  /**
   * Write a single character.
   *
   * @exception IOException If an I/O error occurs
   */
  public void write(int c) throws IOException
  {
    super.write(c);
    m_out.write(c);
  }

  /**
   * Write a portion of an array of characters.
   *
   * @param cbuf Buffer of characters to be written
   * @param off Offset from which to start reading characters
   * @param len Number of characters to be written
   *
   * @exception IOException If an I/O error occurs
   */
  public void write(char cbuf[], int off, int len) throws IOException
  {
    super.write(cbuf, off, len);
    m_out.write(cbuf, off, len);
  }

  /**
   * Write a portion of a string.
   *
   * @param str A String
   * @param off Offset from which to start writing characters
   * @param len Number of characters to write
   *
   * @exception IOException If an I/O error occurs
   */
  public void write(String str, int off, int len) throws IOException
  {
    super.write(str, off, len);
    m_out.write(str, off, len);
  }

  /**
   * Flush the stream.
   *
   * @exception IOException If an I/O error occurs
   */
  public void flush() throws IOException
  {
    super.flush();
    m_out.flush();
  }

  /**
   * Close the stream.
   *
   * @exception IOException If an I/O error occurs
   */
  public void close() throws IOException
  {
    super.close();
    m_out.close();
  }

  /**
   * Main entry point, for testing.
   */
  public static void main(String[] args)
  {
    PrintWriter pw = null;
    try
    {
      FileWriter fileOut = new FileWriter("teeTest.out");
      OutputStreamWriter stdOut = new OutputStreamWriter(System.out);
      TeeWriter tee = new TeeWriter(fileOut, stdOut);
      pw = new PrintWriter(tee);
      pw.println("   Jabberwocky");
      pw.println("       by ");
      pw.println("  Lewis Carroll");
      pw.println();
      pw.println("Twas brillig, and the slithy toves\n"
              + "Did gyre and gimble in the wabe:\n"
              + "All mimsy were the borogoves,\n"
              + "And the mome raths outgrabe.");
      pw.flush();
    }
    catch (IOException ioe)
    {
      ioe.printStackTrace();
    } finally
    {
      pw.close();
    }
  }

  ///// Private data //////
  private Writer m_out;
}