/src/edu/ucsb/nceas/metacat/MetaCatServlet.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/MetaCatServlet.java @ 2596

-            jones
+/**
-            jones
+ *  '$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
-            berkley
+ *    Authors: Matt Jones, Dan Higgins, Jivka Bojilova, Chad Berkley
-            jones
+ *    Release: @release@
             jones
-            jones
+ *   '$Author$'
  *     '$Date$'
  * '$Revision$'
             jones
  * This program 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 program 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 program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-            jones
+ */
 package edu.ucsb.nceas.metacat;
-            jones
+import java.io.BufferedInputStream;
-            bojilova
+import java.io.File;
-            jones
+import java.io.FileInputStream;
 import java.io.IOException;
-            jones
+import java.io.PrintWriter;
-            jones
+import java.io.StringReader;
-            jones
+import java.net.MalformedURLException;
 import java.net.URL;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-            jones
+import java.sql.Timestamp;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-            jones
+import java.util.Enumeration;
 import java.util.Hashtable;
-            jones
+import java.util.Iterator;
-            jones
+import java.util.PropertyResourceBundle;
-            tao
+import java.util.Vector;
-            jones
+import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
             jones
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletContext;
 import javax.servlet.ServletException;
-            jones
+import javax.servlet.ServletOutputStream;
-            jones
+import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-            bojilova
+import javax.servlet.http.HttpSession;
             jones
-            jones
+import org.ecoinformatics.eml.EMLParser;
             jones
-            jones
+import com.oreilly.servlet.multipart.FilePart;
 import com.oreilly.servlet.multipart.MultipartParser;
 import com.oreilly.servlet.multipart.ParamPart;
 import com.oreilly.servlet.multipart.Part;
-            jones
+import edu.ucsb.nceas.utilities.Options;
-            jones
+/**
  * A metadata catalog server implemented as a Java Servlet
             sgarg
-            jones
+ * <p>
-            jones
+ * 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= -- export a zip format for data packadge <br>
  * action=read -- read any metadata/data file from Metacat and from Internet
  * <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>
  * 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>
  * qformat=zip -- zip resultset from query <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>
  * acltext -- XML access text for a document to load into the database <br>
  * dtdtext -- XML DTD text for a new DTD to load into Metacat XML Catalog <br>
  * query -- actual query text (to go with 'action=query' or 'action=squery')
  * <br>
  * valtext -- XML text to be validated <br>
  * action=getaccesscontrol -- retrieve acl info for Metacat document <br>
  * action=getdoctypes -- retrieve all doctypes (publicID) <br>
  * action=getdtdschema -- retrieve a DTD or Schema file <br>
  * action=getdataguide -- retrieve a Data Guide <br>
  * action=getprincipals -- retrieve a list of principals in XML <br>
  * datadoc -- data document name (id) <br>
-            jones
+ * action=getlog -- get a report of events that have occurred in the system<br>
  * ipAddress --  filter on one or more IP addresses<br>
  * principal -- filter on one or more principals (LDAP DN syntax)<br>
  * docid -- filter on one or more document identifiers (with revision)<br>
  * event -- filter on event type (e.g., read, insert, update, delete)<br>
  * start -- filter out events before the start date-time<br>
  * end -- filter out events before the end date-time<br>
-            jones
+ * <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.
-            jones
+ */
-            jones
+public class MetaCatServlet extends HttpServlet
+{
             jones
-            jones
+    private ServletConfig config = null;
             jones
-            jones
+    private ServletContext context = null;
             jones
-            jones
+    private String resultStyleURL = null;
             jones
-            jones
+    private String xmlcatalogfile = null;
             tao
-            jones
+    private String saxparser = null;
             jones
-            jones
+    private String datafilepath = null;
             bojilova
-            jones
+    private File dataDirectory = null;
             tao
-            jones
+    private String servletpath = null;
             jones
-            jones
+    private String htmlpath = null;
             bojilova
-            jones
+    private PropertyResourceBundle options = null;
             jones
-            jones
+    private MetaCatUtil util = null;
             jones
-            jones
+    private DBConnectionPool connPool = null;
             jones
-            tao
+    private static Hashtable sessionHash = new Hashtable();
             jones
-            jones
+    private static final String PROLOG = "<?xml version=\"1.0\"?>";
             jones
-            jones
+    private static final String SUCCESS = "<success>";
             tao
-            jones
+    private static final String SUCCESSCLOSE = "</success>";
             tao
-            jones
+    private static final String ERROR = "<error>";
             tao
-            jones
+    private static final String ERRORCLOSE = "</error>";
             tao
-            jones
+    public static final String SCHEMALOCATIONKEYWORD = ":schemaLocation";
             tao
-            jones
+    public static final String NONAMESPACELOCATION = ":noNamespaceSchemaLocation";
             tao
-            jones
+    public static final String EML2KEYWORD = ":eml";
             tao
-            jones
+    public static final String XMLFORMAT = "xml";
             tao
-            jones
+    private static final String CONFIG_DIR = "WEB-INF";
             tao
-            jones
+    private static final String CONFIG_NAME = "metacat.properties";
             sgarg
     public static String LOG_CONFIG_NAME;
-            jones
+    /**
      * 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();
             tao
-            jones
+            // Initialize the properties file for our options
             String dirPath = context.getRealPath(CONFIG_DIR);
             File propertyFile = new File(dirPath, CONFIG_NAME);
             sgarg
     	    LOG_CONFIG_NAME = dirPath + "/log4j.properties";
-            jones
+            Options options = null;
             try {
                 options = Options.initialize(propertyFile);
                 MetaCatUtil.debugMessage("Options configured: "
                         + options.getOption("configured"), 20);
             } catch (IOException ioe) {
                 MetaCatUtil.debugMessage("Error in loading options: "
                         + ioe.getMessage(), 20);
+            }
             berkley
-            jones
+            util = new MetaCatUtil();
             tao
-            jones
+            //initial DBConnection pool
             connPool = DBConnectionPool.getInstance();
             tao
-            jones
+            // Get the configuration file information
             resultStyleURL = MetaCatUtil.getOption("resultStyleURL");
             xmlcatalogfile = MetaCatUtil.getOption("xmlcatalogfile");
             saxparser = MetaCatUtil.getOption("saxparser");
             datafilepath = MetaCatUtil.getOption("datafilepath");
             dataDirectory = new File(datafilepath);
             servletpath = MetaCatUtil.getOption("servletpath");
             htmlpath = MetaCatUtil.getOption("htmlpath");
             tao
-            sgarg
+            // Index the paths specified in the metacat.properties
             checkIndexPaths();
-            jones
+            System.out.println("Metacat (" + Version.getVersion()
-            sgarg
+                               + ") initialized.");
-            jones
+        } catch (ServletException ex) {
             throw ex;
         } catch (SQLException e) {
             MetaCatUtil.debugMessage("Error in MetacatServlet.init: "
                     + e.getMessage(), 20);
             tao
             jones
             tao
-            jones
+    /**
      * Close all db connections from the pool
      */
     public void destroy()
+    {
         // Close all db connection
         System.out.println("Destroying MetacatServlet");
         DBConnectionPool.release();
+    }
             sgarg
-            jones
+    /** 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);
+    }
-            jones
+    /**
-            sgarg
+     * Index the paths specified in the metacat.properties
      */
-            jones
+    private void checkIndexPaths(){
-            sgarg
+        MetaCatUtil.pathsForIndexing
             = MetaCatUtil.getOptionList(MetaCatUtil.getOption("indexed_paths"));
             jones
-            sgarg
+        if (MetaCatUtil.pathsForIndexing != null) {
             jones
-            sgarg
+            MetaCatUtil.debugMessage("Indexing paths....", 20);
             jones
-            sgarg
+            DBConnection conn = null;
             int serialNumber = -1;
             PreparedStatement pstmt = null;
             PreparedStatement pstmt1 = null;
             ResultSet rs = null;
             jones
-            sgarg
+            for (int i = 0; i < MetaCatUtil.pathsForIndexing.size(); i++) {
                 MetaCatUtil.formattedDebugMessage("Checking if '"
                            + (String) MetaCatUtil.pathsForIndexing.elementAt(i)
                            + "' is indexed.... ",30, false, true);
             jones
-            sgarg
+                try {
                     //check out DBConnection
                     conn = DBConnectionPool.
                         getDBConnection("MetaCatServlet.checkIndexPaths");
                     serialNumber = conn.getCheckOutSerialNumber();
             jones
-            sgarg
+                    pstmt = conn.prepareStatement(
                         "SELECT * FROM xml_path_index " + "WHERE path = ?");
                     pstmt.setString(1, (String) MetaCatUtil.pathsForIndexing
                                     .elementAt(i));
             jones
-            sgarg
+                    pstmt.execute();
                     rs = pstmt.getResultSet();
             jones
-            sgarg
+                    if (!rs.next()) {
                         MetaCatUtil.formattedDebugMessage("not indexed yet.", 30,
                                                        true, false);
                         rs.close();
                         pstmt.close();
                         conn.increaseUsageCount(1);
             jones
-            sgarg
+                        MetaCatUtil.debugMessage(
                               "Inserting following path in xml_path_index: "
                               + (String)MetaCatUtil.pathsForIndexing
                                                    .elementAt(i), 60);
             jones
-            sgarg
+                        pstmt = conn.prepareStatement("SELECT DISTINCT n.docid, "
                               + "n.nodedata, n.nodedatanumerical, n.parentnodeid"
                               + " FROM xml_nodes n, xml_index i WHERE"
                               + " i.path = ? and n.parentnodeid=i.nodeid and"
                               + " n.nodetype LIKE 'TEXT'");
                         pstmt.setString(1, (String) MetaCatUtil.
                                         pathsForIndexing.elementAt(i));
                         pstmt.execute();
                         rs = pstmt.getResultSet();
             jones
-            sgarg
+                        int count = 0;
                         MetaCatUtil.debugMessage(
                                        "Executed the select statement for: "
                                        + (String) MetaCatUtil.pathsForIndexing
                                          .elementAt(i), 60);
             jones
-            sgarg
+                        try {
                             while (rs.next()) {
             jones
-            sgarg
+                                String docid = rs.getString(1);
                                 String nodedata = rs.getString(2);
                                 float nodedatanumerical = rs.getFloat(3);
                                 int parentnodeid = rs.getInt(4);
             jones
-            sgarg
+                                if (!nodedata.trim().equals("")) {
                                     pstmt1 = conn.prepareStatement(
                                         "INSERT INTO xml_path_index"
                                         + " (docid, path, nodedata, "
                                         + "nodedatanumerical, parentnodeid)"
                                         + " VALUES (?, ?, ?, ?, ?)");
             jones
-            sgarg
+                                    pstmt1.setString(1, docid);
                                     pstmt1.setString(2, (String) MetaCatUtil.
                                                 pathsForIndexing.elementAt(i));
                                     pstmt1.setString(3, nodedata);
                                     pstmt1.setFloat(4, nodedatanumerical);
                                     pstmt1.setFloat(5, parentnodeid);
             jones
-            sgarg
+                                    pstmt1.execute();
                                     pstmt1.close();
             jones
-            sgarg
+                                    count++;
             jones
             sgarg
+                            }
+                        }
                         catch (Exception e) {
                             System.out.println("Exception:" + e.getMessage());
                             e.printStackTrace();
+                        }
             jones
-            sgarg
+                        rs.close();
                         pstmt.close();
                         conn.increaseUsageCount(1);
             jones
-            sgarg
+                        MetaCatUtil.debugMessage("Indexed " + count
                                 + " records from xml_nodes for '"
                                 + (String) MetaCatUtil.pathsForIndexing.elementAt(i)
                                 + "'", 20);
             jones
-            sgarg
+                    } else {
                         MetaCatUtil.formattedDebugMessage("already indexed.", 30,
                                                        true, false);
+                    }
             jones
-            sgarg
+                    rs.close();
                     pstmt.close();
                     conn.increaseUsageCount(1);
             jones
-            sgarg
+                } catch (Exception e) {
                     MetaCatUtil.debugMessage("error in DocumentImpl.delete: "
                                              + e.getMessage(), 30);
                 }finally {
                     //check in DBonnection
                     DBConnectionPool.returnDBConnection(conn, serialNumber);
+                }
             jones
             sgarg
             jones
-            sgarg
+            MetaCatUtil.debugMessage("Path Indexing Completed", 20);
+        }
+    }
             berkley
             tao
-            jones
+    /**
      * Control servlet response depending on the action parameter specified
      */
     private void handleGetOrPost(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
             tao
             tao
-            jones
+        if (util == null) {
             util = new MetaCatUtil();
+        }
         /*
          * MetaCatUtil.debugMessage("Connection pool size: "
          * +connPool.getSizeOfDBConnectionPool(),10);
          * MetaCatUtil.debugMessage("Free DBConnection number: "
          */
         //If all DBConnection in the pool are free and DBConnection pool
         //size is greater than initial value, shrink the connection pool
         //size to initial value
         DBConnectionPool.shrinkDBConnectionPoolSize();
             tao
-            jones
+        //Debug message to print out the method which have a busy DBConnection
         connPool.printMethodNameHavingBusyDBConnection();
             tao
-            jones
+        String ctype = request.getContentType();
         if (ctype != null && ctype.startsWith("multipart/form-data")) {
             handleMultipartForm(request, response);
         } else {
             tao
-            jones
+            String name = null;
             String[] value = null;
             String[] docid = new String[3];
             Hashtable params = new Hashtable();
             Enumeration paramlist = request.getParameterNames();
             tao
-            jones
+            while (paramlist.hasMoreElements()) {
             tao
-            jones
+                name = (String) paramlist.nextElement();
                 value = request.getParameterValues(name);
             bojilova
-            jones
+                // Decode the docid and mouse click information
                 if (name.endsWith(".y")) {
                     docid[0] = name.substring(0, name.length() - 2);
                     params.put("docid", docid);
                     name = "ypos";
+                }
                 if (name.endsWith(".x")) {
                     name = "xpos";
+                }
             bojilova
-            jones
+                params.put(name, value);
+            }
             bojilova
-            jones
+            //handle param is emptpy
             if (params.isEmpty() || params == null) { return; }
             bojilova
-            jones
+            //if the user clicked on the input images, decode which image
             //was clicked then set the action.
-            sgarg
+            if(params.get("action") == null){
                 PrintWriter out = response.getWriter();
                 response.setContentType("text/xml");
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println("Action not specified");
                 out.println("</error>");
                 out.close();
                 return;
+            }
-            jones
+            String action = ((String[]) params.get("action"))[0];
             MetaCatUtil.debugMessage("Line 230: Action is: " + action, 1);
             bojilova
-            jones
+            // 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 password = null;
             String[] groupnames = null;
             String sess_id = null;
             tao
-            jones
+            // handle login action
             if (action.equals("login")) {
                 PrintWriter out = response.getWriter();
                 handleLoginAction(out, params, request, response);
                 out.close();
             tao
-            jones
+                // handle logout action
             } else if (action.equals("logout")) {
                 PrintWriter out = response.getWriter();
                 handleLogoutAction(out, params, request, response);
                 out.close();
             tao
-            jones
+                // handle shrink DBConnection request
             } else if (action.equals("shrink")) {
                 PrintWriter out = response.getWriter();
                 boolean success = false;
                 //If all DBConnection in the pool are free and DBConnection
                 // pool
                 //size is greater than initial value, shrink the connection
                 // pool
                 //size to initial value
                 success = DBConnectionPool.shrinkConnectionPoolSize();
                 if (success) {
                     //if successfully shrink the pool size to initial value
                     out.println("DBConnection Pool shrunk successfully.");
                 }//if
                 else {
                     out.println("DBConnection pool not shrunk successfully.");
+                }
                 //close out put
                 out.close();
             tao
-            jones
+                // aware of session expiration on every request
             } else {
                 HttpSession sess = request.getSession(true);
                 if (sess.isNew() && !params.containsKey("sessionid")) {
                     // session expired or has not been stored b/w user requests
                     MetaCatUtil.debugMessage(
                             "in session is new or no sessionid", 40);
                     username = "public";
                     sess.setAttribute("username", username);
                 } else {
                     MetaCatUtil.debugMessage("in session is not new or "
                             + " has sessionid parameter", 40);
                     try {
                         if (params.containsKey("sessionid")) {
                             sess_id = ((String[]) params.get("sessionid"))[0];
                             MetaCatUtil.debugMessage("in has sessionid "
                                     + sess_id, 40);
                             if (sessionHash.containsKey(sess_id)) {
                                 MetaCatUtil.debugMessage("find the id "
                                         + sess_id + " in hash table", 40);
                                 sess = (HttpSession) sessionHash.get(sess_id);
+                            }
                         } else {
                             // we already store the session in login, so we
                             // don't need here
                             /*
                              * MetaCatUtil.debugMessage("in no sessionid
                              * parameter ", 40); sess_id =
                              * (String)sess.getId();
                              * MetaCatUtil.debugMessage("storing the session id "
                              * + sess_id + " which has username " +
                              * sess.getAttribute("username") + " into session
                              * hash in handleGetOrPost method", 35);
                              */
+                        }
                     } catch (IllegalStateException ise) {
                         System.out.println(
                                 "error in handleGetOrPost: this shouldn't "
                                 + "happen: the session should be valid: "
                                 + ise.getMessage());
+                    }
             tao
-            jones
+                    username = (String) sess.getAttribute("username");
                     MetaCatUtil.debugMessage("The user name from session is: "
                             + username, 20);
                     password = (String) sess.getAttribute("password");
                     groupnames = (String[]) sess.getAttribute("groupnames");
+                }
             tao
-            jones
+                //make user user username should be public
                 if (username == null || (username.trim().equals(""))) {
                     username = "public";
+                }
                 MetaCatUtil.debugMessage("The user is : " + username, 5);
+            }
             // Now that we know the session is valid, we can delegate the
             // request
             // to a particular action handler
             if (action.equals("query")) {
                 PrintWriter out = response.getWriter();
                 handleQuery(out, params, response, username, groupnames,
                         sess_id);
                 out.close();
             } else if (action.equals("squery")) {
                 PrintWriter out = response.getWriter();
                 if (params.containsKey("query")) {
                     handleSQuery(out, params, response, username, groupnames,
                             sess_id);
                     out.close();
                 } else {
                     out.println(
                             "Illegal action squery without \"query\" parameter");
                     out.close();
+                }
             } else if (action.equals("export")) {
             tao
-            sgarg
+                handleExportAction(params, response, username,
-            jones
+                        groupnames, password);
-            jones
+            } else if (action.equals("read")) {
-            jones
+                handleReadAction(params, request, response, username, password,
-            jones
+                        groupnames);
             } else if (action.equals("readinlinedata")) {
-            jones
+                handleReadInlineDataAction(params, request, response, username,
-            jones
+                        password, groupnames);
             } else if (action.equals("insert") || action.equals("update")) {
                 PrintWriter out = response.getWriter();
                 if ((username != null) && !username.equals("public")) {
-            jones
+                    handleInsertOrUpdateAction(request, response,
                             out, params, username, groupnames);
-            jones
+                } else {
-            sgarg
+                    response.setContentType("text/xml");
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<error>");
-            jones
+                    out.println("Permission denied for user " + username + " "
                             + action);
-            sgarg
+                    out.println("</error>");
             jones
                 out.close();
             } else if (action.equals("delete")) {
                 PrintWriter out = response.getWriter();
                 if ((username != null) && !username.equals("public")) {
-            jones
+                    handleDeleteAction(out, params, request, response, username,
-            jones
+                            groupnames);
                 } else {
-            sgarg
+                    response.setContentType("text/xml");
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<error>");
-            jones
+                    out.println("Permission denied for " + action);
-            sgarg
+                    out.println("</error>");
             jones
                 out.close();
             } else if (action.equals("validate")) {
                 PrintWriter out = response.getWriter();
                 handleValidateAction(out, params);
                 out.close();
             } else if (action.equals("setaccess")) {
                 PrintWriter out = response.getWriter();
                 handleSetAccessAction(out, params, username);
                 out.close();
             } else if (action.equals("getaccesscontrol")) {
                 PrintWriter out = response.getWriter();
                 handleGetAccessControlAction(out, params, response, username,
                         groupnames);
                 out.close();
             } else if (action.equals("getprincipals")) {
                 PrintWriter out = response.getWriter();
                 handleGetPrincipalsAction(out, username, password);
                 out.close();
             } else if (action.equals("getdoctypes")) {
                 PrintWriter out = response.getWriter();
                 handleGetDoctypesAction(out, params, response);
                 out.close();
             } else if (action.equals("getdtdschema")) {
                 PrintWriter out = response.getWriter();
                 handleGetDTDSchemaAction(out, params, response);
                 out.close();
             } else if (action.equals("getlastdocid")) {
                 PrintWriter out = response.getWriter();
                 handleGetMaxDocidAction(out, params, response);
                 out.close();
             } else if (action.equals("getrevisionanddoctype")) {
                 PrintWriter out = response.getWriter();
                 handleGetRevisionAndDocTypeAction(out, params);
                 out.close();
             } else if (action.equals("getversion")) {
                 response.setContentType("text/xml");
                 PrintWriter out = response.getWriter();
                 out.println(Version.getVersionAsXml());
                 out.close();
-            jones
+            } else if (action.equals("getlog")) {
-            sgarg
+                handleGetLogAction(params, request, response, username, groupnames);
-            jones
+            } else if (action.equals("buildindex")) {
-            sgarg
+                handleBuildIndexAction(params, request, response, username, groupnames);
-            jones
+            } else if (action.equals("login") || action.equals("logout")) {
-            jones
+                /*
-            jones
+            } 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) {
-            jones
+                        Hashtable qparams = MetaCatUtil.parseQuery(u.getQuery());
-            jones
+                        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) {
                     System.out.println(
                             "bad url from MetacatServlet.handleGetOrPost");
                     out.println(mue.getMessage());
                     mue.printStackTrace(out);
                     out.close();
+                }
-            jones
+                */
-            jones
+            } else {
                 PrintWriter out = response.getWriter();
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println(
                      "Error: action not registered.  Please report this error.");
                 out.println("</error>");
                 out.close();
+            }
             tao
-            jones
+            //util.closeConnections();
             // Close the stream to the client
             //out.close();
+        }
+    }
             bojilova
-            jones
+    // LOGIN & LOGOUT SECTION
     /**
      * 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)
             tao
             tao
-            jones
+        AuthSession sess = null;
             sgarg
         if(params.get("username") == null){
             response.setContentType("text/xml");
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println("Username not specified");
             out.println("</error>");
             return;
+        }
         if(params.get("password") == null){
             response.setContentType("text/xml");
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println("Password not specified");
             out.println("</error>");
             return;
+        }
-            jones
+        String un = ((String[]) params.get("username"))[0];
         MetaCatUtil.debugMessage("user " + un + " try to login", 20);
         String pw = ((String[]) params.get("password"))[0];
             tao
-            sgarg
+        String qformat = "xml";
         if(params.get("qformat") != null){
             qformat = ((String[]) params.get("qformat"))[0];
+        }
-            jones
+        try {
             sess = new AuthSession();
         } catch (Exception e) {
             System.out.println("error in MetacatServlet.handleLoginAction: "
                     + e.getMessage());
             out.println(e.getMessage());
             return;
+        }
         boolean isValid = sess.authenticate(request, un, pw);
             tao
-            jones
+        //if it is authernticate is true, store the session
         if (isValid) {
             HttpSession session = sess.getSessions();
             String id = session.getId();
             MetaCatUtil.debugMessage("Store session id " + id
                     + "which has username" + session.getAttribute("username")
                     + " into hash in login method", 35);
             sessionHash.put(id, session);
+        }
             tao
-            jones
+        // format and transform the output
         if (qformat.equals("xml")) {
             response.setContentType("text/xml");
             out.println(sess.getMessage());
         } else {
             try {
                 DBTransform trans = new DBTransform();
                 response.setContentType("text/html");
                 trans.transformXMLDocument(sess.getMessage(),
                         "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,
                         out, null);
             } catch (Exception e) {
             tao
-            jones
+                MetaCatUtil.debugMessage(
                         "Error in MetaCatServlet.handleLoginAction: "
                                 + e.getMessage(), 30);
+            }
+        }
+    }
             berkley
-            jones
+    /**
      * Handle the logout request. Close the connection.
      */
     private void handleLogoutAction(PrintWriter out, Hashtable params,
             HttpServletRequest request, HttpServletResponse response)
             tao
             berkley
-            sgarg
+        String qformat = "xml";
         if(params.get("qformat") != null){
             qformat = ((String[]) params.get("qformat"))[0];
+        }
             berkley
-            jones
+        // close the connection
         HttpSession sess = request.getSession(false);
         MetaCatUtil.debugMessage("After get session in logout request", 40);
         if (sess != null) {
             MetaCatUtil.debugMessage("The session id " + sess.getId()
                     + " will be invalidate in logout action", 30);
             MetaCatUtil.debugMessage("The session contains user "
                     + sess.getAttribute("username")
                     + " will be invalidate in logout action", 30);
             sess.invalidate();
+        }
             berkley
-            jones
+        // produce output
         StringBuffer output = new StringBuffer();
         output.append("<?xml version=\"1.0\"?>");
         output.append("<logout>");
         output.append("User logged out");
         output.append("</logout>");
             tao
-            jones
+        //format and transform the output
         if (qformat.equals("xml")) {
             response.setContentType("text/xml");
             out.println(output.toString());
         } else {
             try {
                 DBTransform trans = new DBTransform();
                 response.setContentType("text/html");
                 trans.transformXMLDocument(output.toString(),
                         "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,
                         out, null);
             } catch (Exception e) {
                 MetaCatUtil.debugMessage(
                         "Error in MetaCatServlet.handleLogoutAction"
                                 + e.getMessage(), 30);
+            }
             berkley
             jones
             tao
-            jones
+    // END OF LOGIN & LOGOUT SECTION
             berkley
-            jones
+    // SQUERY & QUERY SECTION
     /**
      * Retreive the squery xml, execute it and display it
             sgarg
-            jones
+     * @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
      */
-            jones
+    private void handleSQuery(PrintWriter out, Hashtable params,
-            jones
+            HttpServletResponse response, String user, String[] groups,
             String sessionid)
+    {
         double startTime = System.currentTimeMillis() / 1000;
         DBQuery queryobj = new DBQuery(saxparser);
         queryobj.findDocuments(response, out, params, user, groups, sessionid);
         double outPutTime = System.currentTimeMillis() / 1000;
         MetaCatUtil.debugMessage("total search time: "
                 + (outPutTime - startTime), 30);
             tao
             jones
             berkley
-            jones
+    /**
      * Create the xml query, execute it and display the results.
             sgarg
-            jones
+     * @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
      */
-            jones
+    private void handleQuery(PrintWriter out, Hashtable params,
-            jones
+            HttpServletResponse response, String user, String[] groups,
             String sessionid)
             tao
-            jones
+        //create the query and run it
         String xmlquery = DBQuery.createSQuery(params);
         String[] queryArray = new String[1];
         queryArray[0] = xmlquery;
         params.put("query", queryArray);
         double startTime = System.currentTimeMillis() / 1000;
         DBQuery queryobj = new DBQuery(saxparser);
         queryobj.findDocuments(response, out, params, user, groups, sessionid);
         double outPutTime = System.currentTimeMillis() / 1000;
         MetaCatUtil.debugMessage("total search time: "
                 + (outPutTime - startTime), 30);
             berkley
-            jones
+        //handleSQuery(out, params, response,user, groups, sessionid);
             tao
             berkley
-            jones
+    // END OF SQUERY & QUERY SECTION
             berkley
-            jones
+    //Exoport section
     /**
      * Handle the "export" request of data package from Metacat in zip format
             sgarg
-            jones
+     * @param params the Hashtable of HTTP request parameters
      * @param response the HTTP response object linked to the client
      * @param user the username sent the request
      * @param groups the user's groupnames
      */
-            sgarg
+    private void handleExportAction(Hashtable params,
             HttpServletResponse response,
-            jones
+            String user, String[] groups, String passWord)
             jones
         // Output stream
         ServletOutputStream out = null;
         // Zip output stream
         ZipOutputStream zOut = null;
         DBQuery queryObj = null;
             berkley
-            jones
+        String[] docs = new String[10];
         String docId = "";
             tao
-            bojilova
+        try {
-            jones
+            // read the params
             if (params.containsKey("docid")) {
                 docs = (String[]) params.get("docid");
             bojilova
-            jones
+            // Create a DBuery to handle export
             queryObj = new DBQuery(saxparser);
             // Get the docid
             docId = docs[0];
             // Make sure the client specify docid
             if (docId == null || docId.equals("")) {
                 response.setContentType("text/xml"); //MIME type
                 // Get a printwriter
                 PrintWriter pw = response.getWriter();
                 // Send back message
                 pw.println("<?xml version=\"1.0\"?>");
                 pw.println("<error>");
                 pw.println("You didn't specify requested docid");
                 pw.println("</error>");
                 // Close printwriter
                 pw.close();
                 return;
+            }
             // Get output stream
             out = response.getOutputStream();
             response.setContentType("application/zip"); //MIME type
-            sgarg
+            response.setHeader("Content-Disposition",
             		"attachment; filename="
             		+ docId + ".zip"); // Set the name of the zip file
-            jones
+            zOut = new ZipOutputStream(out);
             zOut = queryObj
                     .getZippedPackage(docId, out, user, groups, passWord);
             zOut.finish(); //terminate the zip file
             zOut.close(); //close the zip stream
             bojilova
-            jones
+        } catch (Exception e) {
             try {
                 response.setContentType("text/xml"); //MIME type
                 // Send error message back
                 if (out != null) {
                     PrintWriter pw = new PrintWriter(out);
                     pw.println("<?xml version=\"1.0\"?>");
                     pw.println("<error>");
                     pw.println(e.getMessage());
                     pw.println("</error>");
                     // Close printwriter
                     pw.close();
                     // Close output stream
                     out.close();
+                }
                 // Close zip output stream
                 if (zOut != null) {
                     zOut.close();
+                }
             } catch (IOException ioe) {
                 MetaCatUtil.debugMessage("Problem with the servlet output "
                         + "in MetacatServlet.handleExportAction: "
                         + ioe.getMessage(), 30);
             bojilova
-            jones
+            MetaCatUtil.debugMessage(
                     "Error in MetacatServlet.handleExportAction: "
                             + e.getMessage(), 30);
             e.printStackTrace(System.out);
             bojilova
             tao
             jones
             tao
-            jones
+    /**
      * In eml2 document, the xml can have inline data and data was stripped off
      * and store in file system. This action can be used to read inline data
      * only
             sgarg
-            jones
+     * @param params the Hashtable of HTTP request parameters
      * @param response the HTTP response object linked to the client
      * @param user the username sent the request
      * @param groups the user's groupnames
      */
     private void handleReadInlineDataAction(Hashtable params,
-            sgarg
+            HttpServletRequest request, HttpServletResponse response,
-            jones
+            String user, String passWord, String[] groups)
             jones
         String[] docs = new String[10];
         String inlineDataId = null;
         String docId = "";
         ServletOutputStream out = null;
             tao
-            jones
+        try {
             // read the params
             if (params.containsKey("inlinedataid")) {
                 docs = (String[]) params.get("inlinedataid");
+            }
             // Get the docid
             inlineDataId = docs[0];
             // Make sure the client specify docid
-            sgarg
+            if (inlineDataId == null || inlineDataId.equals("")) {
-            jones
+                throw new Exception("You didn't specify requested inlinedataid"); }
             tao
-            jones
+            // check for permission
             docId = MetaCatUtil
                     .getDocIdWithoutRevFromInlineDataID(inlineDataId);
             PermissionController controller = new PermissionController(docId);
             // check top level read permission
             if (!controller.hasPermission(user, groups,
-            sgarg
+                    AccessControlInterface.READSTRING))
+            {
-            jones
+                throw new Exception("User " + user
                         + " doesn't have permission " + " to read document "
                         + docId);
+            }
-            sgarg
+            else
+            {
               //check data access level
               try
+              {
                 Hashtable unReadableInlineDataList =
-            sgarg
+                    PermissionController.getUnReadableInlineDataIdList(docId,
                     user, groups, false);
                 if (unReadableInlineDataList.containsValue(
                           MetaCatUtil.getInlineDataIdWithoutRev(inlineDataId)))
             sgarg
                   throw new Exception("User " + user
                        + " doesn't have permission " + " to read inlinedata "
                        + inlineDataId);
             jones
-            sgarg
+                }//if
               }//try
               catch (Exception e)
+              {
                 throw e;
               }//catch
             }//else
-            jones
+            // Get output stream
             out = response.getOutputStream();
             // read the inline data from the file
             String inlinePath = MetaCatUtil.getOption("inlinedatafilepath");
             File lineData = new File(inlinePath, inlineDataId);
             FileInputStream input = new FileInputStream(lineData);
             byte[] buffer = new byte[4 * 1024];
             int bytes = input.read(buffer);
             while (bytes != -1) {
                 out.write(buffer, 0, bytes);
                 bytes = input.read(buffer);
+            }
-            tao
+            out.close();
             tao
-            sgarg
+            EventLog.getInstance().log(request.getRemoteAddr(), user,
-            jones
+                    inlineDataId, "readinlinedata");
-            jones
+        } catch (Exception e) {
             try {
                 PrintWriter pw = null;
                 // Send error message back
                 if (out != null) {
                     pw = new PrintWriter(out);
                 } else {
                     pw = response.getWriter();
+                }
                 pw.println("<?xml version=\"1.0\"?>");
                 pw.println("<error>");
                 pw.println(e.getMessage());
                 pw.println("</error>");
                 // Close printwriter
                 pw.close();
                 // Close output stream if out is not null
                 if (out != null) {
                     out.close();
+                }
             } catch (IOException ioe) {
                 MetaCatUtil.debugMessage("Problem with the servlet output "
                         + "in MetacatServlet.handleExportAction: "
                         + ioe.getMessage(), 30);
+            }
             MetaCatUtil.debugMessage(
                     "Error in MetacatServlet.handleReadInlineDataAction: "
                             + e.getMessage(), 30);
             tao
             jones
     /*
      * Get the nodeid from xml_nodes for the inlinedataid
      */
     private long getInlineDataNodeId(String inLineDataId, String docId)
             throws SQLException
             tao
-            jones
+        long nodeId = 0;
         String INLINE = "inline";
         boolean hasRow;
         PreparedStatement pStmt = null;
         DBConnection conn = null;
         int serialNumber = -1;
         String sql = "SELECT nodeid FROM xml_nodes WHERE docid=? AND nodedata=? "
                 + "AND nodetype='TEXT' AND parentnodeid IN "
                 + "(SELECT nodeid FROM xml_nodes WHERE docid=? AND "
                 + "nodetype='ELEMENT' AND nodename='" + INLINE + "')";
             tao
-            jones
+        try {
             //check out DBConnection
             conn = DBConnectionPool
                     .getDBConnection("AccessControlList.isAllowFirst");
             serialNumber = conn.getCheckOutSerialNumber();
             tao
-            jones
+            pStmt = conn.prepareStatement(sql);
             //bind value
             pStmt.setString(1, docId);//docid
             pStmt.setString(2, inLineDataId);//inlinedataid
             pStmt.setString(3, docId);
             // excute query
             pStmt.execute();
             ResultSet rs = pStmt.getResultSet();
             hasRow = rs.next();
             // get result
             if (hasRow) {
                 nodeId = rs.getLong(1);
             }//if
         } catch (SQLException e) {
             throw e;
         } finally {
             try {
                 pStmt.close();
             } finally {
                 DBConnectionPool.returnDBConnection(conn, serialNumber);
+            }
             tao
-            jones
+        MetaCatUtil.debugMessage("The nodeid for inlinedataid " + inLineDataId
                 + " is: " + nodeId, 35);
         return nodeId;
+    }
             tao
-            jones
+    /**
      * Handle the "read" request of metadata/data files from Metacat or any
      * files from Internet; transformed metadata XML document into HTML
      * presentation if requested; zip files when more than one were requested.
             sgarg
-            jones
+     * @param params the Hashtable of HTTP request parameters
-            jones
+     * @param request the HTTP request object linked to the client
-            jones
+     * @param response the HTTP response object linked to the client
      * @param user the username sent the request
      * @param groups the user's groupnames
      */
-            jones
+    private void handleReadAction(Hashtable params, HttpServletRequest request,
-            jones
+            HttpServletResponse response, String user, String passWord,
             String[] groups)
+    {
         ServletOutputStream out = null;
         ZipOutputStream zout = null;
         PrintWriter pw = null;
         boolean zip = false;
         boolean withInlineData = true;
             tao
-            jones
+        try {
             String[] docs = new String[0];
             String docid = "";
             String qformat = "";
             String abstrpath = null;
             bojilova
-            jones
+            // read the params
             if (params.containsKey("docid")) {
                 docs = (String[]) params.get("docid");
+            }
             if (params.containsKey("qformat")) {
                 qformat = ((String[]) params.get("qformat"))[0];
+            }
             // the param for only metadata (eml)
-            sgarg
+            // we don't support read a eml document without inline data now.
             /*if (params.containsKey("inlinedata")) {
             tao
-            jones
+                String inlineData = ((String[]) params.get("inlinedata"))[0];
                 if (inlineData.equalsIgnoreCase("false")) {
                     withInlineData = false;
+                }
-            sgarg
+            }*/
-            jones
+            if ((docs.length > 1) || qformat.equals("zip")) {
                 zip = true;
                 out = response.getOutputStream();
                 response.setContentType("application/zip"); //MIME type
                 zout = new ZipOutputStream(out);
+            }
             // go through the list of docs to read
             for (int i = 0; i < docs.length; i++) {
                 try {
             tao
-            jones
+                    URL murl = new URL(docs[i]);
-            jones
+                    Hashtable murlQueryStr = MetaCatUtil.parseQuery(
                             murl.getQuery());
-            jones
+                    // case docid="http://.../?docid=aaa"
                     // or docid="metacat://.../?docid=bbb"
                     if (murlQueryStr.containsKey("docid")) {
                         // get only docid, eliminate the rest
                         docid = (String) murlQueryStr.get("docid");
                         if (zip) {
-            jones
+                            addDocToZip(request, docid, zout, user, groups);
-            jones
+                        } else {
-            jones
+                            readFromMetacat(request, response, docid, qformat,
-            jones
+                                    abstrpath, user, groups, zip, zout,
                                     withInlineData, params);
+                        }
             tao
-            jones
+                        // case docid="http://.../filename"
                     } else {
                         docid = docs[i];
                         if (zip) {
-            jones
+                            addDocToZip(request, docid, zout, user, groups);
-            jones
+                        } else {
                             readFromURLConnection(response, docid);
+                        }
+                    }
             sgarg
-            jones
+                } catch (MalformedURLException mue) {
                     docid = docs[i];
                     if (zip) {
-            jones
+                        addDocToZip(request, docid, zout, user, groups);
-            jones
+                    } else {
-            sgarg
+                        readFromMetacat(request, response, docid, qformat,
                                 abstrpath, user, groups, zip, zout,
-            jones
+                                withInlineData, params);
             jones
+                }
             jones
             tao
-            jones
+            if (zip) {
                 zout.finish(); //terminate the zip file
                 zout.close(); //close the zip stream
+            }
             tao
-            jones
+        } catch (McdbDocNotFoundException notFoundE) {
             // To handle doc not found exception
             // the docid which didn't be found
             String notFoundDocId = notFoundE.getUnfoundDocId();
             String notFoundRevision = notFoundE.getUnfoundRevision();
             MetaCatUtil.debugMessage("Missed id: " + notFoundDocId, 30);
             MetaCatUtil.debugMessage("Missed rev: " + notFoundRevision, 30);
             try {
                 // read docid from remote server
                 readFromRemoteMetaCat(response, notFoundDocId,
                         notFoundRevision, user, passWord, out, zip, zout);
                 // Close zout outputstream
                 if (zout != null) {
                     zout.close();
+                }
                 // close output stream
                 if (out != null) {
                     out.close();
+                }
             tao
-            jones
+            } catch (Exception exc) {
                 MetaCatUtil.debugMessage(
                         "Erorr in MetacatServlet.hanldReadAction: "
                                 + exc.getMessage(), 30);
                 try {
                     if (out != null) {
                         response.setContentType("text/xml");
                         // Send back error message by printWriter
                         pw = new PrintWriter(out);
                         pw.println("<?xml version=\"1.0\"?>");
                         pw.println("<error>");
                         pw.println(notFoundE.getMessage());
                         pw.println("</error>");
                         pw.close();
                         out.close();
             tao
-            jones
+                    } else {
                         response.setContentType("text/xml"); //MIME type
                         // Send back error message if out = null
                         if (pw == null) {
                             // If pw is null, open the respnose
                             pw = response.getWriter();
+                        }
                         pw.println("<?xml version=\"1.0\"?>");
                         pw.println("<error>");
                         pw.println(notFoundE.getMessage());
                         pw.println("</error>");
                         pw.close();
+                    }
                     // close zout
                     if (zout != null) {
                         zout.close();
+                    }
                 } catch (IOException ie) {
                     MetaCatUtil.debugMessage("Problem with the servlet output "
                             + "in MetacatServlet.handleReadAction: "
                             + ie.getMessage(), 30);
+                }
+            }
         } catch (Exception e) {
             try {
             berkley
-            jones
+                if (out != null) {
                     response.setContentType("text/xml"); //MIME type
                     pw = new PrintWriter(out);
                     pw.println("<?xml version=\"1.0\"?>");
                     pw.println("<error>");
                     pw.println(e.getMessage());
                     pw.println("</error>");
                     pw.close();
                     out.close();
                 } else {
                     response.setContentType("text/xml"); //MIME type
                     // Send back error message if out = null
                     if (pw == null) {
                         pw = response.getWriter();
+                    }
                     pw.println("<?xml version=\"1.0\"?>");
                     pw.println("<error>");
                     pw.println(e.getMessage());
                     pw.println("</error>");
                     pw.close();
             tao
             jones
                 // Close zip output stream
                 if (zout != null) {
                     zout.close();
+                }
             tao
-            jones
+            } catch (IOException ioe) {
                 MetaCatUtil.debugMessage("Problem with the servlet output "
                         + "in MetacatServlet.handleReadAction: "
                         + ioe.getMessage(), 30);
                 ioe.printStackTrace(System.out);
             bojilova
             jones
             tao
-            jones
+            MetaCatUtil.debugMessage(
                     "Error in MetacatServlet.handleReadAction: "
                             + e.getMessage(), 30);
             //e.printStackTrace(System.out);
             bojilova
             jones
             tao
-            sgarg
+    /** read metadata or data from Metacat
-            jones
+     */
-            sgarg
+    private void readFromMetacat(HttpServletRequest request,
-            jones
+            HttpServletResponse response, String docid, String qformat,
             String abstrpath, String user, String[] groups, boolean zip,
             ZipOutputStream zout, boolean withInlineData, Hashtable params)
             throws ClassNotFoundException, IOException, SQLException,
             McdbException, Exception
             tao
             tao
-            jones
+        try {
             tao
-            jones
+            DocumentImpl doc = new DocumentImpl(docid);
             tao
-            jones
+            //check the permission for read
-            jones
+            if (!DocumentImpl.hasReadPermission(user, groups, docid)) {
-            jones
+                Exception e = new Exception("User " + user
                         + " does not have permission"
                         + " to read the document with the docid " + docid);
             bojilova
-            jones
+                throw e;
+            }
             tao
-            jones
+            if (doc.getRootNodeID() == 0) {
                 // this is data file
                 String filepath = MetaCatUtil.getOption("datafilepath");
                 if (!filepath.endsWith("/")) {
                     filepath += "/";
+                }
                 String filename = filepath + docid;
                 FileInputStream fin = null;
                 fin = new FileInputStream(filename);
             tao
-            jones
+                //MIME type
                 String contentType = getServletContext().getMimeType(filename);
                 if (contentType == null) {
                     ContentTypeProvider provider = new ContentTypeProvider(
                             docid);
                     contentType = provider.getContentType();
                     MetaCatUtil.debugMessage("Final contenttype is: "
                             + contentType, 30);
+                }
             bojilova
-            jones
+                response.setContentType(contentType);
                 // if we decide to use "application/octet-stream" for all data
                 // returns
                 // response.setContentType("application/octet-stream");
             bojilova
-            jones
+                try {
             bojilova
-            jones
+                    ServletOutputStream out = response.getOutputStream();
                     byte[] buf = new byte[4 * 1024]; // 4K buffer
                     int b = fin.read(buf);
                     while (b != -1) {
                         out.write(buf, 0, b);
                         b = fin.read(buf);
+                    }
                 } finally {
                     if (fin != null) fin.close();
+                }
             sgarg
-            jones
+            } else {
                 // this is metadata doc
-            sgarg
+                if (qformat.equals("xml") || qformat.equals("")) {
                     // if equals "", that means no qformat is specified. hence
                     // by default the document should be returned in xml format
-            jones
+                    // set content type first
                     response.setContentType("text/xml"); //MIME type
                     PrintWriter out = response.getWriter();
                     doc.toXml(out, user, groups, withInlineData);
                 } else {
                     response.setContentType("text/html"); //MIME type
                     PrintWriter out = response.getWriter();
             tao
-            jones
+                    // Look up the document type
                     String doctype = doc.getDoctype();
                     // Transform the document to the new doctype
                     DBTransform dbt = new DBTransform();
                     dbt.transformXMLDocument(doc.toString(user, groups,
                             withInlineData), doctype, "-//W3C//HTML//EN",
                             qformat, out, params);
+                }
             tao
             jones
-            sgarg
+            EventLog.getInstance().log(request.getRemoteAddr(), user,
-            jones
+                    docid, "read");
-            jones
+        } catch (Exception except) {
             throw except;
+        }
+    }
             tao
-            sgarg
+    /**
      * read data from URLConnection
-            jones
+     */
     private void readFromURLConnection(HttpServletResponse response,
             String docid) throws IOException, MalformedURLException
+    {
         ServletOutputStream out = response.getOutputStream();
         String contentType = getServletContext().getMimeType(docid); //MIME
                                                                      // type
         if (contentType == null) {
             if (docid.endsWith(".xml")) {
                 contentType = "text/xml";
             } else if (docid.endsWith(".css")) {
                 contentType = "text/css";
             } else if (docid.endsWith(".dtd")) {
                 contentType = "text/plain";
             } else if (docid.endsWith(".xsd")) {
                 contentType = "text/xml";
             } else if (docid.endsWith("/")) {
                 contentType = "text/html";
             } else {
                 File f = new File(docid);
                 if (f.isDirectory()) {
                     contentType = "text/html";
                 } else {
                     contentType = "application/octet-stream";
+                }
+            }
             tao
-            jones
+        response.setContentType(contentType);
         // if we decide to use "application/octet-stream" for all data returns
         // response.setContentType("application/octet-stream");
             tao
-            jones
+        // this is http url
         URL url = new URL(docid);
         BufferedInputStream bis = null;
         try {
             bis = new BufferedInputStream(url.openStream());
-            bojilova
+            byte[] buf = new byte[4 * 1024]; // 4K buffer
-            jones
+            int b = bis.read(buf);
-            bojilova
+            while (b != -1) {
-            jones
+                out.write(buf, 0, b);
                 b = bis.read(buf);
             bojilova
-            jones
+        } finally {
             if (bis != null) bis.close();
             berkley
             tao
             berkley
             tao
-            sgarg
+    /**
-            jones
+     * read file/doc and write to ZipOutputStream
             sgarg
-            jones
+     * @param docid
      * @param zout
      * @param user
      * @param groups
      * @throws ClassNotFoundException
      * @throws IOException
      * @throws SQLException
      * @throws McdbException
      * @throws Exception
      */
-            sgarg
+    private void addDocToZip(HttpServletRequest request, String docid,
-            jones
+            ZipOutputStream zout, String user, String[] groups) throws
             ClassNotFoundException, IOException, SQLException, McdbException,
             Exception
             tao
-            jones
+        byte[] bytestring = null;
         ZipEntry zentry = null;
             tao
-            bojilova
+        try {
-            jones
+            URL url = new URL(docid);
             tao
-            jones
+            // this http url; read from URLConnection; add to zip
             zentry = new ZipEntry(docid);
             zout.putNextEntry(zentry);
             BufferedInputStream bis = null;
             try {
                 bis = new BufferedInputStream(url.openStream());
                 byte[] buf = new byte[4 * 1024]; // 4K buffer
                 int b = bis.read(buf);
                 while (b != -1) {
                     zout.write(buf, 0, b);
                     b = bis.read(buf);
+                }
             } finally {
                 if (bis != null) bis.close();
+            }
             zout.closeEntry();
             berkley
-            jones
+        } catch (MalformedURLException mue) {
             jones
-            jones
+            // this is metacat doc (data file or metadata doc)
             try {
                 DocumentImpl doc = new DocumentImpl(docid);
             tao
-            jones
+                //check the permission for read
-            jones
+                if (!DocumentImpl.hasReadPermission(user, groups, docid)) {
-            jones
+                    Exception e = new Exception("User " + user
                             + " does not have "
                             + "permission to read the document with the docid "
                             + docid);
                     throw e;
+                }
             tao
-            jones
+                if (doc.getRootNodeID() == 0) {
                     // this is data file; add file to zip
                     String filepath = MetaCatUtil.getOption("datafilepath");
                     if (!filepath.endsWith("/")) {
                         filepath += "/";
+                    }
                     String filename = filepath + docid;
                     FileInputStream fin = null;
                     fin = new FileInputStream(filename);
                     try {
             tao
-            jones
+                        zentry = new ZipEntry(docid);
                         zout.putNextEntry(zentry);
                         byte[] buf = new byte[4 * 1024]; // 4K buffer
                         int b = fin.read(buf);
                         while (b != -1) {
                             zout.write(buf, 0, b);
                             b = fin.read(buf);
+                        }
                     } finally {
                         if (fin != null) fin.close();
+                    }
                     zout.closeEntry();
             berkley
-            jones
+                } else {
                     // this is metadata doc; add doc to zip
                     bytestring = doc.toString().getBytes();
                     zentry = new ZipEntry(docid + ".xml");
                     zentry.setSize(bytestring.length);
                     zout.putNextEntry(zentry);
                     zout.write(bytestring, 0, bytestring.length);
                     zout.closeEntry();
+                }
-            sgarg
+                EventLog.getInstance().log(request.getRemoteAddr(), user,
-            jones
+                        docid, "read");
-            jones
+            } catch (Exception except) {
                 throw except;
+            }
             tao
             jones
             bojilova
-            jones
+    /**
      * If metacat couldn't find a data file or document locally, it will read
      * this docid from its home server. This is for the replication feature
      */
     private void readFromRemoteMetaCat(HttpServletResponse response,
             String docid, String rev, String user, String password,
             ServletOutputStream out, boolean zip, ZipOutputStream zout)
             throws Exception
             tao
-            jones
+        // Create a object of RemoteDocument, "" is for zipEntryPath
         RemoteDocument remoteDoc = new RemoteDocument(docid, rev, user,
                 password, "");
         String docType = remoteDoc.getDocType();
         // Only read data file
         if (docType.equals("BIN")) {
             // If it is zip format
             if (zip) {
                 remoteDoc.readDocumentFromRemoteServerByZip(zout);
             } else {
                 if (out == null) {
                     out = response.getOutputStream();
+                }
                 response.setContentType("application/octet-stream");
                 remoteDoc.readDocumentFromRemoteServer(out);
+            }
         } else {
             throw new Exception("Docid: " + docid + "." + rev
                     + " couldn't find");
+        }
             jones
-            jones
+    /**
      * Handle the database putdocument request and write an XML document to the
      * database connection
      */
-            jones
+    private void handleInsertOrUpdateAction(HttpServletRequest request,
             HttpServletResponse response, PrintWriter out, Hashtable params,
-            jones
+            String user, String[] groups)
+    {
         DBConnection dbConn = null;
         int serialNumber = -1;
             tao
-            sgarg
+        if(params.get("docid") == null){
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println("Docid not specified");
             out.println("</error>");
-            sgarg
+            MetaCatUtil.debugMessage("Docid not specified",10);
-            sgarg
+            return;
+        }
             sgarg
         if(!MetaCatUtil.canInsertOrUpdate(user, groups)){
         	out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println("User '" + user + "' not allowed to insert and update");
             out.println("</error>");
             MetaCatUtil.debugMessage("User '" + user + "' not allowed to insert and update",10);
             return;
+        }
             sgarg
-            jones
+        try {
             // Get the document indicated
             String[] doctext = (String[]) params.get("doctext");
             String pub = null;
             if (params.containsKey("public")) {
                 pub = ((String[]) params.get("public"))[0];
+            }
             tao
-            jones
+            StringReader dtd = null;
             if (params.containsKey("dtdtext")) {
                 String[] dtdtext = (String[]) params.get("dtdtext");
                 try {
                     if (!dtdtext[0].equals("")) {
                         dtd = new StringReader(dtdtext[0]);
+                    }
                 } catch (NullPointerException npe) {
+                }
+            }
             sgarg
             if(doctext == null){
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println("Document text not submitted");
                 out.println("</error>");
                 return;
+            }
-            jones
+            StringReader xml = new StringReader(doctext[0]);
             boolean validate = false;
             DocumentImplWrapper documentWrapper = null;
             try {
                 // look inside XML Document for <!DOCTYPE ... PUBLIC/SYSTEM ...
                 // >
                 // in order to decide whether to use validation parser
                 validate = needDTDValidation(xml);
                 if (validate) {
                     // set a dtd base validation parser
                     String rule = DocumentImpl.DTD;
                     documentWrapper = new DocumentImplWrapper(rule, validate);
                 } else if (needSchemaValidation(xml)) {
                     // for eml2
-            sgarg
+                    String namespace = findNamespace(xml);
-            sgarg
+                    if (namespace.compareTo(DocumentImpl.EML2_0_0NAMESPACE) == 0
                                 || namespace.compareTo(
                                 DocumentImpl.EML2_0_1NAMESPACE) == 0) {
-            jones
+                        // set eml2 base validation parser
-            tao
+                        String rule = DocumentImpl.EML200;
-            jones
+                        // using emlparser to check id validation
                         EMLParser parser = new EMLParser(doctext[0]);
                         documentWrapper = new DocumentImplWrapper(rule, true);
-            sgarg
+                    } else if (namespace.compareTo(
                                 DocumentImpl.EML2_1_0NAMESPACE) == 0) {
                         // set eml2 base validation parser
                         String rule = DocumentImpl.EML210;
                         // using emlparser to check id validation
                         EMLParser parser = new EMLParser(doctext[0]);
                         documentWrapper = new DocumentImplWrapper(rule, true);
-            jones
+                    } else {
                         // set schema base validation parser
                         String rule = DocumentImpl.SCHEMA;
                         documentWrapper = new DocumentImplWrapper(rule, true);
+                    }
                 } else {
                     documentWrapper = new DocumentImplWrapper("", false);
+                }
             bojilova
-            jones
+                String[] action = (String[]) params.get("action");
                 String[] docid = (String[]) params.get("docid");
                 String newdocid = null;
             bojilova
-            jones
+                String doAction = null;
                 if (action[0].equals("insert")) {
                     doAction = "INSERT";
                 } else if (action[0].equals("update")) {
                     doAction = "UPDATE";
+                }
             bojilova
-            jones
+                try {
                     // get a connection from the pool
                     dbConn = DBConnectionPool
                             .getDBConnection("MetaCatServlet.handleInsertOrUpdateAction");
                     serialNumber = dbConn.getCheckOutSerialNumber();
             berkley
-            jones
+                    // write the document to the database
                     try {
                         String accNumber = docid[0];
                         MetaCatUtil.debugMessage("" + doAction + " "
                                 + accNumber + "...", 10);
                         if (accNumber.equals("")) {
                             accNumber = null;
             jones
-            jones
+                        newdocid = documentWrapper.write(dbConn, xml, pub, dtd,
                                 doAction, accNumber, user, groups);
-            sgarg
+                        EventLog.getInstance().log(request.getRemoteAddr(),
-            jones
+                                user, accNumber, action[0]);
                     } catch (NullPointerException npe) {
-            jones
+                        newdocid = documentWrapper.write(dbConn, xml, pub, dtd,
                                 doAction, null, user, groups);
-            sgarg
+                        EventLog.getInstance().log(request.getRemoteAddr(),
-            jones
+                                user, "", action[0]);
+                    }
+                }
-            jones
+                finally {
                     // Return db connection
                     DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+                }
             berkley
-            jones
+                // set content type and other response header fields first
                 //response.setContentType("text/xml");
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<success>");
                 out.println("<docid>" + newdocid + "</docid>");
                 out.println("</success>");
             berkley
-            jones
+            } catch (NullPointerException npe) {
                 //response.setContentType("text/xml");
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println(npe.getMessage());
                 out.println("</error>");
+            }
         } catch (Exception e) {
             //response.setContentType("text/xml");
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
             tao
             tao
             berkley
-            jones
+    /**
      * Parse XML Document to look for <!DOCTYPE ... PUBLIC/SYSTEM ... > in
      * order to decide whether to use validation parser
      */
     private static boolean needDTDValidation(StringReader xmlreader)
             throws IOException
             tao
             tao
-            jones
+        StringBuffer cbuff = new StringBuffer();
         java.util.Stack st = new java.util.Stack();
         boolean validate = false;
         int c;
         int inx;
             tao
-            jones
+        // read from the stream until find the keywords
         while ((st.empty() || st.size() < 4) && ((c = xmlreader.read()) != -1)) {
             cbuff.append((char) c);
             berkley
-            jones
+            // "<!DOCTYPE" keyword is found; put it in the stack
             if ((inx = cbuff.toString().indexOf("<!DOCTYPE")) != -1) {
                 cbuff = new StringBuffer();
                 st.push("<!DOCTYPE");
+            }
             // "PUBLIC" keyword is found; put it in the stack
             if ((inx = cbuff.toString().indexOf("PUBLIC")) != -1) {
                 cbuff = new StringBuffer();
                 st.push("PUBLIC");
+            }
             // "SYSTEM" keyword is found; put it in the stack
             if ((inx = cbuff.toString().indexOf("SYSTEM")) != -1) {
                 cbuff = new StringBuffer();
                 st.push("SYSTEM");
+            }
             // ">" character is found; put it in the stack
             // ">" is found twice: fisrt from <?xml ...?>
             // and second from <!DOCTYPE ... >
             if ((inx = cbuff.toString().indexOf(">")) != -1) {
                 cbuff = new StringBuffer();
                 st.push(">");
+            }
+        }
             jones
-            jones
+        // close the stream
         xmlreader.reset();
             tao
-            jones
+        // check the stack whether it contains the keywords:
         // "<!DOCTYPE", "PUBLIC" or "SYSTEM", and ">" in this order
         if (st.size() == 4) {
             if (((String) st.pop()).equals(">")
                     && (((String) st.peek()).equals("PUBLIC") | ((String) st
                             .pop()).equals("SYSTEM"))
                     && ((String) st.pop()).equals("<!DOCTYPE")) {
                 validate = true;
+            }
+        }
             tao
-            jones
+        MetaCatUtil.debugMessage("Validation for dtd is " + validate, 10);
         return validate;
             tao
-            jones
+    // END OF INSERT/UPDATE SECTION
             higgins
-            jones
+    /* check if the xml string contains key words to specify schema loocation */
     private boolean needSchemaValidation(StringReader xml) throws IOException
+    {
         boolean needSchemaValidate = false;
         if (xml == null) {
             MetaCatUtil.debugMessage("Validation for schema is "
                     + needSchemaValidate, 10);
             return needSchemaValidate;
+        }
         System.out.println("before get target line");
         String targetLine = getSchemaLine(xml);
-            sgarg
+        System.out.println("after get target line");
-            jones
+        // to see if the second line contain some keywords
         if (targetLine != null
                 && (targetLine.indexOf(SCHEMALOCATIONKEYWORD) != -1 || targetLine
                         .indexOf(NONAMESPACELOCATION) != -1)) {
             // if contains schema location key word, should be validate
             needSchemaValidate = true;
+        }
             tao
-            jones
+        MetaCatUtil.debugMessage("Validation for schema is "
                 + needSchemaValidate, 10);
         return needSchemaValidate;
             higgins
             jones
             tao
-            jones
+    /* check if the xml string contains key words to specify schema loocation */
-            sgarg
+    private String findNamespace(StringReader xml) throws IOException
             jones
-            sgarg
+        String namespace = null;
         String eml2_0_0NameSpace = DocumentImpl.EML2_0_0NAMESPACE;
-            sgarg
+        String eml2_0_1NameSpace = DocumentImpl.EML2_0_1NAMESPACE;
-            sgarg
+        String eml2_1_0NameSpace = DocumentImpl.EML2_1_0NAMESPACE;
-            jones
+        if (xml == null) {
             MetaCatUtil.debugMessage("Validation for schema is "
-            sgarg
+                    + namespace, 10);
             return namespace;
             jones
         String targetLine = getSchemaLine(xml);
             bojilova
-            jones
+        if (targetLine != null) {
             tao
-            jones
+            int startIndex = targetLine.indexOf(SCHEMALOCATIONKEYWORD);
             int start = 1;
             int end = 1;
             String schemaLocation = null;
             int count = 0;
             if (startIndex != -1) {
                 for (int i = startIndex; i < targetLine.length(); i++) {
                     if (targetLine.charAt(i) == '"') {
                         count++;
+                    }
                     if (targetLine.charAt(i) == '"' && count == 1) {
                         start = i;
+                    }
                     if (targetLine.charAt(i) == '"' && count == 2) {
                         end = i;
                         break;
+                    }
+                }
+            }
             schemaLocation = targetLine.substring(start + 1, end);
             MetaCatUtil.debugMessage("schemaLocation in xml is: "
                     + schemaLocation, 30);
-            sgarg
+            if (schemaLocation.indexOf(eml2_0_0NameSpace) != -1) {
                 namespace = eml2_0_0NameSpace;
-            sgarg
+            } else if (schemaLocation.indexOf(eml2_0_1NameSpace) != -1) {
                 namespace = eml2_0_1NameSpace;
-            sgarg
+            } else if (schemaLocation.indexOf(eml2_1_0NameSpace) != -1) {
                 namespace = eml2_1_0NameSpace;
             jones
+        }
             jones
-            sgarg
+        MetaCatUtil.debugMessage("Validation for eml is " + namespace,
-            jones
+);
             sgarg
-            sgarg
+        return namespace;
             tao
             jones
             higgins
-            jones
+    private String getSchemaLine(StringReader xml) throws IOException
+    {
         // find the line
         String secondLine = null;
         int count = 0;
         int endIndex = 0;
         int startIndex = 0;
         final int TARGETNUM = 2;
         StringBuffer buffer = new StringBuffer();
         boolean comment = false;
         char thirdPreviousCharacter = '?';
         char secondPreviousCharacter = '?';
         char previousCharacter = '?';
         char currentCharacter = '?';
-            sgarg
+        int tmp = xml.read();
         while (tmp != -1) {
             currentCharacter = (char)tmp;
-            jones
+            //in a comment
             if (currentCharacter == '-' && previousCharacter == '-'
                     && secondPreviousCharacter == '!'
                     && thirdPreviousCharacter == '<') {
                 comment = true;
+            }
             //out of comment
             if (comment && currentCharacter == '>' && previousCharacter == '-'
                     && secondPreviousCharacter == '-') {
                 comment = false;
+            }
             higgins
-            jones
+            //this is not comment
             if (currentCharacter != '!' && previousCharacter == '<' && !comment) {
                 count++;
+            }
             // get target line
             if (count == TARGETNUM && currentCharacter != '>') {
                 buffer.append(currentCharacter);
+            }
             if (count == TARGETNUM && currentCharacter == '>') {
                 break;
+            }
             thirdPreviousCharacter = secondPreviousCharacter;
             secondPreviousCharacter = previousCharacter;
             previousCharacter = currentCharacter;
-            sgarg
+            tmp = xml.read();
             jones
         secondLine = buffer.toString();
         MetaCatUtil
                 .debugMessage("the second line string is: " + secondLine, 25);
         xml.reset();
         return secondLine;
+    }
             jones
-            jones
+    /**
      * Handle the database delete request and delete an XML document from the
      * database connection
      */
     private void handleDeleteAction(PrintWriter out, Hashtable params,
-            sgarg
+            HttpServletRequest request, HttpServletResponse response,
-            jones
+            String user, String[] groups)
             jones
             tao
-            jones
+        String[] docid = (String[]) params.get("docid");
             tao
-            sgarg
+        if(docid == null){
           response.setContentType("text/xml");
           out.println("<?xml version=\"1.0\"?>");
           out.println("<error>");
-            sgarg
+          out.println("Docid not specified.");
-            sgarg
+          out.println("</error>");
         } else {
             tao
-            sgarg
+            // delete the document from the database
-            jones
+            try {
             sgarg
                 try {
-            tao
+                    // null means notify server is null
                     DocumentImpl.delete(docid[0], user, groups, null);
-            sgarg
+                    EventLog.getInstance().log(request.getRemoteAddr(),
                                                user, docid[0], "delete");
                     response.setContentType("text/xml");
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<success>");
                     out.println("Document deleted.");
                     out.println("</success>");
+                }
                 catch (AccessionNumberException ane) {
                     response.setContentType("text/xml");
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<error>");
-            sgarg
+                    //out.println("Error deleting document!!!");
-            sgarg
+                    out.println(ane.getMessage());
                     out.println("</error>");
+                }
+            }
             catch (Exception e) {
-            jones
+                response.setContentType("text/xml");
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
-            sgarg
+                out.println(e.getMessage());
-            jones
+                out.println("</error>");
+            }
+        }
             tao
             tao
-            jones
+    /**
      * Handle the validation request and return the results to the requestor
      */
     private void handleValidateAction(PrintWriter out, Hashtable params)
             tao
             tao
-            jones
+        // Get the document indicated
         String valtext = null;
         DBConnection dbConn = null;
         int serialNumber = -1;
             tao
-            jones
+        try {
             valtext = ((String[]) params.get("valtext"))[0];
         } catch (Exception nullpe) {
             tao
-            jones
+            String docid = null;
             try {
                 // Find the document id number
                 docid = ((String[]) params.get("docid"))[0];
             tao
-            jones
+                // Get the document indicated from the db
                 DocumentImpl xmldoc = new DocumentImpl(docid);
                 valtext = xmldoc.toString();
             bojilova
-            jones
+            } catch (NullPointerException npe) {
             tao
-            jones
+                out.println("<error>Error getting document ID: " + docid
                         + "</error>");
                 //if ( conn != null ) { util.returnConnection(conn); }
                 return;
             } catch (Exception e) {
             bojilova
-            jones
+                out.println(e.getMessage());
+            }
+        }
             bojilova
-            jones
+        try {
             // get a connection from the pool
             dbConn = DBConnectionPool
                     .getDBConnection("MetaCatServlet.handleValidateAction");
             serialNumber = dbConn.getCheckOutSerialNumber();
             DBValidate valobj = new DBValidate(saxparser, dbConn);
             boolean valid = valobj.validateString(valtext);
             tao
-            jones
+            // set content type and other response header fields first
             bojilova
-            jones
+            out.println(valobj.returnErrors());
             bojilova
-            jones
+        } catch (NullPointerException npe2) {
             // set content type and other response header fields first
             tao
-            jones
+            out.println("<error>Error validating document.</error>");
         } catch (Exception e) {
             bojilova
-            jones
+            out.println(e.getMessage());
         } finally {
             // Return db connection
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             tao
-            jones
+    /**
      * Handle "getrevsionanddoctype" action Given a docid, return it's current
      * revision and doctype from data base The output is String look like
      * "rev;doctype"
      */
     private void handleGetRevisionAndDocTypeAction(PrintWriter out,
             Hashtable params)
+    {
         // To store doc parameter
         String[] docs = new String[10];
         // Store a single doc id
         String givenDocId = null;
         // Get docid from parameters
         if (params.containsKey("docid")) {
             docs = (String[]) params.get("docid");
+        }
         // Get first docid form string array
         givenDocId = docs[0];
             bojilova
-            jones
+        try {
             // Make sure there is a docid
             if (givenDocId == null || givenDocId.equals("")) { throw new Exception(
                     "User didn't specify docid!"); }//if
             tao
-            jones
+            // Create a DBUtil object
             DBUtil dbutil = new DBUtil();
             // Get a rev and doctype
             String revAndDocType = dbutil
                     .getCurrentRevisionAndDocTypeForGivenDocument(givenDocId);
             out.println(revAndDocType);
             bojilova
-            jones
+        } catch (Exception e) {
             // Handle exception
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
+        }
             bojilova
             jones
             tao
-            jones
+    /**
      * Handle "getaccesscontrol" action. Read Access Control List from db
      * connection in XML format
      */
     private void handleGetAccessControlAction(PrintWriter out,
             Hashtable params, HttpServletResponse response, String username,
             String[] groupnames)
+    {
         DBConnection dbConn = null;
         int serialNumber = -1;
         String docid = ((String[]) params.get("docid"))[0];
             bojilova
-            jones
+        try {
             tao
-            jones
+            // get connection from the pool
             dbConn = DBConnectionPool
                     .getDBConnection("MetaCatServlet.handleGetAccessControlAction");
             serialNumber = dbConn.getCheckOutSerialNumber();
             AccessControlList aclobj = new AccessControlList(dbConn);
             String acltext = aclobj.getACL(docid, username, groupnames);
             out.println(acltext);
             bojilova
-            jones
+        } catch (Exception e) {
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
         } finally {
             // Retrun db connection to pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             tao
-            jones
+    /**
      * Handle the "getprincipals" action. Read all principals from
      * authentication scheme in XML format
      */
     private void handleGetPrincipalsAction(PrintWriter out, String user,
             String password)
+    {
         try {
             AuthSession auth = new AuthSession();
             String principals = auth.getPrincipals(user, password);
             out.println(principals);
             bojilova
-            jones
+        } catch (Exception e) {
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
+        }
+    }
             bojilova
-            jones
+    /**
      * Handle "getdoctypes" action. Read all doctypes from db connection in XML
      * format
      */
     private void handleGetDoctypesAction(PrintWriter out, Hashtable params,
             HttpServletResponse response)
+    {
         try {
             DBUtil dbutil = new DBUtil();
             String doctypes = dbutil.readDoctypes();
             out.println(doctypes);
         } catch (Exception e) {
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
+        }
+    }
             tao
-            jones
+    /**
      * Handle the "getdtdschema" action. Read DTD or Schema file for a given
      * doctype from Metacat catalog system
      */
     private void handleGetDTDSchemaAction(PrintWriter out, Hashtable params,
             HttpServletResponse response)
+    {
             bojilova
-            jones
+        String doctype = null;
         String[] doctypeArr = (String[]) params.get("doctype");
             bojilova
-            jones
+        // get only the first doctype specified in the list of doctypes
         // it could be done for all doctypes in that list
         if (doctypeArr != null) {
             doctype = ((String[]) params.get("doctype"))[0];
+        }
             bojilova
-            jones
+        try {
             DBUtil dbutil = new DBUtil();
             String dtdschema = dbutil.readDTDSchema(doctype);
             out.println(dtdschema);
             tao
-            jones
+        } catch (Exception e) {
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
+        }
             bojilova
             tao
-            jones
+    /**
      * Handle the "getlastdocid" action. Get the latest docid with rev number
      * from db connection in XML format
      */
     private void handleGetMaxDocidAction(PrintWriter out, Hashtable params,
             HttpServletResponse response)
+    {
             bojilova
-            jones
+        String scope = ((String[]) params.get("scope"))[0];
         if (scope == null) {
             scope = ((String[]) params.get("username"))[0];
+        }
             bojilova
-            jones
+        try {
             tao
-            jones
+            DBUtil dbutil = new DBUtil();
             String lastDocid = dbutil.getMaxDocid(scope);
             out.println("<?xml version=\"1.0\"?>");
             out.println("<lastDocid>");
             out.println("  <scope>" + scope + "</scope>");
             out.println("  <docid>" + lastDocid + "</docid>");
             out.println("</lastDocid>");
             bojilova
-            jones
+        } catch (Exception e) {
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(e.getMessage());
             out.println("</error>");
+        }
             tao
             tao
-            jones
+    /**
-            jones
+     * Print a report from the event log based on filter parameters passed in
      * from the web.
             sgarg
-            jones
+     * @param params the parameters from the web request
      * @param request the http request object for getting request details
      * @param response the http response object for writing output
      */
     private void handleGetLogAction(Hashtable params, HttpServletRequest request,
-            sgarg
+            HttpServletResponse response, String username, String[] groups)
             jones
         try {
-            jones
+            response.setContentType("text/xml");
             PrintWriter out = response.getWriter();
             sgarg
-            jones
+            // Check that the user is authenticated as an administrator account
-            sgarg
+            if (!MetaCatUtil.isAdministrator(username, groups)) {
-            jones
+                out.print("<error>");
-            sgarg
+                out.print("The user \"" + username +
-            jones
+                        "\" is not authorized for this action.");
                 out.print("</error>");
                 return;
             jones
             sgarg
-            jones
+            // Get all of the parameters in the correct formats
             String[] ipAddress = (String[])params.get("ipaddress");
             String[] principal = (String[])params.get("principal");
             String[] docid = (String[])params.get("docid");
             String[] event = (String[])params.get("event");
             String[] startArray = (String[]) params.get("start");
             String[] endArray = (String[]) params.get("end");
             String start = null;
             String end = null;
             if (startArray != null) {
                 start = startArray[0];
+            }
             if (endArray != null) {
                 end = endArray[0];
+            }
             Timestamp startDate = null;
             Timestamp endDate = null;
             SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             try {
                 if (start != null) {
                     startDate = new Timestamp((format.parse(start)).getTime());
+                }
                 if (end != null) {
                     endDate = new Timestamp((format.parse(end)).getTime());
+                }
             } catch (ParseException e) {
                 System.out.println("Failed to created Timestamp from input.");
+            }
             sgarg
-            jones
+            // Request the report by passing the filter parameters
             out.println(EventLog.getInstance().getReport(ipAddress, principal,
                     docid, event, startDate, endDate));
             out.close();
         } catch (IOException e) {
             MetaCatUtil.debugMessage(
                     "Could not open http response for writing: " + e.getMessage(), 5);
             jones
             jones
             sgarg
-            jones
+    /**
      * Rebuild the index for one or more documents. If the docid parameter is
      * provided, rebuild for just that one document or list of documents. If
      * not, then rebuild the index for all documents in the xml_documents
      * table.
+     *
      * @param params the parameters from the web request
      * @param request the http request object for getting request details
      * @param response the http response object for writing output
      * @param username the username of the authenticated user
      */
-            sgarg
+    private void handleBuildIndexAction(Hashtable params,
-            jones
+            HttpServletRequest request, HttpServletResponse response,
-            sgarg
+            String username, String[] groups)
             jones
         // Get all of the parameters in the correct formats
         String[] docid = (String[])params.get("docid");
         // Rebuild the indices for appropriate documents
-            jones
+        try {
             response.setContentType("text/xml");
             PrintWriter out = response.getWriter();
             sgarg
-            jones
+            // Check that the user is authenticated as an administrator account
-            sgarg
+            if (!MetaCatUtil.isAdministrator(username, groups)) {
-            jones
+                out.print("<error>");
-            sgarg
+                out.print("The user \"" + username +
-            jones
+                        "\" is not authorized for this action.");
                 out.print("</error>");
                 return;
+            }
             // Process the documents
             out.println("<success>");
             if (docid == null || docid.length == 0) {
                 // Process all of the documents
                 try {
                     Vector documents = getDocumentList();
                     Iterator it = documents.iterator();
                     while (it.hasNext()) {
                         String id = (String) it.next();
                         buildDocumentIndex(id, out);
+                    }
                 } catch (SQLException se) {
                     out.print("<error>");
                     out.print(se.getMessage());
                     out.println("</error>");
+                }
             } else {
                 // Only process the requested documents
                 for (int i = 0; i < docid.length; i++) {
                     buildDocumentIndex(docid[i], out);
+                }
+            }
             out.println("</success>");
-            jones
+            out.close();
         } catch (IOException e) {
             MetaCatUtil.debugMessage(
-            sgarg
+                    "Could not open http response for writing: "
-            jones
+                    + e.getMessage(), 5);
+        }
+    }
             sgarg
-            jones
+    /**
-            sgarg
+     * Build the index for one document by reading the document and
-            jones
+     * calling its buildIndex() method.
+     *
      * @param docid the document (with revision) to rebuild
      * @param out the PrintWriter to which output is printed
      */
     private void buildDocumentIndex(String docid, PrintWriter out)
+    {
         try {
             DocumentImpl doc = new DocumentImpl(docid, false);
             doc.buildIndex();
             out.print("<docid>" + docid);
             out.println("</docid>");
         } catch (McdbException me) {
             out.print("<error>");
             out.print(me.getMessage());
             out.println("</error>");
+        }
+    }
     /**
-            jones
+     * Handle documents passed to metacat that are encoded using the
      * "multipart/form-data" mime type. This is typically used for uploading
      * data files which may be binary and large.
      */
     private void handleMultipartForm(HttpServletRequest request,
             HttpServletResponse response)
+    {
         PrintWriter out = null;
         String action = null;
             bojilova
-            jones
+        // Parse the multipart form, and save the parameters in a Hashtable and
         // save the FileParts in a hashtable
             jones
-            jones
+        Hashtable params = new Hashtable();
         Hashtable fileList = new Hashtable();
         int sizeLimit = (new Integer(MetaCatUtil.getOption("datafilesizelimit")))
                 .intValue();
         MetaCatUtil.debugMessage(
                 "The limit size of data file is: " + sizeLimit, 50);
             jones
-            jones
+        try {
             // MBJ: need to put filesize limit in Metacat config
             // (metacat.properties)
             MultipartParser mp = new MultipartParser(request,
                     sizeLimit * 1024 * 1024);
             Part part;
             while ((part = mp.readNextPart()) != null) {
                 String name = part.getName();
             jones
-            jones
+                if (part.isParam()) {
                     // it's a parameter part
                     ParamPart paramPart = (ParamPart) part;
                     String value = paramPart.getStringValue();
                     params.put(name, value);
                     if (name.equals("action")) {
                         action = value;
+                    }
                 } else if (part.isFile()) {
                     // it's a file part
                     FilePart filePart = (FilePart) part;
                     fileList.put(name, filePart);
             jones
-            jones
+                    // Stop once the first file part is found, otherwise going
                     // onto the
                     // next part prevents access to the file contents. So...for
                     // upload
                     // to work, the datafile must be the last part
                     break;
+                }
+            }
         } catch (IOException ioe) {
             try {
                 out = response.getWriter();
             } catch (IOException ioe2) {
                 System.err
                         .println("Fatal Error: couldn't get response output stream.");
+            }
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println("Error: problem reading multipart data.");
             out.println("</error>");
             jones
-            jones
+        // Get the session information
         String username = null;
         String password = null;
         String[] groupnames = null;
         String sess_id = null;
             jones
-            jones
+        // be aware of session expiration on every request
         HttpSession sess = request.getSession(true);
         if (sess.isNew()) {
             // session expired or has not been stored b/w user requests
             username = "public";
             sess.setAttribute("username", username);
         } else {
             username = (String) sess.getAttribute("username");
             password = (String) sess.getAttribute("password");
             groupnames = (String[]) sess.getAttribute("groupnames");
             try {
                 sess_id = (String) sess.getId();
             } catch (IllegalStateException ise) {
                 System.out
                         .println("error in  handleMultipartForm: this shouldn't "
                                 + "happen: the session should be valid: "
                                 + ise.getMessage());
+            }
+        }
             tao
-            jones
+        // Get the out stream
         try {
             out = response.getWriter();
-            jones
+        } catch (IOException ioe2) {
-            jones
+            MetaCatUtil.debugMessage("Fatal Error: couldn't get response "
                     + "output stream.", 30);
             jones
             tao
-            jones
+        if (action.equals("upload")) {
             if (username != null && !username.equals("public")) {
                 handleUploadAction(request, out, params, fileList, username,
                         groupnames);
             } else {
             tao
-            jones
+                out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println("Permission denied for " + action);
                 out.println("</error>");
+            }
         } else {
             /*
              * try { out = response.getWriter(); } catch (IOException ioe2) {
              * System.err.println("Fatal Error: couldn't get response output
              * stream.");
              */
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println(
                     "Error: action not registered.  Please report this error.");
             out.println("</error>");
+        }
         out.close();
             jones
-            jones
+    /**
      * Handle the upload action by saving the attached file to disk and
      * registering it in the Metacat db
      */
     private void handleUploadAction(HttpServletRequest request,
             PrintWriter out, Hashtable params, Hashtable fileList,
             String username, String[] groupnames)
             tao
-            jones
+        //PrintWriter out = null;
         //Connection conn = null;
         String action = null;
         String docid = null;
             jones
-            jones
+        /*
          * response.setContentType("text/xml"); try { out =
          * response.getWriter(); } catch (IOException ioe2) {
          * System.err.println("Fatal Error: couldn't get response output
          * stream.");
          */
             jones
-            jones
+        if (params.containsKey("docid")) {
             docid = (String) params.get("docid");
+        }
             jones
-            jones
+        // Make sure we have a docid and datafile
         if (docid != null && fileList.containsKey("datafile")) {
             jones
-            jones
+            // Get a reference to the file part of the form
             FilePart filePart = (FilePart) fileList.get("datafile");
             String fileName = filePart.getFileName();
             MetaCatUtil.debugMessage("Uploading filename: " + fileName, 10);
             tao
-            jones
+            // Check if the right file existed in the uploaded data
             if (fileName != null) {
             tao
-            jones
+                try {
                     //MetaCatUtil.debugMessage("Upload datafile " + docid
                     // +"...", 10);
                     //If document get lock data file grant
                     if (DocumentImpl.getDataFileLockGrant(docid)) {
                         // register the file in the database (which generates
                         // an exception
                         //if the docid is not acceptable or other untoward
                         // things happen
                         DocumentImpl.registerDocument(fileName, "BIN", docid,
-            sgarg
+                                username, groupnames);
             tao
-            jones
+                        // Save the data file to disk using "docid" as the name
                         dataDirectory.mkdirs();
                         File newFile = new File(dataDirectory, docid);
                         long size = filePart.writeTo(newFile);
             tao
-            sgarg
+                        EventLog.getInstance().log(request.getRemoteAddr(),
-            jones
+                                username, docid, "upload");
-            jones
+                        // Force replication this data file
                         // To data file, "insert" and update is same
                         // The fourth parameter is null. Because it is
                         // notification server
                         // and this method is in MetaCatServerlet. It is
                         // original command,
                         // not get force replication info from another metacat
                         ForceReplicationHandler frh = new ForceReplicationHandler(
                                 docid, "insert", false, null);
             tao
-            jones
+                        // set content type and other response header fields
                         // first
                         out.println("<?xml version=\"1.0\"?>");
                         out.println("<success>");
                         out.println("<docid>" + docid + "</docid>");
                         out.println("<size>" + size + "</size>");
                         out.println("</success>");
+                    }
                 } catch (Exception e) {
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<error>");
                     out.println(e.getMessage());
                     out.println("</error>");
+                }
             } else {
                 // the field did not contain a file
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println("The uploaded data did not contain a valid file.");
                 out.println("</error>");
+            }
         } else {
             // Error bcse docid missing or file missing
             out.println("<?xml version=\"1.0\"?>");
             out.println("<error>");
             out.println("The uploaded data did not contain a valid docid "
                     + "or valid file.");
             out.println("</error>");
             jones
             jones
             tao
-            jones
+    /*
      * A method to handle set access action
      */
     private void handleSetAccessAction(PrintWriter out, Hashtable params,
             String username)
             tao
-            jones
+        String[] docList = null;
         String[] principalList = null;
         String[] permissionList = null;
         String[] permTypeList = null;
         String[] permOrderList = null;
         String permission = null;
         String permType = null;
         String permOrder = null;
         Vector errorList = new Vector();
         String error = null;
         Vector successList = new Vector();
         String success = null;
             berkley
-            jones
+        // Get parameters
         if (params.containsKey("docid")) {
             docList = (String[]) params.get("docid");
+        }
         if (params.containsKey("principal")) {
             principalList = (String[]) params.get("principal");
+        }
         if (params.containsKey("permission")) {
             permissionList = (String[]) params.get("permission");
             berkley
             jones
         if (params.containsKey("permType")) {
             permTypeList = (String[]) params.get("permType");
             berkley
             jones
         if (params.containsKey("permOrder")) {
             permOrderList = (String[]) params.get("permOrder");
             berkley
             jones
             berkley
-            jones
+        // Make sure the parameter is not null
         if (docList == null || principalList == null || permTypeList == null
                 || permissionList == null) {
             error = "Please check your parameter list, it should look like: "
                     + "?action=setaccess&docid=pipeline.1.1&principal=public"
                     + "&permission=read&permType=allow&permOrder=allowFirst";
             errorList.addElement(error);
             outputResponse(successList, errorList, out);
             return;
+        }
             berkley
-            jones
+        // Only select first element for permission, type and order
         permission = permissionList[0];
         permType = permTypeList[0];
         if (permOrderList != null) {
             permOrder = permOrderList[0];
+        }
             berkley
-            jones
+        // Get package doctype set
         Vector packageSet = MetaCatUtil.getOptionList(MetaCatUtil
                 .getOption("packagedoctypeset"));
         //debug
         if (packageSet != null) {
             for (int i = 0; i < packageSet.size(); i++) {
                 MetaCatUtil.debugMessage("doctype in package set: "
                         + (String) packageSet.elementAt(i), 34);
+            }
+        }
             berkley
-            jones
+        // handle every accessionNumber
         for (int i = 0; i < docList.length; i++) {
             String accessionNumber = docList[i];
             String owner = null;
             String publicId = null;
             // Get document owner and public id
             try {
                 owner = getFieldValueForDoc(accessionNumber, "user_owner");
                 publicId = getFieldValueForDoc(accessionNumber, "doctype");
             } catch (Exception e) {
                 MetaCatUtil.debugMessage("Error in handleSetAccessAction: "
                         + e.getMessage(), 30);
                 error = "Error in set access control for document - "
                         + accessionNumber + e.getMessage();
                 errorList.addElement(error);
                 continue;
+            }
             //check if user is the owner. Only owner can do owner
             if (username == null || owner == null || !username.equals(owner)) {
                 error = "User - " + username
                         + " does not have permission to set "
                         + "access control for docid - " + accessionNumber;
                 errorList.addElement(error);
                 continue;
+            }
             berkley
-            jones
+            // If docid publicid is BIN data file or other beta4, 6 package
             // document
             // we could not do set access control. Because we don't want
             // inconsistent
             // to its access docuemnt
             if (publicId != null && packageSet != null
                     && packageSet.contains(publicId)) {
                 error = "Could not set access control to document "
                         + accessionNumber
                         + "because it is in a pakcage and it has a access file for it";
                 errorList.addElement(error);
                 continue;
+            }
             berkley
-            jones
+            // for every principle
             for (int j = 0; j < principalList.length; j++) {
                 String principal = principalList[j];
                 try {
                     //insert permission
                     AccessControlForSingleFile accessControl = new AccessControlForSingleFile(
                             accessionNumber, principal, permission, permType,
                             permOrder);
                     accessControl.insertPermissions();
                     success = "Set access control to document "
                             + accessionNumber + " successfully";
                     successList.addElement(success);
                 } catch (Exception ee) {
                     MetaCatUtil.debugMessage(
                             "Erorr in handleSetAccessAction2: "
                                     + ee.getMessage(), 30);
                     error = "Faild to set access control for document "
                             + accessionNumber + " because " + ee.getMessage();
                     errorList.addElement(error);
                     continue;
+                }
+            }
             tao
-            jones
+        outputResponse(successList, errorList, out);
+    }
             berkley
-            jones
+    /*
      * A method try to determin a docid's public id, if couldn't find null will
      * be returned.
      */
     private String getFieldValueForDoc(String accessionNumber, String fieldName)
             throws Exception
             tao
-            jones
+        if (accessionNumber == null || accessionNumber.equals("")
                 || fieldName == null || fieldName.equals("")) { throw new Exception(
                 "Docid or field name was not specified"); }
             berkley
-            jones
+        PreparedStatement pstmt = null;
         ResultSet rs = null;
         String fieldValue = null;
         String docId = null;
         DBConnection conn = null;
         int serialNumber = -1;
             berkley
-            jones
+        // get rid of revision if access number has
         docId = MetaCatUtil.getDocIdFromString(accessionNumber);
         try {
             //check out DBConnection
             conn = DBConnectionPool
                     .getDBConnection("MetaCatServlet.getPublicIdForDoc");
             serialNumber = conn.getCheckOutSerialNumber();
             pstmt = conn.prepareStatement("SELECT " + fieldName
                     + " FROM xml_documents " + "WHERE docid = ? ");
             berkley
-            jones
+            pstmt.setString(1, docId);
             pstmt.execute();
             rs = pstmt.getResultSet();
             boolean hasRow = rs.next();
             int perm = 0;
             if (hasRow) {
                 fieldValue = rs.getString(1);
             } else {
                 throw new Exception("Could not find document: "
                         + accessionNumber);
+            }
         } catch (Exception e) {
             MetaCatUtil.debugMessage(
                     "Exception in MetacatServlet.getPublicIdForDoc: "
                             + e.getMessage(), 30);
             throw e;
         } finally {
             try {
                 rs.close();
                 pstmt.close();
             berkley
-            jones
+            } finally {
                 DBConnectionPool.returnDBConnection(conn, serialNumber);
+            }
+        }
         return fieldValue;
             tao
             berkley
-            jones
+    /*
-            jones
+     * Get the list of documents from the database and return the list in an
      * Vector of identifiers.
+     *
      * @ returns the array of identifiers
      */
     private Vector getDocumentList() throws SQLException
+    {
         Vector docList = new Vector();
         PreparedStatement pstmt = null;
         ResultSet rs = null;
         DBConnection conn = null;
         int serialNumber = -1;
         try {
             //check out DBConnection
             conn = DBConnectionPool
                     .getDBConnection("MetaCatServlet.getDocumentList");
             serialNumber = conn.getCheckOutSerialNumber();
             pstmt = conn.prepareStatement("SELECT docid, rev"
                     + " FROM xml_documents ");
             pstmt.execute();
             rs = pstmt.getResultSet();
             while (rs.next()) {
                 String docid = rs.getString(1);
                 String rev = rs.getString(2);
                 docList.add(docid + "." + rev);
+            }
         } catch (SQLException e) {
             MetaCatUtil.debugMessage(
                     "Exception in MetacatServlet.getDocumentList: "
                             + e.getMessage(), 30);
             throw e;
         } finally {
             try {
                 rs.close();
                 pstmt.close();
             } catch (SQLException se) {
                 MetaCatUtil.debugMessage(
                     "Exception in MetacatServlet.getDocumentList: "
                             + se.getMessage(), 30);
                 throw se;
             } finally {
                 DBConnectionPool.returnDBConnection(conn, serialNumber);
+            }
+        }
         return docList;
+    }
     /*
-            jones
+     * A method to output setAccess action result
      */
     private void outputResponse(Vector successList, Vector errorList,
             PrintWriter out)
             tao
-            jones
+        boolean error = false;
         boolean success = false;
         // Output prolog
         out.println(PROLOG);
         // output success message
         if (successList != null) {
             for (int i = 0; i < successList.size(); i++) {
                 out.println(SUCCESS);
                 out.println((String) successList.elementAt(i));
                 out.println(SUCCESSCLOSE);
                 success = true;
+            }
+        }
         // output error message
         if (errorList != null) {
             for (int i = 0; i < errorList.size(); i++) {
                 out.println(ERROR);
                 out.println((String) errorList.elementAt(i));
                 out.println(ERRORCLOSE);
                 error = true;
+            }
+        }
             berkley
-            jones
+        // if no error and no success info, send a error that nothing happened
         if (!error && !success) {
             out.println(ERROR);
             out.println("Nothing happend for setaccess action");
             out.println(ERRORCLOSE);
+        }
             tao
             tao
     /**
      * Method to get session table which store the session info
      * @return
      */
     public static Hashtable getSessionHash()
+    {
         return sessionHash;
+    }
             jones

Project

General

Profile

Metacat