Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that handles the SAX XML events as they

 *             are generated from XML documents

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Jivka Bojilova

 *    Release: @release@

 *

 *   '$Author: tao $'

 *     '$Date: 2003-04-11 09:22:09 -0700 (Fri, 11 Apr 2003) $'

 * '$Revision: 1540 $'

 *

 * 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

 */

package edu.ucsb.nceas.metacat;

import java.sql.*;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.StringReader;

import java.util.Stack;

import java.util.Vector;

import java.util.Hashtable;

import java.util.Enumeration;

import java.util.EmptyStackException;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.DefaultHandler;

/**

 * A database aware Class implementing callback bethods for the SAX parser to

 * call when processing the XML stream and generating events

 */

public class EmlSAXHandler extends DBSAXHandler implements 

                                                      AccessControlInterface

{

   private Vector allowRules = new Vector();

   private Vector denyRules = new Vector();

   private String documentId = null;

   private Vector subDocumentIdList = new Vector();

   private boolean processTopLeverAccess = false;

   private boolean processAdditionalAccess = false;

   private boolean processOtherAccess = false;

   private AccessSection accessObject= null;

   private AccessRule accessRule = null;

   private Vector accessObjectList = new Vector(); // store every access rule

   private Hashtable topLevelAccessControlMap = new Hashtable();

   private Hashtable additionalAccessControlMap = new Hashtable();// store 

                                                 //subtree access for single

                                                 // additionalmetacat

   private Vector additionalAccessMapList = new Vector();// store maps for 

                                                       // every addionalmetadata

   private Vector describesId = new Vector(); // store the ids in

                                      //additionalmetadata/describes

   private Stack subTreeInfoStack = new Stack();

   private Vector subTreeList = new Vector();// store the final subtree

   private int inLineDataIndex = 1;

   private Hashtable unChangableSubTreeHash = new Hashtable();

   private Stack currentUnChangedableSubtreeNodeStack;

   private boolean startCriticalSubTree = false;

   private boolean firstElementForCriticalSubTree = false;

   private String firstElementNameForCriticalSubTree;

   private boolean needCheckingAccessModule = false;

   private Vector unChangableAccessSubTreeVector;

   private AccessSection topAccessSection;

   // Constant

   private static final String EML ="eml";

   private static final String DESCRIBES = "describes";

   private static final String ADDITIONALMETADATA = "additionalMetadata";

   private static final String ORDER = "order";

   private static final String ID ="id";

   private static final String REFERENCES = "references";

   public  static final String INLINE = "inline";

   private static final String PERMISSIONERROR ="User try to update a subtree"+

                               " which it doesn't have write permission!";

   private static final String TOPLEVEL = "top";

   private static final String SUBTREELEVEL ="subtree";

    /** Construct an instance of the handler class

    * In this constructor, user can specify the version need to upadate

    *

    * @param conn the JDBC connection to which information is written

    * @param action - "INSERT" or "UPDATE"

    * @param docid to be inserted or updated into JDBC connection

    * @param revision, the user specified the revision need to be update

    * @param user the user connected to MetaCat servlet and owns the document

    * @param groups the groups to which user belongs

    * @param pub flag for public "read" access on document

    * @param serverCode the serverid from xml_replication on which this document

    *        resides.

    *

    */

   public EmlSAXHandler(DBConnection conn, String action, String docid,

     String revision, String user, String[] groups, String pub, int serverCode)

                              throws SAXException

   {

     super(conn, action, docid, revision, user, groups, pub, serverCode);

     // Get the unchangable subtrees (user doesn't have write permission)

     try

     {

       PermissionController control = new PermissionController(docid);

       //unChangableSubTreeHash = getUnchangableSubTree(control, user, groups);

       //If the action is update and user doesn't have "ALL" permission

       // we need to check if user update access subtree

       if (action.equals("UPDATE") && 

         control.hasPermission(user, groups, AccessControlInterface.ALLSTRING))

       {

         needCheckingAccessModule = true;

         unChangableAccessSubTreeVector = getAccessSubTreeListFromDB();

       }

     }

     catch (Exception e)

     {

       throw new SAXException(e.getMessage());

     }

   }

   /* Pass a permission control and get the list of unchangable subtree*/

   private Hashtable getUnchangableSubTree(PermissionController controller,

                                           String user, String[]groups)

                                           throws Exception

   {

     Hashtable list = null;

     Hashtable result = new Hashtable();

     // get unwritable sutree from controller

     list = controller.hasUnaccessableSubTree(user, groups, 

                                          AccessControlInterface.WRITESTRING);

      if (list != null)

      {

         Enumeration en = list.elements();

         while (en.hasMoreElements())

         {

           // Get  a subtree without node record list

           SubTree treeWithoutStack = (SubTree)en.nextElement();

           String subTreeId   = treeWithoutStack.getSubTreeId();

           MetaCatUtil.debugMessage("unchangable subtree id: " + subTreeId, 40);

           long   startNodeId = treeWithoutStack.getStartNodeId();

           MetaCatUtil.debugMessage("unchangable subtree startnodeid: " +

                                    startNodeId, 40);

           long   endNodeId   = treeWithoutStack.getEndNodeId();

           MetaCatUtil.debugMessage("unchangable subtree endnodeid: " +

                                     endNodeId, 40);

           // Get a subtree has the nodelist

           SubTree tree = new SubTree(docid, subTreeId, startNodeId, endNodeId);

           // add this tree to the result

           result.put(subTreeId, tree);

          }//while

      }//if

      return result;

   }

   /*

    * Get the subtree node info from xml_accesssubtree table

    */

   private Vector getAccessSubTreeListFromDB() throws Exception

   {

      Vector result = new Vector();

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String sql = "SELECT controllevel, subtreeid, startnodeid, endnodeid) " + 

                   "FROM xml_accesssubtree WHERE docid like ? " +

                   "ORDER BY startnodeid ASC";

      try 

      {

        pstmt = connection.prepareStatement(sql);

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.execute();

        // Get result set

        rs = pstmt.getResultSet();

        while (rs.next())

        {

          String level = rs.getString(1);

          String sectionId = rs.getString(2);

          long startNodeId = rs.getLong(3);

          long endNodeId = rs.getLong(4);

          // create a new access section

          AccessSection accessObj = new AccessSection();

          accessObj.setControlLevel(level);

          accessObj.setDocId(docid);

          accessObj.setSubTreeId(sectionId);

          accessObj.setStartNodeId(startNodeId);

          accessObj.setEndNodeId(endNodeId); 

          Stack nodeStack = accessObj.getSubTreeNodeList();

          accessObj.setSubTreeNodeStack(nodeStack);

          // add this access obj into vector

          result.add(accessObj);

          // Get the top level access subtree control

          if ( level != null && level.equals(TOPLEVEL))

          {

            topAccessSection = accessObj;

          }

        }

        pstmt.close();

      }//try 

      catch (SQLException e) 

      {

        throw new 

        SAXException("EMLSAXHandler.getAccessSubTreeListFromDB(): " + 

                      e.getMessage());

      }//catch

      finally

      {

        try

        {

          pstmt.close();

        }

        catch(SQLException ee)

        {

          throw new 

          SAXException("EMLSAXHandler.getAccessSubTreeListFromDB(): " + 

          ee.getMessage());

        }

      }//finally

      return result;

   }

   /** SAX Handler that is called at the start of each XML element */

   public void startElement(String uri, String localName,

                            String qName, Attributes atts)

               throws SAXException 

  {

      // for element <eml:eml...> qname is "eml:eml", local name is "eml"            

     // for element <acl....> both qname and local name is "eml"

     // uri is namesapce

     MetaCatUtil.debugMessage("Start ELEMENT(qName) " + qName, 50);

     MetaCatUtil.debugMessage("Start ELEMENT(localName) " + localName, 50);

     MetaCatUtil.debugMessage("Start ELEMENT(uri) " + uri, 50);

     DBSAXNode parentNode = null;

     DBSAXNode currentNode = null;

     // Get a reference to the parent node for the id

     try 

     {

       parentNode = (DBSAXNode)nodeStack.peek();

     } 

     catch (EmptyStackException e) 

     {

       parentNode = null;

     }

     // If hit a text node, we need write this text for current's parent node

     // This will happend if the element is mixted

     if (hitTextNode && parentNode != null)

     {

       //compare text node data

       if (startCriticalSubTree)

       {

            NodeRecord node = null;

            try

            { 

              node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();

            }

            catch (EmptyStackException ee)

            {

              MetaCatUtil.debugMessage("Node stack is empty for text data in startElement", 35);

              throw new SAXException(PERMISSIONERROR);

            }

            MetaCatUtil.debugMessage("current node type from xml is TEXT in start element", 40);

            MetaCatUtil.debugMessage("node type from stack: " + 

                                        node.getNodeType(), 40);

            MetaCatUtil.debugMessage("current node data from xml is: " + 

                                        textBuffer.toString(), 40);

            MetaCatUtil.debugMessage("node data from stack: " +

                                        node.getNodeData(), 40);

            MetaCatUtil.debugMessage("node name from stack: " +

                                        node.getNodeName(), 40);

            MetaCatUtil.debugMessage("node is: "+ node.getNodeId(), 40);              

            if (!node.getNodeType().equals("TEXT") || 

               !(textBuffer.toString()).equals(node.getNodeData())) 

            { 

              MetaCatUtil.debugMessage("current node type from xml is TEXT in start element", 40);

              MetaCatUtil.debugMessage("node type from stack: " + 

                                        node.getNodeType(), 40);

              MetaCatUtil.debugMessage("current node data from xml is: " + 

                                        textBuffer.toString(), 40);

              MetaCatUtil.debugMessage("node data from stack: " +

                                        node.getNodeData(), 40);

              MetaCatUtil.debugMessage("node name from stack: " +

                                        node.getNodeName(), 40);

              MetaCatUtil.debugMessage("node is: "+ node.getNodeId(), 40);

              throw new SAXException(PERMISSIONERROR);

            }//if

        }//if

       // write the textbuffer into db for parent node.

        endNodeId = writeTextForDBSAXNode(textBuffer, parentNode);

        // rest hitTextNode

        hitTextNode =false;

        // reset textbuffer

        textBuffer = null;

        textBuffer = new StringBuffer();

     }

     // Document representation that points to the root document node

     if (atFirstElement) 

     {

       atFirstElement = false;

       // If no DOCTYPE declaration: docname = root element

       // doctype = root element name or name space

       if (docname == null) 

       {

         docname = localName;

         // if uri isn't null doctype = uri(namespace)

         // othewise root element

         if (uri != null && !(uri.trim()).equals(""))

         {

           doctype = uri;

         }

         else

         {

           doctype = docname;

         }

         MetaCatUtil.debugMessage("DOCNAME-a: " + docname, 30);

         MetaCatUtil.debugMessage("DOCTYPE-a: " + doctype, 30);

       } 

       else if (doctype == null) 

       {

         // because docname is not null and it is declared in dtd

         // so could not be in schema, no namespace

         doctype = docname;

         MetaCatUtil.debugMessage("DOCTYPE-b: " + doctype, 30);

       }

       rootNode.writeNodename(docname);

       try 

       {

         // for validated XML Documents store a reference to XML DB Catalog

         // Because this is select statement and it needn't to roll back if

         // insert document action fialed.

         // In order to decrease DBConnection usage count, we get a new

         // dbconnection from pool

         String catalogid = null;

         DBConnection dbConn = null;

         int serialNumber = -1;

         if ( systemid != null ) 

         {

           try

           {

            // Get dbconnection

            dbConn=DBConnectionPool.getDBConnection

                                          ("DBSAXHandler.startElement");

            serialNumber=dbConn.getCheckOutSerialNumber();

            Statement stmt = dbConn.createStatement();

            ResultSet rs = stmt.executeQuery(

                          "SELECT catalog_id FROM xml_catalog " +

                          "WHERE entry_type = 'DTD' " +

                          "AND public_id = '" + doctype + "'");

            boolean hasRow = rs.next();

            if ( hasRow ) {

              catalogid = rs.getString(1);

            }

            stmt.close();

           }//try

           finally

           {

             // Return dbconnection

             DBConnectionPool.returnDBConnection(dbConn, serialNumber);

           }//finally

         }

         //create documentImpl object by the constructor which can specify

         //the revision

         currentDocument = new DocumentImpl(connection, rootNode.getNodeID(),

                               docname, doctype, docid, revision, action, user,

                               this.pub, catalogid, this.serverCode);

       } 

       catch (Exception ane) 

       {

         throw (new SAXException("Error in DBSaxHandler.startElement " +

                                 action, ane));

       }

     }

     // Create the current node representation

     currentNode = new DBSAXNode(connection, qName, localName, parentNode,

                                 currentDocument.getRootNodeID(),docid,

                                 currentDocument.getDoctype());

     // Use a local variable to store the element node id

     // If this element is a start point of subtree(section), it will be stored

     // otherwise, it will be discated

     long startNodeId = currentNode.getNodeID();

     // Add all of the namespaces

     String prefix;

     String nsuri;

     Enumeration prefixes = namespaces.keys();

     while ( prefixes.hasMoreElements() ) 

     {

       prefix = (String)prefixes.nextElement();

       nsuri = (String)namespaces.get(prefix);

       endNodeId = currentNode.setNamespace(prefix, nsuri, docid);

     }

     // Add all of the attributes

     for (int i=0; i<atts.getLength(); i++) 

     {

       String attributeName = atts.getQName(i);

       String attributeValue = atts.getValue(i);

       endNodeId = 

                currentNode.setAttribute(attributeName, attributeValue, docid);

       // To handle name space and schema location if the attribute name is

       // xsi:schemaLocation. If the name space is in not in catalog table

       // it will be regeistered.

       if (attributeName != null && 

           attributeName.indexOf(MetaCatServlet.SCHEMALOCATIONKEYWORD) != -1)

       {

         SchemaLocationResolver resolver = 

                                  new SchemaLocationResolver(attributeValue);

         resolver.resolveNameSpace();

       }

       else if (attributeName !=null && attributeName.equals(ID))

       {

         //check unchangedable subtree hash if contains this subtree id

         if (unChangableSubTreeHash.containsKey(attributeValue))

         {

           // this subtree couldn't be changed by the user and move it from hash

           SubTree currentUnChangedableSubtree = (SubTree)

                                  unChangableSubTreeHash.remove(attributeValue);

           currentUnChangedableSubtreeNodeStack = currentUnChangedableSubtree.

                                                         getSubTreeNodeStack();

           startCriticalSubTree = true;

           firstElementForCriticalSubTree = true;

         }

         // handle subtree info

         SubTree subTress = new SubTree();

         // set sub tree id

         subTress.setSubTreeId(attributeValue);

         // set sub tree sstart lement name

         subTress.setStartElementName(currentNode.getTagName());

         // set start node number

         subTress.setStartNodeId(startNodeId);

         // add to stack, but it didn't get end node id yet

         subTreeInfoStack.push(subTress);

       }

     }//for

     // handle access stuff

     if (localName.equals(ACCESS))

     {

       // if it is in addtionalmetacat

       if (parentNode.getTagName() == ADDITIONALMETADATA)

       {

         processAdditionalAccess = true;

       }

       else

       {

         //make sure the access is top level

         // this mean current node's parent's parent should be "eml"

         DBSAXNode tmpNode = (DBSAXNode) nodeStack.pop();// pop out parent node

         //peek out grandParentNode

         DBSAXNode grandParentNode = (DBSAXNode)nodeStack.peek();

         // put parent node back

         nodeStack.push(tmpNode);

         String grandParentTag = grandParentNode.getTagName();

         if (grandParentTag.equals(EML))

         {

           processTopLeverAccess = true;

         }

         else

         {

           // process other access embedded into resource level module

           processOtherAccess = true;

         }

       }

       // create access object 

       accessObject = new AccessSection();

         // set permission order

       String permOrder = currentNode.getAttribute(ORDER);

       accessObject.setPermissionOrder(permOrder);

       // set access id

       String accessId = currentNode.getAttribute(ID);

       accessObject.setSubTreeId(accessId);

       accessObject.setStartNodeId(startNodeId);

     }

     // Set up a access rule for allow

     else if (parentNode.getTagName() != null && 

       (parentNode.getTagName()).equals(ACCESS) && localName.equals(ALLOW))

     {

       accessRule = new AccessRule(); 

       //set permission type "allow"

       accessRule.setPermissionType(ALLOW);

     }

     // set up an access rule for den

     else if (parentNode.getTagName() != null 

       && (parentNode.getTagName()).equals(ACCESS) && localName.equals(DENY))

     {

       accessRule = new AccessRule();

       //set permission type "allow"

       accessRule.setPermissionType(DENY);

     }

     // Add the node to the stack, so that any text data can be

     // added as it is encountered

     nodeStack.push(currentNode);

     // Add the node to the vector used by thread for writing XML Index

     nodeIndex.addElement(currentNode);

    // handle critical subtree

    if (startCriticalSubTree && firstElementForCriticalSubTree)

    {

      //store the element name

      firstElementNameForCriticalSubTree = qName;

      firstElementForCriticalSubTree = false;

    }//for first element

    // handle critical subtree

    if (startCriticalSubTree)

    {

      //Get element subtree node stack (element node)

      NodeRecord elementNode = null;

      try

      {

        elementNode= (NodeRecord) currentUnChangedableSubtreeNodeStack.pop();

      }

      catch (EmptyStackException ee)

      {

        MetaCatUtil.debugMessage("Node stack is empty for element data", 35);

        throw new SAXException(PERMISSIONERROR);

      }

      MetaCatUtil.debugMessage("current node type from xml is ELEMENT", 40);

      MetaCatUtil.debugMessage("node type from stack: " + 

                                  elementNode.getNodeType(), 40);

      MetaCatUtil.debugMessage("node name from xml document: " + 

                                  localName, 40);

      MetaCatUtil.debugMessage("node name from stack: " +

                                  elementNode.getNodeName(), 40);

      MetaCatUtil.debugMessage("node data from stack: " +

                                  elementNode.getNodeData(), 40);

      MetaCatUtil.debugMessage("node is: "+ elementNode.getNodeId(), 40);

      // if this node is not element or local name not equal or name space not

      // equals, throw an exception

      if (!elementNode.getNodeType().equals("ELEMENT") || 

          !localName.equals(elementNode.getNodeName()))

        //  (uri != null && !uri.equals(elementNode.getNodePrefix())))

      {

        MetaCatUtil.debugMessage("current node type from xml is ELEMENT", 40);

        MetaCatUtil.debugMessage("node type from stack: " + 

                                  elementNode.getNodeType(), 40);

        MetaCatUtil.debugMessage("node name from xml document: " + 

                                  localName, 40);

        MetaCatUtil.debugMessage("node name from stack: " +

                                  elementNode.getNodeName(), 40);

        MetaCatUtil.debugMessage("node data from stack: " +

                                  elementNode.getNodeData(), 40);

        MetaCatUtil.debugMessage("node is: "+ elementNode.getNodeId(), 40);

        throw new SAXException(PERMISSIONERROR);

      }

      //compare namespace

     Enumeration nameEn = namespaces.keys();

     while ( nameEn.hasMoreElements() ) 

     {

       //Get namespacke node stack (element node)

       NodeRecord nameNode = null;

       try

       { 

         nameNode = (NodeRecord) currentUnChangedableSubtreeNodeStack.pop();

       }

       catch (EmptyStackException ee)

       {

         MetaCatUtil.debugMessage("Node stack is empty for namespace data", 35);

         throw new SAXException(PERMISSIONERROR);

       }

       String prefixName = (String)nameEn.nextElement(); 

       String nameSpaceUri = (String)namespaces.get(prefixName);

       if (!nameNode.getNodeType().equals("NAMESPACE") || 

           !prefixName.equals(nameNode.getNodeName()) || 

           !nameSpaceUri.equals(nameNode.getNodeData()))

       { 

         MetaCatUtil.debugMessage("current node type from xml is NAMESPACE", 40);

         MetaCatUtil.debugMessage("node type from stack: " + 

                                  nameNode.getNodeType(), 40);

         MetaCatUtil.debugMessage("current node name from xml is: " + 

                                   prefixName, 40);

         MetaCatUtil.debugMessage("node name from stack: " +

                                  nameNode.getNodeName(), 40);

         MetaCatUtil.debugMessage("current node data from xml is: " + 

                                   nameSpaceUri, 40);

         MetaCatUtil.debugMessage("node data from stack: " +

                                  nameNode.getNodeData(), 40);

         MetaCatUtil.debugMessage("node is: "+ nameNode.getNodeId(), 40);

         throw new SAXException(PERMISSIONERROR);

       }

     }//while

      //compare attributes

      for (int i=0; i<atts.getLength(); i++)

      {

        NodeRecord attriNode = null;

        try

        {

          attriNode = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();

        }

        catch (EmptyStackException ee)

        {

          MetaCatUtil.debugMessage("Node stack is empty for attribute data", 35);

          throw new SAXException(PERMISSIONERROR);

        }

        String attributeName = atts.getQName(i);

        String attributeValue = atts.getValue(i);

        MetaCatUtil.debugMessage("current node type from xml is ATTRIBUTE ", 40);

        MetaCatUtil.debugMessage("node type from stack: " + 

                                   attriNode.getNodeType(), 40);

        MetaCatUtil.debugMessage("current node name from xml is: " + 

                                    attributeName, 40);

        MetaCatUtil.debugMessage("node name from stack: " +

                                    attriNode.getNodeName(), 40);

        MetaCatUtil.debugMessage("current node data from xml is: " + 

                                    attributeValue, 40);

        MetaCatUtil.debugMessage("node data from stack: " +

                                    attriNode.getNodeData(), 40);

        MetaCatUtil.debugMessage("node is: "+ attriNode.getNodeId(), 40);

        if (!attriNode.getNodeType().equals("ATTRIBUTE") || 

            !attributeName.equals(attriNode.getNodeName()) ||

            !attributeValue.equals(attriNode.getNodeData()))

        {

          MetaCatUtil.debugMessage("current node type from xml is ATTRIBUTE ", 40);

          MetaCatUtil.debugMessage("node type from stack: " + 

                                   attriNode.getNodeType(), 40);

          MetaCatUtil.debugMessage("current node name from xml is: " + 

                                    attributeName, 40);

          MetaCatUtil.debugMessage("node name from stack: " +

                                    attriNode.getNodeName(), 40);

          MetaCatUtil.debugMessage("current node data from xml is: " + 

                                    attributeValue, 40);

          MetaCatUtil.debugMessage("node data from stack: " +

                                    attriNode.getNodeData(), 40);

          MetaCatUtil.debugMessage("node is: "+ attriNode.getNodeId(), 40);

          throw new SAXException(PERMISSIONERROR);

        }

      }//for

    }

    // reset name space

    namespaces = null;

    namespaces = new Hashtable();

  }

  /** SAX Handler that is called at the end of each XML element */

   public void endElement(String uri, String localName,

                          String qName) throws SAXException 

  {

     MetaCatUtil.debugMessage("End ELEMENT " + qName, 50);

     // Get the node from the stack

     DBSAXNode currentNode = (DBSAXNode)nodeStack.pop();

     String currentTag = currentNode.getTagName();

     // If before the end element, the parser hit text nodes and store them

     // into the buffer, write the buffer to data base. The reason we put

     // write database here is for xerces some time split text node

     if (hitTextNode)

     {

        // get access value

        String data = null;

        // add principal

       if (currentTag.equals(PRINCIPAL) && accessRule != null) 

       {

          data = (textBuffer.toString()).trim();

          accessRule.addPrincipal(data);

       } 

       else if (currentTag.equals(PERMISSION) && accessRule != null) 

       {

         data = (textBuffer.toString()).trim();

         // we conbine different a permission into one value

         int permission = accessRule.getPermission();

         // add permision

         if ( data.toUpperCase().equals(READSTRING) ) 

         {

           permission = permission | READ;

         } 

         else if ( data.toUpperCase().equals(WRITESTRING) ) 

         {

           permission = permission | WRITE;

         } 

         else if ( data.toUpperCase().equals(CHMODSTRING)) 

         {

           permission = permission | CHMOD;

         } 

         else if ( data.toUpperCase().equals(ALLSTRING) ) 

         {

          permission = permission | ALL;

         }

         accessRule.setPermission(permission);

       }

       // put additionalmetadata/describes into vector

       else if (currentTag.equals(DESCRIBES))

       {

          data = (textBuffer.toString()).trim();

          describesId.add(data);

       }

       else if (currentTag.equals(REFERENCES) && 

               (processTopLeverAccess ||

                processAdditionalAccess || processOtherAccess))

       {

         // get reference 

         data = (textBuffer.toString()).trim();

         // put reference id into accessSection

         accessObject.setReferences(data);

       }

       // write text to db if it is not inline data

       if (!localName.equals(INLINE))

       {

          MetaCatUtil.debugMessage("Write text into DB in End Element", 50);

          //compare whitespace if need

          if (startCriticalSubTree)

          {

            NodeRecord node = null;

            try

            {

              node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();

            }

            catch (EmptyStackException ee)

            {

              MetaCatUtil.debugMessage("the stack is empty for text data", 32);

              throw new SAXException(PERMISSIONERROR);

            }

            MetaCatUtil.debugMessage("current node type from xml is TEXT in endElement", 40);

            MetaCatUtil.debugMessage("node type from stack: " + 

                                        node.getNodeType(), 40);

            MetaCatUtil.debugMessage("current node data from xml is: " + 

                                        textBuffer.toString(), 40);

            MetaCatUtil.debugMessage("node data from stack: " +

                                        node.getNodeData(), 40);

            MetaCatUtil.debugMessage("node name from stack: " + 

                                        node.getNodeName(), 40);

            MetaCatUtil.debugMessage("node is from stack: " + 

                                        node.getNodeId(), 40);

            if (!node.getNodeType().equals("TEXT") || 

               !(textBuffer.toString()).equals(node.getNodeData())) 

            { 

              MetaCatUtil.debugMessage("current node type from xml is TEXT in endElement", 40);

              MetaCatUtil.debugMessage("node type from stack: " + 

                                        node.getNodeType(), 40);

              MetaCatUtil.debugMessage("current node data from xml is: " + 

                                        textBuffer.toString(), 40);

              MetaCatUtil.debugMessage("node data from stack: " +

                                        node.getNodeData(), 40);

              MetaCatUtil.debugMessage("node name from stack: " + 

                                        node.getNodeName(), 40);

              MetaCatUtil.debugMessage("node is from stack: " + 

                                        node.getNodeId(), 40);

              throw new SAXException(PERMISSIONERROR);

            }//if

          }//if

          endNodeId = writeTextForDBSAXNode(textBuffer, currentNode);

       }

       else

       {

          MetaCatUtil.debugMessage("Write inline data into file system", 35);

          //check if user changed inine data or not if user doesn't have

          // write permission

          if (startCriticalSubTree)

          {

            NodeRecord node = null;

            String inlineData;

            try

            {

              node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();

              // get file name from db

              String fileName = node.getNodeData();

              MetaCatUtil.debugMessage("in handle inline data", 35);

              MetaCatUtil.debugMessage("the inline data file name from node is: "+

                                      fileName, 40);

              inlineData = readInlineDataFromFileSystem(fileName);

            }

            catch (EmptyStackException ee)

            {

              MetaCatUtil.debugMessage("the stack is empty for text data", 32);

              throw new SAXException(PERMISSIONERROR);

            }

            catch (McdbException eee)

            {

              throw new SAXException(eee.getMessage());

            }

            if (!(textBuffer.toString()).equals(inlineData))

            {

              MetaCatUtil.debugMessage("inline data was changed by a user" +

                                       " who doesn't have permission", 30);

              throw new SAXException(PERMISSIONERROR);

            }//if

          }//if

          // write inline data into file system and return file name

          textBuffer = writeInlineDataIntoFile(textBuffer);

          // write file name into db

          endNodeId = writeTextForDBSAXNode(textBuffer, currentNode);

       }

     }//if

     //end crtical subtree(user doesn't have permission to write)

     //When reach the first element and stack is empty

     if (localName.equals(firstElementNameForCriticalSubTree) && 

         currentUnChangedableSubtreeNodeStack.isEmpty()) 

     {

       startCriticalSubTree = false;

     }

     //set hitText false

     hitTextNode = false;

     // reset textbuff

     textBuffer = null;

     textBuffer = new StringBuffer();

     // hand sub stree stuff

     if (!subTreeInfoStack.empty())

     {

       SubTree tree = (SubTree)subTreeInfoStack.peek();// get last subtree

       if (tree != null && tree.getStartElementName() != null && 

         (tree.getStartElementName()).equals(currentTag))

       {

         // find the end of sub tree and set the end node id

         tree.setEndNodeId(endNodeId);

         // add the subtree into the final store palace

         subTreeList.add(tree);

         // get rid of it from stack

         subTreeInfoStack.pop();

       }//if

     }//if

     // access stuff

     if (currentTag.equals(ALLOW) || currentTag.equals(DENY))

     {

       // finish parser a ccess rule and  assign it to new one

       AccessRule newRule = accessRule;

       //add the new rule to access section object