/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 2245

Added by sgarg over 20 years ago

Merging in changes made in branch 'dataaccess' by Jing Tao.

src/edu/ucsb/nceas/metacat/SubTree.java
34	34	import java.sql.SQLException;
35	35	import java.sql.ResultSet;
36	36
	37	import org.xml.sax.SAXException;
37	38
38	39	/**
39	40	* A Class that represents an XML Subtree
...	...
46	47	protected long startNodeId = -1;
47	48	protected long endNodeId = -1;
48	49	private Stack subTreeNodeStack = null;
49
	50
50	51	/**
51	52	* Defualt constructor
52	53	*/
53	54	public SubTree()
54	55	{
55
	56
56	57	}
57
	58
58	59	/**
59	60	* Constructor of subtree
60	61	*/
61		public SubTree(String myDocId, String mySubTreeId,
	62	public SubTree(String myDocId, String mySubTreeId,
62	63	long myStartNodeId, long myEndNodeId)
63		throws McdbException
64	64	{
65	65	this.docId = myDocId;
66	66	MetaCatUtil.debugMessage("Docid of Subtree: " + docId, 30);
...	...
70	70	MetaCatUtil.debugMessage("start node id of Subtree: " + startNodeId, 30);
71	71	this.endNodeId = myEndNodeId;
72	72	MetaCatUtil.debugMessage("end node id of subtree: " + endNodeId, 30);
73		subTreeNodeStack = getSubTreeNodeList();
	73
74	74	}
75
	75
76	76	/**
77	77	* Get subtree node stack
78	78	*/
79		public Stack getSubTreeNodeStack()
	79	public Stack getSubTreeNodeStack() throws SAXException
80	80	{
	81	try
	82	{
	83	subTreeNodeStack = getSubTreeNodeList();
	84	}
	85	catch (McdbException e)
	86	{
	87	throw new SAXException(e.getMessage());
	88	}
81	89	return this.subTreeNodeStack;
82	90	}
83
	91
84	92	/**
85	93	* Set subtree node stack
86	94	*/
...	...
88	96	{
89	97	this.subTreeNodeStack = myStack;
90	98	}
91
	99
92	100	/** Set the a docId */
93	101	public void setDocId(String myId)
94	102	{
...	...
97	105	}
98	106
99	107	/** Get the docId */
100		public String getDocId()
	108	public String getDocId()
101	109	{
102	110	return this.docId;
103	111	}
104	112
105
	113
106	114	/** Set the a subtreeId */
107	115	public void setSubTreeId(String myId)
108	116	{
...	...
111	119	}
112	120
113	121	/** Get the subTreeId */
114		public String getSubTreeId()
	122	public String getSubTreeId()
115	123	{
116	124	return this.subTreeId;
117	125	}
118	126
119		/**
	127	/**
120	128	* Set a startElementName
121	129	*/
122		public void setStartElementName(String elementName)
	130	public void setStartElementName(String elementName)
123	131	{
124	132	MetaCatUtil.debugMessage("set start elementname: "+elementName, 35);
125	133	this.startElementName = elementName;
126	134	}
127
	135
128	136	/**
129	137	* Get startElementName
130	138	*/
...	...
132	140	{
133	141	return this.startElementName;
134	142	}
135
	143
136	144	/** Set a start node id */
137	145	public void setStartNodeId(long nodeId)
138	146	{
139	147	MetaCatUtil.debugMessage("set start node id: "+nodeId, 35);
140	148	this.startNodeId = nodeId;
141	149	}
142
	150
143	151	/** Get start node id */
144	152	public long getStartNodeId()
145	153	{
146	154	return this.startNodeId;
147	155	}
148
	156
149	157	/** Set a end node id */
150	158	public void setEndNodeId(long nodeId)
151	159	{
152	160	MetaCatUtil.debugMessage("set end node id: "+nodeId, 35);
153	161	this.endNodeId = nodeId;
154	162	}
155
	163
156	164	/** Get end node id */
157	165	public long getEndNodeId()
158	166	{
159	167	return this.endNodeId;
160	168	}
161
	169
162	170	/* Put a subtree node into a stack, on top is the start point of subtree*/
163		public Stack getSubTreeNodeList() throws McdbException
	171	private Stack getSubTreeNodeList() throws McdbException
164	172	{
165	173	Stack nodeRecordList = new Stack();
166	174	// make sure it works
...	...
171	179	PreparedStatement pstmt = null;
172	180	DBConnection dbconn = null;
173	181	int serialNumber = -1;
174
	182
175	183	long nodeid = 0;
176	184	long parentnodeid = 0;
177	185	long nodeindex = 0;
...	...
180	188	String nodeprefix = null;
181	189	String nodedata = null;
182	190	String sql = "SELECT nodeid, parentnodeid, nodeindex, " +
183		"nodetype, nodename, nodeprefix, nodedata " +
	191	"nodetype, nodename, nodeprefix, nodedata " +
184	192	"FROM xml_nodes WHERE docid = ? AND nodeid >= ? AND " +
185	193	"nodeid <= ? ORDER BY nodeid DESC";
186		try
	194	try
187	195	{
188	196	dbconn=DBConnectionPool.
189	197	getDBConnection("SubTree.getSubTreeNodeList");
...	...
198	206	pstmt.execute();
199	207	ResultSet rs = pstmt.getResultSet();
200	208	boolean tableHasRows = rs.next();
201
202		while (tableHasRows)
	209
	210	while (tableHasRows)
203	211	{
204	212	nodeid = rs.getLong(1);
205	213	parentnodeid = rs.getLong(2);
...	...
220	228	pstmt.close();
221	229
222	230	} //try
223		catch (SQLException e)
	231	catch (SQLException e)
224	232	{
225	233	throw new McdbException("Error in SubTree.getSubTreeNodeList 1 " +
226	234	e.getMessage());
...	...
241	249	DBConnectionPool.returnDBConnection(dbconn, serialNumber);
242	250	}
243	251	}//finally
244
	252
245	253	return nodeRecordList;
246
	254
247	255	}//getSubtreeNodeList
248
	256
249	257	/** methods from Comparator interface */
250	258	public int compare(Object o1, Object o2)
251	259	{
...	...
263	271	{
264	272	return 0;
265	273	}
266
	274
267	275	}//cpmpare
268
	276
269	277	/** method from Comparator interface */
270	278	public boolean equals(Object obj)
271	279	{
...	...
279	287	return false;
280	288	}
281	289	}
282
	290
283	291	}

                 PermissionController controller = new PermissionController(docId);
                 // check top level read permission
                 if (!controller.hasPermission(user, groups,
                         AccessControlInterface.READSTRING)) {
                         AccessControlInterface.READSTRING))
+                {
                     throw new Exception("User " + user
                             + " doesn't have permission " + " to read document "
                             + docId);
                 } else if (controller.hasSubTreeAccessControl()) {
                     // if the document has subtree control, we need to check
                     // subtree control
                     // get node id for inlinedata
                     long nodeId = getInlineDataNodeId(inlineDataId, docId);
                     if (!controller.hasPermissionForSubTreeNode(user, groups,
                         AccessControlInterface.READSTRING, nodeId)) {
                         throw new Exception(
                         "User " + user + " doesn't have permission "
                         + " to read inlinedata " + inlineDataId);
+                    }
+                }
                 else
+                {
                   //check data access level
                   try
+                  {
                     Hashtable unReadableInlineDataList =
                     PermissionController.getUnReadableInlineDataIdList(docId,user,groups);
                     if (unReadableInlineDataList.containsValue(inlineDataId))
+                    {
                       throw new Exception("User " + user
                            + " doesn't have permission " + " to read inlinedata "
                            + inlineDataId);
                     }//if
                   }//try
                   catch (Exception e)
+                  {
                     throw e;
                   }//catch
                 }//else
                 // Get output stream
                 out = response.getOutputStream();
                 // read the inline data from the file
-...
                     qformat = ((String[]) params.get("qformat"))[0];
+                }
                 // the param for only metadata (eml)
                 if (params.containsKey("inlinedata")) {
                 // we don't support read a eml document without inline data now.
                 /*if (params.containsKey("inlinedata")) {
                     String inlineData = ((String[]) params.get("inlinedata"))[0];
                     if (inlineData.equalsIgnoreCase("false")) {
                         withInlineData = false;
+                    }
+                }
                 }*/
                 if ((docs.length > 1) || qformat.equals("zip")) {
                     zip = true;
                     out = response.getOutputStream();

     /**
      *  '$RCSfile$'
      *    Purpose: A class that handles checking permssision for a document
                    and subtree in a document
+     *
                    and subtree in a document
+     *
      *  Copyright: 2000 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
      *    Authors: Chad Berkley
-...
      * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      */
     package edu.ucsb.nceas.metacat;
     import java.sql.*;
     import java.util.Enumeration;
     import java.util.Hashtable;
     import java.util.Stack;
     import java.util.Vector;
     import java.util.Iterator;
     public class PermissionController
+    {
-...
        private boolean hasSubTreeAccessControl = false; // flag if has a subtree
                                                         // access for this docid
        private Vector subTreeList = new Vector();
        private long TOPLEVELSTARTNODEID = 0; //if start node is 0, means it is top
                                              //level document
        /**
         * Constructor for PermissionController
         * @param myDocid      the docid need to access
-...
+       {
          // Get rid of rev number
          docId = MetaCatUtil.getSmartDocId(myDocid);
          hasSubTreeAccessControl = checkSubTreeAccessControl();
          //hasSubTreeAccessControl = checkSubTreeAccessControl();
+       }
        /**
         * Constructor for PermssionController
         * @param myDocid String
         * @param needDeleteRev boolean
         */
        public PermissionController(String myDocid, boolean needDeleteRevFromDocid)
+       {
          if (!needDeleteRevFromDocid)
+         {
            docId = myDocid;
+         }
          else
+         {
              docId = MetaCatUtil.getDocIdFromAccessionNumber(myDocid);
+         }
+       }
        /**
         * Return if a document has subtree access control
         */
        public boolean hasSubTreeAccessControl()
+       {
          return hasSubTreeAccessControl;
+       }
        /*
         * Go through the access table and find if has subtree access control
         * if has, store the subtree into list and return true. Otherwise,
         * return false
         */
       private boolean checkSubTreeAccessControl() throws McdbException
+      {
         boolean flag = false;
         PreparedStatement pStmt=null;
         ResultSet rs=null;
         DBConnection conn=null;
         int serialNumber=-1;
         String query="SELECT subtreeid, startnodeid, endnodeid from xml_access " +
                      "where docid =? ";
         try
+        {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection("PermissionController.hasSubTreeA");
           serialNumber=conn.getCheckOutSerialNumber();
           pStmt=conn.prepareStatement(query);
           //bind the value to query
           pStmt.setString(1, docId);
           //execute the query
           pStmt.execute();
           rs=pStmt.getResultSet();
           //process the result
           while (rs.next()) //
+          {
             String subTreeId = rs.getString(1);
             MetaCatUtil.debugMessage("subtreeid: "+subTreeId, 35);
             long startNodeId = rs.getLong(2);
             MetaCatUtil.debugMessage("subtree startNodeId: "+startNodeId, 35);
             long endNodeId = rs.getLong(3);
             MetaCatUtil.debugMessage("subtree endNodeId: "+endNodeId, 35);
             // if startnodeid field in table is empty,startNodeId will be 0
             if (subTreeId != null && startNodeId != 0 && startNodeId != 0)
+            {
               flag = true;// has subtree control
               SubTree tree = new SubTree();
               tree.setSubTreeId(subTreeId);
               tree.setStartNodeId(startNodeId);
               tree.setEndNodeId(endNodeId);
               subTreeList.add(tree);
+             }
+          }
         }//try
         catch (SQLException e)
+        {
           throw new McdbException(e);
+        }
         finally
+        {
           try
+          {
             pStmt.close();
+          }
           catch(SQLException ee)
+          {
             throw new McdbException(ee);
+          }
           finally
+          {
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
         return flag;
+      }
       /**
         * Check from db connection if at least one of the list of @principals
         * @param user  the user name
         * @param groups  the groups which the use is in
         * @param myPermission  permission type to check for
         */
       public boolean hasPermission(String user, String[]groups, String myPermission)
       public boolean hasPermission(String user, String[]groups, String myPermission)
                                   throws SQLException, Exception
+      {
         boolean hasPermission=false;
         String [] userPackage=null;
         int permission =AccessControlList.intValue(myPermission);
         //for the commnad line invocation
         if ((user==null) && (groups==null || groups.length==0))
+        {
           return true;
+        }
         //create a userpackage including user, public and group member
         userPackage=createUsersPackage(user, groups);
         //if the requested document is access documents and requested permission
         //is "write", the user should have "all" right
         if (isAccessDocument(docId) && (permission == AccessControlInterface.WRITE))
+        {
           hasPermission = hasPermission(userPackage,docId, 7);// 7 is all permission
         }//if
         else //in other situation, just check the request permission
+        {
           // Check for @permission on @docid for @user and/or @groups
           hasPermission = hasPermission(userPackage,docId, permission);
         }//else
         return hasPermission;
+      }
       /**
         * Check from db connection if the users in String array @principals has
         * @permission on @docid*
         * @permission on @docid*
         * @param principals, names in userPakcage need to check for @permission
         * @param docid, document identifier to check on
         * @param permission, permission (write or all...) to check for
         * @param permission, permission (write or all...) to check for
         */
       private boolean hasPermission(String [] principals, String docId,
                                                int permission)
                              throws SQLException
+      {
         long startId = TOPLEVELSTARTNODEID;// this is for top level, so startid is 0
         try
         try
+        {
           //first, if there is a docid owner in user package, return true
           //because doc owner has all permssion
           //because doc owner has all permssion
           if (containDocumentOwner(principals, docId))
+          {
               return true;
+          }
           //If there is no owner in user package, checking the table
           //check perm_order
           if (isAllowFirst(principals, docId, startId))
+          {
             if (hasExplicitDenyRule(principals, docId, permission, startId))
+            {
               //if it is allowfirst and has deny rule(either explicit )
               //deny access
               return false;
             }//if
             else if ( hasAllowRule(principals, docId, permission, startId))
+            {
               //if it is allowfirst and hasn't deny rule and has allow rule
               //allow access
               return true;
             }//else if
             else
+            {
               //other situation deny access
               return false;
             }//else
          }//if isAllowFirst
-...
           MetaCatUtil.debugMessage("There is a exception in hasPermission method: "
                              +e.getMessage(), 50);
+        }
         return false;
       }//hasPermission
       /**
        *  Method to check if a person has permission to a inline data file
        * @param user String
        * @param groups String[]
        * @param myPermission String
        * @param inlineDataId String
        * @throws McdbException
        * @return boolean
        */
       private boolean hasPermissionForInlineData(String user, String[] groups,
                                           String myPermission, String inlineDataId)
                                           throws Exception
+      {
          // this method can call the public method - hasPermission(...)
          // the only difference is about the ownership, you couldn't find the owner
          // from inlinedataId directly. You should get it from eml document itself
          String []userPackage = createUsersPackage(user, groups);
          if (containDocumentOwner(userPackage, docId))
+         {
            return true;
+         }
          else
+         {
              PermissionController controller =
                                    new PermissionController(inlineDataId, false);
              return controller.hasPermission(user, groups, myPermission);
+         }
+      }
       /**
        * The method to determine of a node can be access by a user just by subtree
        * access control
        */
-...
+      {
         boolean flag = true;
         // Get unaccessble subtree for this user
         Hashtable unaccessableSubTree = hasUnaccessableSubTree(user, groups,
         Hashtable unaccessableSubTree = hasUnaccessableSubTree(user, groups,
                                                                myPermission);
         Enumeration en = unaccessableSubTree.elements();
         while (en.hasMoreElements())
-...
         return flag;
+      }
       /**
        * This method will return a hasTable of subtree which user doesn't has the
        * This method will return a hasTable of subtree which user doesn't has the
        * permssion to access
        * @param user  the user name
        * @param groups  the groups which the use is in
        * @param myPermission  permission type to check for
        */
       public Hashtable hasUnaccessableSubTree(String user, String[] groups,
       public Hashtable hasUnaccessableSubTree(String user, String[] groups,
                                            String myPermission) throws McdbException
+      {
         Hashtable resultUnaccessableSubTree = new Hashtable();
         String [] principals=null;
         int permission =AccessControlList.intValue(myPermission);
         //for the commnad line invocation return null(no unaccessable subtree)
         if ((user==null) && (groups==null || groups.length==0))
+        {
           return resultUnaccessableSubTree;
+        }
         //create a userpackage including user, public and group member
         principals=createUsersPackage(user, groups);
         //for the document owner return null(no unaccessable subtree)
-...
+        {
           throw new McdbException(ee);
+        }
         // go through every subtree which has access control
         for (int i = 0; i< subTreeList.size(); i++)
+        {
           SubTree tree = (SubTree)subTreeList.elementAt(i);
           long startId = tree.getStartNodeId();
             try
+            {
               if (isAllowFirst(principals, docId, startId))
+              {
                 if (hasExplicitDenyRule(principals, docId, permission, startId ))
+                {
                  //if it is allowfirst and has deny rule
                   // put the subtree into unaccessable vector
                   if (!resultUnaccessableSubTree.containsKey(new Long(startId)))
-...
+                {
                   //if it is allowfirst and hasn't deny rule and has allow rule
                   //allow access do nothing
                 }//else if
                 else
+                {
-...
+                  {
                     resultUnaccessableSubTree.put(new Long(startId), tree);
+                  }
                 }//else
               }//if isAllowFirst
               else //denyFirst
-...
                 if (hasAllowRule(principals, docId, permission,startId))
+                {
                   //if it is denyFirst and has allow rule, allow access, do nothing
+                }
                 else
+                {
-...
                                        "UnaccessableSubTree "+e.getMessage(), 30);
               throw new McdbException(e);
+            }
         }//for
         // merge the subtree if a subtree is another subtree'subtree
         // merge the subtree if a subtree is another subtree'subtree
         resultUnaccessableSubTree = mergeEquivalentSubtree(resultUnaccessableSubTree);
         return resultUnaccessableSubTree;
       }//hasUnaccessableSubtree
       /*
       /*
        * A method to merge nested subtree into bigger one. For example subtree b
        * is a subtree of subtree a. And user doesn't have read permission for both
        * so we only use subtree a is enough.
-...
             String  treeId  = tree.getSubTreeId();
             long    startId = tree.getStartNodeId();
             long    endId   = tree.getEndNodeId();
             Enumeration enu = unAccessSubTree.elements();
             while (enu.hasMoreElements())
+            {
-...
               if (startId > subTreeStartId && endId < subTreeEndId)
+              {
                 needDelete = true;
                 MetaCatUtil.debugMessage("the subtree: "+ treeId +
                 MetaCatUtil.debugMessage("the subtree: "+ treeId +
                                          " need to be get rid of from unaccessable"+
                                          " subtree list becuase it is a subtree of"+
                                          " another subtree in the list", 45);
-...
           return newSubTreeHash;
         }//else
+      }
       /**
         * Check if a document id is a access document. Access document need user
         * has "all" permission to access it.
-...
             ResultSet rs = pStmt.getResultSet();
             boolean hasRow = rs.next();
             String doctype = null;
             if (hasRow)
             if (hasRow)
+            {
               doctype = rs.getString(1);
+            }
             pStmt.close();
             // if it is an access document
             if (doctype != null && ((MetaCatUtil.getOptionList(MetaCatUtil.
                getOption("accessdoctype")).contains(doctype))))
+            {
               return true;
+            }
+          }
           catch(SQLException e)
+          {
             throw new SQLException("PermissionControl.isAccessDocument " +
                          "Error checking" +
                          " on document " + docId + ". " + e.getMessage());
-...
               DBConnectionPool.returnDBConnection(conn, serialNumber);
+            }
+          }
           return false;
         }//isAccessDocument
       /**
         * Check if a stirng array contains a given documents' owner
         * @param principals, a string array storing the username, groups name and
         * public.
         * @param docid, the id of given documents
         */
         * @param docid, the id of given documents
         */
       private boolean containDocumentOwner( String[] principals, String docId)
                         throws SQLException
+      {
         int lengthOfArray=principals.length;
         boolean hasRow;
         boolean hasRow;
         PreparedStatement pStmt=null;
         DBConnection conn = null;
         int serialNumber = -1;
         try
+        {
           //check out DBConnection
-...
           serialNumber=conn.getCheckOutSerialNumber();
           pStmt = conn.prepareStatement(
                     "SELECT 'x' FROM xml_documents " +
                     "WHERE docid = ? AND lower(user_owner) = ?");
                     "WHERE docid = ? AND lower(user_owner) = ?");
           //check every element in the string array too see if it conatains
           //the owner of document
           for (int i=0; i<lengthOfArray; i++)
+          {
             // Bind the values to the query
             pStmt.setString(1, docId);
             pStmt.setString(2, principals[i]);
             MetaCatUtil.debugMessage("the principle stack is : " +
             MetaCatUtil.debugMessage("the principle stack is : " +
                                       principals[i], 40);
             pStmt.execute();
             ResultSet rs = pStmt.getResultSet();
             hasRow = rs.next();
             if (hasRow)
             if (hasRow)
+            {
               pStmt.close();
                MetaCatUtil.debugMessage("find the owner", 40);
               return true;
             }//if
             }//if
           }//for
         }//try
         catch (SQLException e)
         catch (SQLException e)
+        {
             pStmt.close();
             throw new
             throw new
             SQLException("PermissionControl.hasPermission(). " +
                          "Error checking ownership for " + principals[0] +
                          " on document #" + docId + ". " + e.getMessage());
-...
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
         return false;
         return false;
       }//containDocumentOwner
       /**
         * Check if the permission order for user at that documents is allowFirst
         * @param principals, list of names of principals to check for
         * @param principals, list of names of principals to check for
         * @param docid, document identifier to check for
         */
       private boolean isAllowFirst(String [] principals, String docId,
       private boolean isAllowFirst(String [] principals, String docId,
                                    long startId)
                       throws SQLException, Exception
+      {
-...
           sql = "SELECT perm_order FROM xml_access " +
             "WHERE lower(principal_name)= ? AND docid = ? AND startnodeid = ?";
+        }
         try
+        {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection("AccessControlList.isAllowFirst");
           serialNumber=conn.getCheckOutSerialNumber();
           //select permission order from database
           pStmt = conn.prepareStatement(sql);
           //check every name in the array
           for (int i=0; i<lengthOfArray;i++)
+          {
             //bind value
             pStmt.setString(1, principals[i]);//user name
             pStmt.setString(2, docId);//docid
             // if subtree, we need set subtree id
             // if subtree, we need set subtree id
             if (!topLever)
+            {
               pStmt.setLong(3, startId);
+            }
             pStmt.execute();
             ResultSet rs = pStmt.getResultSet();
             hasRow=rs.next();
-...
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
         //if reach here, means there is no permssion record for given names and
         //if reach here, means there is no permssion record for given names and
         //docid. So throw a exception.
         throw new Exception("There is no permission record for user"+principals[0]+
                             "at document "+docId);
       }//isAllowFirst
       /**
         * Check if the users array has allow rules for given users, docid and
         * Check if the users array has allow rules for given users, docid and
         * permission.
         * If it has permission rule and ticket count is greater than 0, the ticket
         * number will decrease one for every allow rule
         * @param principals, list of names of principals to check for
         * @param principals, list of names of principals to check for
         * @param docid, document identifier to check for
         * @param permission, the permssion need to check
         */
       private boolean hasAllowRule(String [] principals, String docId,
       private boolean hasAllowRule(String [] principals, String docId,
                                       int permission, long startId)
                       throws SQLException, Exception
+     {
-...
+       {
          // for toplevel
          topLever = true;
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
        "AND lower(principal_name) = ? AND perm_type = ? AND startnodeid is NULL";
+       }
        else
+       {
          topLever =false;
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
           "AND lower(principal_name) = ? AND perm_type = ? AND startnodeid = ?";
+       }
        try
-...
          //check out DBConnection
          conn=DBConnectionPool.getDBConnection("AccessControlList.hasAllowRule");
          serialNumber=conn.getCheckOutSerialNumber();
         //This sql statement will select entry with
         //This sql statement will select entry with
         //begin_time<=currentTime<=end_time in xml_access table
         //If begin_time or end_time is null in table, isnull(begin_time, sysdate)
         //function will assign begin_time=sysdate
-...
         //bind docid, perm_type
         pStmt.setString(1, docId);
         pStmt.setString(3, AccessControlInterface.ALLOW);
         // if subtree lever, need to set subTreeId
         if (!topLever)
+        {
           pStmt.setLong(4, startId);
+        }
         //bind every elenment in user name array
         for (int i=0;i<lengthOfArray; i++)
+        {
-...
           while (rs.next())//check every entry for one user
+          {
             permissionValueInTable=rs.getInt(1);
             //permission is ok
             //permission is ok
             //the user have a permission to access the file
             if (( permissionValueInTable & permissionValue )== permissionValue )
+            {
                allow=true;//has allow rule entry
             }//if
           }//while
-...
+       }
         return allow;
      }//hasAllowRule
        /**
         * Check if the users array has explicit deny rules for given users, docid
         * Check if the users array has explicit deny rules for given users, docid
         * and permission. That means the perm_type is deny and current time is
         * less than end_time and greater than begin time, or no time limit.
         * @param principals, list of names of principals to check for
         * @param principals, list of names of principals to check for
         * @param docid, document identifier to check for
         * @param permission, the permssion need to check
         */
       private boolean hasExplicitDenyRule(String [] principals, String docId,
       private boolean hasExplicitDenyRule(String [] principals, String docId,
                                           int permission, long startId)
                       throws SQLException
+     {
-...
        int serialNumber = -1;
        String sql = null;
        boolean topLevel = false;
        // decide top level or subtree level
        if (startId == TOPLEVELSTARTNODEID)
+       {
          topLevel = true;
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
         "AND lower(principal_name) = ? AND perm_type = ? AND startnodeid is NULL";
+       }
        else
+       {
          topLevel = false;
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
          sql = "SELECT permission FROM xml_access WHERE docid = ? " +
          "AND lower(principal_name) = ? AND perm_type = ? AND startnodeid = ?";
+       }
        try
+       {
          //check out DBConnection
          conn=DBConnectionPool.getDBConnection("PermissionControl.hasExplicitDeny");
          serialNumber=conn.getCheckOutSerialNumber();
          pStmt = conn.prepareStatement(sql);
         //bind docid, perm_type
         pStmt.setString(1, docId);
         pStmt.setString(3, AccessControlInterface.DENY);
         // subtree level need to set up subtreeid
         if (!topLevel)
+        {
           pStmt.setLong(4, startId);
+        }
         //bind every elenment in user name array
         for (int i=0;i<lengthOfArray; i++)
+        {
-...
           while (rs.next())//check every entry for one user
+          {
             permissionValueInTable=rs.getInt(1);
             //permission is ok the user doesn't have permission to access the file
             if (( permissionValueInTable & permissionValue )== permissionValue )
+            {
                pStmt.close();
                return true;
-...
+         }
        }//finally
        return false;//no deny rule
       }//hasExplicitDenyRule
       }//hasExplicitDenyRule
       /**
         * Creat a users pakages to check permssion rule, user itself, public and
         * the gourps the user belong will be include in this package
-...
+      {
         String [] usersPackage=null;
         int lengthOfPackage;
         if (groups!=null)
+        {
           //if gouprs is not null and user is not public, we should create a array
           //to store the groups and user and public.
           //if gouprs is not null and user is not public, we should create a array
           //to store the groups and user and public.
           //So the length of userPackage is the length of group plus two
           if (!user.equalsIgnoreCase(AccessControlInterface.PUBLIC))
+          {
-...
+            {
               usersPackage[0]= user.toLowerCase();
               MetaCatUtil.debugMessage("after transfer to lower case(not null): "+
                                          usersPackage[0], 45);
                                          usersPackage[0], 45);
+            }
             else
+            {
-...
+              }
             } //for
           }//else user=public
         }//if groups!=null
         else
+        {
-...
         }//else groups==null
         return usersPackage;
       }//createUsersPackage
       /**
         * This method will return a data set id for given access id.
         * @param accessDocId, the accessDocId which need to be found data set id
        * A static method to get Hashtable which cointains a inlinedata object list that
        * user can't read it. The key is subtree id of inlinedata, the data is
        * internal file name for the inline data which is stored as docid
        * in xml_access table or data object doc id.
        * @param docidWithoutRev, metadata docid which should be the accessfileid
        *                         in the table
        * @param user , the name of user
        * @param groups, the group which the user belong to
        */
       private String getDataSetId(String accessDocId)
                                   throws SQLException
        public static Hashtable getUnReadableInlineDataIdList(String docidWithoutRev,
                                                        String user, String[] groups)
                                                     throws Exception
+       {
          Hashtable inlineDataList = getUnAccessableInlineDataIdList(docidWithoutRev,
                                   user, groups, AccessControlInterface.READSTRING);
          return inlineDataList;
+       }
        /**
       * A static method to get Hashtable which cointains a inline  data object list that
       * user can't overwrite it. The key is subtree id of inline data distrubition,
       * the value is internal file name for the inline data which is stored as docid
       * in xml_access table or data object doc id.
       * @param docidWithoutRev, metadata docid which should be the accessfileid
       *                         in the table
       * @param user , the name of user
       * @param groups, the group which the user belong to
       */
       public static Hashtable getUnWritableInlineDataIdList(String docidWithoutRev,
                                                       String user, String[] groups)
                                                    throws Exception
+      {
         String dataSetId=null;
         PreparedStatement pStmt=null;
         ResultSet rs=null;
         DBConnection conn=null;
         int serialNumber=-1;
         String query="SELECT docId from xml_relation where subject = ? or "
                                                     +"object = ?";
         try
+        {
           //check out DBConnection
           conn=DBConnectionPool.getDBConnection("PermissionControl.getDataSetId");
           serialNumber=conn.getCheckOutSerialNumber();
           pStmt=conn.prepareStatement(query);
           //bind the value to query
           pStmt.setString(1, accessDocId);
           pStmt.setString(2, accessDocId);
           //execute the query
           pStmt.execute();
           rs=pStmt.getResultSet();
           //process the result
           if (rs.next()) //There are some records for the data set id for access id
         Hashtable inlineDataList = getUnAccessableInlineDataIdList(docidWithoutRev,
                                 user, groups, AccessControlInterface.WRITESTRING);
         return inlineDataList;
+      }
        /*
         * This method will get hashtable which contains a unaccessable distribution
         * inlinedata object list
         */
        private static Hashtable getUnAccessableInlineDataIdList(String docid,
                                    String user, String[] groups, String permission)
                                  throws SQLException,McdbException, Exception
+       {
           Hashtable unAccessbleIdList = new Hashtable();
           Hashtable allIdList = getAllInlineDataIdList(docid);
           Enumeration en = allIdList.keys();
           while (en.hasMoreElements())
+          {
             dataSetId=rs.getString(1);
             String subTreeId = (String) en.nextElement();
             String fileId = (String) allIdList.get(subTreeId);
             //Here fileid is internal file id for line data. It stored in docid
             // field in xml_access table. so we don't need to delete rev
             PermissionController controller = new PermissionController(docid, false);
             if (!controller.hasPermissionForInlineData(user, groups, permission, fileId))
+            {
               MetaCatUtil.debugMessage("Put subtree id " +subTreeId + " and " +
                                        "inline data file name " + fileId + " into "+
                                        "un"+permission+" hash", 20);
               unAccessbleIdList.put(subTreeId, fileId);
+            }
+          }
           else //No data set id for the given access id in xml_relation table
+          {
             dataSetId=null;
+          }
         }//try
         finally
+        {
           try
+          {
             pStmt.close();
+          }
           finally
+          {
             DBConnectionPool.returnDBConnection(conn, serialNumber);
+          }
+        }
         return dataSetId;
       }//getDataPackageId()
           return unAccessbleIdList;
+       }
        /*
         * This method will get a hash table from xml_access table for all records
         * about the inline data. The key is subtree id and data is a inline internal
         * file name
         */
        private static Hashtable getAllInlineDataIdList(String docid) throws SQLException
+       {
          Hashtable inlineDataList = new Hashtable();
          String sql = "SELECT subtreeid, docid FROM xml_access WHERE " +
                        "accessfileid = ? AND subtreeid  IS NOT NULL";
          PreparedStatement pStmt=null;
          ResultSet rs=null;
          DBConnection conn=null;
          int serialNumber=-1;
          try
+         {
            //check out DBConnection
            conn=DBConnectionPool.getDBConnection("PermissionControl.getDataSetId");
            serialNumber=conn.getCheckOutSerialNumber();
            pStmt=conn.prepareStatement(sql);
            //bind the value to query
            pStmt.setString(1, docid);
            //execute the query
            pStmt.execute();
            rs=pStmt.getResultSet();
            //process the result
            while(rs.next())
+           {
              String subTreeId = rs.getString(1);
              String inlineDataId = rs.getString(2);
              if (subTreeId != null && !subTreeId.trim().equals("") &&
                 inlineDataId != null && !inlineDataId.trim().equals(""))
+             {
                inlineDataList.put(subTreeId, inlineDataId);
+             }
           }//while
          }//try
          finally
+         {
            try
+           {
              pStmt.close();
+           }
            finally
+           {
              DBConnectionPool.returnDBConnection(conn, serialNumber);
+           }
          }//finally
          return inlineDataList;
        }//getAllInlineDataIdList
+    }

         StringWriter docwriter = new StringWriter();
         String userName = null;
         String[] groupNames = null;
         boolean withInlineData = false;
         boolean withInlineData = true;
         try
+        {
           this.toXml(docwriter, userName, groupNames, withInlineData);
-...
        * Print a text representation of the XML document to a Writer
+       *
        * @param pw the Writer to which we print the document
        *  Now we decide no matter withinInlineData's value, the document will
+       *
        */
       public void toXml(Writer pw, String user, String[] groups, boolean withInLineData)
                                                               throws McdbException
-...
         MetaCatUtil util = new MetaCatUtil();
         // Here add code to handle subtree access control
         PermissionController control = new PermissionController(docid);
         /*PermissionController control = new PermissionController(docid);
         Hashtable unaccessableSubTree =control.hasUnaccessableSubTree(user, groups,
                                                  AccessControlInterface.READSTRING);
-...
         else
+        {
           nodeRecordLists = getNodeRecordList(rootnodeid);
+        }
         }*/
         nodeRecordLists = getNodeRecordList(rootnodeid);
         Stack openElements = new Stack();
         boolean atRootElement = true;
         boolean previousNodeWasElement = false;
-...
           // Handle the TEXT nodes
           } else if (currentNode.nodetype.equals("TEXT")) {
             if (previousNodeWasElement) {
             if (previousNodeWasElement)
+            {
               out.print(">");
+            }
             if (!prcocessInlineData || !withInLineData)
             if (!prcocessInlineData)
+            {
               // if it is not inline data just out put data or it is line data
               // but user don't want it, just put local id in inlinedata
               // if it is not inline data just out put data
               out.print(currentNode.nodedata);
+            }
             else
+            {
               // if it is inline data and user want to see it, pull out from
               // file system and output it
               // for inline data, the data base only store the file name, so we
               // can combine the file name and inline data file path, to get it
               // if it is inline data first to get the inline data internal id
               String fileName = currentNode.nodedata;
               Reader reader =
                             Eml200SAXHandler.readInlineDataFromFileSystem(fileName);
               char [] characterArray = new char [4*1024];
               String accessfileName = MetaCatUtil.getDocIdWithoutRevFromInlineDataID(fileName);
               // check if user has read permision for this inline data
               boolean readInlinedata = false;
               try
+              {
                 int length = reader.read(characterArray);
                 while ( length != -1)
                 Hashtable unReadableInlineDataList =
                     PermissionController.getUnReadableInlineDataIdList(accessfileName,user,groups);
                 if (!unReadableInlineDataList.containsValue(fileName))
+                {
                   out.print(new String(characterArray, 0, length));
                   out.flush();
                   length = reader.read(characterArray);
                   readInlinedata = true;
+                }
                 reader.close();
+              }
               catch (IOException e)
               catch (Exception e)
+              {
                 throw new McdbException(e.getMessage());
+              }
+            }
             // reset proccess inline data false
             prcocessInlineData =false;
               if (readInlinedata)
+              {
                 //user want to see it, pull out from
                 // file system and output it
                 // for inline data, the data base only store the file name, so we
                 // can combine the file name and inline data file path, to get it
                 Reader reader =
                     Eml200SAXHandler.readInlineDataFromFileSystem(fileName);
                 char[] characterArray = new char[4 * 1024];
                 try
+                {
                   int length = reader.read(characterArray);
                   while (length != -1)
+                  {
                     out.print(new String(characterArray, 0, length));
                     out.flush();
                     length = reader.read(characterArray);
+                  }
                   reader.close();
+                }
                 catch (IOException e)
+                {
                   throw new McdbException(e.getMessage());
+                }
               }//if can read inline data
               else
+              {
                  // if user can't read it, we only send it back a empty string
                  // in inline element.
                  out.print("");
               }// else can't read inlinedata
               // reset proccess inline data false
               prcocessInlineData =false;
             }// in inlinedata part
             previousNodeWasElement = false;
           // Handle the COMMENT nodes
           } else if (currentNode.nodetype.equals("COMMENT")) {
             if (previousNodeWasElement) {
-...
           MetaCatUtil.debugMessage("Start deleting doc "+docid+ "...", 20);
         // check for 'write' permission for 'user' to delete this document
           if ( !hasWritePermission(user, groups, accnum) ) {
           if ( !hasAllPermission(user, groups, accnum) ) {
             throw new Exception("User " + user +
                   " does not have permission to delete XML Document #" + accnum);
+          }
-...
           pstmt.close();
           conn.increaseUsageCount(1);
           pstmt = conn.
                  prepareStatement("DELETE FROM xml_access WHERE docid = ?");
           pstmt.setString(1, docid);
           pstmt.execute();
           pstmt.close();
           conn.increaseUsageCount(1);
           // Delete it from relation table
           pstmt = conn.
                    prepareStatement("DELETE FROM xml_relation WHERE docid = ?");
-...
                                                 AccessControlInterface.READSTRING);
+      }
       /**
        * Check for "WRITE" permission on @docid for @user and/or @groups
        * from DB connection
        */
       private static boolean hasAllPermission (String user,
                                      String[] groups, String docid )
                      throws SQLException, Exception
+      {
         // Check for WRITE permission on @docid for @user and/or @groups
         PermissionController controller = new PermissionController(docid);
         return controller.hasPermission(user,groups,
                                        AccessControlInterface.ALLSTRING);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 2245

Added by sgarg over 20 years ago