Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements a metadata catalog as a java Servlet

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Dan Higgins, Jivka Bojilova, Chad Berkley

 *    Release: @release@

 *

 *   '$Author: jones $'

 *     '$Date: 2000-11-27 13:55:08 -0800 (Mon, 27 Nov 2000) $'

 * '$Revision: 566 $'

 */

package edu.ucsb.nceas.metacat;

import java.io.PrintWriter;

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStreamReader;

import java.io.DataInputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.ResourceBundle; 

import java.util.PropertyResourceBundle;

import java.net.URL;

import java.net.MalformedURLException;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.Connection;

import java.sql.SQLException;

import java.lang.reflect.*;

import java.net.*;

import java.util.zip.*;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpUtils;

import javax.servlet.ServletOutputStream;

import oracle.xml.parser.v2.XSLStylesheet;

import oracle.xml.parser.v2.XSLException;

import oracle.xml.parser.v2.XMLDocumentFragment;

import oracle.xml.parser.v2.XSLProcessor;

import org.xml.sax.SAXException;

/**

 * A metadata catalog server implemented as a Java Servlet

 *

 * <p>Valid parameters are:<br>

 * action=query -- query the values of all elements and attributes

 *                     and return a result set of nodes<br>

 * action=squery -- structured query (see pathquery.dtd)<br>

 * action=insert -- insert an XML document into the database store<br>

 * action=update -- update an XML document that is in the database store<br>

 * action=delete --  delete an XML document from the database store<br>

 * action=validate -- vallidate the xml contained in valtext<br>

 * action=read -- display an XML document in XML or HTML<br>

 * doctype -- document type list returned by the query (publicID)<br>

 * qformat=xml -- display resultset from query in XML<br>

 * qformat=html -- display resultset from query in HTML<br>

 * docid=34 -- display the document with the document ID number 34<br>

 * doctext -- XML text of the document to load into the database<br>

 * acl - xml access file for a document to load into the database<br>

 * query -- actual query text (to go with 'action=query' or 'action=squery')<br>

 * valtext -- XML text to be validated<br>

 * action=getdatadoc -- retreive a stored datadocument<br>

 * action=getdoctypes -- retreive all doctypes (publicID)<br>

 * action=getdataguide -- retreive a Data Guide<br>

 * datadoc -- data document name (id)<br>

 * <p>

 * The particular combination of parameters that are valid for each 

 * particular action value is quite specific.  This documentation

 * will be reorganized to reflect this information.

 */

public class MetaCatServlet extends HttpServlet {

  private ServletConfig config = null;

  private ServletContext context = null;

  private Hashtable connectionPool = new Hashtable();

  private String resultStyleURL = null;

  private String xmlcatalogfile = null;

  private String saxparser = null;

  private String defaultdatapath = null; 

  private String servletpath = null; 

  private PropertyResourceBundle options = null;

  private MetaCatUtil util = null;

  // path to directory where data files 

  // that can be downloaded will be stored

  private String htmlpath = null; 

  // script to get data file and put it 

  // in defaultdocpath dir

  private String executescript  = null;  

  /**

   * Initialize the servlet by creating appropriate database connections

   */

  public void init( ServletConfig config ) throws ServletException {

    try {

      super.init( config );

      this.config = config;

      this.context = config.getServletContext(); 

      System.out.println("MetaCatServlet Initialize");

      util = new MetaCatUtil();

      // Get the configuration file information

      resultStyleURL = util.getOption("resultStyleURL");

      xmlcatalogfile = util.getOption("xmlcatalogfile");

      saxparser = util.getOption("saxparser");

      defaultdatapath = util.getOption("defaultdatapath");

      executescript = util.getOption("executescript");

      servletpath = util.getOption("servletpath");

      htmlpath = util.getOption("htmlpath");

      try {

        // Open a pool of db connections

        connectionPool = util.getConnectionPool();

      } catch (Exception e) {

        System.err.println("Error creating pool of database connections");

        System.err.println(e.getMessage());

      }

    } catch ( ServletException ex ) {

      throw ex;

    }

  }

  /**

   * Close all db connections from the pool

   */

  public void destroy() {

    if (util != null) {

        util.closeConnections();

    }

  }

  /** Handle "GET" method requests from HTTP clients */

  public void doGet (HttpServletRequest request, HttpServletResponse response)

    throws ServletException, IOException {

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  /** Handle "POST" method requests from HTTP clients */

  public void doPost( HttpServletRequest request, HttpServletResponse response)

    throws ServletException, IOException {

    // Process the data and send back the response

    handleGetOrPost(request, response);

  }

  /**

   * Control servlet response depending on the action parameter specified

   */

  private void handleGetOrPost(HttpServletRequest request, 

    HttpServletResponse response) 

    throws ServletException, IOException 

 {

    if ( util == null ) {

        util = new MetaCatUtil(); 

    }

    if ( connectionPool == null ) {

      try {

        // Open a pool of db connections

        connectionPool = util.getConnectionPool();

      } catch (Exception e) {

        System.err.println("Error creating pool of database connections");

        System.err.println(e.getMessage());

      }

    }    

    // Get a handle to the output stream back to the client

    //PrintWriter pwout = response.getWriter();

    //response.setContentType("text/html");

    String name = null;

    String[] value = null;

    String[] docid = new String[3];

    Hashtable params = new Hashtable();

    Enumeration paramlist = request.getParameterNames();

    while (paramlist.hasMoreElements()) {

      name = (String)paramlist.nextElement();

      value = request.getParameterValues(name);

      // Decode the docid and mouse click information

      if (name.endsWith(".y")) {

        docid[0] = name.substring(0,name.length()-2);

        //out.println("docid => " + docid[0]);

        params.put("docid", docid);

        name = "ypos";

      }

      if (name.endsWith(".x")) {

        name = "xpos";

      } 

      //pwout.println(name + " => " + value[0]);

      params.put(name,value); 

    }  

    //if the user clicked on the input images, decode which image

    //was clicked then set the action.

    String action = ((String[])params.get("action"))[0];  

    util.debugMessage("Line 213: Action is: " + action);

    //MBJELIMINATE String action = decodeMouseAction(params);

    //if(action.equals("error"))

    //{

      //util.debugMessage("Line 218: Action is: " + action);

      //action = ((String[])params.get("action"))[0];  

    //}

    // This block handles session management for the servlet

    // by looking up the current session information for all actions

    // other than "login" and "logout"

    String username = null;

    String groupname = null;

    // handle login action

    if (action.equals("login")) {

      handleLoginAction(response.getWriter(), params, request, response);

    // handle logout action  

    } else if (action.equals("logout")) {

      handleLogoutAction(response.getWriter(), params, request, response);

    // aware of session expiration on every request  

    } else {   

      HttpSession sess = request.getSession(true);

      if (sess.isNew()) { 

        // session expired or has not been stored b/w user requests

        username = "public";

      } else {

        username = (String)sess.getAttribute("username");

        groupname = (String)sess.getAttribute("groupname");

      }  

    }    

    // Now that we know the session is valid, we can delegate the request

    // to a particular action handler

    if(action.equals("query"))

    {

      handleQuery(response.getWriter(), params, response, username, groupname); 

    } 

    else if(action.equals("squery"))

    {

      if(params.containsKey("query"))

      {

        handleSQuery(response.getWriter(), params, response, username, groupname); 

      }

      else

      {

        PrintWriter out = response.getWriter();

        out.println("Illegal action squery without \"query\" parameter");

      }

    }

    else if (action.equals("read")) {

      PrintWriter out = response.getWriter();

      try {

        handleReadAction(out, params, response);

      } catch (ClassNotFoundException e) {

        out.println(e.getMessage());

      } catch (SQLException se) {

        out.println(se.getMessage());

      }

    } 

/*

    else if (action.equals("getrelateddocument")) {

      PrintWriter out = response.getWriter();

      try {

        handleGetRelatedDocumentAction(out, params, response);

      } catch (ClassNotFoundException e) {

        out.println(e.getMessage());

      } catch (SQLException se) {

        out.println(se.getMessage());

      }

    }

*/

    else if (action.equals("insert") || action.equals("update")) {

      PrintWriter out = response.getWriter();

      if ( (username != null) &&  !username.equals("public") ) {

        handleInsertOrUpdateAction(out, params, response, username, groupname);

      } else {  

        out.println("Permission denied for " + action);

      }  

    } else if (action.equals("delete")) {

      PrintWriter out = response.getWriter();

      if ( (username != null) &&  !username.equals("public") ) {

        handleDeleteAction(out, params, response, username, groupname);

      } else {  

        out.println("Permission denied for " + action);

      }  

    } else if (action.equals("validate")) {

      PrintWriter out = response.getWriter();

      handleValidateAction(out, params, response); 

    } else if (action.equals("getabstract")) {

      PrintWriter out = response.getWriter();

      try{

        handleViewAbstractAction(out, params, response);

      }

      catch(Exception e)

      {

        out.println("error viewing abstract: " + e.getMessage());

      }

    } else if (action.equals("getdatadoc")) {

      response.setContentType("application/zip");

      ServletOutputStream out = response.getOutputStream();

      handleGetDataDocumentAction(out, params, response);  

    } else if (action.equals("getdoctypes")) {

      PrintWriter out = response.getWriter();

      handleGetDoctypesAction(out, params, response);  

    } else if (action.equals("getdataguide")) {

      PrintWriter out = response.getWriter();

      handleGetDataGuideAction(out, params, response);  

    } else if (action.equals("login") || action.equals("logout")) {

    } else if (action.equals("protocoltest")) {

      String testURL = "metacat://dev.nceas.ucsb.edu/NCEAS.897766.9";

      try {

        testURL = ((String[])params.get("url"))[0];

      } catch (Throwable t) {

      }

      String phandler = System.getProperty("java.protocol.handler.pkgs");

      response.setContentType("text/html");

      PrintWriter out = response.getWriter();

      out.println("<body bgcolor=\"white\">");

      out.println("<p>Handler property: <code>" + phandler + "</code></p>");

      out.println("<p>Starting test for:<br>");

      out.println("    " + testURL + "</p>");

      try {

        URL u = new URL(testURL);

        out.println("<pre>");

        out.println("Protocol: " + u.getProtocol());

        out.println("    Host: " + u.getHost());

        out.println("    Port: " + u.getPort());

        out.println("    Path: " + u.getPath());

        out.println("     Ref: " + u.getRef());

        String pquery = u.getQuery();

        out.println("   Query: " + pquery);

        out.println("  Params: ");

        if (pquery != null) {

          Hashtable qparams = util.parseQuery(u.getQuery());

          for (Enumeration en = qparams.keys(); en.hasMoreElements(); ) {

            String pname = (String)en.nextElement();

            String pvalue = (String)qparams.get(pname);

            out.println("    " + pname + ": " + pvalue);

          }

        }

        out.println("</pre>");

        out.println("</body>");

        out.close();

      } catch (MalformedURLException mue) {

        out.println(mue.getMessage());

        mue.printStackTrace(out);

        out.close();

      }

    } else {

      PrintWriter out = response.getWriter();

      out.println("Error: action not registered.  Please report this error.");

    }

    util.closeConnections();

    // Close the stream to the client

    //out.close();

  }

  /**

   * decodes the mouse click information coming from the client.

   * This function may be overwritten to provide specific functionality

   * for different applications.

   * @param params the parameters from the CGI

   * @return action the action to be performed or "error" if an error was

   * generated

   */

  protected String decodeMouseAction(Hashtable params)

  {

    // Determine what type of request the user made

    // if the action parameter is set, use it as a default

    // but if the ypos param is set, calculate the action needed

    String action=null;

    long ypos = 0;

    try {

      ypos = (new Long(((String[])params.get("ypos"))[0]).longValue());

      //out.println("<P>YPOS IS " + ypos);

      if (ypos <= 13) {

        action = "read";

      } else if (ypos > 13 && ypos <= 27) {

        action = "validate";

      } else if (ypos > 27) {

        action = "transform";

      }

      return action;

    } catch (Exception npe) {

      //

      // MBJ -- NOTE that this should be handled more gracefully with

      //        the new exception infrastructure -- this "error" return

      //        value is inappropriate

      //out.println("<P>Caught exception looking for Y value.");

      return "error";

    }  

  }

  /** 

   * Handle the login request. Create a new session object.

   * Do user authentication through the session.

   */

  private void handleLoginAction(PrintWriter out, Hashtable params, 

               HttpServletRequest request, HttpServletResponse response) {

    AuthSession sess = null;

    String un = ((String[])params.get("username"))[0];

    String pw = ((String[])params.get("password"))[0];

    String action = ((String[])params.get("action"))[0];

    String qformat = ((String[])params.get("qformat"))[0];

    try {

      sess = new AuthSession();

    } catch (Exception e) {

      out.println(e.getMessage());

      return;

    }

    boolean isValid = sess.authenticate(request, un, pw);

    // format and transform the output

    if (qformat.equals("html")) {

      Connection conn = null;

      try {

        conn = util.getConnection();

        DBTransform trans = new DBTransform(conn);

        response.setContentType("text/html");

        trans.transformXMLDocument(sess.getMessage(), "-//NCEAS//login//EN",

                                   "-//W3C//HTML//EN", out);

        util.returnConnection(conn); 

      } catch(Exception e) {

        util.returnConnection(conn); 

      } 

    // any output is returned  

    } else {

      response.setContentType("text/xml");

      out.println(sess.getMessage()); 

    }

/* WITHOUT XSLT transformation

    // redirects response to html page

    if (qformat.equals("html")) {

      // user authentication successful

      if (isValid) {

        response.sendRedirect(

                 response.encodeRedirectUrl(htmlpath + "/metacat.html"));

      // unsuccessful user authentication 

      } else {

        response.sendRedirect(htmlpath + "/login.html");

      }

    // any output is returned  

    } else {

      response.setContentType("text/xml");

      out.println(sess.getMessage()); 

    }

*/        

  }    

  /** 

   * Handle the logout request. Close the connection.

   */

  private void handleLogoutAction(PrintWriter out, Hashtable params, 

               HttpServletRequest request, HttpServletResponse response) {

    String qformat = ((String[])params.get("qformat"))[0];

    // close the connection

    HttpSession sess = request.getSession(false);

    if (sess != null) { sess.invalidate();  }    

    // produce output

    StringBuffer output = new StringBuffer();

    output.append("<?xml version=\"1.0\"?>");

    output.append("<logout>");

    output.append("User logged out");

    output.append("</logout>");

    //format and transform the output

    if (qformat.equals("html")) {

      Connection conn = null;

      try {

        conn = util.getConnection();

        DBTransform trans = new DBTransform(conn);

        response.setContentType("text/html");

        trans.transformXMLDocument(output.toString(), "-//NCEAS//login//EN", 

                                   "-//W3C//HTML//EN", out);

        util.returnConnection(conn); 

      } catch(Exception e) {

        util.returnConnection(conn); 

      } 

    // any output is returned  

    } else {

      response.setContentType("text/xml");

      out.println(output.toString()); 

    }

/* WITHOUT XSLT transformation

    // redirects response to html page

    if (qformat.equals("html")) {

        response.sendRedirect(htmlpath + "/index.html"); 

      } catch(Exception e) {

        util.returnConnection(conn); 

      } 

    // any output is returned  

    } else {

      response.setContentType("text/xml");

      out.println(output.toString()); 

    }

*/

  }

  /**      

   * Retreive the squery xml, execute it and display it

   *

   * @param out the output stream to the client

   * @param params the Hashtable of parameters that should be included

   * in the squery.

   * @param response the response object linked to the client

   * @param conn the database connection 

   */

  protected void handleSQuery(PrintWriter out, Hashtable params, 

                 HttpServletResponse response, String user, String group)

  { 

    String xmlquery = ((String[])params.get("query"))[0];

    String qformat = ((String[])params.get("qformat"))[0];

    String resultdoc = null;

    String[] returndoc = null;

    if(params.contains("returndoc"))

    {

      returndoc = (String[])params.get("returndoc");

    }

    Hashtable doclist = runQuery(xmlquery, user, group, returndoc);

    //String resultdoc = createResultDocument(doclist, transformQuery(xmlquery));

    resultdoc = createResultDocument(doclist, transformQuery(xmlquery));

    //format and transform the results                                        

    if(qformat.equals("html")) {

      transformResultset(resultdoc, response, out);

    } else if(qformat.equals("xml")) {

      response.setContentType("text/xml");

      out.println(resultdoc);

    } else {

      out.println("invalid qformat: " + qformat); 

    }

  }

   /**

    * Create the xml query, execute it and display the results.

    *

    * @param out the output stream to the client

    * @param params the Hashtable of parameters that should be included

    * in the squery.

    * @param response the response object linked to the client

    */ 

  protected void handleQuery(PrintWriter out, Hashtable params, 

                 HttpServletResponse response, String user, String group)

  {

    //create the query and run it

    String[] returndoc = null;

    if(params.containsKey("returndoc"))

    {

      returndoc = (String[])params.get("returndoc");

    }

    String xmlquery = DBQuery.createSQuery(params);

    Hashtable doclist = runQuery(xmlquery, user, group, returndoc);

    String qformat = ((String[])params.get("qformat"))[0];

    String resultdoc = null;

    resultdoc = createResultDocument(doclist, transformQuery(params));

    //format and transform the results                                        

    if(qformat.equals("html")) {

      transformResultset(resultdoc, response, out);

    } else if(qformat.equals("xml")) {

      response.setContentType("text/xml");

      out.println(resultdoc);

    } else { 

      out.println("invalid qformat: " + qformat); 

    }

  }

  /**

   * Removes the <?xml version="x"?> tag from the beginning of xmlquery

   * so it can properly be placed in the <query> tag of the resultset.

   * This method is overwritable so that other applications can customize

   * the structure of what is in the <query> tag.

   * 

   * @param xmlquery is the query to remove the <?xml version="x"?> tag from.

   */

  protected String transformQuery(Hashtable params)

  {

    //DBQuery.createSQuery is a re-calling of a previously called 

    //function but it is necessary

    //so that overriding methods have access to the params hashtable

    String xmlquery = DBQuery.createSQuery(params);

    //the <?xml version="1.0"?> tag is the first 22 characters of the

    xmlquery = xmlquery.trim();

    int index = xmlquery.indexOf("?>");

    return xmlquery.substring(index + 2, xmlquery.length());

  }

  /**

   * removes the <?xml version="1.0"?> tag from the beginning.  This takes a

   * string as a param instead of a hashtable.

   * 

   * @param xmlquery a string representing a query.

   */

  protected String transformQuery(String xmlquery)

  {

    xmlquery = xmlquery.trim();

    int index = xmlquery.indexOf("?>");

    return xmlquery.substring(index + 2, xmlquery.length());

  }

  /**

   * Run the query and return a hashtable of results.

   *

   * @param xmlquery the query to run

   */

  private Hashtable runQuery(String xmlquery, String user, String group, 

                             String[] returndoc)

  {

    Hashtable doclist=null;

    Connection conn = null;

    try

    {

      conn = util.getConnection();

      DBQuery queryobj = new DBQuery(conn, saxparser);

      doclist = queryobj.findDocuments(new StringReader(xmlquery),user,group,

                                       returndoc);

      util.returnConnection(conn);

      return doclist;

    } 

    catch (Exception e) 

    {

      util.returnConnection(conn); 

      util.debugMessage("Error in runQuery: " + e.getMessage());

      doclist = null;

      return doclist;

    }    

  }

  /**

   * Transorms an xml resultset document to html and sends it to the browser

   *

   * @param resultdoc the string representation of the document that needs

   * to be transformed.

   * @param response the HttpServletResponse object bound to the client.

   * @param out the output stream to the client

   */ 

  protected void transformResultset(String resultdoc, 

                                    HttpServletResponse response,

                                    PrintWriter out)

  {

    Connection conn = null;

    try {

      conn = util.getConnection();

      DBTransform trans = new DBTransform(conn);

      response.setContentType("text/html");

      trans.transformXMLDocument(resultdoc, "-//NCEAS//resultset//EN", 

                                 "-//W3C//HTML//EN", out);

      util.returnConnection(conn); 

    }

    catch(Exception e)

    {

      util.returnConnection(conn); 

    } 

  }

  /**

   * Transforms a hashtable of documents to an xml or html result.

   * If there is a returndoc, then it only displays documents of

   * whatever type returndoc represents.  If a result is found in a document

   * that is not of type returndoc then this attempts to find a relation 

   * between this document and one that satifies the returndoc doctype.

   *

   * @param doclist- the hashtable to transform

   * @param xmlquery- the query that returned the dolist result

   * @param resultdoc- the document type to backtrack to.

   */

  protected String createResultDocument(Hashtable doclist, String xmlquery)

  {

    // Create a buffer to hold the xml result

    StringBuffer resultset = new StringBuffer();

    // Print the resulting root nodes 

    String docid = null;

    String document = null;

    resultset.append("<?xml version=\"1.0\"?>\n");

    resultset.append("<resultset>\n");

    resultset.append("  <query>" + xmlquery + "</query>");   

    if(doclist != null)

    {

      Enumeration doclistkeys = doclist.keys(); 

      while (doclistkeys.hasMoreElements()) 

      {

        docid = (String)doclistkeys.nextElement();

        document = (String)doclist.get(docid);

        resultset.append("  <document>" + document + "</document>");

      }

    }

    resultset.append("</resultset>");

    //System.out.println(resultset.toString());

    return resultset.toString();

  }

  /**

   * Handle the request to view the abstract of a document.

   * The abstractpath CGI parameter gives the xml path to the abstract

   * node.  

   */

  private void handleViewAbstractAction(PrintWriter out, Hashtable params,

               HttpServletResponse response) throws IOException, SQLException

  {

    String abstractpath = null;

    String docid = null;

    Connection conn = null;

    response.setContentType("text/html");

    try

    {

      docid = ((String[])params.get("docid"))[0];

      if(params.containsKey("abstractpath"))

      {

        //the CGI parameter abstractpath holds the path to the abstract

        //that should be displayed.

        abstractpath = ((String[])params.get("abstractpath"))[0];

      }

      else

      {

        out.println("error: no abstractpath parameter"); 

      }

      conn = util.getConnection();

      Object[] abstracts = DBQuery.getNodeContent(abstractpath, docid, conn);

      out.println("<html><head><title>Abstract</title></head>");

      out.println("<body bgcolor=\"white\"><h1>Abstract</h1>");

      for(int i=0; i<abstracts.length; i++)

      {

        out.println("<p>" + (String)abstracts[i] + "</p>");

      }

      out.println("</body></html>");

    }

    catch (IOException ioe)

    {

       util.debugMessage("error in handlegetabstract: " + ioe.getMessage());

    }

    catch(SQLException sqle)

    {

      util.debugMessage("error in handlegetabstract: " + sqle.getMessage()); 

    }

    catch(Exception e)

    {

      util.debugMessage("error in handlegetabstract: " + e.getMessage());

    }

    util.returnConnection(conn);

  }

  /** 

   * Handle the database getrelateddocument request and return a XML document, 

   * possibly transformed from XML into HTML

   */

  private void handleGetRelatedDocumentAction(PrintWriter out, Hashtable params,

               HttpServletResponse response, URL murl) 

               throws ClassNotFoundException, IOException, SQLException 

  {

    String docid = null;

    Connection conn = null;

    //if(params.containsKey("url"))

    //{//the identifier for the related document is contained in the URL param

      try

      {

        DocumentImpl xmldoc=null;

        //MetacatURL murl = new MetacatURL(((String[])params.get("url"))[0]);

        if(murl.getProtocol().equals("metacat"))

        {//get the document from the database if it is the right type of url

          //Hashtable murlParams = murl.getHashParams();

          Hashtable murlParams = util.parseQuery(murl.getQuery());

          if(murlParams.containsKey("docid"))

          {//the docid should be first

            docid = (String)murlParams.get("docid"); //get the docid value

            conn = util.getConnection();

            xmldoc = new DocumentImpl(conn, docid);

            String qformat = ((String[])params.get("qformat"))[0];

            if (qformat.equals("xml")) 

            { 

              // set content type and other response header fields first

              response.setContentType("text/xml");

              xmldoc.toXml(out);

              //out.println(xmldoc);

            } 

            else if (qformat.equals("html")) 

            {

              response.setContentType("text/html");

              // Look up the document type

              String sourcetype = xmldoc.getDoctype();

              // Transform the document to the new doctype

              DBTransform dbt = new DBTransform(conn);

              dbt.transformXMLDocument(xmldoc.toString(), sourcetype, 

                                 "-//W3C//HTML//EN", out);

            }

            util.returnConnection(conn);

          }

          else

          {

            //throw new Exception("handleGetDocument: bad URL");

            System.err.println("handleGetDocument: bad URL");

          }

        }

        else if(murl.getProtocol().equals("http"))

        {//get the document from the internet

          //Hashtable murlParams = murl.getHashParams();

          Hashtable murlParams = util.parseQuery(murl.getQuery());

          if(murlParams.containsKey("httpurl"))

          {//httpurl is the param name for an http url.

            URL urlconn = new URL((String)murlParams.get("httpurl"));  

            //create a new url obj.

            //DataInputStream htmldoc = new DataInputStream(urlconn.openStream());

            BufferedReader htmldoc = new BufferedReader(

                                   new InputStreamReader(urlconn.openStream()));

            //bind a data stream.

            try

            { //display the document

              String line=null;

              while((line = htmldoc.readLine()) != null)

              {

                out.println(line); 

              }

            }

            catch(Exception e)

            {

              util.debugMessage("error viewing html document"); 

            }

          }

        }

      }

      catch (McdbException e) {

        response.setContentType("text/xml");

        e.toXml(out);

      } catch   (Throwable t) {

        response.setContentType("text/html");

        out.println(t.getMessage());

      } finally {

        util.returnConnection(conn);

      }

    //} // end if

  }   

  /** 

   * Handle the database read request and return an XML document, 

   * possibly transformed from XML into HTML

   */

  private void handleReadAction(PrintWriter out, Hashtable params, 

               HttpServletResponse response) 

               throws ClassNotFoundException, IOException, SQLException 

  {