Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that loads eml-access.xml file containing ACL 

 *             for a metadata document into relational DB

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Jivka Bojilova

 *    Release: @release@

 *

 *   '$Author: berkley $'

 *     '$Date: 2001-10-24 10:53:54 -0700 (Wed, 24 Oct 2001) $'

 * '$Revision: 862 $'

 *

 * 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.io.*;

import java.sql.*;

import java.util.Stack;

import java.util.Vector;

import java.util.Hashtable;

import java.net.URL;

import java.net.MalformedURLException;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.ContentHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.XMLReaderFactory;

import org.xml.sax.helpers.DefaultHandler;

/** 

 * A Class that loads eml-access.xml file containing ACL for a metadata

 * document into relational DB. It extends DefaultHandler class to handle

 * SAX parsing events when processing the XML stream.

 */

public class AccessControlList extends DefaultHandler {

  private static final int CHMOD = 1;

  private static final int WRITE = 2;

  private static final int READ = 4;

  private static final int ALL = 7;

  private static String sysdate = MetaCatUtil.dbAdapter.getDateTimeFunction();

  private static String isnull = MetaCatUtil.dbAdapter.getIsNULLFunction();

  private Connection conn;

  private String parserName;

  private Stack elementStack;

  private String server;

  private String sep;

  private boolean	processingDTD;

  private String  user;

  private String[] groups;

  private String  aclid;

  private int     rev;

  private String 	docname;

  private String 	doctype;

  private String 	systemid;

  private String docurl;

  private Vector resourceURL;

  private Vector resourceID;

  private Vector principal;

  private int    permission;

  private String permType;

  private String permOrder;

//  private String publicAcc;

  private String beginTime;

  private String endTime;

  private int    ticketCount;

  private int    serverCode = 1;

  private Vector aclObjects = new Vector();

  private boolean instarttag = true;

  private String tagName = "";

  /**

   * Construct an instance of the AccessControlList class.

   * It is used by the permission check up from DBQuery or DocumentImpl

   * and from "getaccesscontrol" action

   *

   * @param conn the JDBC connection where acl info is get

   */

  public AccessControlList(Connection conn) throws SQLException

  {

    this.conn = conn;

  }

  /**

   * Construct an instance of the AccessControlList class.

   * It parse acl file and loads acl data into db connection.

   *

   * @param conn the JDBC connection where acl data are loaded

   * @param aclid the Accession# of the document with the acl data

   * @param acl the acl file containing acl data

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

   * @param groups the groups to which user belongs

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

   *        resides.

   */

  public AccessControlList(Connection conn, String aclid, //Reader acl,

                           String user, String[] groups, int serverCode)

                  throws SAXException, IOException, McdbException

  {

    String parserName = MetaCatUtil.getOption("saxparser");

    this.server = MetaCatUtil.getOption("server");

    this.sep = MetaCatUtil.getOption("accNumSeparator");

    this.conn = conn;

    this.parserName = parserName;

    this.processingDTD = false;

    this.elementStack = new Stack();

    this.user = user;

    this.groups = groups;

    this.aclid = aclid;

    this.resourceURL = new Vector();

    this.resourceID = new Vector();

    this.principal = new Vector();

    this.permission = 0;

    this.ticketCount = 0;

  //  this.publicAcc = null;

    this.serverCode = serverCode;

    // read the access file from db connection

    DocumentImpl acldoc = new DocumentImpl(conn, aclid);

    String acl = acldoc.toString();

    this.rev = acldoc.getRev();

    // Initialize the parse

    XMLReader parser = initializeParser();

    // parse the access file and write the info to xml_access

    parser.parse(new InputSource(new StringReader(acl)));

  }

// NOT USED

//  /**

//   * Construct an instance of the AccessControlList class.

//   * It parses eml-access file and loads acl data into db connection.

//   * It is used from command line execution.

//   *

//   * @param conn the JDBC connection where acl data are loaded

//   * @param docid the Accession# of the document with the acl data

//   * @param aclfilename the name of acl file containing acl data

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

//   * @param groups the groups to which user belongs

//   */

//  public AccessControlList( Connection conn, String aclid, String aclfilename,

//                           String user, String[] groups )

//                  throws SAXException, IOException, McdbException

//  {

//    this(conn, aclid, new FileReader(new File(aclfilename).toString()), 

//         user, groups, 1);

//  }

  /* Set up the SAX parser for reading the XML serialized ACL */

  private XMLReader initializeParser() throws SAXException 

  {

    XMLReader parser = null;

    // Get an instance of the parser

    parser = XMLReaderFactory.createXMLReader(parserName);

    // Turn off validation

    parser.setFeature("http://xml.org/sax/features/validation", true);

    // Set Handlers in the parser

    // Set the ContentHandler to this instance

    parser.setContentHandler((ContentHandler)this);

    // make a DBEntityResolver instance

    // Set the EntityReslover to DBEntityResolver instance

    EntityResolver eresolver = new DBEntityResolver(conn,this,null);

    parser.setEntityResolver((EntityResolver)eresolver);

    // Set the ErrorHandler to this instance

    parser.setErrorHandler((ErrorHandler)this);

    return parser; 

  }

  /**

   * Callback method used by the SAX Parser when beginning of the document

   */

  public void startDocument() throws SAXException 

  {

    //delete all previously submitted permissions @ relations

    //this happens only on UPDATE of the access file

    try {

      this.aclObjects = getACLObjects(aclid);

      //delete all permissions for resources related to @aclid if any

      if ( aclid != null ) {

        deletePermissionsForRelatedResources(aclid);

      }

    } catch (SQLException sqle) {

      throw new SAXException(sqle);

    }

  }

  /**

   * Callback method used by the SAX Parser when the start tag of an 

   * element is detected. Used in this context to parse and store

   * the acl information in class variables.

   */

  public void startElement (String uri, String localName, 

                            String qName, Attributes atts) 

         throws SAXException 

  {

    instarttag = true;

    if(localName.equals("allow"))

    {

      tagName = "allow";

    }

    else if(localName.equals("deny"))

    {

      tagName = "deny";

    }

    BasicNode currentNode = new BasicNode(localName);

    if (atts != null) {

      int len = atts.getLength();

      for (int i = 0; i < len; i++) {

        currentNode.setAttribute(atts.getLocalName(i), atts.getValue(i));

      }

    }

    if ( currentNode.getTagName().equals("acl") ) {

      permOrder = currentNode.getAttribute("order");

    //  publicAcc = currentNode.getAttribute("public");

    }

    elementStack.push(currentNode); 

  }

  /**

   * Callback method used by the SAX Parser when the text sequences of an 

   * xml stream are detected. Used in this context to parse and store

   * the acl information in class variables.

   */ 

  public void characters(char ch[], int start, int length)

         throws SAXException 

  {

    if(!instarttag)

    {

      return;

    }

    String inputString = new String(ch, start, length);

    inputString = inputString.trim(); 

    //System.out.println("==============inputString: " + inputString);

    BasicNode currentNode = (BasicNode)elementStack.peek(); 

    String currentTag = currentNode.getTagName();

      if (currentTag.equals("principal")) {

        principal.addElement(inputString);

      } else if (currentTag.equals("permission")) {

        if ( inputString.trim().toUpperCase().equals("READ") ) {

          permission = permission | READ;

        } else if ( inputString.trim().toUpperCase().equals("WRITE") ) {

          permission = permission | WRITE;

        } else if ( inputString.trim().toUpperCase().equals("CHANGEPERMISSION") ) {

          permission = permission | CHMOD;

        } else if ( inputString.trim().toUpperCase().equals("ALL") ) {

          permission = permission | ALL;

        }/*else{

          throw new SAXException("Unknown permission type: " + inputString);

        }*/

      } else if ( currentTag.equals("startDate") && beginTime == null ) {

        beginTime = inputString.trim();

      } else if ( currentTag.equals("stopDate") && endTime == null) {

        endTime = inputString.trim();

      } else if (currentTag.equals("ticketCount") && ticketCount == 0 ) {

        try {

          ticketCount = (new Integer(inputString.trim())).intValue();

        } catch (NumberFormatException nfe) {

          throw new SAXException("Wrong integer format for:" + inputString);

        }

      }

  }

  /**

   * Callback method used by the SAX Parser when the end tag of an 

   * element is detected. Used in this context to parse and store

   * the acl information in class variables.

   */

  public void endElement (String uri, String localName, String qName)

         throws SAXException 

  {

    instarttag = false;

    BasicNode leaving = (BasicNode)elementStack.pop();

    String leavingTagName = leaving.getTagName();

    if ( leavingTagName.equals("allow") ||

         leavingTagName.equals("deny")    ) {

      if ( permission > 0 ) {

        // insert into db calculated permission for the list of principals

        try {

// System.out.println("before insertPermission " +leavingTagName);

          // go through the objects in xml_relation about this acl doc

          for (int i=0; i < aclObjects.size(); i++) {

            // docid of the current object

            String docid = (String)aclObjects.elementAt(i); 

            DocumentIdentifier docID = new DocumentIdentifier(docid);

            docid = docID.getIdentifier();

// System.out.println(docid);

            insertPermissions(docid,leavingTagName);

          }

        } catch (SQLException sqle) {

          throw new SAXException(sqle);

        } catch (Exception e) {

          throw new SAXException(e);

        }

      }

      // reset the allow/deny permission

      principal = new Vector();

      permission = 0;

      beginTime = null;

      endTime = null;

      ticketCount = 0;

    }

  }

  /** 

    * SAX Handler that receives notification of DOCTYPE. Sets the DTD.

    * @param name name of the DTD

    * @param publicId Public Identifier of the DTD

    * @param systemId System Identifier of the DTD

    */

  public void startDTD(String name, String publicId, String systemId) 

              throws SAXException {

    docname = name;

    doctype = publicId;

    systemid = systemId;

  }

  /** 

   * SAX Handler that receives notification of the start of entities.

   * @param name name of the entity

   */

  public void startEntity(String name) throws SAXException {

    if (name.equals("[dtd]")) {

      processingDTD = true;

    }

  }

  /** 

   * SAX Handler that receives notification of the end of entities.

   * @param name name of the entity

   */

  public void endEntity(String name) throws SAXException {

    if (name.equals("[dtd]")) {

      processingDTD = false;

    }

  }

  /**

   * Get the document name.

   */

  public String getDocname() {

    return docname;

  }

  /**

   * Get the document processing state.

   */

  public boolean processingDTD() {

    return processingDTD;

  }

  /* Get all objects associated with @aclid from db.*/

  private Vector getACLObjects(String aclid) 

          throws SQLException 

  {

    Vector aclObjects = new Vector();

    // delete all acl records for resources related to @aclid if any

    PreparedStatement pstmt = conn.prepareStatement(

                             "SELECT object FROM xml_relation " +

                             "WHERE subject = ? ");

    pstmt.setString(1,aclid);

    pstmt.execute();

    ResultSet rs = pstmt.getResultSet();

    boolean hasRows = rs.next();

    while (hasRows) {

      aclObjects.addElement(rs.getString(1));

      hasRows = rs.next();

    }

    pstmt.close();

    return aclObjects;

  }

  /* Delete from db all permission for resources related to @aclid if any.*/

  private void deletePermissionsForRelatedResources(String aclid) 

          throws SQLException 

  {

    // delete all acl records for resources related to @aclid if any

    Statement stmt = conn.createStatement();

    stmt.execute("DELETE FROM xml_access WHERE accessfileid = '" + aclid + "'");

    stmt.close();

  }

  /* Insert into db calculated permission for the list of principals */

  private void insertPermissions(String docid, String permType ) 

          throws SQLException 

  {

    PreparedStatement pstmt;

    try {

      pstmt = conn.prepareStatement(

              "INSERT INTO xml_access " + 

              "(docid, principal_name, permission, perm_type, perm_order," +

              "begin_time,end_time,ticket_count, accessfileid) VALUES " +

              "(?,?,?,?,?,to_date(?,'mm/dd/yy'),to_date(?,'mm/dd/yy'),?,?)");

      // Bind the values to the query

      pstmt.setString(1, docid);

      pstmt.setInt(3, permission);

      pstmt.setString(4, permType);

      pstmt.setString(5, permOrder);

      pstmt.setString(6, beginTime);

      pstmt.setString(7, endTime);

      pstmt.setString(9, aclid);

      if ( ticketCount > 0 ) {

        pstmt.setString(8, "" + ticketCount);

      } else {

        pstmt.setString(8, "");

      }

      String prName;

      for ( int j = 0; j < principal.size(); j++ ) {

        prName = (String)principal.elementAt(j);

        pstmt.setString(2, prName);

        pstmt.execute();

      /*    

        // check if there are conflict with permission's order

        String permOrderOpos = permOrder;

        int perm = getPermissions(permission, prName, docid, permOrder);

        if (  perm != 0 ) {

          if ( permOrder.equals("allowFirst") ) {

            permOrderOpos = "denyFirst";

          } else if ( permOrder.equals("denyFirst") ) {

            permOrderOpos = "allowFirst";

          }

          throw new SQLException("Permission(s) " + txtValue(perm) + 

                    " for \"" + prName + "\" on document #" + docid +

                    " has/have been used with \"" + permOrderOpos + "\"");

        }

      */

      }

      pstmt.close();

    } catch (SQLException e) {

      throw new 

      SQLException("AccessControlList.insertPermissions(): " + e.getMessage());

    }

  }

  /* Get permissions with permission order different than @permOrder. */

  private int getPermissions(int permission, String principal,

                             String docid, String permOrder)

          throws SQLException 

  {

    PreparedStatement pstmt;

    pstmt = conn.prepareStatement(

            "SELECT permission FROM xml_access " +

            "WHERE docid = ? " +

            "AND principal_name = ? " +

            "AND perm_order NOT = ?");

    pstmt.setString(1, docid);

    pstmt.setString(2, principal);

    pstmt.setString(3, permOrder);

    pstmt.execute();

    ResultSet rs = pstmt.getResultSet();

    boolean hasRow = rs.next();

    int perm = 0;

    while ( hasRow ) {

      perm = rs.getInt(1);

      perm = permission & perm;

      if ( perm != 0 ) {

        pstmt.close();

        return perm;

      }

      hasRow = rs.next();

    }

    pstmt.close();

    return 0;

  }

  /* Get the int value of READ, WRITE or ALL. */

  private int intValue ( String permission )

  {

    if ( permission.equals("READ") ) {

      return READ;

    } else if ( permission.equals("WRITE") ) {

      return WRITE;

    } else if ( permission.equals("ALL") ) {

      return ALL;

    }

    return -1;

  }

  /* Get the text value of READ, WRITE or ALL. */

  private String txtValue ( int permission )

  {

    StringBuffer txtPerm = new StringBuffer("\"");

    if ( (permission & READ) != 0 ) {

      txtPerm.append("read");

    } 

    if ( (permission & WRITE) != 0 ) {

      if ( txtPerm.length() > 0 ) txtPerm.append(",");

      txtPerm.append("write");

    }

    if ( (permission & ALL) != 0 ) {

      if ( txtPerm.length() > 0 ) txtPerm.append(",");

      txtPerm.append("all");

    }

    return txtPerm.append("\"").toString();

  }

  /**

    * Check from db connection if at least one of the list of @principals

    * has @permission on @docid.

    * @param permission permission type to check for

    * @param principals list of names of principals to check for @permission

    * @param docid document identifier to check on

    */

  public boolean hasPermission(String permission, String user,

                               String[] groups, String docid )

                 throws SQLException

  {

    // b' of the command line invocation

    if ( (user == null) && (groups == null || groups.length == 0) ) {

      return true;

    }

    // Check for @permission on @docid for @user and/or @groups

    boolean hasPermission = hasPermission(permission,user,docid);

    int i = 0;

    if ( groups != null ) {

      while ( !hasPermission && i<groups.length ) {

        hasPermission = hasPermission(permission,groups[i++],docid);

      }

    }

    // Check for @permission for "public" user

    if ( !hasPermission ) {

      hasPermission = hasPermission(permission,"public",docid);

    }

    return hasPermission;

  }

  /**

    * Check from db connection if @principal has @permission on @docid.

    * @param permission permission type to check for

    * @param principal name of principal to check for @permission

    * @param docid document identifier to check on

    */

  private boolean hasPermission(String permission,

                                String principal, String docid)

                 throws SQLException

  {

    PreparedStatement pstmt;

    // check public access to @docid from xml_documents table

    if ( permission.equals("READ") ) {

      try {

        pstmt = conn.prepareStatement(

                "SELECT 'x' FROM xml_documents " +

                "WHERE docid = ? AND public_access = 1");

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean hasRow = rs.next();

        pstmt.close();

        if (hasRow) {

          return true;

        }

//System.out.println("Passed the check for public access");      

      } catch (SQLException e) {

        throw new 

        SQLException("AccessControlList.hasPermission(). " +

                     "Error checking public access for document #"+docid+

                     ". " + e.getMessage());

      }

    }

    // since owner of resource has all permission on it,

    // check if @principal is owner of @docid in xml_documents table

    if ( principal != null ) {

      try {

        pstmt = conn.prepareStatement(

                "SELECT 'x' FROM xml_documents " +

                "WHERE docid = ? AND user_owner = ?");

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.setString(2, principal);

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean hasRow = rs.next();

        pstmt.close();

        if (hasRow) {

          return true;

        }

//System.out.println("Passed the check for ownership");      

      } catch (SQLException e) {

        throw new 

        SQLException("AccessControlList.hasPermission(). " +

                     "Error checking ownership for " + principal +

                     " on document #" + docid + ". " + e.getMessage());

      }

      // check @principal's @permission on @docid from xml_access table

      int accessValue = 0;

      int ticketCount = 0;

      String permOrder = "";

      try {

        pstmt = conn.prepareStatement(

                "SELECT permission, perm_order, ticket_count " +

                "FROM xml_access " +

                "WHERE docid = ? " + 

                "AND principal_name = ? " +

                "AND perm_type = ? " +

                "AND " + sysdate + 

                " BETWEEN " + isnull + "(begin_time," + sysdate + ") " +

                     "AND " + isnull + "(end_time," + sysdate + ")");

        // check if it is "deny" with "allowFirst" first

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.setString(2, principal);

        pstmt.setString(3, "deny");

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

        boolean hasRows = rs.next();

        while ( hasRows ) {

          accessValue = rs.getInt(1);

          permOrder = rs.getString(2);

          ticketCount = rs.getInt(3);

          if ( ( accessValue & intValue(permission) ) == intValue(permission) &&

               ( permOrder.equals("allowFirst") ) &&

               ( rs.wasNull() || ticketCount > 0 ) ) {

            if ( !rs.wasNull() && ticketCount > 0 ) {

              decreaseNumberOfAccess(accessValue,principal,docid,"deny","allowFirst");

            }

            pstmt.close();

            return false;

          }

          hasRows = rs.next();

        }

//System.out.println("Passed the check for \"deny\" access with \"allowFirst\"");      

        // it is not denied then check if it is "allow"

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.setString(2, principal);

        pstmt.setString(3, "allow");

        pstmt.execute();

        rs = pstmt.getResultSet();

        hasRows = rs.next();

        while ( hasRows ) {

          accessValue = rs.getInt(1);

          permOrder = rs.getString(2);

          ticketCount = rs.getInt(3);

          if ( ( accessValue & intValue(permission) )==intValue(permission) &&

               ( rs.wasNull() || ticketCount > 0 ) ) {

            if ( !rs.wasNull() && ticketCount > 0 ) {

              decreaseNumberOfAccess(accessValue,principal,docid,"allow",permOrder);

            }

            pstmt.close();

            return true;

          }

          hasRows = rs.next();

        }

//System.out.println("Passed the check for \"allow\" access");      

        // it is not allowed then check if it is "deny" with "denyFirst"

        // Bind the values to the query

        pstmt.setString(1, docid);

        pstmt.setString(2, principal);

        pstmt.setString(3, "deny");

        pstmt.execute();

        rs = pstmt.getResultSet();

        hasRows = rs.next();

        while ( hasRows ) {

          accessValue = rs.getInt(1);

          permOrder = rs.getString(2);

          ticketCount = rs.getInt(3);

          if ( ( accessValue & intValue(permission) ) == intValue(permission) &&

               ( permOrder.equals("denyFirst") ) &&

               ( rs.wasNull() || ticketCount > 0 ) ) {

            if ( !rs.wasNull() && ticketCount > 0 ) {

              decreaseNumberOfAccess(accessValue,principal,docid,"deny","denyFirst");

            }

            pstmt.close();

            return false;

          }

          hasRows = rs.next();

        }

//System.out.println("Passed the check for \"deny\" access wirh \"denyFirst\"");      

        pstmt.close();

        return false;

      } catch (SQLException e) {

        throw new 

        SQLException("AccessControlList.hasPermission(). " +

                     "Error checking " + permission + " permission for " +

                     principal + " on document #" + docid + ". " +

                     e.getMessage());

      }

    }

    return false;

  }

  /* Decrease the number of access to @docid for @principal in db. */

  private void decreaseNumberOfAccess(int permission, String principal,

                                      String docid, String permType, 

                                      String permOrder) 

               throws SQLException

  {

    PreparedStatement pstmt;

    pstmt = conn.prepareStatement(

            "UPDATE xml_access SET ticket_count = ticket_count - 1 " +

            "WHERE docid = ? " +

            "AND principal_name = ? " +

            "AND permission = ? " +

            "AND perm_type = ? " +

            "AND perm_order = ? " +

            "AND " + sysdate + 

            " BETWEEN " + isnull + "(begin_time," + sysdate + ") " +

                 "AND " + isnull + "(end_time," + sysdate + ")");

    // Bind the values to the query

    pstmt.setString(1, docid);

    pstmt.setString(2, principal);

    pstmt.setInt(3, permission);

    pstmt.setString(4, permType);

    pstmt.setString(5, permOrder);

    pstmt.execute();

    pstmt.close();

  }

  /**

    * Get Access Control List information for document from db connetion.

    * User or Group should have permissions for reading

    * access control information for a document specified by @docid.

    * @param docid document identifier which acl info to get

    * @param user name of user connected to Metacat system

    * @param groups names of user's groups to which user belongs

    */

  public String getACL(String docid, String user, String[] groups) 

          throws SQLException 

  {

    StringBuffer output = new StringBuffer();

    StringBuffer outTemp = new StringBuffer();

    MetaCatUtil util = new MetaCatUtil();

    String accDoctype = util.getOption("accessdoctype");

    String server = util.getOption("server");

    String docurl = "metacat://" + server + "/?docid=" + docid;

    String systemID;

    boolean isOwned = false;

    boolean hasPermission = false;

    String publicAcc;

    String acfid = "";

    String acfid_prev = "";

    String principal;

    Vector principalArr = new Vector();

    int permission;

    int perm_prev = -1;

    String permType;

    String permOrder = "";

    String permOrder_prev = "";

    String beginTime = "";

    String begin_prev = "";

    String endTime = "";

    String end_prev = "";

    int ticketCount = -1;

    int ticket_prev = -1;

    try {

      isOwned = isOwned(docid, user);

      systemID = getSystemID(accDoctype);

      publicAcc = getPublicAccess(docid);

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

      output.append("<!DOCTYPE acl PUBLIC \"" + accDoctype + "\" \"" +

                    systemID + "\">\n");

      output.append("<acl authSystem=\"\">\n");

      PreparedStatement pstmt;

      pstmt = conn.prepareStatement(

              "SELECT distinct accessfileid, principal_name, permission, " +

              "perm_type, perm_order, to_char(begin_time,'mm/dd/yyyy'), " +

              "to_char(end_time,'mm/dd/yyyy'), ticket_count " +

              "FROM xml_access WHERE docid = ? " +

              "ORDER BY accessfileid, perm_order, perm_type, permission");

      // Bind the values to the query

      pstmt.setString(1, docid);

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean hasRows = rs.next();

      while (hasRows) {

        acfid = rs.getString(1);

        principal = rs.getString(2);

        permission = rs.getInt(3);

        permType = rs.getString(4);

        permOrder = rs.getString(5);

        beginTime = rs.getString(6);

        endTime = rs.getString(7);

        ticketCount = rs.getInt(8);

        // if @docid is not owned by @user, only ACL info from that

        // access files to which @user/@groups has "read" permission

        // is extracted

        if ( !isOwned ) {

          if ( !acfid.equals(acfid_prev) ) {

            acfid_prev = acfid;

            hasPermission = this.hasPermission("READ",user,groups,acfid);

          }

          if ( !hasPermission ) {

            rs.next();

            continue;

          }

        }

        // open <resource> tag

        if ( !permOrder.equals(permOrder_prev) ) {

          // close </resource> tag if any was opened 

          output.append(outTemp.toString());

          outTemp = new StringBuffer();

          if ( !permOrder_prev.equals("") ) {

            output.append("  </resource>\n");

          }

          output.append("  <resource order=\"" + permOrder + "\" public=\"" +

                        publicAcc + "\">\n");

          output.append("    <resourceIdentifier>" + docurl + 

                        "</resourceIdentifier>\n");

          permOrder_prev = permOrder;

        }

        // close </allow> or </deny> tag then open new one

        if ( permission != perm_prev ||

             (endTime == null) && (end_prev != null) ||

             (beginTime == null) && (begin_prev != null) ||

             endTime != null && !endTime.equals(end_prev)  ||

             beginTime != null && !beginTime.equals(begin_prev) ||