149510

Strip down ACL code and support libraries to the bare minimum.

9 files changed, 88 insertions, 93 deletions

diff --git a/lib/libaccess/Makefile b/lib/libaccess/Makefile
index 2acb484b..c5433f7f 100644
--- a/lib/libaccess/Makefile
+++ b/lib/libaccess/Makefile
@@ -43,14 +43,8 @@ OBJS=$(addprefix $(OBJDEST)/,	usi.o \
 				attrec.o \
 				nseframe.o \
 				nsdb.o \
-				nsdbmgmt.o \
 				nsuser.o \
-				nsumgmt.o \
 				nsgroup.o \
-				nsgmgmt.o \
-				nsadb.o \
-				nscert.o \
-				nsamgmt.o \
 				nsautherr.o \
 				symbols.o \
                                 acltools.o \
@@ -67,7 +61,6 @@ OBJS=$(addprefix $(OBJDEST)/,	usi.o \
 				usrcache.o \
 				lasgroup.o \
 				lasuser.o \
-				lasprogram.o \
                                 aclspace.o \
                                 acl.tab.o \
                                 acl.yy.o \
@@ -77,10 +70,15 @@ OBJS=$(addprefix $(OBJDEST)/,	usi.o \
 				aclparse.o \
 				aclbuild.o \
 				aclerror.o \
-				acladmin.o \
-				aclcgi.o \
+				nsadb.o  \
+				nscert.o  \
+				nsamgmt.o  \
+				nsgmgmt.o  \
+				nsdbmgmt.o  \
+				nsumgmt.o  \
                                 $(OSOBJS) \
 				)
+ 
 
 #
 # AVA Mapping files. Currently not compiled in (FORTEZZA for reference only).
diff --git a/lib/libaccess/aclcache.cpp b/lib/libaccess/aclcache.cpp
index 34d2ecfb..acb1fc1d 100644
--- a/lib/libaccess/aclcache.cpp
+++ b/lib/libaccess/aclcache.cpp
@@ -4,7 +4,7 @@
  * All rights reserved.
  * END COPYRIGHT BLOCK **/
 
-#include <base/nsassert.h>
+#include <prlog.h>
 #include <base/crit.h>
 #include <base/ereport.h>
 #include <plhash.h>
@@ -125,20 +125,20 @@ ACL_ListHashUpdate(ACLListHandle_t **acllistp)
     NSErr_t *errp = 0;
     ACLListHandle_t *tmp_acllist;
 
-    NS_ASSERT(ACL_AssertAcllist(*acllistp));
+    PR_ASSERT(ACL_AssertAcllist(*acllistp));
 
     tmp_acllist = (ACLListHandle_t *)PR_HashTableLookup(ACLListHash, *acllistp);
     if (tmp_acllist  &&  tmp_acllist != *acllistp) {
-	NS_ASSERT(*acllistp  &&  *acllistp != ACL_LIST_NO_ACLS);
+	PR_ASSERT(*acllistp  &&  *acllistp != ACL_LIST_NO_ACLS);
 	ACL_ListDestroy(errp, *acllistp);
 	*acllistp = tmp_acllist;
-	NS_ASSERT(ACL_CritHeld());
+	PR_ASSERT(ACL_CritHeld());
         tmp_acllist->ref_count++;	/* we're gonna use it */
     } else { 			/* Wasn't in the list */
 	PR_HashTableAdd(ACLListHash, *acllistp, *acllistp);
     }
 
-    NS_ASSERT(ACL_AssertAcllist(*acllistp));
+    PR_ASSERT(ACL_AssertAcllist(*acllistp));
     return;
 }
 
@@ -156,15 +156,15 @@ ACL_ListHashEnter(ACLListHandle_t **acllistp)
 
     /*  Look for a matching ACL List and use it if we find one.  */
     if (*acllistp)  {
-	NS_ASSERT(*acllistp != ACL_LIST_NO_ACLS);
-        NS_ASSERT(ACL_AssertAcllist(*acllistp));
+	PR_ASSERT(*acllistp != ACL_LIST_NO_ACLS);
+        PR_ASSERT(ACL_AssertAcllist(*acllistp));
 	ACL_ListHashUpdate(acllistp);
     } else {
 	*acllistp = ACL_LIST_NO_ACLS;
     }
 
     ACL_CritExit();
-    NS_ASSERT(ACL_AssertAcllist(*acllistp));
+    PR_ASSERT(ACL_AssertAcllist(*acllistp));
     return;
 }
 
@@ -184,12 +184,12 @@ ACL_ListHashCheck(ACLListHandle_t **acllistp)
 
     tmp_acllist = (ACLListHandle_t *)PR_HashTableLookup(ACLListHash, *acllistp);
     if (tmp_acllist) {
-	NS_ASSERT(*acllistp  &&  *acllistp != ACL_LIST_NO_ACLS);
+	PR_ASSERT(*acllistp  &&  *acllistp != ACL_LIST_NO_ACLS);
 	*acllistp = tmp_acllist;
-	NS_ASSERT(ACL_CritHeld());
+	PR_ASSERT(ACL_CritHeld());
         tmp_acllist->ref_count++;	/* we're gonna use it */
         ACL_CritExit();
-	NS_ASSERT(ACL_AssertAcllist(*acllistp));
+	PR_ASSERT(ACL_AssertAcllist(*acllistp));
         return 1;		/* Normal path */
     } else { 			/* Wasn't in the list */
         ACL_CritExit();
@@ -280,7 +280,7 @@ int
 ACL_INTCacheCheck(int which, char *uri, ACLListHandle_t **acllistp)
 {
     PLHashTable *hash;
-    NS_ASSERT(uri && acl_uri_hash && acl_uri_get_hash);
+    PR_ASSERT(uri && acl_uri_hash && acl_uri_get_hash);
 
     /*  ACL cache:  If the ACL List is already in the cache, there's no need
      *  to go through the pathcheck directives.
@@ -300,12 +300,12 @@ ACL_INTCacheCheck(int which, char *uri, ACLListHandle_t **acllistp)
     *acllistp = (ACLListHandle_t *)PR_HashTableLookup(hash, uri);
     if (*acllistp != NULL) {
 	if (*acllistp != ACL_LIST_NO_ACLS) {
-            NS_ASSERT((*acllistp)->ref_count >= 0);
-	    NS_ASSERT(ACL_CritHeld());
+            PR_ASSERT((*acllistp)->ref_count >= 0);
+	    PR_ASSERT(ACL_CritHeld());
 	    (*acllistp)->ref_count++;
 	}
         ACL_CritExit();
-	NS_ASSERT(ACL_AssertAcllist(*acllistp));
+	PR_ASSERT(ACL_AssertAcllist(*acllistp));
         return 1;		/* Normal path */
     }
 
@@ -339,7 +339,7 @@ ACL_INTCacheEnter(int which, char *uri, ACLListHandle_t **acllistp)
     NSErr_t *errp = 0;
     PLHashTable *hash;
 
-    NS_ASSERT(uri);
+    PR_ASSERT(uri);
 
     ACL_CritEnter();
 
@@ -356,7 +356,7 @@ ACL_INTCacheEnter(int which, char *uri, ACLListHandle_t **acllistp)
     tmpacllist = (ACLListHandle_t *)PR_HashTableLookup(hash, uri);
     if (tmpacllist != NULL) {
         if (tmpacllist != ACL_LIST_NO_ACLS) {
-	    NS_ASSERT(ACL_CritHeld());
+	    PR_ASSERT(ACL_CritHeld());
             tmpacllist->ref_count++;	/* we're going to use it */
         }
 	ACL_CritExit();
@@ -364,15 +364,15 @@ ACL_INTCacheEnter(int which, char *uri, ACLListHandle_t **acllistp)
 	    ACL_ListDestroy(errp, *acllistp);
 	}
 	*acllistp = tmpacllist;
-	NS_ASSERT(ACL_AssertAcllist(*acllistp));
+	PR_ASSERT(ACL_AssertAcllist(*acllistp));
 	return;
     }
 
     /*  Didn't find another list, so put ours in.  */
     /*  Look for a matching ACL List and use it if we find one.  */
     if (*acllistp)  {
-	NS_ASSERT(*acllistp != ACL_LIST_NO_ACLS);
-        NS_ASSERT(ACL_AssertAcllist(*acllistp));
+	PR_ASSERT(*acllistp != ACL_LIST_NO_ACLS);
+        PR_ASSERT(ACL_AssertAcllist(*acllistp));
 	ACL_ListHashUpdate(acllistp);
     } else {
 	*acllistp = ACL_LIST_NO_ACLS;
@@ -380,7 +380,7 @@ ACL_INTCacheEnter(int which, char *uri, ACLListHandle_t **acllistp)
     PR_HashTableAdd(hash, pool_strdup((void **)acl_uri_hash_pool, uri), (void *)*acllistp);
 
     ACL_CritExit();
-    NS_ASSERT(ACL_AssertAcllist(*acllistp));
+    PR_ASSERT(ACL_AssertAcllist(*acllistp));
     return;
 }
 
@@ -422,13 +422,13 @@ ACL_AddAclName(char *path, ACLListHandle_t **acllistp, ACLListHandle_t
     if (!acl)
 	return;
 
-    NS_ASSERT(ACL_AssertAcl(acl));
+    PR_ASSERT(ACL_AssertAcl(acl));
 
     if (!*acllistp)
 	*acllistp = ACL_ListNew(errp);
     ACL_ListAppend(NULL, *acllistp, acl, 0);
 
-    NS_ASSERT(ACL_AssertAcllist(*acllistp));
+    PR_ASSERT(ACL_AssertAcllist(*acllistp));
     return;
 }
 
@@ -456,8 +456,8 @@ ACLListHandle_t *masterlist)
     int  prefixlen;
     char *dst;
 
-    NS_ASSERT(path);
-    NS_ASSERT(prefix);
+    PR_ASSERT(path);
+    PR_ASSERT(prefix);
 
     dst = strncpy(ppath, prefix, ACL_PATH_MAX);
     if (dst >= (ppath+ACL_PATH_MAX-1)) {
@@ -522,7 +522,7 @@ ACL_Init(void)
     ACL_InitAttr2Index();
     ACLGlobal = (ACLGlobal_p)PERM_CALLOC(sizeof(ACLGlobal_s));
     oldACLGlobal = (ACLGlobal_p)PERM_CALLOC(sizeof(ACLGlobal_s));
-    NS_ASSERT(ACLGlobal && oldACLGlobal);
+    PR_ASSERT(ACLGlobal && oldACLGlobal);
     ACL_DATABASE_POOL = pool_create();
     ACL_METHOD_POOL = pool_create();
     ACL_CritInit();
diff --git a/lib/libaccess/aclerror.cpp b/lib/libaccess/aclerror.cpp
index 2cbf2874..68395c72 100644
--- a/lib/libaccess/aclerror.cpp
+++ b/lib/libaccess/aclerror.cpp
@@ -17,7 +17,7 @@
 #else
 #include "nspr/prprf.h"
 #endif
-#include <base/nsassert.h>
+#include "prlog.h"
 #include "libaccess/nserror.h"
 #include "libaccess/nsautherr.h"
 #include "libaccess/aclerror.h"
@@ -110,7 +110,7 @@ void aclErrorFmt(NSErr_t * errp, char * msgbuf, int maxlen, int maxdepth)
 		    strncpy(msgbuf, efp->ef_errv[0], maxlen);
 		    break;
 		default:
-		    NS_ASSERT(0); /* don't break -- continue into case 0 */
+		    PR_ASSERT(0); /* don't break -- continue into case 0 */
 		case 0:
 	            switch (efp->ef_retcode) {
 	            case ACLERRFAIL:
diff --git a/lib/libaccess/aclflush.cpp b/lib/libaccess/aclflush.cpp
index dfee47d6..05fa18e4 100644
--- a/lib/libaccess/aclflush.cpp
+++ b/lib/libaccess/aclflush.cpp
@@ -7,7 +7,7 @@
  * Source file for the ACL_CacheFlush-related routines.
  */
 
-#include	<base/nsassert.h>
+#include	<prlog.h>
 #include	<base/util.h>
 #include	<libaccess/acl.h>
 #include	"aclpriv.h"
@@ -25,15 +25,15 @@ deletelists(PRHashEntry *he, PRIntn i, void *arg)
     ACLListHandle_t *acllist=(ACLListHandle_t *)he->value;
     NSErr_t *errp = 0;
 
-    NS_ASSERT(he);
-    NS_ASSERT(he->value);
+    PR_ASSERT(he);
+    PR_ASSERT(he->value);
 
     if (acllist->ref_count) {
 	//  If the list is in use, increment the counter.  Then set the 
 	//  stale flag.  The other user can't delete the list since we're
 	//  counted as well.  Finally, decrement the counter and whoever
 	//  sets it to zero will delete the ACL List.
-	NS_ASSERT(ACL_CritHeld());
+	PR_ASSERT(ACL_CritHeld());
 	acllist->ref_count++;
 	acllist->flags |= ACL_LIST_STALE;
 	if (--acllist->ref_count == 0)
@@ -54,8 +54,8 @@ restartdeletelists(PRHashEntry *he, PRIntn i, void *arg)
     //  what.
     ACLListHandle_t *acllist=(ACLListHandle_t *)he->value;
 
-    NS_ASSERT(he);
-    NS_ASSERT(he->value);
+    PR_ASSERT(he);
+    PR_ASSERT(he->value);
 
     ACL_ListDestroy(errp, acllist);
 
@@ -67,7 +67,7 @@ static AclCacheFlushFunc_t AclCacheFlushRoutine = NULL;
 NSAPI_PUBLIC int
 ACL_CacheFlushRegister(AclCacheFlushFunc_t flush_func)
 {
-    NS_ASSERT(flush_func);
+    PR_ASSERT(flush_func);
     AclCacheFlushRoutine = flush_func;
 
     return 0;
@@ -79,12 +79,12 @@ ACL_CacheFlush(void)
     ACLGlobal_p	newACLGlobal;
     NSErr_t *errp = 0;
 
-    NS_ASSERT(ACLGlobal);
-    NS_ASSERT(ACLGlobal->masterlist);
-    NS_ASSERT(ACLGlobal->listhash);
-    NS_ASSERT(ACLGlobal->urihash);
-    NS_ASSERT(ACLGlobal->urigethash);
-    NS_ASSERT(ACLGlobal->pool);
+    PR_ASSERT(ACLGlobal);
+    PR_ASSERT(ACLGlobal->masterlist);
+    PR_ASSERT(ACLGlobal->listhash);
+    PR_ASSERT(ACLGlobal->urihash);
+    PR_ASSERT(ACLGlobal->urigethash);
+    PR_ASSERT(ACLGlobal->pool);
 
     ACL_CritEnter();
 
@@ -142,12 +142,12 @@ ACL_Restart(void *clntData)
 {
     NSErr_t *errp = 0;
 
-    NS_ASSERT(ACLGlobal);
-    NS_ASSERT(ACLGlobal->masterlist);
-    NS_ASSERT(ACLGlobal->listhash);
-    NS_ASSERT(ACLGlobal->urihash);
-    NS_ASSERT(ACLGlobal->urigethash);
-    NS_ASSERT(ACLGlobal->pool);
+    PR_ASSERT(ACLGlobal);
+    PR_ASSERT(ACLGlobal->masterlist);
+    PR_ASSERT(ACLGlobal->listhash);
+    PR_ASSERT(ACLGlobal->urihash);
+    PR_ASSERT(ACLGlobal->urigethash);
+    PR_ASSERT(ACLGlobal->pool);
 
     //	Unlike ACL_CacheFlush, this routine can be much more cavalier about
     //	freeing up memory, since there's guaranteed to be no users about at
diff --git a/lib/libaccess/acltools.cpp b/lib/libaccess/acltools.cpp
index 1283147e..9a9c820f 100644
--- a/lib/libaccess/acltools.cpp
+++ b/lib/libaccess/acltools.cpp
@@ -3384,9 +3384,9 @@ ACL_Decompose(NSErr_t *errp, char **acl, ACLListHandle_t *acl_list)
 
 /*
  * The following routines are used to validate input parameters.  They always
- * return 1, or cause an NS_ASSERT failure.  The proper way to use them is 
- * with an NS_ASSERT in the calling function.  E.g.
- *	NS_ASSERT(ACL_AssertAcllist(acllist));
+ * return 1, or cause an PR_ASSERT failure.  The proper way to use them is 
+ * with an PR_ASSERT in the calling function.  E.g.
+ *	PR_ASSERT(ACL_AssertAcllist(acllist));
  */
 
 int
@@ -3395,18 +3395,18 @@ ACL_AssertAcllist(ACLListHandle_t *acllist)
     ACLWrapper_t *wrap;
 
     if (acllist == ACL_LIST_NO_ACLS) return 1;
-    NS_ASSERT(acllist);
-    NS_ASSERT(acllist->acl_list_head);
-    NS_ASSERT(acllist->acl_list_tail);
-    NS_ASSERT(acllist->acl_count);
-    NS_ASSERT(acllist->ref_count > 0);
+    PR_ASSERT(acllist);
+    PR_ASSERT(acllist->acl_list_head);
+    PR_ASSERT(acllist->acl_list_tail);
+    PR_ASSERT(acllist->acl_count);
+    PR_ASSERT(acllist->ref_count > 0);
 
     for (wrap=acllist->acl_list_head; wrap; wrap=wrap->wrap_next) {
-	NS_ASSERT(ACL_AssertAcl(wrap->acl));
+	PR_ASSERT(ACL_AssertAcl(wrap->acl));
     }
 
     /* Artificially limit ACL lists to 10 ACLs for now */
-    NS_ASSERT(acllist->acl_count < 10);
+    PR_ASSERT(acllist->acl_count < 10);
 
     return 1;
 }
@@ -3414,11 +3414,11 @@ ACL_AssertAcllist(ACLListHandle_t *acllist)
 int
 ACL_AssertAcl(ACLHandle_t *acl)
 {
-    NS_ASSERT(acl);
-    NS_ASSERT(acl->ref_count);
-    NS_ASSERT(acl->expr_count);
-    NS_ASSERT(acl->expr_list_head);
-    NS_ASSERT(acl->expr_list_tail);
+    PR_ASSERT(acl);
+    PR_ASSERT(acl->ref_count);
+    PR_ASSERT(acl->expr_count);
+    PR_ASSERT(acl->expr_list_head);
+    PR_ASSERT(acl->expr_list_tail);
 
     return 1;
 }
diff --git a/lib/libaccess/aclutil.cpp b/lib/libaccess/aclutil.cpp
index 8d30fffb..add9a203 100644
--- a/lib/libaccess/aclutil.cpp
+++ b/lib/libaccess/aclutil.cpp
@@ -106,7 +106,7 @@ EvalToRes(int value)
 	case LAS_EVAL_NEED_MORE_INFO:
 		return ACL_RES_DENY;
         default:
-		NS_ASSERT(1);
+		PR_ASSERT(1);
 		return ACL_RES_ERROR;
 	}
 }
diff --git a/lib/libaccess/avadb.c b/lib/libaccess/avadb.c
index c0d98704..a2884082 100644
--- a/lib/libaccess/avadb.c
+++ b/lib/libaccess/avadb.c
@@ -11,8 +11,6 @@
 #include "libaccess/avadb.h"
 #include "base/session.h"
 #include "base/pblock.h"
-#include "frame/req.h"
-#include "frame/log.h"
 
 #include "libadmin/libadmin.h"
 #include "libaccess/avapfile.h"
diff --git a/lib/libaccess/oneeval.cpp b/lib/libaccess/oneeval.cpp
index be837599..088940ff 100644
--- a/lib/libaccess/oneeval.cpp
+++ b/lib/libaccess/oneeval.cpp
@@ -19,7 +19,6 @@
 #include <netsite.h>
 #include <base/systems.h>
 #include <base/crit.h>
-#include <base/session.h>
 #include <libaccess/nserror.h>
 #include <libaccess/acl.h>
 #include "aclpriv.h"
@@ -489,7 +488,7 @@ ACLEvalBuildContext(
 		break;
 
 	    default:
-		NS_ASSERT(0);
+		PR_ASSERT(0);
 	    
 	    }	/*  switch expr_type  */
 
@@ -683,14 +682,14 @@ ACL_INTEvalTestRights(
 		    rarray_p->acelist[rarray_p->count++] = 
 		      (ACLAceNumEntry_t *)ACL_HashTableLookup_const(cache->Table, 
 		      (char *)generic_rights[g_num]);
-		    NS_ASSERT (rarray_p->count < ACL_MAX_GENERIC);
+		    PR_ASSERT (rarray_p->count < ACL_MAX_GENERIC);
 		}
             }
         }
 
         rights_cnt++;
         rights++;
-	NS_ASSERT (rights_cnt < ACL_MAX_TEST_RIGHTS);
+	PR_ASSERT (rights_cnt < ACL_MAX_TEST_RIGHTS);
     }
 
     /*    Special case - look for an entry that applies to "all" rights     */
@@ -974,10 +973,10 @@ ACL_EvalDestroy(NSErr_t *errp, pool_handle_t *pool, ACLEvalHandle_t *acleval)
 {
     if (!acleval->acllist  ||  acleval->acllist == ACL_LIST_NO_ACLS)
 	return;
-    NS_ASSERT(acleval->acllist->ref_count > 0);
+    PR_ASSERT(acleval->acllist->ref_count > 0);
 
     ACL_CritEnter();
-    NS_ASSERT(ACL_CritHeld());
+    PR_ASSERT(ACL_CritHeld());
     if (--acleval->acllist->ref_count == 0) {
 	if (ACL_LIST_IS_STALE(acleval->acllist)) {
 	    ACL_ListDestroy(errp, acleval->acllist);
@@ -1004,10 +1003,10 @@ ACL_ListDecrement(NSErr_t *errp, ACLListHandle_t *acllist)
     if (!acllist  ||  acllist == ACL_LIST_NO_ACLS)
 	return 0;
 
-    NS_ASSERT(ACL_AssertAcllist(acllist));
+    PR_ASSERT(ACL_AssertAcllist(acllist));
 
     ACL_CritEnter();
-    NS_ASSERT(ACL_CritHeld());
+    PR_ASSERT(ACL_CritHeld());
     if (--acllist->ref_count == 0) {
 	if (ACL_LIST_IS_STALE(acllist)) {
 	    ACL_ListDestroy(errp, acllist);
@@ -1021,7 +1020,7 @@ ACL_ListDecrement(NSErr_t *errp, ACLListHandle_t *acllist)
 NSAPI_PUBLIC int
 ACL_EvalSetACL(NSErr_t *errp, ACLEvalHandle_t *acleval, ACLListHandle_t *acllist)
 {
-        NS_ASSERT(ACL_AssertAcllist(acllist));
+        PR_ASSERT(ACL_AssertAcllist(acllist));
 
         acleval->acllist = acllist;
         return(0);
diff --git a/lib/libaccess/register.cpp b/lib/libaccess/register.cpp
index 2973e1d5..22074d67 100644
--- a/lib/libaccess/register.cpp
+++ b/lib/libaccess/register.cpp
@@ -11,7 +11,7 @@
 #include <plhash.h>
 #include <base/systems.h>
 #include <base/util.h>
-#include <base/nsassert.h>
+#include <prlog.h>
 #include "permhash.h"
 #include <libaccess/nserror.h>
 #include <libaccess/acl.h>
@@ -48,7 +48,7 @@ ACL_LasHashInit()
 				     PR_CompareValues,
 				     &ACLPermAllocOps,
 				     NULL);
-    NS_ASSERT(ACLLasEvalHash);
+    PR_ASSERT(ACLLasEvalHash);
 
     ACLLasFlushHash = PR_NewHashTable(0,
 				     PR_HashString,
@@ -56,7 +56,7 @@ ACL_LasHashInit()
 				     PR_CompareValues,
 				     &ACLPermAllocOps,
 				     NULL);
-    NS_ASSERT(ACLLasFlushHash);
+    PR_ASSERT(ACLLasFlushHash);
 
     ACLMethodHash = PR_NewHashTable(ACL_MAX_METHOD,
 				     PR_HashCaseString,
@@ -64,7 +64,7 @@ ACL_LasHashInit()
 				     PR_CompareValues,
 				     &ACLPermAllocOps,
 				     NULL);
-    NS_ASSERT(ACLMethodHash);
+    PR_ASSERT(ACLMethodHash);
 
     ACLDbTypeHash = PR_NewHashTable(ACL_MAX_DBTYPE,
 				     PR_HashCaseString,
@@ -72,7 +72,7 @@ ACL_LasHashInit()
 				     PR_CompareValues,
 				     &ACLPermAllocOps,
 				     NULL);
-    NS_ASSERT(ACLDbTypeHash);
+    PR_ASSERT(ACLDbTypeHash);
 
     for (i = 0; i < ACL_MAX_DBTYPE; i++)
 	ACLDbParseFnTable[i] = 0;
@@ -83,7 +83,7 @@ ACL_LasHashInit()
 				     PR_CompareValues,
 				     &ACLPermAllocOps,
 				     NULL);
-    NS_ASSERT(ACLDbTypeHash);
+    PR_ASSERT(ACLDbTypeHash);
 
     ACLDbNameHash = PR_NewHashTable(0, 
 				    PR_HashCaseString,
@@ -91,7 +91,7 @@ ACL_LasHashInit()
 				    PR_CompareValues,
 				    &ACLPermAllocOps, 
 				    ACL_DATABASE_POOL);
-    NS_ASSERT(ACLDbNameHash);
+    PR_ASSERT(ACLDbNameHash);
 
     ACLUserLdbHash = PR_NewHashTable(0, 
 				     PR_HashCaseString,
@@ -99,7 +99,7 @@ ACL_LasHashInit()
 				     PR_CompareValues,
 				     &ACLPermAllocOps, 
 				     NULL);
-    NS_ASSERT(ACLUserLdbHash);
+    PR_ASSERT(ACLUserLdbHash);
 
     return;
 }
@@ -166,7 +166,7 @@ NSAPI_PUBLIC int
 ACL_LasFindEval(NSErr_t *errp, char *attr_name, LASEvalFunc_t *eval_funcp)
 {
  
-    NS_ASSERT(attr_name);
+    PR_ASSERT(attr_name);
     if (!attr_name) return -1;
  
     *eval_funcp = (LASEvalFunc_t)PR_HashTableLookup(ACLLasEvalHash, attr_name);
@@ -187,7 +187,7 @@ NSAPI_PUBLIC int
 ACL_LasFindFlush(NSErr_t *errp, char *attr_name, LASFlushFunc_t *flush_funcp)
 {
  
-    NS_ASSERT(attr_name);
+    PR_ASSERT(attr_name);
     if (!attr_name) return -1;
  
     *flush_funcp = (LASFlushFunc_t)PR_HashTableLookup(ACLLasFlushHash, attr_name);