Moving NSCP Directory Server from DirectoryBranch to TRUNK, initial drop. (foxworth)ldapserver7x

22 files changed, 8331 insertions, 0 deletions

diff --git a/lib/base/Makefile b/lib/base/Makefile
new file mode 100644
index 00000000..f58195d3
--- /dev/null
+++ b/lib/base/Makefile
@@ -0,0 +1,111 @@
+#
+# BEGIN COPYRIGHT BLOCK
+# Copyright 2001 Sun Microsystems, Inc.
+# Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+# All rights reserved.
+# END COPYRIGHT BLOCK
+#
+# The base library contains the base set of functionality for ldapserver
+# servers. Cross-platform I/O and other generic functions are
+# provided here.
+
+
+MCOM_ROOT=../../..
+MODULE=LibBase
+
+include ../../nsdefs.mk
+
+OBJDEST=$(OBJDIR)/lib/base
+
+ifeq ($(ARCH), WINNT)
+LIBS=$(OBJDIR)/lib/libbase.lib
+ifeq ($(BSCINFO), yes)
+BSCS=$(OBJDIR)/lib/libbase.bsc
+endif
+else
+LIBS=$(OBJDIR)/lib/libbase.a
+endif
+
+include ../../nsconfig.mk
+
+MCC_INCLUDE += $(ADMINUTIL_INCLUDE)
+
+LOCAL_DEPS = $(NSPR_DEP) $(ADMINUTIL_DEP) $(SECURITY_DEP) $(DBM_DEP)
+
+all: $(LOCAL_DEPS) $(OBJDEST) $(LIBS) $(BSCS)
+
+$(OBJDEST):
+	mkdir -p $(OBJDEST)
+
+ifeq ($(ARCH), WINNT)
+OSOBJS = nterrors.o eventlog.o eventhandler.o ntpipe.o pathnames.o
+else
+OSOBJS = 
+endif
+
+OBJS = $(addprefix $(OBJDEST)/,	\
+				dstats.o \
+				daemon.o \
+				shexp.o \
+				regexp.o \
+				pblock.o \
+				plist.o \
+				buffer.o \
+				netbuf.o \
+				file.o \
+				net.o \
+				session.o \
+				cinfo.o \
+				util.o \
+				ereport.o \
+				sem.o \
+				fsmutex.o \
+				systhr.o \
+				crit.o \
+				rwlock.o \
+				dns.o \
+				dnsdmain.o \
+				shmem.o \
+				dll.o \
+				servssl.o \
+				lexer.o \
+		                restart.o \
+				objndx.o \
+				cache.o \
+				pool.o \
+				time_cache.o \
+				dns_cache.o \
+				system.o \
+				xp.o \
+				nscperror.o \
+				language.o \
+				fasttime.o \
+				secpwd.o \
+				$(OSOBJS) \
+				) 
+
+MODULE_CFLAGS=-I$(NSROOT)/include/base
+
+ifeq ($(PRODUCT),"Netscape Catalog Server")
+ifeq ($(ARCH), WINNT)
+MCC_INCLUDE := $(subst -I$(MCOM_ROOT)/lib/libnet,,$(MCC_INCLUDE))
+endif
+endif
+
+#$(OBJDEST)/fasttime.o : $(OBJDIR)/fasttime.o
+#	cp $< $@
+
+$(LIBS): $(OBJS)
+	rm -f $@
+	$(AR) $(OBJS)
+	$(RANLIB) $@
+
+ifeq ($(ARCH), WINNT)
+ifeq ($(BSCINFO), yes)
+$(BSCS): $(OBJS)
+	$(BSCMAKE) $(OBJDEST)/*.sbr
+endif
+endif
+
+include $(INCLUDE_DEPENDS)
+
diff --git a/lib/base/crit.cpp b/lib/base/crit.cpp
new file mode 100644
index 00000000..06f5fba4
--- /dev/null
+++ b/lib/base/crit.cpp
@@ -0,0 +1,399 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * crit.c: Critical section abstraction. Used in threaded servers to protect
+ *         areas where two threads can interfere with each other.
+ *
+ *         Condvars are condition variables that are used for thread-thread 
+ *         synchronization.
+ * 
+ * Rob McCool
+ */
+
+#include "systems.h"
+
+#include "netsite.h"
+#include "crit.h"
+#include "pool.h"
+#include "ereport.h"
+
+#include "base/dbtbase.h"
+
+#ifdef USE_NSPR
+/*
+#include "prmon.h"
+#include "private/primpl.h"
+*/
+#include "nspr.h"
+
+/* private/primpl.h is gone fromnspr21 19971028 */
+#if 0
+#ifdef XP_WIN32
+#include "private/primpl.h"
+#endif /* XP_WIN32 */
+#endif
+
+#include "prthread.h"
+#include "prlock.h"
+#include "prcvar.h"
+#include "prinrval.h"
+
+/*
+ * Defined to replace PR_Monitor() with PR_Lock().
+ */
+typedef struct critical {
+	PRLock		*lock;
+	PRUint32	count;
+	PRThread	*owner;
+} critical_t;
+
+typedef struct condvar {
+	critical_t	*lock;
+	PRCondVar	*cvar;
+} condvar_t;
+
+#endif
+/* -------------------------- critical sections --------------------------- */
+
+/* Useful for ASSERTs only. Returns non-zero if the current thread is the owner.
+ */
+NSAPI_PUBLIC int crit_owner_is_me(CRITICAL id)
+{
+#ifdef USE_NSPR
+    critical_t *crit = (critical_t*)id;
+
+    return (crit->owner == PR_GetCurrentThread());
+#else
+    return 1;
+#endif
+}
+
+NSAPI_PUBLIC CRITICAL crit_init(void)
+{
+#ifdef USE_NSPR
+    critical_t *crit = (critical_t*)PERM_MALLOC(sizeof(critical_t)) ;
+
+    if (crit) {
+        if (!(crit->lock = PR_NewLock())) {
+            PERM_FREE(crit);
+            return NULL;
+        }
+        crit->count = 0;
+        crit->owner = 0;
+    }
+    return (void *) crit;
+#else
+    return NULL;
+#endif
+}
+
+NSAPI_PUBLIC void crit_enter(CRITICAL id)
+{
+#ifdef USE_NSPR
+    critical_t *crit = (critical_t*)id;
+    PRThread *me = PR_GetCurrentThread();
+
+    if ( crit->owner == me) {
+        NS_ASSERT(crit->count > 0);
+        crit->count++;
+    } 
+    else {
+        PR_Lock(crit->lock);
+        NS_ASSERT(crit->count == 0);
+        crit->count = 1;
+        crit->owner = me;
+    }
+#endif
+}
+
+NSAPI_PUBLIC void crit_exit(CRITICAL id)
+{
+#ifdef USE_NSPR
+    critical_t	*crit = (critical_t*)id;
+
+    if (crit->owner != PR_GetCurrentThread()) 
+        return;
+
+    if ( --crit->count == 0) {
+        crit->owner = 0;
+        PR_Unlock(crit->lock);
+    }
+    NS_ASSERT(crit->count >= 0);
+#endif
+}
+
+NSAPI_PUBLIC void crit_terminate(CRITICAL id)
+{
+#ifdef USE_NSPR
+    critical_t	*crit = (critical_t*)id;
+
+    PR_DestroyLock((PRLock*)crit->lock);
+    PERM_FREE(crit);
+#endif
+}
+
+
+/* ------------------------- condition variables -------------------------- */
+
+
+NSAPI_PUBLIC CONDVAR condvar_init(CRITICAL id)
+{
+#ifdef USE_NSPR
+    critical_t	*crit = (critical_t*)id;
+
+    condvar_t *cvar = (condvar_t*)PERM_MALLOC(sizeof(condvar_t)) ;
+
+    if (crit) {
+        cvar->lock = crit;
+        if ((cvar->cvar = PR_NewCondVar((PRLock *)cvar->lock->lock)) == 0) {
+            PERM_FREE(cvar);
+            return NULL;
+        }
+    }
+    return (void *) cvar;
+#endif
+}
+
+NSAPI_PUBLIC void condvar_wait(CONDVAR _cv)
+{
+#ifdef USE_NSPR
+    condvar_t *cv = (condvar_t *)_cv;
+    /* Save away recursion count so we can restore it after the wait */
+    int saveCount = cv->lock->count;
+    PRThread *saveOwner = cv->lock->owner;
+
+    NS_ASSERT(cv->lock->owner == PR_GetCurrentThread());
+    cv->lock->count = 0;
+    cv->lock->owner = 0;
+
+    PR_WaitCondVar(cv->cvar, PR_INTERVAL_NO_TIMEOUT);
+
+    cv->lock->count = saveCount;
+    cv->lock->owner = saveOwner;
+#endif
+}
+
+
+NSAPI_PUBLIC void condvar_timed_wait(CONDVAR _cv, long secs)
+{
+#ifdef USE_NSPR
+    condvar_t *cv = (condvar_t *)_cv;
+    /* Save away recursion count so we can restore it after the wait */
+    int saveCount = cv->lock->count;
+    PRThread *saveOwner = cv->lock->owner;
+ 
+    NS_ASSERT(cv->lock->owner == PR_GetCurrentThread());
+    cv->lock->count = 0;
+    cv->lock->owner = 0;
+    
+    PRIntervalTime timeout = PR_INTERVAL_NO_TIMEOUT;
+    if (secs > 0) 
+	timeout = PR_SecondsToInterval(secs); 
+    PR_WaitCondVar(cv->cvar, timeout);
+ 
+    cv->lock->count = saveCount;
+    cv->lock->owner = saveOwner;
+#endif
+}
+
+
+
+NSAPI_PUBLIC void condvar_notify(CONDVAR _cv)
+{
+#ifdef USE_NSPR
+    condvar_t *cv = (condvar_t *)_cv;
+    NS_ASSERT(cv->lock->owner == PR_GetCurrentThread());
+    PR_NotifyCondVar(cv->cvar);
+#endif
+}
+
+NSAPI_PUBLIC void condvar_notifyAll(CONDVAR _cv)
+{
+#ifdef USE_NSPR
+    condvar_t *cv = (condvar_t *)_cv;
+    NS_ASSERT(cv->lock->owner == PR_GetCurrentThread());
+    PR_NotifyAllCondVar(cv->cvar);
+#endif
+}
+
+NSAPI_PUBLIC void condvar_terminate(CONDVAR _cv)
+{
+#ifdef USE_NSPR
+    condvar_t *cv = (condvar_t *)_cv;
+    PR_DestroyCondVar(cv->cvar);
+    PERM_FREE(cv);
+#endif
+}
+
+/* ----------------------- Counting semaphores ---------------------------- */
+/* These are currently not listed in crit.h because they aren't yet used; 
+ * although they do work.
+ */
+
+/*
+ * XXXMB - these should be in NSPR.  
+ *
+ */
+
+#if defined(SOLARIS) && defined(HW_THREADS)
+#include <synch.h>
+typedef sema_t counting_sem_t;
+#elif defined(IRIX) && defined(HW_THREADS)
+#include <ulocks.h>
+typedef usema_t *counting_sem_t;
+#else
+typedef struct counting_sem_t {
+	CRITICAL lock;
+	CRITICAL cv_lock;
+	CONDVAR cv;
+	int count;
+	int max;
+} counting_sem_t;
+#endif
+
+NSAPI_PUBLIC COUNTING_SEMAPHORE
+cs_init(int initial_count)
+{
+	counting_sem_t *cs = (counting_sem_t *)PERM_MALLOC(sizeof(counting_sem_t));
+#if defined(SOLARIS) && defined(HW_THREADS)
+    if ( sema_init(cs, initial_count, USYNC_THREAD, NULL) < 0) {
+		ereport(LOG_FAILURE, XP_GetAdminStr(DBT_csInitFailureS_), system_errmsg());
+		PERM_FREE(cs);
+		return NULL;
+	}
+
+	return (COUNTING_SEMAPHORE)cs;
+#elif defined(IRIX) && defined(HW_THREADS)
+	usptr_t *arena;
+
+	usconfig(CONF_INITSIZE, 64*1024);
+	if ( (arena = usinit("/tmp/cs.locks")) == NULL) 
+		return NULL;
+
+	if ( (cs = (counting_sem_t *)usnewsema(arena, 0)) == NULL)
+		return NULL;
+
+	return cs;
+	
+#else
+
+	cs->count = initial_count;
+	cs->lock = crit_init();
+	cs->cv_lock = crit_init();
+	cs->cv = condvar_init(cs->cv_lock);
+
+	return (COUNTING_SEMAPHORE)cs;
+#endif
+}
+
+NSAPI_PUBLIC void
+cs_terminate(COUNTING_SEMAPHORE csp)
+{
+	counting_sem_t *cs = (counting_sem_t *)csp;
+
+#if defined(SOLARIS) && defined(HW_THREADS)
+    if ( sema_destroy(cs) < 0 ) {
+		ereport(LOG_FAILURE, XP_GetAdminStr(DBT_csTerminateFailureS_), system_errmsg());
+	}
+    PERM_FREE(cs);
+	return;
+#elif defined(IRIX) && defined(HW_THREADS)
+	/* usfreesema() */
+	return;
+#else
+	condvar_terminate(cs->cv);
+	crit_terminate(cs->cv_lock);
+	crit_terminate(cs->lock);
+	PERM_FREE(cs);
+
+	return;
+#endif
+}
+
+NSAPI_PUBLIC int
+cs_wait(COUNTING_SEMAPHORE csp)
+{
+	counting_sem_t *cs = (counting_sem_t *)csp;
+	int ret;
+
+#if defined(SOLARIS) && defined(HW_THREADS)
+    if ( (ret = sema_wait(cs)) < 0 ) {
+		ereport(LOG_FAILURE, XP_GetAdminStr(DBT_csWaitFailureS_), system_errmsg());
+		return -1;
+	}
+	return ret;
+#elif defined(IRIX) && defined(HW_THREADS)
+	uspsema(cs);
+	return 0;
+#else
+	crit_enter(cs->lock);
+	while ( cs->count == 0 ) {
+		crit_enter(cs->cv_lock);
+		crit_exit(cs->lock);
+		condvar_wait(cs->cv);
+		crit_exit(cs->cv_lock);
+		crit_enter(cs->lock);
+	}
+	ret = --(cs->count);
+	crit_exit(cs->lock);
+
+	return 0;
+#endif
+}
+
+NSAPI_PUBLIC int
+cs_trywait(COUNTING_SEMAPHORE csp)
+{
+	counting_sem_t *cs = (counting_sem_t *)csp;
+	int ret;
+
+#if defined(SOLARIS) && defined(HW_THREADS)
+	ret = sema_trywait(cs)?-1:0;
+    return ret;
+#elif defined(IRIX) && defined(HW_THREADS)
+	ret = uscpsema(cs);
+	return (ret == 1)?0:-1;
+#else
+	crit_enter(cs->lock);
+	if (cs->count > 0) {
+		ret = --(cs->count);
+		crit_exit(cs->lock);
+        return 0;
+    }
+    crit_exit(cs->lock);
+	return -1;
+
+#endif
+}
+
+NSAPI_PUBLIC int 
+cs_release(COUNTING_SEMAPHORE csp)
+{
+	counting_sem_t *cs = (counting_sem_t *)csp;
+	int ret;
+
+#if defined(SOLARIS) && defined(HW_THREADS)
+    if ( (ret = sema_post(cs)) < 0 ) {
+		ereport(LOG_FAILURE, XP_GetAdminStr(DBT_csPostFailureS_), system_errmsg());
+		return -1;
+	}
+	return ret;
+#elif defined(IRIX) && defined(HW_THREADS)
+	usvsema(cs);
+	return 0;
+#else
+	crit_enter(cs->lock);
+	ret = ++(cs->count);
+	if (cs->count == 1) {
+		crit_enter(cs->cv_lock);
+		condvar_notify(cs->cv);
+		crit_exit(cs->cv_lock);
+	}
+	crit_exit(cs->lock);
+
+	return 0;
+#endif
+}
diff --git a/lib/base/dns.cpp b/lib/base/dns.cpp
new file mode 100644
index 00000000..f9e38886
--- /dev/null
+++ b/lib/base/dns.cpp
@@ -0,0 +1,176 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * dns.c: DNS resolution routines
+ * 
+ * Rob McCool
+ */
+#define DNS_GUESSING
+
+#include "netsite.h"
+#ifdef XP_UNIX
+#include "systems.h"
+#else /* XP_WIN32 */
+#include "base/systems.h"
+#endif /* XP_WIN32 */
+
+#include "net.h"    /* SYS_NETFD, various headers to do DNS */
+
+/* Under NT, these are taken care of by net.h including winsock.h */
+#ifdef XP_UNIX
+#include <arpa/inet.h>  /* inet_ntoa */
+#include <netdb.h>  /* struct hostent */
+#ifdef NEED_GHN_PROTO
+extern "C" int gethostname (char *name, size_t namelen);
+#endif
+#endif
+#ifdef DNS_CACHE
+#include "base/dns_cache.h"
+#include "base/ereport.h"
+#endif /* DNS_CACHE */
+#include <stdio.h>
+#include <nspr.h>
+#include "frame/conf.h"
+
+/* ---------------------------- dns_find_fqdn ----------------------------- */
+
+
+/* defined in dnsdmain.c */
+extern "C"  NSAPI_PUBLIC char *dns_guess_domain(char * hname);
+
+char *net_find_fqdn(PRHostEnt *p)
+{
+    int x;
+
+    if((!p->h_name) || (!p->h_aliases))
+        return NULL;
+
+    if(!strchr(p->h_name, '.')) {
+        for(x = 0; p->h_aliases[x]; ++x) {
+            if((strchr(p->h_aliases[x], '.')) && 
+               (!strncmp(p->h_aliases[x], p->h_name, strlen(p->h_name))))
+            {
+                return STRDUP(p->h_aliases[x]);
+            }
+        }
+#ifdef DNS_GUESSING
+	return dns_guess_domain(p->h_name);
+#else
+	return NULL;
+#endif /* DNS_GUESSING */
+    } 
+    else 
+        return STRDUP(p->h_name);
+}
+
+
+/* ----------------------------- dns_ip2host ------------------------------ */
+
+
+char *dns_ip2host(char *ip, int verify)
+{
+    /*    struct in_addr iaddr;  */
+    PRNetAddr iaddr;
+    char *hn;
+#ifdef DNS_CACHE
+    dns_cache_entry_t *dns_entry;
+#endif
+    static unsigned long laddr = 0;
+    static char myhostname[256];
+    PRHostEnt   hent;
+    char        buf[PR_NETDB_BUF_SIZE];
+    PRStatus    err;
+
+
+    err = PR_InitializeNetAddr(PR_IpAddrNull, 0, &iaddr);
+
+    if((iaddr.inet.ip = inet_addr(ip)) == -1)
+        goto bong;
+
+#ifdef DNS_CACHE
+    if ( (dns_entry = dns_cache_lookup_ip((unsigned int)iaddr.inet.ip)) ) {
+        hn = NULL;
+        if ( dns_entry->host && 
+             /* Only use entry if the cache entry has been verified or if 
+              * verify is off...
+              */
+             (dns_entry->verified || !verify) ) {
+	  hn = STRDUP( dns_entry->host );
+	  (void)dns_cache_use_decrement(dns_entry);
+	  return hn;
+        }
+	dns_cache_delete(dns_entry);
+	dns_entry = 0;
+    }
+#endif
+
+    /*
+     * See if it happens to be the localhost IP address, and try
+     * the local host name if so.
+     */
+    if (laddr == 0) {
+	laddr = inet_addr("127.0.0.1");
+	myhostname[0] = 0;
+	PR_GetSystemInfo(PR_SI_HOSTNAME, myhostname, sizeof(myhostname));
+    }
+
+    /* Have to match the localhost IP address and have a hostname */
+    if ((iaddr.inet.ip == laddr) && (myhostname[0] != 0)) {
+        /*
+         * Now try for a fully-qualified domain name, starting with
+         * the local hostname.
+         */
+        err =  PR_GetHostByName(myhostname,
+				buf,
+				PR_NETDB_BUF_SIZE,
+				&hent);
+
+        /* Don't verify if we get a fully-qualified name this way */
+        verify = 0;
+    }
+    else {
+      err = PR_GetHostByAddr(&iaddr, 
+			     buf,
+			     PR_NETDB_BUF_SIZE,
+			     &hent);
+    }
+
+    if ((err == PR_FAILURE) || !(hn = net_find_fqdn(&hent))) goto bong;
+
+
+    if(verify) {
+        char **haddr = 0;
+       	err = PR_GetHostByName(hn,
+			       buf,
+			       PR_NETDB_BUF_SIZE,
+			       &hent);
+ 
+        if(err == PR_SUCCESS) {
+            for(haddr = hent.h_addr_list; *haddr; haddr++) {
+                if(((struct in_addr *)(*haddr))->s_addr == iaddr.inet.ip)
+                    break;
+            }
+        }
+
+        if((err == PR_FAILURE) || (!(*haddr)))
+            goto bong;
+    }
+
+#ifdef DNS_CACHE
+    if ( (dns_entry = dns_cache_insert(hn, (unsigned int)iaddr.inet.ip, verify)) ) {
+        (void) dns_cache_use_decrement(dns_entry);
+    } 
+#endif /* DNS_CACHE */
+    return hn;
+  bong:
+#ifdef DNS_CACHE
+    /* Insert the lookup failure */
+    if ( (dns_entry = dns_cache_insert(NULL, (unsigned int)iaddr.inet.ip, verify)) ) {
+        (void) dns_cache_use_decrement(dns_entry);
+    } 
+#endif /* DNS_CACHE */
+    return NULL;
+}
diff --git a/lib/base/dnsdmain.cpp b/lib/base/dnsdmain.cpp
new file mode 100644
index 00000000..f37e475c
--- /dev/null
+++ b/lib/base/dnsdmain.cpp
@@ -0,0 +1,159 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * dnsdmain.c: DNS domain guessing stuff moved out of dns.c because of the
+ * string ball problems
+ */
+
+
+#include "netsite.h"
+#include "base/net.h"
+#include <string.h>
+#include <stdio.h>
+#ifdef XP_UNIX
+#include <unistd.h>
+#endif
+#include <ctype.h>
+#include "util.h"
+
+/* Under NT, this is taken care of by net.h including winsock.h */
+#ifdef XP_UNIX
+#include <netdb.h>  /* struct hostent */
+#endif
+extern "C" {
+#include <nspr.h>
+}
+#include "frame/conf.h"
+
+
+
+/* This is contained in resolv.h on most systems. */
+#define _PATH_RESCONF "/etc/resolv.conf"
+
+#ifdef XP_UNIX
+NSPR_BEGIN_EXTERN_C
+#ifdef Linux
+extern int getdomainname(char *, size_t);
+#else 
+extern int getdomainname(char *, int);
+#endif /* Linux */
+#if defined(HPUX) || defined (UnixWare) || defined(Linux) || defined(IRIX6_5)
+extern int gethostname (char *name, size_t namelen);
+#else
+#ifndef AIX
+extern int gethostname (char *name, int namelen);
+#endif
+#endif
+NSPR_END_EXTERN_C
+#endif
+
+
+/* ---------------------------- dns_guess_domain -------------------------- */
+
+
+extern "C" NSAPI_PUBLIC char *dns_guess_domain(char * hname)
+{
+    FILE *f;
+    char * cp;
+    int hnlen;
+    char line[256];
+    static int dnlen = 0;
+    static char * domain = 0;
+    PRHostEnt   hent;
+    char        buf[PR_NETDB_BUF_SIZE];
+    PRStatus    err;
+
+    /* Sanity check */
+    if (strchr(hname, '.')) {
+	return STRDUP(hname);
+    }
+
+    if (dnlen == 0) {
+
+	/* First try a little trick that seems to often work... */
+
+	/*
+	 * Get the local host name, even it doesn't come back
+	 * fully qualified.
+	 */
+	line[0] = 0;
+	gethostname(line, sizeof(line));
+	if (line[0] != 0) {
+	  /* Is it fully qualified? */
+	  domain = strchr(line, '.');
+	  if (domain == 0) {
+	    /* No, try gethostbyname() */
+	    err = PR_GetHostByName(line,
+				      buf,
+				      PR_NETDB_BUF_SIZE,
+				      &hent);
+	    if (err == PR_SUCCESS) {
+	      /* See if h_name is fully-qualified */
+	      if (hent.h_name) 	domain = strchr(hent.h_name, '.');
+
+	      /* Otherwise look for a fully qualified alias */
+	      if ((domain == 0) &&
+		  (hent.h_aliases && hent.h_aliases[0])) {
+		char **p;
+		for (p = hent.h_aliases; *p; ++p) {
+		  domain = strchr(*p, '.');
+		  if (domain) break;
+		}
+	      }
+	    }
+	  }
+	}
+
+	/* Still no luck? */
+	if (domain == 0) {
+
+	    f = fopen(_PATH_RESCONF, "r");
+
+	    /* See if there's a domain entry in their resolver configuration */
+	    if(f) {
+		while(fgets(line, sizeof(line), f)) {
+		    if(!strncasecmp(line, "domain ", 7)) {
+			for (cp = &line[7]; *cp && isspace(*cp); ++cp) ;
+			if (*cp) {
+			    domain = cp;
+			    for (; *cp && !isspace(*cp); ++cp) ;
+			    *cp = 0;
+			}
+			break;
+		    }
+		}
+		fclose(f);
+	    }
+	}
+
+#ifndef NO_DOMAINNAME
+	if (domain == 0) {
+	    /* No domain found. Try getdomainname. */
+	    getdomainname(line, sizeof(line));
+	    if (line[0] != 0) domain = &line[0];
+	}
+#endif
+
+	if (domain != 0) {
+	    if (domain[0] == '.') ++domain;
+	    domain = STRDUP(domain);
+	    dnlen = strlen(domain);
+	}
+	else dnlen = -1;
+    }
+
+    if (domain != 0) {
+	hnlen = strlen(hname);
+	if ((hnlen + dnlen + 2) <= sizeof(line)) {
+	    strcpy(line, hname);
+	    line[hnlen] = '.';
+	    strcpy(&line[hnlen+1], domain);
+	    return STRDUP(line);
+	}
+    }
+
+    return 0;
+}
diff --git a/lib/base/ereport.cpp b/lib/base/ereport.cpp
new file mode 100644
index 00000000..3454d01f
--- /dev/null
+++ b/lib/base/ereport.cpp
@@ -0,0 +1,249 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * ereport.c:  Records transactions, reports errors to administrators, etc.
+ * 
+ * Rob McCool
+ */
+
+
+#include "private/pprio.h" /* for nspr20 binary release */
+#include "netsite.h"
+#include "file.h"      /* system_fopenWA, system_write_atomic */
+#include "pblock.h"
+#include "session.h"
+#include "util.h"      /* util_vsprintf */
+#include "ereport.h"
+
+#include "base/dbtbase.h"
+
+#include <stdarg.h>
+#include <stdio.h>      /* vsprintf */
+#include <string.h>     /* strcpy */
+#include <time.h>       /* localtime */
+
+#ifdef XP_UNIX
+#include <syslog.h>     /* error logging to syslog */
+
+static SYS_FILE _error_fd;
+#else /* WIN32 */
+#include <nt/regparms.h>
+#include <nt/messages.h>
+#include "eventlog.h"
+
+static SYS_FILE _error_fd;
+#endif /* XP_UNIX */
+
+static PRBool _ereport_initialized = PR_FALSE;
+
+
+NSAPI_PUBLIC SYS_FILE ereport_getfd(void) { return _error_fd; }
+
+
+
+/* ----------------------------- ereport_init ----------------------------- */
+
+
+NSAPI_PUBLIC char *ereport_init(char *err_fn, char *email, 
+                                PASSWD pwuser, char *version)
+{
+    char err[MAGNUS_ERROR_LEN];
+    SYS_FILE new_fd;
+
+#ifdef XP_UNIX
+    if(!strcmp(err_fn, "SYSLOG")) {
+#ifdef NET_SSL
+        openlog("secure-httpd", LOG_PID, LOG_DAEMON);
+#else
+        openlog("httpd", LOG_PID, LOG_DAEMON);
+#endif
+	_error_fd = PR_ImportFile(ERRORS_TO_SYSLOG);
+
+        _ereport_initialized = PR_TRUE;
+        return NULL;
+    }
+#endif /* XP_UNIX */
+    if( (new_fd = system_fopenWA(err_fn)) == SYS_ERROR_FD) {
+        util_snprintf(err, MAGNUS_ERROR_LEN, "can't open error log %s (%s)", err_fn,
+                     system_errmsg());
+#ifdef XP_UNIX
+	_error_fd = PR_ImportFile(STDERR_FILENO);
+#else
+	_error_fd = PR_ImportFile(NULL);
+#endif
+        return STRDUP(err);
+    }
+    _error_fd = new_fd;
+
+#ifdef XP_UNIX
+    if(pwuser)
+        chown(err_fn, pwuser->pw_uid, pwuser->pw_gid);
+#endif /* XP_UNIX */
+
+    _ereport_initialized = PR_TRUE;
+
+    ereport(LOG_INFORM, XP_GetAdminStr(DBT_successfulServerStartup_));
+    ereport(LOG_INFORM, XP_GetAdminStr(DBT_SBS_), MAGNUS_VERSION_STRING, BUILD_NUM);
+    if (strcasecmp(BUILD_NUM, version)) {
+        ereport(LOG_WARN, XP_GetAdminStr(DBT_netscapeExecutableAndSharedLibra_));
+        ereport(LOG_WARN, XP_GetAdminStr(DBT_executableVersionIsS_), version);
+        ereport(LOG_WARN, XP_GetAdminStr(DBT_sharedLibraryVersionIsS_), BUILD_NUM);
+
+    }
+
+    /* Initialize thread-specific error handling */
+    system_errmsg_init();
+
+    return NULL;
+}
+
+
+
+/* -------------------------- ereport_terminate --------------------------- */
+
+
+NSAPI_PUBLIC void ereport_terminate(void)
+{
+    if (!_ereport_initialized)
+        return;
+
+#ifdef XP_UNIX
+    ereport(LOG_INFORM, XP_GetAdminStr(DBT_errorReportingShuttingDown_));
+    if(PR_FileDesc2NativeHandle(_error_fd) != ERRORS_TO_SYSLOG)
+        system_fclose(_error_fd);
+    else
+        closelog();
+#else /* WIN32 */
+    if(PR_FileDesc2NativeHandle(_error_fd) != NULL)
+        system_fclose(_error_fd);
+#endif /* XP_UNIX */
+
+}
+
+
+/* ------------------------------- ereport -------------------------------- */
+
+
+static int degree_msg[] = {
+                            DBT_warning_,
+                            DBT_config_,
+                            DBT_security_,
+                            DBT_failure_,
+                            DBT_catastrophe_,
+                            DBT_info_,
+                            DBT_verbose_
+                          };
+
+#ifdef XP_UNIX
+static int degree_syslog[] = {
+    LOG_WARNING, LOG_ERR, LOG_NOTICE, LOG_ALERT, LOG_CRIT, LOG_INFO, LOG_INFO
+};
+#endif/* XP_UNIX */
+
+
+NSAPI_PUBLIC int ereport_v(int degree, char *fmt, va_list args)
+{
+    char errstr[MAX_ERROR_LEN];
+    int pos = 0;
+    struct tm *tms, tmss;
+    time_t t;
+#ifdef MCC_PROXY
+    char *p;
+    int i;
+#endif /* MCC_PROXY */
+
+    if (!_ereport_initialized)
+        return IO_OKAY;
+
+#ifdef XP_UNIX
+    if(PR_FileDesc2NativeHandle(_error_fd) != ERRORS_TO_SYSLOG) {
+#endif /* XP_UNIX */
+        t = time(NULL);
+        tms = system_localtime(&t, &tmss);
+        util_strftime(errstr, ERR_TIMEFMT, tms);
+        pos = strlen(errstr);
+
+        pos += util_snprintf(&errstr[pos], MAX_ERROR_LEN - pos, " %s: ",
+                            XP_GetAdminStr(degree_msg[degree]));
+#ifdef XP_UNIX 
+    }
+#endif /* XP_UNIX */
+
+    pos += util_vsnprintf(&errstr[pos], sizeof(errstr) - pos, fmt, args);
+
+    pos += util_snprintf(&errstr[pos], sizeof(errstr) - pos, ENDLINE);
+
+#ifdef MCC_PROXY
+    /* Thanx to netlib, the proxy sometimes generates multiline err msgs */
+    for(p=errstr, i=pos-1; i>0; i--, p++) {
+	if (*p == '\n' || *p == '\r') *p = ' ';
+    }
+#endif /* MCC_PROXY */
+
+#if defined XP_UNIX
+    if(PR_FileDesc2NativeHandle(_error_fd) != ERRORS_TO_SYSLOG)
+        return system_fwrite_atomic(_error_fd, errstr, pos);
+    syslog(degree_syslog[degree], errstr);
+    return IO_OKAY;
+#elif defined XP_WIN32 /* XP_WIN32 */
+	if(PR_FileDesc2NativeHandle(_error_fd) != NULL)
+	{
+#ifdef MCC_HTTPD
+	/* also write to NT Event Log if error is serious */
+		switch (degree) 
+		{
+         case LOG_MISCONFIG:
+         case LOG_SECURITY:
+         case LOG_CATASTROPHE:
+           LogErrorEvent(NULL, EVENTLOG_ERROR_TYPE, 
+                         0, MSG_BAD_PARAMETER, 
+                         errstr, NULL);
+           break;
+			default:
+           break;
+		}
+#endif
+		return system_fwrite_atomic(_error_fd, errstr, pos);
+	}
+	else { /* log to the EventLogger */
+                /* Write to the event logger... */
+		switch (degree) {
+                  case LOG_WARN:
+                    LogErrorEvent(NULL, EVENTLOG_WARNING_TYPE, 
+                                  0, MSG_BAD_PARAMETER, 
+                                  errstr, NULL);
+                    break;
+                  case LOG_MISCONFIG:
+                  case LOG_SECURITY:
+                  case LOG_FAILURE:
+                  case LOG_CATASTROPHE:
+                    LogErrorEvent(NULL, EVENTLOG_ERROR_TYPE, 
+                                  0, MSG_BAD_PARAMETER, 
+                                  errstr, NULL);
+                    break;
+
+                  case LOG_INFORM:
+                  default:
+                    LogErrorEvent(NULL, EVENTLOG_INFORMATION_TYPE, 
+                                  0, MSG_BAD_PARAMETER, 
+                                  errstr, NULL);
+                    break;
+		}
+		return (IO_OKAY);
+	}
+#endif /* XP_WIN32 */
+	
+}
+
+NSAPI_PUBLIC int ereport(int degree, char *fmt, ...)
+{
+    va_list args;
+    int rv;
+    va_start(args, fmt);
+    rv = ereport_v(degree, fmt, args);
+    va_end(args);
+    return rv;
+}
diff --git a/lib/base/eventlog.cpp b/lib/base/eventlog.cpp
new file mode 100644
index 00000000..b8762842
--- /dev/null
+++ b/lib/base/eventlog.cpp
@@ -0,0 +1,70 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+//                                                                          //
+//  Name: EVENTLOG                                                          //
+//	Platforms: WIN32                                                        //
+//  ......................................................................  //
+//  Revision History:                                                       //
+//  01-12-95  Initial Version, Aruna Victor (aruna@netscape.com)            //
+//  12-02-96  Code cleanup, Andy Hakim (ahakim@netscape.com)                //
+//            - consolidated admin and http functions into one              //
+//            - moved registry modification code to installer               //
+//            - removed several unecessary functions                        //
+//            - changed function parameters to existing functions           //
+//                                                                          //
+//--------------------------------------------------------------------------//
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "netsite.h"
+#include "base/eventlog.h"
+#include "frame/conf.h"
+#include <nt/regparms.h>
+#include <nt/messages.h>
+
+HANDLE ghEventSource;
+
+NSPR_BEGIN_EXTERN_C
+
+NSAPI_PUBLIC HANDLE InitializeLogging(char *szEventLogName)
+{
+    ghEventSource = RegisterEventSource(NULL, szEventLogName);
+    return ghEventSource;
+}
+
+
+
+NSAPI_PUBLIC BOOL TerminateLogging(HANDLE hEventSource)
+{
+    BOOL bReturn = FALSE;
+    if(hEventSource == NULL)
+        hEventSource = ghEventSource;
+    if(hEventSource)
+        bReturn = DeregisterEventSource(hEventSource);
+    return(bReturn);
+}
+
+
+
+NSAPI_PUBLIC BOOL LogErrorEvent(HANDLE hEventSource, WORD fwEventType, WORD fwCategory, DWORD IDEvent, LPTSTR chMsg, LPTSTR lpszMsg)
+{
+    BOOL bReturn = FALSE;
+    LPTSTR lpszStrings[2];
+
+	lpszStrings[0] = chMsg;
+    lpszStrings[1] = lpszMsg;
+
+    if(hEventSource == NULL)
+        hEventSource = ghEventSource;
+
+    if(hEventSource)
+        bReturn = ReportEvent(hEventSource, fwEventType, fwCategory,
+                        IDEvent, NULL, 2, 0, (LPCTSTR *)lpszStrings, NULL);
+    return(bReturn);
+}
+
+NSPR_END_EXTERN_C
diff --git a/lib/base/file.cpp b/lib/base/file.cpp
new file mode 100644
index 00000000..7382be46
--- /dev/null
+++ b/lib/base/file.cpp
@@ -0,0 +1,702 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * file.c: system specific functions for reading/writing files
+ * 
+ * See file.h for formal definitions of what these functions do
+ *
+ * Rob McCool
+ */
+
+
+#include "base/file.h"
+#include "ereport.h"
+#ifdef BSD_RLIMIT
+#include <sys/time.h>
+#include <sys/resource.h>
+#else
+#include <stdlib.h>
+#include <signal.h>
+#endif
+#ifdef XP_WIN32
+#include <time.h>  /* time */
+#include <sys/stat.h> /* stat */
+#include <errno.h>
+#include <direct.h>
+#include <base/nterr.h>
+/* Removed for ns security integration
+#include <xp_error.h>
+*/
+#endif
+#include <prerror.h>
+
+#include "private/pprio.h"
+#include "prlock.h"
+
+extern "C" char *nscperror_lookup(int err);
+
+/* --- globals -------------------------------------------------------------*/
+/* PRFileDesc * SYS_ERROR_FD = NULL; */
+
+const int errbuf_size = 256;
+const unsigned int LOCKFILERANGE=0x7FFFFFFF;
+PRLock *_atomic_write_lock = NULL;
+
+/* --------------------------------- stat --------------------------------- */
+
+
+   /* XXXMB - Can't convert to PR_GetFileInfo because we directly exported
+    * the stat interface... Damn.
+    */
+NSAPI_PUBLIC int system_stat(char *path, struct stat *finfo)
+{
+#ifdef XP_WIN32
+
+    int chop, l;
+
+/* The NT stat is very peculiar about directory names. */
+/* XXX aruna - there is a bug here, maybe in the C runtime.
+ * Stating the same path in a separate program succeeds. From
+ * jblack's profiling, this needs to be replaced by the Win32
+ * calls anyway.*/
+
+    l = strlen(path);
+    if((path[l - 1] == '/') && 
+       (!(isalpha(path[0]) && (!strcmp(&path[1], ":/")))))
+    {
+        chop = 1;
+        path[--l] = '\0';
+    }
+    else chop = 0;
+#endif /* XP_WIN32 */
+
+#ifdef XP_UNIX
+    if(stat(path, finfo) == -1)
+        return -1;
+#else /* XP_WIN32 */
+
+    if(_stat(path, (struct _stat *)finfo) == -1) {
+        /* XXXMB - this sucks; 
+         * try to convert to an error code we'll expect...
+         */
+        switch(errno) {
+            case ENOENT: PR_SetError(PR_FILE_NOT_FOUND_ERROR, errno); break;
+            default: PR_SetError(PR_UNKNOWN_ERROR, errno); break;
+        }
+        return -1;
+    }
+
+    /* NT sets the time fields to -1 if it thinks that the file
+     * is a device ( like com1.html, lpt1.html etc)	In this case
+     * simply set last modified time to the current time....
+     */
+
+    if (finfo->st_mtime == -1) {
+        finfo->st_mtime = time(NULL);
+    }
+    if (finfo->st_atime == -1) {
+        finfo->st_atime = 0;
+    }
+    if (finfo->st_ctime == -1) {
+        finfo->st_ctime = 0;
+    }
+    if(chop)
+        path[l++] = '/';
+
+#endif /* XP_WIN32 */
+
+    if(S_ISREG(finfo->st_mode) && (path[strlen(path) - 1] == '/')) {
+        /* File with trailing slash */
+        errno = ENOENT;
+        return -1;
+    }
+    return 0;
+}
+
+
+NSAPI_PUBLIC int system_fread(SYS_FILE fd, char *buf, int sz) 
+{
+    /* XXXMB - this is the *one* function which does return a length
+     * instead of the IO_ERROR/IO_OKAY.
+     */
+    return PR_Read(fd, buf, sz);
+}
+
+NSAPI_PUBLIC int system_fwrite(SYS_FILE fd, char *buf, int sz) {
+    int n,o,w;
+
+    for(n=sz,o=0; n; n-=w,o+=w) {
+        if((w = PR_Write(fd, &buf[o], n)) < 0)
+            return IO_ERROR;
+    }
+    return IO_OKAY;
+}
+
+/* ---------------------------- Standard UNIX ----------------------------- */
+
+#ifdef XP_UNIX
+
+#include <sys/file.h>   /* flock */
+
+NSAPI_PUBLIC int system_fwrite_atomic(SYS_FILE fd, char *buf, int sz) 
+{
+    int ret;
+#if 0
+    if(flock(fd,LOCK_EX) == -1)
+        return IO_ERROR;
+#endif
+    ret = system_fwrite(fd,buf,sz);
+#if 0
+    if(flock(fd,LOCK_UN) == -1)
+        return IO_ERROR;  /* ??? */
+#endif
+    return ret;
+}
+
+/* -------------------------- system_nocoredumps -------------------------- */
+
+
+NSAPI_PUBLIC int system_nocoredumps(void)
+{
+#ifdef BSD_RLIMIT
+    struct rlimit rl;
+
+    rl.rlim_cur = 0;
+    rl.rlim_max = 0;
+    return setrlimit(RLIMIT_CORE, &rl);
+#else
+#if defined(SNI)
+/* C++ compiler seems to find more that one overloaded instance of exit() ?! */
+#define EXITFUNC ::exit
+#else
+#define EXITFUNC exit
+#endif
+    signal(SIGQUIT, EXITFUNC);
+    signal(SIGILL, EXITFUNC);
+    signal(SIGTRAP, EXITFUNC);
+    signal(SIGABRT, EXITFUNC);
+    signal(SIGIOT, EXITFUNC);
+    signal(SIGEMT, EXITFUNC);
+    signal(SIGFPE, EXITFUNC);
+    signal(SIGBUS, EXITFUNC);
+    signal(SIGSEGV, EXITFUNC);
+    signal(SIGSYS, EXITFUNC);
+
+
+    return 0;
+#endif
+}
+#endif /* XP_UNIX */
+
+/* --------------------------- file_setinherit ---------------------------- */
+
+NSAPI_PUBLIC int file_setinherit(SYS_FILE fd, int value)
+{
+#if defined(XP_WIN32)
+    int ret;
+
+//    ret = SetHandleInformation((HANDLE)PR_FileDesc2NativeHandle(fd), 0, value?HANDLE_FLAG_INHERIT:0);
+	// This function did nothing before since the mask was set to 0.
+    ret = SetHandleInformation((HANDLE)PR_FileDesc2NativeHandle(fd), HANDLE_FLAG_INHERIT, value?HANDLE_FLAG_INHERIT:0);
+    return ret==0?-1:0;
+#elif defined(XP_UNIX)
+    int flags = 0;
+    PRInt32 nativeFD;
+    PRFileDesc *bottom = fd;
+
+    while (bottom->lower != NULL) {
+      bottom = bottom->lower;
+    }
+
+    nativeFD = PR_FileDesc2NativeHandle(bottom);
+#if 0
+fprintf(stderr, "\nInfo(file_setinherit): Native file descriptor is %d\n", nativeFD);
+#endif
+    flags = fcntl(nativeFD, F_GETFD, 0);
+    if(flags == -1)
+        return -1;
+    if(value)
+        flags &= (~FD_CLOEXEC);
+    else
+        flags |= FD_CLOEXEC;
+    fcntl(nativeFD, F_SETFD, flags);
+    return 0;
+    
+    /* Comment out for ns security/ nspr integration (HACK for NOW)
+    int flags = fcntl(PR_FileDesc2NativeHandle(fd), F_GETFD, 0);
+    if(flags == -1)
+        return -1;
+    if(value)
+        flags &= (~FD_CLOEXEC);
+    else
+        flags |= FD_CLOEXEC;
+    fcntl(PR_FileDesc2NativeHandle(fd), F_SETFD, flags);
+    return 0;
+    */
+#endif
+}
+
+NSAPI_PUBLIC SYS_FILE system_fopenRO(char *p)
+{
+    SYS_FILE f = PR_Open(p, PR_RDONLY, 0);
+
+    if (!f)
+        return SYS_ERROR_FD;
+    return f;
+}
+
+NSAPI_PUBLIC SYS_FILE system_fopenWA(char *p)
+{
+    SYS_FILE f = PR_Open(p, PR_RDWR|PR_CREATE_FILE|PR_APPEND, 0644);
+
+    if (!f)
+        return SYS_ERROR_FD;
+    return f;
+}
+
+NSAPI_PUBLIC SYS_FILE system_fopenRW(char *p)
+{
+    SYS_FILE f = PR_Open(p, PR_RDWR|PR_CREATE_FILE, 0644);
+
+    if (!f)
+        return SYS_ERROR_FD;
+    return f;
+}
+
+NSAPI_PUBLIC SYS_FILE system_fopenWT(char *p)
+{
+    SYS_FILE f = PR_Open(p, PR_RDWR|PR_CREATE_FILE|PR_TRUNCATE, 0644);
+
+    if (!f)
+        return SYS_ERROR_FD;
+    return f;
+}
+
+NSAPI_PUBLIC int system_fclose(SYS_FILE fd)
+{
+    return (PR_Close(fd));
+}
+
+
+#ifdef FILE_WIN32
+
+int CgiBuffering;
+
+NSAPI_PUBLIC SYS_FILE system_fopen(char *path, int access, int flags)
+{
+    char p2[MAX_PATH];
+    SYS_FILE ret;
+    HANDLE fd;
+
+	if (strlen(path) >= MAX_PATH) {
+		return SYS_ERROR_FD;
+	}
+
+    file_unix2local(path, p2);
+
+    fd = CreateFile(p2, access, FILE_SHARE_READ | FILE_SHARE_WRITE, 
+                    NULL, flags, 0, NULL);
+    ret = PR_ImportFile((int32)fd);
+
+    if(ret == INVALID_HANDLE_VALUE)
+        return SYS_ERROR_FD;
+
+    return ret;
+}
+
+
+
+NSAPI_PUBLIC int system_pread(SYS_FILE fd, char *buf, int BytesToRead) {
+    unsigned long BytesRead = 0;
+    int result = 0;
+    BOOLEAN TimeoutSet = FALSE;
+
+    /* XXXMB - nspr20 should be able to do this; but right now it doesn't
+     * return proper error info.
+     * fix it later...
+     */
+    if(ReadFile((HANDLE)PR_FileDesc2NativeHandle(fd), (LPVOID)buf, BytesToRead, &BytesRead, NULL) == FALSE) {
+        if (GetLastError() == ERROR_BROKEN_PIPE) {
+            return IO_EOF;
+        } else {
+            return IO_ERROR;
+        }
+    }
+    return (BytesRead ? BytesRead : IO_EOF);
+}
+
+NSAPI_PUBLIC int system_pwrite(SYS_FILE fd, char *buf, int BytesToWrite) 
+{
+    unsigned long BytesWritten;
+    
+    if (WriteFile((HANDLE)PR_FileDesc2NativeHandle(fd), (LPVOID)buf, 
+                  BytesToWrite, &BytesWritten, NULL) == FALSE) {
+        return IO_ERROR;
+    }
+    return BytesWritten;
+}
+
+
+NSAPI_PUBLIC int system_fwrite_atomic(SYS_FILE fd, char *buf, int sz) 
+{
+    int ret;
+
+#if 0
+    if(system_flock(fd) == IO_ERROR)
+        return IO_ERROR;
+#endif
+    /* XXXMB - this is technically thread unsafe, but it catches any 
+     * callers of fwrite_atomic when we're single threaded and just coming
+     * to life.
+     */
+    if (!_atomic_write_lock) {
+        _atomic_write_lock = PR_NewLock();
+    }
+    PR_Lock(_atomic_write_lock);
+    ret = system_fwrite(fd,buf,sz);
+    PR_Unlock(_atomic_write_lock);
+#if 0
+     if(system_ulock(fd) == IO_ERROR)
+        return IO_ERROR;
+#endif
+    return ret;
+}
+
+
+NSAPI_PUBLIC void file_unix2local(char *path, char *p2)
+{
+    /* Try to handle UNIX-style paths */
+    if((!strchr(path, FILE_PATHSEP))) {
+        int x;
+
+        for(x = 0; path[x]; x++)
+            p2[x] = (path[x] == '/' ? '\\' : path[x]);
+        p2[x] = '\0';
+    }
+    else
+        strcpy(p2, path);
+}
+
+
+NSAPI_PUBLIC int system_nocoredumps(void)
+{
+    return 0;
+}
+
+/* --------------------------- system_winerr ------------------------------ */
+
+
+#include <winsock.h>
+#include <errno.h>
+#include "util.h"
+
+NSAPI_PUBLIC char *system_winsockerr(void)
+{
+	int errn = WSAGetLastError();
+
+	return FindError(errn);
+}
+
+NSAPI_PUBLIC char *system_winerr(void)
+{
+	int errn = GetLastError();
+
+	if (errn == 0)
+		errn = WSAGetLastError();
+	return FindError(errn);
+}
+
+/* ------------------------- Dir related stuff ---------------------------- */
+
+
+NSAPI_PUBLIC SYS_DIR dir_open(char *pathp)
+{
+    dir_s *ret = (dir_s *) MALLOC(sizeof(dir_s));
+    char path[MAX_PATH];
+    int l;
+
+	if (strlen(pathp) >= MAX_PATH) {
+		return NULL;
+	}
+
+    l = util_sprintf(path, "%s", pathp) - 1;
+	path[strlen(pathp)] = '\0';
+    if(path[strlen(path) - 1] != FILE_PATHSEP)
+        	strcpy (path + strlen(path), "\\*.*");
+	else
+		util_sprintf(path, "%s*.*", path);
+
+    ret->de.d_name = NULL;
+    if( (ret->dp = FindFirstFile(path, &ret->fdata)) != INVALID_HANDLE_VALUE)
+        return ret;
+    FREE(ret);
+    return NULL;
+}
+
+NSAPI_PUBLIC SYS_DIRENT *dir_read(SYS_DIR ds)
+{
+    if(FindNextFile(ds->dp, &ds->fdata) == FALSE)
+        return NULL;
+    if(ds->de.d_name)
+        FREE(ds->de.d_name);
+    ds->de.d_name = STRDUP(ds->fdata.cFileName);
+
+    return &ds->de;
+}
+
+NSAPI_PUBLIC void dir_close(SYS_DIR ds)
+{
+    FindClose(ds->dp);
+    if(ds->de.d_name)
+        FREE(ds->de.d_name);
+    FREE(ds);
+}
+
+#endif /* FILE_WIN32 */
+
+NSAPI_PUBLIC int file_notfound(void)
+{
+#ifdef FILE_WIN32
+    int errn = PR_GetError();
+    return (errn == PR_FILE_NOT_FOUND_ERROR);
+#else
+    return (errno == ENOENT);
+#endif
+}
+
+NSAPI_PUBLIC int dir_create_all(char *dir)
+{
+    struct stat fi;
+    char *t;
+
+#ifdef XP_WIN32
+    t = dir + 3;
+#else /* XP_UNIX */
+    t = dir + 1;
+#endif
+    while(1) {
+        t = strchr(t, FILE_PATHSEP);
+        if(t) *t = '\0';
+        if(stat(dir, &fi) == -1) {
+            if(dir_create(dir) == -1)
+                return -1;
+        }
+        if(t) *t++ = FILE_PATHSEP;
+        else break;
+    }
+    return 0;
+}
+
+
+#ifdef XP_UNIX
+#if !defined(SNI) && !defined(LINUX)
+extern char *sys_errlist[];
+#endif /* SNI */
+#endif
+
+#ifdef NET_SSL
+
+#define ERRMSG_SIZE 35
+#ifdef THREAD_ANY
+static int errmsg_key = -1;
+#include "systhr.h"
+/* Removed for ns security integration
+#include "xp_error.h"
+*/
+#else
+static char errmsg[ERRMSG_SIZE];
+#endif
+
+#include "util.h"
+
+static char *_errmsg_new(int code)
+{
+    char *ret;
+#ifdef THREAD_ANY
+    if(!(ret = (char *) systhread_getdata(errmsg_key))) {
+        ret = (char *) PERM_MALLOC(256);
+        systhread_setdata(errmsg_key, (void *)ret);
+    }
+#else
+    ret = errmsg;
+#endif
+    util_snprintf(ret, ERRMSG_SIZE, "libsec code %d", code);
+#ifndef MCC_BATMAN
+    PR_SetError(0,0);
+#endif
+    return ret;
+}
+#endif
+
+
+void system_errmsg_init(void)
+{
+    if (errmsg_key == -1) {
+#if defined(THREAD_ANY) && defined(NET_SSL)
+        errmsg_key = systhread_newkey();
+#endif
+#ifdef XP_WIN32
+        HashNtErrors();
+#endif
+        if (!_atomic_write_lock)
+            _atomic_write_lock = PR_NewLock();
+    }
+}
+
+NSAPI_PUBLIC int system_errmsg_fn(char **buff, size_t maxlen)
+{
+    char static_error[128];
+    char *lmsg = 0; /* Local message pointer */
+    size_t msglen = 0;
+    int sys_error = 0;
+    PRErrorCode nscp_error;
+#ifdef XP_WIN32
+    LPTSTR sysmsg = 0;
+#endif
+
+
+    /* Grab the OS error message */
+#ifdef XP_WIN32
+    sys_error = GetLastError();
+#else
+    sys_error = errno;
+#endif
+    nscp_error = PR_GetError();
+
+    /* If there is a NSPR error, but it is "unknown", try to get the OSError
+     * and use that instead.
+     */
+    if (nscp_error == PR_UNKNOWN_ERROR)
+        errno = PR_GetOSError();
+
+    if (nscp_error != 0 && nscp_error != PR_UNKNOWN_ERROR){
+        char *nscp_error_msg;
+
+        nscp_error_msg = nscperror_lookup(nscp_error);
+        if(nscp_error_msg){
+            PR_SetError(0, 0);
+            lmsg = nscp_error_msg;
+        } else {
+            util_snprintf(static_error, ERRMSG_SIZE, "unknown error %d", nscp_error);
+            lmsg = static_error;
+        }
+    } else {
+#if defined(XP_WIN32)
+        msglen = FormatMessage(
+                    FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ALLOCATE_BUFFER,
+                    NULL, 
+                    GetLastError(), 
+                    LOCALE_SYSTEM_DEFAULT, 
+                    (LPTSTR)&sysmsg, 
+                    0, 
+                    0);
+        if (msglen > 0)
+            lmsg = sysmsg;
+        else
+            lmsg = system_winerr();
+        SetLastError(0);
+#else
+/* replaced
+#if defined(SNI) || defined(LINUX)
+	/ C++ platform has no definition for sys_errlist /
+	lmsg = strerror(errno);
+#else
+	lmsg = sys_errlist[errno];
+#endif
+with lmsg =strerror(errno);*/
+	lmsg=strerror(errno);
+        errno = 0;
+#endif
+    }
+
+    /* At this point lmsg points to something. */
+    msglen = strlen(lmsg);
+
+    if (*buff == NULL)
+        *buff = STRDUP(lmsg);
+    else if (maxlen > msglen)
+        memcpy(*buff, lmsg, msglen+1);
+    else
+        msglen = 0;
+
+#ifdef XP_WIN32
+    /* NT's FormatMessage() dynamically allocated the msg; free it */
+    if (sysmsg)
+        LocalFree(sysmsg);
+#endif
+
+    return msglen;
+}
+
+NSAPI_PUBLIC char *
+system_errmsg(void)
+{
+    char *buff = 0;
+
+    if (errmsg_key == -1)
+        return "unknown early startup error";
+
+    // rmaxwell - This is extremely lame.
+    // Allocate a buffer in thread local storage to 
+    // hold the last error message.
+    // The whole error message facility is broken and should be
+    // updated to get error strings out of the code.
+    if(!(buff = (char *) systhread_getdata(errmsg_key))) {
+        buff = (char *) PERM_MALLOC(errbuf_size);
+        systhread_setdata(errmsg_key, (void *)buff);
+    }
+    system_errmsg_fn(&buff, errbuf_size);
+    if (buff == 0)
+        buff = "Could not retrieve system error message";
+    return buff;
+}
+
+NSAPI_PUBLIC int
+system_rename(char *oldpath, char *newpath)
+{
+    return rename(oldpath, newpath);
+}
+
+NSAPI_PUBLIC int
+system_unlink(char *path)
+{
+    return PR_Delete(path)==PR_FAILURE?-1:0;
+}
+
+NSAPI_PUBLIC int system_lseek(SYS_FILE fd, int off, int wh)
+{
+  switch (wh) {
+  case 0:
+    return PR_Seek(fd, off, PR_SEEK_SET);
+    break;
+  case 1:
+    return PR_Seek(fd, off, PR_SEEK_CUR);
+    break;
+  case 2:
+    return PR_Seek(fd, off, PR_SEEK_END);
+    break;
+  default:
+    return  -1;
+  }
+}
+
+NSAPI_PUBLIC int
+system_tlock(SYS_FILE fd)
+{
+    return PR_TLockFile(fd);
+}
+
+NSAPI_PUBLIC int
+system_flock(SYS_FILE fd)
+{
+    return PR_LockFile(fd);
+}
+
+NSAPI_PUBLIC int 
+system_ulock(SYS_FILE fd)
+{
+    return PR_UnlockFile(fd);
+}
diff --git a/lib/base/fsmutex.cpp b/lib/base/fsmutex.cpp
new file mode 100644
index 00000000..06fe2403
--- /dev/null
+++ b/lib/base/fsmutex.cpp
@@ -0,0 +1,187 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * fsmutex: Mutexes that are filesystem-based so they're available from more
+ * than one process and address space
+ * 
+ * Rob McCool
+ */
+
+#include "base/fsmutex.h"
+#ifdef THREAD_ANY
+#include "base/crit.h"
+#include "base/systhr.h"
+#endif
+
+#include "base/util.h"
+#ifdef XP_WIN32
+typedef HANDLE sys_fsmutex_t;
+#endif
+
+#ifdef XP_UNIX
+#include "base/file.h"
+typedef SYS_FILE sys_fsmutex_t;
+#endif
+
+
+typedef struct {
+    sys_fsmutex_t mutex;
+    char *id;
+#ifdef THREAD_ANY
+    CRITICAL crit;
+#endif
+    int flags;
+} fsmutex_s;
+
+
+
+/* ----------------------------- fsmutex_init ----------------------------- */
+
+
+#ifdef XP_UNIX
+static int 
+_fsmutex_create(fsmutex_s *fsm, char *name, int number)
+{
+    char tn[256];
+    SYS_FILE lfd;
+    int visible = (fsm->flags & FSMUTEX_VISIBLE ? 1 : 0);
+
+    util_snprintf(tn, 256, "/tmp/%s.%d", name, number);
+    if(!visible)
+        unlink(tn);
+    if( (lfd = PR_Open(tn, PR_RDWR|PR_CREATE_FILE, 0644)) == NULL)
+        return -1;
+
+    if(!visible)
+        unlink(tn);
+    else
+        fsm->id = PERM_STRDUP(tn);
+    fsm->mutex = lfd;
+    return 0;
+}
+#endif
+
+#ifdef XP_WIN32
+static int 
+_fsmutex_create(fsmutex_s *fsm, char *name, int number)
+{
+    char tn[256];
+    util_snprintf(tn, sizeof(tn), "%s.%d", name, number);
+
+    fsm->id = NULL;
+    fsm->mutex = CreateMutex(NULL, FALSE, 
+                             (fsm->flags & FSMUTEX_VISIBLE ? tn : NULL));
+    return (fsm->mutex ? 0 : -1);
+}
+#endif
+
+NSAPI_PUBLIC FSMUTEX
+fsmutex_init(char *name, int number, int flags)
+{
+    fsmutex_s *ret = (fsmutex_s *) PERM_MALLOC(sizeof(fsmutex_s));
+
+    ret->flags = flags;
+    if(_fsmutex_create(ret, name, number) == -1) {
+        PERM_FREE(ret);
+        return NULL;
+    }
+#ifdef THREAD_ANY
+    if(flags & FSMUTEX_NEEDCRIT)
+        ret->crit = crit_init();
+#endif
+    return (FSMUTEX) ret;
+}
+
+#ifdef XP_UNIX
+NSAPI_PUBLIC void 
+fsmutex_setowner(FSMUTEX fsm, uid_t uid, gid_t gid)
+{
+    if(!geteuid())
+        (void) chown( ((fsmutex_s *)fsm)->id, uid, gid);
+}
+#endif
+
+
+/* -------------------------- fsmutex_terminate --------------------------- */
+
+
+#ifdef XP_UNIX
+static void 
+_fsmutex_delete(fsmutex_s *fsm)
+{
+    if(fsm->flags & FSMUTEX_VISIBLE)
+        unlink(fsm->id);
+    PERM_FREE(fsm->id);
+    PR_Close(fsm->mutex);
+}
+#endif
+
+#ifdef XP_WIN32
+static void 
+_fsmutex_delete(fsmutex_s *fsm)
+{
+    CloseHandle(fsm->mutex);
+}
+#endif
+
+NSAPI_PUBLIC void
+fsmutex_terminate(FSMUTEX id)
+{
+    fsmutex_s *fsm = (fsmutex_s *) id;
+
+    _fsmutex_delete(fsm);
+#ifdef THREAD_ANY
+    if(fsm->flags & FSMUTEX_NEEDCRIT)
+        crit_terminate(fsm->crit);
+#endif
+    PERM_FREE(fsm);
+}
+
+
+/* ----------------------------- fsmutex_lock ----------------------------- */
+
+
+NSAPI_PUBLIC void
+fsmutex_lock(FSMUTEX id)
+{
+    fsmutex_s *fsm = (fsmutex_s *) id;
+#ifdef THREAD_ANY
+    if(fsm->flags & FSMUTEX_NEEDCRIT)
+        crit_enter(fsm->crit);
+#endif
+#ifdef XP_UNIX
+#ifdef THREAD_NSPR_USER
+    /* Poll to avoid blocking. XXXrobm If errno is wrong this may go awry. */
+    while(system_tlock(fsm->mutex) == -1)
+        systhread_sleep(1000);
+#else
+    system_flock(fsm->mutex );
+#endif
+#endif
+#ifdef XP_WIN32
+    WaitForSingleObject(fsm->mutex, INFINITE);
+#endif
+}
+
+
+/* ---------------------------- fsmutex_unlock ---------------------------- */
+
+
+NSAPI_PUBLIC void
+fsmutex_unlock(FSMUTEX id)
+{
+    fsmutex_s *fsm = (fsmutex_s *) id;
+#ifdef XP_UNIX
+    system_ulock(fsm->mutex);
+#endif
+#ifdef XP_WIN32
+    ReleaseMutex(fsm->mutex);
+#endif
+#ifdef THREAD_ANY
+    if(fsm->flags & FSMUTEX_NEEDCRIT)
+        crit_exit(fsm->crit);
+#endif
+}
diff --git a/lib/base/lexer.cpp b/lib/base/lexer.cpp
new file mode 100644
index 00000000..e521c51f
--- /dev/null
+++ b/lib/base/lexer.cpp
@@ -0,0 +1,978 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+
+/*
+ * Description (lexer.c)
+ *
+ *	This module provides functions to assist parsers in lexical
+ *	analysis.  The idea is to provide a slightly higher-level
+ *	interface than that of ctype.h.
+ */
+
+#include "netsite.h"
+#include "base/nsassert.h"
+
+#include "lexer_pvt.h"
+#include "base/lexer.h"
+
+/*
+ * Description (lex_class_check)
+ *
+ *	This function checks whether a given character belongs to one or
+ *	specified character classes.
+ *
+ * Arguments:
+ *
+ *	chtab			- character class table pointer
+ *	code			- character code to be tested
+ *	cbits			- bit mask of character classes
+ *
+ * Returns:
+ *
+ *	The return value is zero if the code is not in any of the character
+ *	classes.  It is non-zero, if the code is in at least one of the
+ *	classes.
+ */
+NSAPI_PUBLIC 
+int lex_class_check(void * chtab, char code, unsigned long cbits)
+{
+    LEXClassTab_t * lct;		/* character class table pointer */
+    unsigned char * bp;			/* bit vector pointer */
+    int rv = 0;				/* return value */
+    int i;				/* loop index */
+
+    lct = (LEXClassTab_t *)chtab;
+
+    bp = lct->lct_bv + code * lct->lct_bvbytes;
+
+    for (i = 0; i < lct->lct_bvbytes; ++i) {
+	if (*bp++ & cbits) {
+	    rv = 1;
+	    break;
+	}
+	cbits >>= 8;
+    }
+
+    return rv;
+}
+
+/*
+ * Description (lex_class_create)
+ *
+ *	This function creates a new character class table.  A
+ *	character class table is used to map a character code to a
+ *	set of character classes.  The mapping for a given character
+ *	is expressed as a bit vector, where each bit indicates the
+ *	membership of that character in one of the character classes.
+ *
+ * Arguments:
+ *
+ *	classc		- the number of character classes being defined
+ *	classv		- pointers to null-terminated strings containing
+ *			  the character codes in each character class
+ *	pchtab		- indicates where to store a returned handle for
+ *			  the character class table
+ *
+ * Returns:
+ *
+ *	If successful, the return value is the number of character
+ *	classes specified (classc), and a handle for the created table
+ *	is returned through pchtab.
+ *
+ * Usage Notes:
+ *
+ *	Null (\000) can never be in any character classes, since it
+ *	marks the end of the classv[] strings.
+ *
+ *	classv[] can included NULL pointers, in which case bits will be
+ *	allocated for corresponding empty character classes.
+ */
+NSAPI_PUBLIC 
+int lex_class_create(int classc, char * classv[], void **pchtab)
+{
+    int ncodes = 128;			/* number of character encodings */
+    int bvbytes;			/* bytes per bit vector */
+    LEXClassTab_t * ct;			/* class table pointer */
+    unsigned char * bp;			/* bit vector pointer */
+    char * cp;				/* class string pointer */
+    int bitmask;			/* class bit mask */
+    int bnum;				/* byte number in bit vector */
+    int ci;				/* character index */
+    int i;				/* class index */
+
+    /* Get number of bytes per bit vector */
+    NS_ASSERT(classc > 0);
+    bvbytes = (classc + 7) >> 3;
+
+    /* Allocate the character class table */
+    ct = (LEXClassTab_t *)calloc(1, sizeof(LEXClassTab_t) + ncodes * bvbytes);
+    if (ct == NULL) {
+
+	/* Error - insufficient memory */
+	return LEXERR_MALLOC;
+    }
+
+    /* Initialize the class table */
+    ct->lct_classc = classc;
+    ct->lct_bvbytes = bvbytes;
+    ct->lct_bv = (unsigned char *)(ct + 1);
+
+    /* Initialize the bit vectors */
+    for (i = 0; i < classc; ++i) {
+
+	cp = classv[i];
+	if (cp != NULL) {
+
+	    bitmask = 1 << (i & 7);
+	    bnum = i >> 7;
+
+	    while ((ci = *cp++) != 0) {
+		bp = ct->lct_bv + ci + bnum;
+		*bp |= bitmask;
+	    }
+	}
+    }
+
+    /* Return pointer to table */
+    NS_ASSERT(pchtab != NULL);
+    *pchtab = (void *)ct;
+
+    return classc;
+}
+
+NSAPI_PUBLIC 
+void lex_class_destroy(void * chtab)
+{
+    FREE((void *)chtab);
+}
+
+NSAPI_PUBLIC 
+LEXStream_t * lex_stream_create(LEXStreamGet_t strmget, void * strmid,
+				char * buf, int buflen)
+{
+    LEXStream_t * lst;		/* stream structure pointer */
+
+    /* Allocate the stream structure */
+    lst = (LEXStream_t *)MALLOC(sizeof(LEXStream_t));
+    if (lst == NULL) {
+	/* Error - insufficient memory */
+	return 0;
+    }
+
+    lst->lst_strmid = strmid;
+    lst->lst_get = strmget;
+
+    /*
+     * Allocate a buffer for the stream if there's a positive length
+     * but a NULL buffer pointer.
+     */
+    if ((buflen > 0) && (buf == NULL)) {
+
+	buf = (char *)MALLOC(buflen);
+	if (buf == NULL) {
+	    FREE((void *)lst);
+	    return 0;
+	}
+
+	/* Also initialize the current position and residual length */
+	lst->lst_cp = buf;
+	lst->lst_len = 0;
+	lst->lst_flags = LST_FREEBUF;
+    }
+
+    lst->lst_buf = buf;
+    lst->lst_buflen = buflen;
+
+    return lst;
+}
+
+NSAPI_PUBLIC 
+void lex_stream_destroy(LEXStream_t * lst)
+{
+    if ((lst->lst_flags & LST_FREEBUF) && (lst->lst_buf != NULL)) {
+	FREE(lst->lst_buf);
+    }
+    FREE((void *)lst);
+}
+
+/*
+ * Description (lex_token_new)
+ *
+ *      This function creates a new token object.  A token object is
+ *      used to accumulate text in an associated buffer.  If the
+ *      'growlen' argument is specified as a value that is greater
+ *      than zero, then the token buffer will be reallocated as
+ *      necessary to accomodate more text.  The initial size of
+ *      the token buffer is given by 'initlen', which may be zero,
+ *      and should be zero if lex_token_setbuf() is used.
+ *
+ *      The token object is allocated from the memory pool given
+ *      by the 'pool' argument.  The default pool for the current
+ *      thread is used if 'pool' is null.
+ *
+ * Arguments:
+ *
+ *      pool                    - handle for memory pool to be used
+ *      initlen                 - initial length of token buffer
+ *      growlen                 - amount to grow a full token buffer
+ *      token                   - pointer to returned token handle
+ *
+ * Returns:
+ *
+ *      If successful, the function return value is zero and a handle
+ *      for the new token is returned via 'token'.  Otherwise a negative
+ *      error code is returned.
+ */
+
+NSAPI_PUBLIC
+int lex_token_new(pool_handle_t * pool, int initlen, int growlen, void **token)
+{
+    LEXToken_t * lt;			/* new token pointer */
+
+    /* Allocate the token structure */
+    if (pool) {
+        lt = (LEXToken_t *)pool_calloc(pool, 1, sizeof(LEXToken_t));
+    }
+    else {
+        lt = (LEXToken_t *)CALLOC(sizeof(LEXToken_t));
+    }
+    if (lt == NULL) {
+	/* Error - insufficient memory */
+	return LEXERR_MALLOC;
+    }
+
+    /* Save the memory pool handle for future allocations */
+    lt->lt_mempool = pool;
+
+    /* Allocate the initial token buffer if initlen > 0 */
+    if (initlen > 0) {
+        if (pool) {
+            lt->lt_buf = (char *)pool_malloc(pool, initlen);
+        }
+        else {
+            lt->lt_buf = (char *)MALLOC(initlen);
+        }
+        if (lt->lt_buf == NULL) {
+            /* Error - insufficient memory */
+            if (pool) {
+                pool_free(pool, (void *)lt);
+            }
+            else {
+                FREE((void *)lt);
+            }
+            return LEXERR_MALLOC;
+        }
+
+        lt->lt_initlen = initlen;
+        lt->lt_buflen = initlen;
+        lt->lt_buf[0] = 0;
+    }
+
+    if (growlen > 0) lt->lt_inclen = growlen;
+
+    NS_ASSERT(token != NULL);
+    *token = (void *)lt;
+
+    return 0;
+}
+
+/*
+ * Description (lex_token_start)
+ *
+ *      This function discards any current contents of the token buffer
+ *      associated with a specified token object, so that any new data
+ *      appended to the token will start at the beginning of the token
+ *      buffer.  If there is no token buffer currently associated with
+ *      the token, and the 'initlen' value specified to lex_token_new()
+ *      was greater than zero, then a new token buffer is allocated.
+ *      This function enables a token and optionally its token buffer
+ *      to be reused.
+ *
+ * Arguments:
+ *
+ *      token                           - handle for token object
+ *
+ * Returns:
+ *
+ *      If successful, the function return value is zero.  Otherwise
+ *      a negative error code is returned.
+ */
+
+NSAPI_PUBLIC int
+lex_token_start(void * token)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;	/* token pointer */
+
+    /* Do we need to allocate a token buffer? */
+    if ((lt->lt_buf == NULL) && (lt->lt_initlen > 0)) {
+
+	/* Allocate the initial token buffer */
+        if (lt->lt_mempool) {
+            lt->lt_buf = (char *)pool_malloc(lt->lt_mempool, lt->lt_initlen);
+        }
+        else {
+            lt->lt_buf = (char *)MALLOC(lt->lt_initlen);
+        }
+	if (lt->lt_buf == NULL) {
+	    /* Error - insufficient memory */
+	    return LEXERR_MALLOC;
+	}
+	lt->lt_buflen = lt->lt_initlen;
+    }
+
+    lt->lt_len = 0;
+    lt->lt_buf[0] = 0;
+
+    return 0;
+}
+
+/*
+ * Description (lex_token_info)
+ *
+ *      This function returns information about the token buffer currently
+ *      associated with a token object.  This includes a pointer to the
+ *      token data, if any, the current length of the token data, and the
+ *      current size of the token buffer.
+ *
+ * Arguments:
+ *
+ *      token                   - handle for token object
+ *      tdatalen                - pointer to returned token data length
+ *                                (may be null)
+ *      tbufflen                - pointer to returned token buffer length
+ *                                (may be null)
+ *
+ * Returns:
+ *
+ *      The function return value is a pointer to the beginning of the
+ *      token data, or null if there is no token buffer associated with
+ *      the token.  The token data length and token buffer length are
+ *      returned via 'tdatalen' and 'tbufflen', respectively.
+ */
+
+NSAPI_PUBLIC
+char * lex_token_info(void * token, int * tdatalen, int * tbufflen)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
+
+    if (tdatalen) *tdatalen = lt->lt_len;
+    if (tbufflen) *tbufflen = lt->lt_buflen;
+
+    return lt->lt_buf;
+}
+
+/*
+ * Description (lex_token)
+ *
+ *      This function returns a pointer to the current token buffer, if any.
+ *      If the length of the token is also needed, use lex_token_info().
+ *      This function would normally be used when the token is a
+ *      null-terminated string.  See also lex_token_take().
+ *
+ * Arguments:
+ *
+ *      token                           - handle for token object
+ *
+ * Returns:
+ *
+ *      A pointer to the beginning of the current token is returned.
+ *      The pointer is null if no token buffer is currently associated
+ *      with the token object.
+ */
+
+NSAPI_PUBLIC 
+char * lex_token(void * token)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
+
+    return lt->lt_buf;
+}
+
+/*
+ * Description (lex_token_destroy)
+ *
+ *      This function destroys a specified token object.  The memory
+ *      associated with the token object and its token buffer, if any,
+ *      is freed to whence it came.  Note that token objects can be
+ *      associated with a memory pool, and destroyed implicitly when
+ *      the pool is destroyed via pool_destroy().
+ *
+ * Arguments:
+ *
+ *      token                           - handle for token object
+ */
+
+NSAPI_PUBLIC 
+void lex_token_destroy(void * token)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
+
+    if (lt) {
+        if (lt->lt_mempool) {
+            if (lt->lt_buf) {
+                pool_free(lt->lt_mempool, (void *)(lt->lt_buf));
+            }
+            pool_free(lt->lt_mempool, (void *)lt);
+        }
+        else {
+            if (lt->lt_buf) {
+                FREE(lt->lt_buf);
+            }
+            FREE(lt);
+        }
+    }
+}
+
+/*
+ * Description (lex_token_get)
+ *
+ *      This function returns a pointer to the current token buffer,
+ *      leaving the token with no associated token buffer.  The caller
+ *      assumes ownership of the returned token buffer.  The length
+ *      of the token data and the length of the token buffer are returned
+ *      if requested.  Note that lex_token_take() performs a similar
+ *      operation.
+ *
+ * Arguments:
+ *
+ *      token                           - handle for token object
+ *      tdatalen                - pointer to returned token data length
+ *                                (may be null)
+ *      tbufflen                - pointer to returned token buffer length
+ *                                (may be null)
+ *
+ * Returns:
+ *
+ *      The function return value is a pointer to the beginning of the
+ *      token data, or null if there is no token buffer associated with
+ *      the token.  The token data length and token buffer length are
+ *      returned via 'tdatalen' and 'tbufflen', respectively.
+ */
+
+NSAPI_PUBLIC 
+char * lex_token_get(void * token, int * tdatalen, int * tbufflen)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
+    char * tokenstr;
+
+    tokenstr = lt->lt_buf;
+    if (tdatalen) *tdatalen = lt->lt_len;
+    if (tbufflen) *tbufflen = lt->lt_buflen;
+
+    lt->lt_buf = NULL;
+    lt->lt_buflen = 0;
+    lt->lt_len = 0;
+
+    return tokenstr;
+}
+
+/*
+ * Description (lex_token_take)
+ *
+ *      This function returns a pointer to the current token buffer,
+ *      leaving the token with no associated token buffer.  The caller
+ *      assumes ownership of the returned token buffer.  Note that
+ *      lex_token_get() performs a similar operation, but returns more
+ *      information.
+ *
+ * Arguments:
+ *
+ *      token                           - handle for token object
+ *
+ * Returns:
+ *
+ *      A pointer to the beginning of the current token is returned.
+ *      The pointer is null if no token buffer is currently associated
+ *      with the token object.
+ */
+
+NSAPI_PUBLIC 
+char * lex_token_take(void * token)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
+    char * tokenstr;
+
+    tokenstr = lt->lt_buf;
+
+    lt->lt_buf = NULL;
+    lt->lt_buflen = 0;
+    lt->lt_len = 0;
+
+    return tokenstr;
+}
+
+/*
+ * Description (lex_token_append)
+ *
+ *      This function appends data to the end of a token.  If 'growlen'
+ *      was specified as a greater-than-zero value for lex_token_new(),
+ *      then the token buffer may be reallocated to accomodate the
+ *      new data if necessary.  A null byte is maintained in the token
+ *      buffer following the token data, but it is not included in the
+ *      token data length.
+ *
+ * Arguments:
+ *
+ *      token                           - handle for token object
+ *      nbytes                          - number of bytes of new data
+ *      src                             - pointer to new data
+ *
+ * Returns:
+ *
+ *      If successful, the function return value is the new length of
+ *      the token data.  Otherwise a negative error code is returned.
+ */
+
+NSAPI_PUBLIC 
+int lex_token_append(void * token, int nbytes, char * src)
+{
+    LEXToken_t * lt = (LEXToken_t *)token;      /* token pointer */
+    int bufsize;
+    int length;
+
+    NS_ASSERT(nbytes >= 0);
+    NS_ASSERT((src != NULL) || (nbytes == 0));
+
+    if (nbytes > 0) {
+
+	bufsize = lt->lt_buflen;
+	length = lt->lt_len + nbytes;
+
+	if (length >= bufsize) {
+
+	    while (length >= bufsize) {
+		bufsize += lt->lt_inclen;
+	    }
+
+            if (lt->lt_mempool) {
+                if (lt->lt_buf) {
+                    lt->lt_buf = (char *)pool_realloc(lt->lt_mempool,
+                                                      lt->lt_buf, bufsize);
+                }
+                else {
+                    lt->lt_buf = (char *)pool_malloc(lt->lt_mempool, bufsize);
+                }
+            }
+            else {
+                if (lt->lt_buf) {
+                    lt->lt_buf = (char *)REALLOC(lt->lt_buf, bufsize);
+                }
+                else {
+                    lt->lt_buf = (char *)MALLOC(bufsize);
+                }
+            }
+        }
+
+	if (lt->lt_buf) {
+
+	    memcpy((void *)(lt->lt_buf + lt->lt_len), (void *)src, nbytes);
+	    lt->lt_buf[length] = 0;
+	    lt->lt_len = length;
+	    lt->lt_buflen = bufsize;
+	}
+        else {
+            /* Error - insufficient memory */
+            return LEXERR_MALLOC;
+        }
+    }
+
+    return lt->lt_len;
+}
+
+NSAPI_PUBLIC 
+int lex_next_char(LEXStream_t * lst, void * chtab, unsigned long cbits)
+{
+    LEXClassTab_t * lct;		/* character class table pointer */
+    unsigned char * bp;			/* bit vector pointer */
+    unsigned long bitmask;		/* class bit mask temporary */
+    int rv;				/* return value */
+    int i;				/* loop index */
+
+    lct = (LEXClassTab_t *)chtab;
+
+    /* Go get more stream data if none left in the buffer */
+    if (lst->lst_len <= 0) {
+	rv = (*lst->lst_get)(lst);
+	if (rv <= 0) {
+	    return rv;
+	}
+    }
+
+    /* Get the next character from the buffer */
+    rv = *lst->lst_cp;
+
+    bitmask = cbits;
+    bp = lct->lct_bv + rv * lct->lct_bvbytes;
+
+    for (i = 0; i < lct->lct_bvbytes; ++i) {
+	if (*bp++ & bitmask) {
+	    /* Update the buffer pointer and length */
+	    lst->lst_cp += 1;
+	    lst->lst_len -= 1;
+	    break;
+	}
+	bitmask >>= 8;
+    }
+
+    return rv;
+}
+
+NSAPI_PUBLIC 
+int lex_scan_over(LEXStream_t * lst, void * chtab, unsigned long cbits,
+		  void * token)
+{
+    LEXClassTab_t * lct;		/* character class table pointer */
+    char * cp;				/* current pointer in stream buffer */
+    unsigned char * bp;			/* bit vector pointer */
+    unsigned long bitmask;		/* class bit mask temporary */
+    int cv = 0;				/* current character value */
+    int rv = 0;				/* return value */
+    int slen;				/* token segment length */
+    int done = 0;			/* done indication */
+    int i;				/* loop index */
+
+    lct = (LEXClassTab_t *)chtab;
+
+    while (!done) {
+
+	/* Go get more stream data if none left in the buffer */
+	if (lst->lst_len <= 0) {
+	    rv = (*lst->lst_get)(lst);
+	    if (rv <= 0) {
+		return rv;
+	    }
+	}
+
+	slen = 0;
+	cp = lst->lst_cp;
+
+	while (slen < lst->lst_len) {
+	    cv = *cp;
+	    bitmask = cbits;
+	    bp = lct->lct_bv + cv * lct->lct_bvbytes;
+	    for (i = 0; i < lct->lct_bvbytes; ++i) {
+		if (*bp++ & bitmask) goto more_token;
+		bitmask >>= 8;
+	    }
+
+	    done = 1;
+	    break;
+
+	  more_token:
+	    slen += 1;
+	    cp += 1;
+	}
+
+	/* If the current segment is not empty, append it to the token */
+	if (slen > 0) {
+	    rv = lex_token_append(token, slen, lst->lst_cp);
+	    if (rv < 0) break;
+
+	    /* Update the stream buffer pointer and length */
+	    lst->lst_cp += slen;
+	    lst->lst_len -= slen;
+	}
+    }
+
+    return ((rv < 0) ? rv : cv);
+}
+
+/*
+ * Description (lex_scan_string)
+ *
+ *	This function parses a quoted string into the specified token.
+ *	The current character in the LEX stream is taken to be the
+ *	beginning quote character.  The quote character may be included
+ *	in the string by preceding it with a '\'.  Any newline
+ *	characters to be included in the string must also be preceded
+ *	by '\'.  The string is terminated by another occurrence of the
+ *	quote character, or an unquoted newline, or EOF.
+ *
+ * Arguments:
+ *
+ *	lst			- pointer to LEX stream structure
+ *	token			- handle for token
+ *	flags			- bit flags (unused - must be zero)
+ *
+ * Returns:
+ *
+ *	The terminating character is returned, or zero if EOF.  The
+ *	string is returned in the token, without the beginning and
+ *	ending quote characters.  An error is indicated by a negative
+ *	return value.
+ */
+
+NSAPI_PUBLIC 
+int lex_scan_string(LEXStream_t * lst, void * token, int flags)
+{
+    char * cp;				/* current pointer in stream buffer */
+    int cv;				/* current character value */
+    int rv;				/* return value */
+    int slen;				/* token segment length */
+    int done = 0;			/* done indication */
+    int cquote = 0;			/* character quote indication */
+    int qchar = -1;			/* quote character */
+
+    while (!done) {
+
+	/* Go get more stream data if none left in the buffer */
+	if (lst->lst_len <= 0) {
+	    rv = (*lst->lst_get)(lst);
+	    if (rv <= 0) {
+		return rv;
+	    }
+	}
+
+	slen = 0;
+	cp = lst->lst_cp;
+
+	while (slen < lst->lst_len) {
+
+	    /* Get the next character */
+	    cv = *cp;
+
+	    /* Pick up the quote character if we don't have it yet */
+	    if (qchar < 0) {
+		qchar = cv;
+
+		/* Don't include it in the string */
+		lst->lst_cp += 1;
+		lst->lst_len -= 1;
+		cp += 1;
+		continue;
+	    }
+
+	    /* cquote is 1 if the last character was '\' */
+	    if (cquote == 0) {
+
+		/* Is this a string terminator? */
+		if ((cv == qchar) || (cv == '\n')) {
+
+		    /* Append whatever we have to this point */
+		    if (slen > 0) goto append_it;
+
+		    /*
+		     * If the terminator is the expected quote character,
+		     * just skip it.  If it's anything else, leave it as
+		     * the current character.
+		     */
+		    if (cv == qchar) {
+			lst->lst_cp += 1;
+			lst->lst_len -= 1;
+		    }
+
+		    done = 1;
+		    goto append_it;
+		}
+
+		/* Got the character quote character? */
+		if (cv == '\\') {
+
+		    /* Append anything we have so far first */
+		    if (slen > 0) goto append_it;
+
+		    /* Then skip the character */
+		    cquote = 1;
+		    lst->lst_cp += 1;
+		    lst->lst_len -= 1;
+		    cp += 1;
+		    continue;
+		}
+	    }
+	    else {
+
+		/* Include any character following '\' */
+		cquote = 0;
+	    }
+
+	    /* Include this character in the string */
+	    slen += 1;
+	    cp += 1;
+	}
+
+      append_it:
+
+	/* If the current segment is not empty, append it to the token */
+	if (slen > 0) {
+	    rv = lex_token_append(token, slen, lst->lst_cp);
+	    if (rv < 0) break;
+
+	    /* Update the stream buffer pointer and length */
+	    lst->lst_cp += slen;
+	    lst->lst_len -= slen;
+	}
+    }
+
+    return ((rv < 0) ? rv : cv);
+}
+
+NSAPI_PUBLIC 
+int lex_scan_to(LEXStream_t * lst, void * chtab, unsigned long cbits,
+		void * token)
+{
+    LEXClassTab_t * lct;		/* character class table pointer */
+    unsigned char * bp;			/* bit vector pointer */
+    char * cp;				/* current pointer in stream buffer */
+    unsigned long bitmask;		/* class bit mask temporary */
+    int cv = 0;				/* current character value */
+    int rv = 0;				/* return value */
+    int slen;				/* token segment length */
+    int done = 0;			/* done indication */
+    int i;				/* loop index */
+
+    lct = (LEXClassTab_t *)chtab;
+
+    while (!done) {
+
+	/* Go get more stream data if none left in the buffer */
+	if (lst->lst_len <= 0) {
+	    rv = (*lst->lst_get)(lst);
+	    if (rv <= 0) {
+		return rv;
+	    }
+	}
+
+	slen = 0;
+	cp = lst->lst_cp;
+
+	while (slen < lst->lst_len) {
+	    cv = *cp;
+	    bitmask = cbits;
+	    bp = lct->lct_bv + cv * lct->lct_bvbytes;
+	    for (i = 0; i < lct->lct_bvbytes; ++i) {
+		if (*bp++ & bitmask) {
+		    done = 1;
+		    goto append_it;
+		}
+		bitmask >>= 8;
+	    }
+
+	    slen += 1;
+	    cp += 1;
+	}
+
+      append_it:
+
+	/* If the current segment is not empty, append it to the token */
+	if (slen > 0) {
+	    rv = lex_token_append(token, slen, lst->lst_cp);
+	    if (rv < 0) break;
+
+	    /* Update the stream buffer pointer and length */
+	    lst->lst_cp += slen;
+	    lst->lst_len -= slen;
+	}
+    }
+
+    return ((rv < 0) ? rv : cv);
+}
+
+NSAPI_PUBLIC 
+int lex_skip_over(LEXStream_t * lst, void * chtab, unsigned long cbits)
+{
+    LEXClassTab_t * lct;		/* character class table pointer */
+    unsigned char * bp;			/* bit vector pointer */
+    char * cp;				/* current pointer in stream buffer */
+    unsigned long bitmask;		/* class bit mask temporary */
+    int rv = 0;				/* return value */
+    int slen;				/* token segment length */
+    int done = 0;			/* done indication */
+    int i;				/* loop index */
+
+    lct = (LEXClassTab_t *)chtab;
+
+    while (!done) {
+
+	/* Go get more stream data if none left in the buffer */
+	if (lst->lst_len <= 0) {
+	    rv = (*lst->lst_get)(lst);
+	    if (rv <= 0) {
+		return rv;
+	    }
+	}
+
+	slen = 0;
+	cp = lst->lst_cp;
+
+	while (slen < lst->lst_len) {
+	    rv = *cp;
+	    bitmask = cbits;
+	    bp = lct->lct_bv + rv * lct->lct_bvbytes;
+	    for (i = 0; i < lct->lct_bvbytes; ++i) {
+		if (*bp++ & bitmask) goto next_ch;
+		bitmask >>= 8;
+	    }
+
+	    done = 1;
+	    break;
+
+	  next_ch:
+	    slen += 1;
+	    cp += 1;
+	}
+
+	if (slen > 0) {
+	    /* Update the stream buffer pointer and length */
+	    lst->lst_cp += slen;
+	    lst->lst_len -= slen;
+	}
+    }
+
+    return rv;
+}
+
+NSAPI_PUBLIC 
+int lex_skip_to(LEXStream_t * lst, void * chtab, unsigned long cbits)
+{
+    LEXClassTab_t * lct;		/* character class table pointer */
+    unsigned char * bp;			/* bit vector pointer */
+    char * cp;				/* current pointer in stream buffer */
+    unsigned long bitmask;		/* class bit mask temporary */
+    int rv;				/* return value */
+    int slen;				/* token segment length */
+    int done = 0;			/* done indication */
+    int i;				/* loop index */
+
+    lct = (LEXClassTab_t *)chtab;
+
+    while (!done) {
+
+	/* Go get more stream data if none left in the buffer */
+	if (lst->lst_len <= 0) {
+	    rv = (*lst->lst_get)(lst);
+	    if (rv <= 0) {
+		return rv;
+	    }
+	}
+
+	slen = 0;
+	cp = lst->lst_cp;
+
+	while (slen < lst->lst_len) {
+	    rv = *cp;
+	    bitmask = cbits;
+	    bp = lct->lct_bv + rv * lct->lct_bvbytes;
+	    for (i = 0; i < lct->lct_bvbytes; ++i) {
+		if (*bp++ & bitmask) {
+		    done = 1;
+		    goto update_it;
+		}
+		bitmask >>= 8;
+	    }
+	    slen += 1;
+	    cp += 1;
+	}
+
+      update_it:
+	/* Update the stream buffer pointer and length */
+	if (slen > 0) {
+	    lst->lst_cp += slen;
+	    lst->lst_len -= slen;
+	}
+    }
+
+    return rv;
+}
diff --git a/lib/base/lexer_pvt.h b/lib/base/lexer_pvt.h
new file mode 100644
index 00000000..d4a43f38
--- /dev/null
+++ b/lib/base/lexer_pvt.h
@@ -0,0 +1,30 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+#ifndef __LEXER_PVT_H
+#define __LEXER_PVT_H
+
+#ifndef _POOL_H_
+#include "base/pool.h"
+#endif /* _POOL_H_ */
+
+typedef struct LEXClassTab_s LEXClassTab_t;
+struct LEXClassTab_s {
+    int lct_classc;			/* number of character classes */
+    int lct_bvbytes;			/* number of bytes per bit vector */
+    unsigned char * lct_bv;		/* pointer to bit vector area */
+};
+
+typedef struct LEXToken_s LEXToken_t;
+struct LEXToken_s {
+    char * lt_buf;			/* token buffer pointer */
+    int lt_len;				/* length of token data */
+    int lt_buflen;			/* current length of buffer */
+    int lt_inclen;                      /* buffer length increment */
+    int lt_initlen;                     /* initial length of token buffer */
+    pool_handle_t * lt_mempool;         /* token memory pool */
+};
+
+#endif /* __LEXER_PVT_H */
diff --git a/lib/base/net.cpp b/lib/base/net.cpp
new file mode 100644
index 00000000..0d15b121
--- /dev/null
+++ b/lib/base/net.cpp
@@ -0,0 +1,578 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * net.c: sockets abstraction and DNS related things
+ * 
+ * Note: sockets created with net_socket are placed in non-blocking mode,
+ *       however this API simulates that the calls are blocking.
+ *
+ * Rob McCool
+ */
+
+
+#include "netsite.h"
+#include "prio.h"
+#include "private/pprio.h"
+#include <nspr.h>
+
+#include <frame/conf.h>
+/* Removed for ns security integration
+#include "sslio/sslio.h"
+*/
+
+#include "net.h"
+#include "util.h"
+#include "daemon.h"  /* child_exit */
+#include "ereport.h" /* error reporting */
+#include <string.h>
+#ifdef XP_UNIX
+#include <arpa/inet.h>  /* inet_ntoa */
+#include <netdb.h>      /* hostent stuff */
+#ifdef NEED_GHN_PROTO
+extern "C" int gethostname (char *name, size_t namelen);
+#endif
+#endif /* XP_UNIX */
+#ifdef LINUX
+#include <sys/ioctl.h> /* ioctl */
+#endif
+
+extern "C" {
+#include "ssl.h"
+}
+
+#if defined(OSF1)
+#include <stropts.h>
+#endif
+#include "base/systems.h"
+#include "base/dbtbase.h"
+
+#if defined(OSF1)
+#include <stropts.h>
+#endif
+
+#ifdef IRIX
+#include <bstring.h>   /* fd_zero uses bzero */
+#endif
+#include "netio.h"
+
+net_io_t net_io_functions;
+/* removed for ns security integration
+#include "xp_error.h"
+*/
+
+#include "libadmin/libadmin.h"
+
+int net_enabledns = 1;
+int net_enableAsyncDNS = 0;
+int net_listenqsize = DAEMON_LISTEN_SIZE;
+unsigned int NET_BUFFERSIZE = NET_DEFAULT_BUFFERSIZE;
+unsigned int NET_READ_TIMEOUT = NET_DEFAULT_READ_TIMEOUT;
+unsigned int NET_WRITE_TIMEOUT = NET_DEFAULT_WRITE_TIMEOUT;
+unsigned int SSL_HANDSHAKE_TIMEOUT = SSL_DEFAULT_HANDSHAKE_TIMEOUT;
+
+
+/* ------------------------------ net_init -------------------------------- */
+NSAPI_PUBLIC int net_init(int security_on)
+{
+    return 0;
+}
+
+/* ------------------------------ net_socket ------------------------------ */
+NSAPI_PUBLIC SYS_NETFD net_socket(int domain, int type, int protocol)
+{
+    SYS_NETFD sock;
+    SYS_NETFD prsock;
+
+    if (security_active) {
+      if (protocol == IPPROTO_TCP) 
+         prsock = PR_NewTCPSocket();
+      else 
+         prsock = PR_NewUDPSocket();
+      if(prsock)
+         sock = SSL_ImportFD(NULL, prsock);
+      else sock = NULL;
+    }
+    else {
+      if (protocol == IPPROTO_TCP) sock = PR_NewTCPSocket();
+      else sock = PR_NewUDPSocket();
+    }
+
+    if (sock == NULL)
+        return (SYS_NETFD)SYS_NET_ERRORFD;
+    return sock;
+}
+
+
+/* ---------------------------- net_getsockopt ---------------------------- */
+NSAPI_PUBLIC int net_getsockopt(SYS_NETFD s, int level, int optname,
+                                void *optval, int *optlen)
+{
+    return getsockopt(PR_FileDesc2NativeHandle(s), level, optname,
+                      (char *)optval, (TCPLEN_T *)optlen);
+}
+
+
+/* ---------------------------- net_setsockopt ---------------------------- */
+
+
+NSAPI_PUBLIC int net_setsockopt(SYS_NETFD s, int level, int optname,
+                                const void *optval, int optlen)
+{
+    return setsockopt(PR_FileDesc2NativeHandle(s), level, optname, 
+                      (const char *)optval, optlen);
+}
+/* ------------------------------ net_listen ------------------------------ */
+
+
+NSAPI_PUBLIC int net_listen(SYS_NETFD s, int backlog)
+{
+    return PR_Listen(s, backlog)==PR_FAILURE?IO_ERROR:0;
+}
+
+
+/* ------------------------- net_create_listener -------------------------- */
+
+
+NSAPI_PUBLIC SYS_NETFD net_create_listener(char *ipstr, int port)
+{
+    SYS_NETFD sd;
+    /*
+    struct sockaddr_in sa_server;
+    */
+    PRNetAddr sa_server;
+    PRStatus status;
+    PRInt32 flags;
+
+    if ((sd = net_socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) == SYS_NET_ERRORFD) {
+        return SYS_NET_ERRORFD;
+    }
+
+#ifdef SOLARIS
+    /*
+     * unset NONBLOCK flag; 
+     */
+    /* Have no idea why Solaris want to unset NONBLOCK flag when it should 
+       be in NON-BLOCK mode, and new NSPR20 does not give file descriptor
+       back, so the code are removed --- yjh    
+    flags = fcntl(sd->osfd, F_GETFL, 0);
+    fcntl(sd->osfd, F_SETFL, flags & ~O_NONBLOCK);
+       */
+#endif
+    /* Convert to NSPR21 for ns security integration
+    ZERO((char *) &sa_server, sizeof(sa_server));
+    sa_server.sin_family=AF_INET;
+    sa_server.sin_addr.s_addr = (ipstr ? inet_addr(ipstr) : htonl(INADDR_ANY));
+    sa_server.sin_port=htons(port);
+    if(net_bind(sd, (struct sockaddr *) &sa_server,sizeof(sa_server)) < 0) {
+        return SYS_NET_ERRORFD;
+    }
+    net_listen(sd, net_listenqsize);
+    */
+
+    if (ipstr) {
+      status = PR_InitializeNetAddr(PR_IpAddrNull, port, &sa_server);
+      if (status == PR_SUCCESS) sa_server.inet.ip = inet_addr(ipstr);
+      else return SYS_NET_ERRORFD;
+    }
+    else {
+      status = PR_InitializeNetAddr(PR_IpAddrAny, port, &sa_server);
+      if (status == PR_FAILURE) return SYS_NET_ERRORFD;
+    }
+
+    status = PR_Bind(sd, &sa_server);
+    if (status == PR_FAILURE) return SYS_NET_ERRORFD;
+
+    
+    status = PR_Listen(sd, net_listenqsize);
+    if (status == PR_FAILURE) return SYS_NET_ERRORFD;
+
+    return sd;
+}
+/* ------------------------------ net_select ------------------------------ */
+
+/*
+NSAPI_PUBLIC int net_select(int nfds, fd_set *r, fd_set *w, fd_set *e,
+                            struct timeval *timeout)
+{
+    PR_fd_set rd, wr, ex;
+    int index;
+    int rv;
+
+    if (nfds > (64*1024))
+        return -1;
+
+    PR_FD_ZERO(&rd);
+    PR_FD_ZERO(&wr);
+    PR_FD_ZERO(&ex);
+
+    for (index=0; index<nfds; index++) {
+        if (FD_ISSET(index, r)) 
+            PR_FD_NSET(index, &rd);
+        if (FD_ISSET(index, w)) 
+            PR_FD_NSET(index, &wr);
+        if (FD_ISSET(index, e)) 
+            PR_FD_NSET(index, &ex);
+    }
+
+    rv = PR_Select(0, &rd, &wr, &ex, PR_SecondsToInterval(timeout->tv_sec));
+    if (rv > 0) {
+        FD_ZERO(r);
+        FD_ZERO(w);
+        FD_ZERO(e);
+        for (index=0; index<nfds; index++) {
+            if (PR_FD_NISSET(index, &rd)) 
+                FD_SET(index, r);
+            if (PR_FD_NISSET(index, &wr)) 
+                FD_SET(index, w);
+            if (PR_FD_NISSET(index, &ex)) 
+                FD_SET(index, e);
+        }
+    }
+
+    return rv;
+}
+*/
+
+NSAPI_PUBLIC int net_select(int nfds, fd_set *r, fd_set *w, fd_set *e,
+                            struct timeval *timeout)
+{
+    return 1;
+}
+
+
+/* ----------------------------- net_isalive ------------------------------ */
+
+
+/* 
+ *  XXXmikep As suggested by shaver@ingenia.com.  If everyone was POSIX
+ *  compilent, a write() of 0 bytes would work as well 
+ */
+NSAPI_PUBLIC int net_isalive(SYS_NETFD sd)
+{
+    char c;
+    if (PR_RecvFrom(sd, &c, 1, MSG_PEEK, NULL, 0) == -1 ) {
+      return 0;
+    }
+    return 1;
+}
+
+
+/* ------------------------------ net_connect ------------------------------ */
+
+NSAPI_PUBLIC int net_connect(SYS_NETFD s, const void *sockaddr, int namelen)
+{
+    int rv;
+
+    child_status(CHILD_WRITING);
+    rv = PR_Connect(s, (PRNetAddr *)sockaddr, PR_INTERVAL_NO_TIMEOUT);
+    child_status(CHILD_PROCESSING);
+
+    return rv==PR_FAILURE?IO_ERROR:0;
+}
+
+
+/* ------------------------------ net_ioctl ------------------------------ */
+
+
+NSAPI_PUBLIC int net_ioctl(SYS_NETFD s, int tag, void *result)
+{
+#if defined(NET_WINSOCK)
+    return ioctlsocket(PR_FileDesc2NativeHandle(s),tag,(unsigned long *)result);
+#elif defined(XP_UNIX)
+    return ioctl(PR_FileDesc2NativeHandle(s), tag, result);
+#else
+    write me;
+#endif
+
+}
+/* --------------------------- net_getpeername ---------------------------- */
+
+
+NSAPI_PUBLIC int net_getpeername(SYS_NETFD s, struct sockaddr *name,
+                                 int *namelen)
+{
+#if defined (SNI) || defined (UnixWare)
+    return getpeername(PR_FileDesc2NativeHandle(s), name, (size_t *)namelen);
+#else /* defined (SNI) || defined (UnixWare) */
+    return getpeername(PR_FileDesc2NativeHandle(s), name, (TCPLEN_T *)namelen);
+#endif /* defined (SNI) || defined (UnixWare) */
+}
+
+
+/* ------------------------------ net_close ------------------------------- */
+
+
+NSAPI_PUBLIC int net_close(SYS_NETFD s)
+{
+    return PR_Close(s)==PR_FAILURE?IO_ERROR:0;
+}
+
+NSAPI_PUBLIC int net_shutdown(SYS_NETFD s, int how)
+{
+  switch (how) {
+  case 0:
+    return PR_Shutdown(s, PR_SHUTDOWN_RCV);
+    break;
+  case 1:
+    return PR_Shutdown(s, PR_SHUTDOWN_SEND);
+    break;
+  case 2:
+    return PR_Shutdown(s, PR_SHUTDOWN_BOTH);
+    break;
+  default:
+    return -1;
+  }
+
+  return 0;
+}
+
+
+
+/* ------------------------------- net_bind ------------------------------- */
+
+NSAPI_PUBLIC int net_bind(SYS_NETFD s, const struct sockaddr *name,
+                          int namelen)
+{
+    return PR_Bind(s, (const PRNetAddr *)name)==PR_FAILURE?IO_ERROR:0;
+}
+
+
+/* ------------------------------ net_accept ------------------------------ */
+
+
+NSAPI_PUBLIC SYS_NETFD net_accept(SYS_NETFD  sd, struct sockaddr *addr,
+    int *addrlen)
+{
+    SYS_NETFD sock = PR_Accept(sd, (PRNetAddr *)addr, PR_INTERVAL_NO_TIMEOUT);
+
+    if (sock == NULL)
+        return SYS_NET_ERRORFD;
+    return sock;
+}
+
+/* ------------------------------- net_read ------------------------------- */
+
+NSAPI_PUBLIC int net_read(SYS_NETFD fd, char *buf, int sz, int timeout)
+{
+    int rv;
+
+    if (timeout == NET_ZERO_TIMEOUT)
+        timeout = PR_INTERVAL_NO_WAIT;
+    else if (timeout == NET_INFINITE_TIMEOUT)
+        timeout = PR_INTERVAL_NO_TIMEOUT;
+    else
+        timeout = PR_SecondsToInterval(timeout);
+
+    child_status(CHILD_READING);
+    rv = PR_Recv(fd, buf, sz, 0, timeout);
+
+    child_status(CHILD_PROCESSING);
+    return rv;
+}
+
+
+/* ------------------------------ net_write ------------------------------- */
+
+#ifndef NEEDS_WRITEV
+int net_writev(SYS_NETFD fd, struct iovec *iov, int iov_size)
+{
+    int rv;
+
+    child_status(CHILD_WRITING);
+    rv  = PR_Writev(fd, (PRIOVec *)iov, iov_size, PR_INTERVAL_NO_TIMEOUT);
+    child_status(CHILD_PROCESSING);
+    return rv;
+}
+
+#else /* NEEDS_WRITEV */
+
+/* Since SSL and NT do not support writev(), we just emulate it.
+ * This does not lead to the optimal number of packets going out...
+ */
+int net_writev(SYS_NETFD fd, struct iovec *iov, int iov_size)
+{
+    int index;
+
+    child_status(CHILD_WRITING);
+
+    for (index=0; index<iov_size; index++) {
+
+        /* net_write already does the buffer for nonblocked IO */
+        if ( net_write(fd, iov[index].iov_base, iov[index].iov_len) ==IO_ERROR){
+            child_status(CHILD_PROCESSING);
+            return IO_ERROR;
+        }
+    }
+
+    child_status(CHILD_PROCESSING);
+    return IO_OKAY;
+}
+#endif /* NEEDS_WRITEV */
+
+
+NSAPI_PUBLIC int net_write(SYS_NETFD fd, char *buf, int sz)
+{
+    int rv;
+
+    child_status(CHILD_WRITING);
+    rv = PR_Send(fd, buf, sz, 0, PR_INTERVAL_NO_TIMEOUT);
+    child_status(CHILD_PROCESSING);
+    if(rv < 0) {
+        return IO_ERROR;
+    }
+    return rv;
+}
+
+NSAPI_PUBLIC int net_socketpair(SYS_NETFD *pair)
+{
+    return PR_NewTCPSocketPair(pair);
+}
+
+#ifdef XP_UNIX
+NSAPI_PUBLIC SYS_NETFD net_dup2(SYS_NETFD prfd, int osfd)
+{
+    SYS_NETFD newfd = NULL;
+
+    if (prfd && PR_FileDesc2NativeHandle(prfd) != osfd) {
+        if (dup2(PR_FileDesc2NativeHandle(prfd), osfd) != -1) {
+            newfd = PR_ImportFile(osfd);
+            if (!newfd)
+                close(osfd);
+        }
+    }
+
+    return newfd;
+}
+
+NSAPI_PUBLIC int net_is_STDOUT(SYS_NETFD prfd)
+{
+  int fd = PR_FileDesc2NativeHandle(prfd);
+  if (fd == STDOUT_FILENO) return 1;
+  return 0;
+}
+
+NSAPI_PUBLIC int net_is_STDIN(SYS_NETFD prfd)
+{
+  int fd = PR_FileDesc2NativeHandle(prfd);
+  if (fd == STDIN_FILENO) return 1;
+  return 0;
+}
+
+#endif /* XP_UNIX */
+
+/* -------------------------- Accept mutex crap --------------------------- */
+
+
+#ifndef NET_WINSOCK
+
+
+#include "sem.h"
+static SEMAPHORE mob_sem;
+static int have_mob_sem;
+
+
+void net_accept_enter(void)
+{
+    if(sem_grab(mob_sem) == -1)
+        ereport(LOG_CATASTROPHE, "sem_grab failed (%s)", system_errmsg());
+    have_mob_sem = 1;
+}
+
+int net_accept_tenter(void)
+{
+    int ret = sem_tgrab(mob_sem);
+    if(ret != -1)
+        have_mob_sem = 1;
+    return ret;
+}
+
+void net_accept_exit(void)
+{
+    if(sem_release(mob_sem) == -1)
+        ereport(LOG_CATASTROPHE, "sem_release failed (%s)", system_errmsg());
+    have_mob_sem = 0;
+}
+
+#ifdef AIX
+#undef accept
+#define accept naccept
+#endif
+
+void net_accept_texit(void)
+{
+    if(have_mob_sem && (sem_release(mob_sem) == -1))
+        ereport(LOG_CATASTROPHE, "sem_release failed (%s)", system_errmsg());
+    have_mob_sem = 0;
+}
+
+int net_accept_init(int port)
+{
+  /* XXXMB how to translate this to nspr? */
+  /* since SSL_AcceptHook is no longer in ns security (HCL_1_5), 
+     so this is gone! (It does exist in HCL_101)
+  SSL_AcceptHook((SSLAcceptFunc)PR_Accept);
+  */
+  have_mob_sem = 0;
+  mob_sem = sem_init("netsite", port);
+  return (mob_sem == SEM_ERROR ? -1 : 0);
+}
+
+void net_accept_terminate(void)
+{
+    sem_terminate(mob_sem);
+}
+
+#endif  /* !NET_WINSOCK */
+
+
+/* ----------------------------- net_ip2host ------------------------------ */
+
+
+char *dns_ip2host(char *ip, int verify);
+
+NSAPI_PUBLIC char *net_ip2host(char *ip, int verify)
+{
+    if(!net_enabledns)
+        return NULL;
+
+    return dns_ip2host(ip, verify);
+}
+
+
+
+/* ---------------------------- util_hostname ----------------------------- */
+
+
+
+#ifdef XP_UNIX
+#include <sys/param.h>
+#else /* WIN32 */
+#define MAXHOSTNAMELEN 255
+#endif /* XP_UNIX */
+
+/* Defined in dns.c */
+char *net_find_fqdn(PRHostEnt *p);
+
+NSAPI_PUBLIC char *util_hostname(void)
+{
+    char str[MAXHOSTNAMELEN];
+    PRHostEnt   hent;
+    char        buf[PR_NETDB_BUF_SIZE];
+    PRStatus    err;
+
+    gethostname(str, MAXHOSTNAMELEN);
+    err = PR_GetHostByName(
+                str,
+                buf,
+                PR_NETDB_BUF_SIZE,
+                &hent);
+
+    if (err == PR_FAILURE) 
+        return NULL;
+    return net_find_fqdn(&hent);
+}
+
+
diff --git a/lib/base/nscperror.c b/lib/base/nscperror.c
new file mode 100644
index 00000000..9d791f89
--- /dev/null
+++ b/lib/base/nscperror.c
@@ -0,0 +1,162 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/* nscperrors.c
+ * Very crude error handling for nspr and libsec.
+ */
+
+#include "netsite.h"
+
+#define NSCP_NSPR_ERROR_BASE		(-6000)
+#define NSCP_NSPR_MAX_ERROR             (NSCP_NSPR_ERROR_BASE + 29)
+#define NSCP_LIBSEC_ERROR_BASE 		(-8192)
+#define NSCP_LIBSEC_MAX_ERROR           (NSCP_LIBSEC_ERROR_BASE + 63)
+#define NSCP_LIBSSL_ERROR_BASE 		(-12288)
+#define NSCP_LIBSSL_MAX_ERROR           (NSCP_LIBSSL_ERROR_BASE + 19)
+
+typedef struct nscp_error_t {
+    int errorNumber;
+    const char *errorString;
+} nscp_error_t;
+
+nscp_error_t nscp_nspr_errors[]  =  {
+    {  0, "NSPR error" },
+    {  1, "Out of memory" },
+    {  2, "Bad file descriptor" },
+    {  3, "Data temporarily not available" },
+    {  4, "Access fault" },
+    {  5, "Invalid method" },
+    {  6, "Illegal access" },
+    {  7, "Unknown error" },
+    {  8, "Pending interrupt" },
+    {  9, "Not implemented" },
+    { 10, "IO error" },
+    { 11, "IO timeout error" },
+    { 12, "IO already pending error" },
+    { 13, "Directory open error" },
+    { 14, "Invalid Argument" },
+    { 15, "Address not available" },
+    { 16, "Address not supported" },
+    { 17, "Already connected" },
+    { 18, "Bad address" },
+    { 19, "Address already in use" },
+    { 20, "Connection refused" },
+    { 21, "Network unreachable" },
+    { 22, "Connection timed out" },
+    { 23, "Not connected" },
+    { 24, "Load library error" },
+    { 25, "Unload library error" },
+    { 26, "Find symbol error" },
+    { 27, "Connection reset by peer" },
+    { 28, "Range Error" },
+    { 29, "File Not Found Error" }
+};
+
+nscp_error_t nscp_libsec_errors[] = {
+    {  0, "SEC_ERROR_IO" },
+    {  1, "SEC_ERROR_LIBRARY_FAILURE" },
+    {  2, "SEC_ERROR_BAD_DATA" },
+    {  3, "SEC_ERROR_OUTPUT_LEN" },
+    {  4, "SEC_ERROR_INPUT_LEN" },
+    {  5, "SEC_ERROR_INVALID_ARGS" },
+    {  6, "SEC_ERROR_INVALID_ALGORITHM" },
+    {  7, "SEC_ERROR_INVALID_AVA" },
+    {  8, "SEC_ERROR_INVALID_TIME" },
+    {  9, "SEC_ERROR_BAD_DER" },
+    { 10, "SEC_ERROR_BAD_SIGNATURE" },
+    { 11, "SEC_ERROR_EXPIRED_CERTIFICATE" },
+    { 12, "SEC_ERROR_REVOKED_CERTIFICATE" },
+    { 13, "SEC_ERROR_UNKNOWN_ISSUER" },
+    { 14, "SEC_ERROR_BAD_KEY" },
+    { 15, "SEC_ERROR_BAD_PASSWORD" },
+    { 16, "SEC_ERROR_UNUSED" },
+    { 17, "SEC_ERROR_NO_NODELOCK" },
+    { 18, "SEC_ERROR_BAD_DATABASE" },
+    { 19, "SEC_ERROR_NO_MEMORY" },
+    { 20, "SEC_ERROR_UNTRUSTED_ISSUER" },
+    { 21, "SEC_ERROR_UNTRUSTED_CERT" },
+    { 22, "SEC_ERROR_DUPLICATE_CERT" },
+    { 23, "SEC_ERROR_DUPLICATE_CERT_TIME" },
+    { 24, "SEC_ERROR_ADDING_CERT" },
+    { 25, "SEC_ERROR_FILING_KEY" },
+    { 26, "SEC_ERROR_NO_KEY" },
+    { 27, "SEC_ERROR_CERT_VALID" },
+    { 28, "SEC_ERROR_CERT_NOT_VALID" },
+    { 29, "SEC_ERROR_CERT_NO_RESPONSE" },
+    { 30, "SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE" },
+    { 31, "SEC_ERROR_CRL_EXPIRED" },
+    { 32, "SEC_ERROR_CRL_BAD_SIGNATURE" },
+    { 33, "SEC_ERROR_CRL_INVALID" },
+    { 34, "SEC_ERROR_" },
+    { 35, "SEC_ERROR_" },
+    { 36, "SEC_ERROR_" },
+    { 37, "SEC_ERROR_" },
+    { 38, "SEC_ERROR_" },
+    { 39, "SEC_ERROR_" },
+    { 40, "SEC_ERROR_" },
+    { 41, "SEC_ERROR_" },
+    { 42, "SEC_ERROR_" },
+    { 43, "SEC_ERROR_" },
+    { 44, "SEC_ERROR_" },
+    { 45, "SEC_ERROR_" },
+    { 46, "SEC_ERROR_" },
+    { 47, "SEC_ERROR_" },
+    { 48, "SEC_ERROR_" },
+    { 49, "SEC_ERROR_" },
+    { 50, "SEC_ERROR_" },
+    { 51, "SEC_ERROR_" },
+    { 52, "SEC_ERROR_" },
+    { 53, "SEC_ERROR_" },
+    { 54, "SEC_ERROR_" },
+    { 55, "SEC_ERROR_" },
+    { 56, "SEC_ERROR_" },
+    { 57, "SEC_ERROR_" },
+    { 58, "SEC_ERROR_" },
+    { 59, "SEC_ERROR_" },
+    { 60, "SEC_ERROR_" },
+    { 61, "SEC_ERROR_" },
+    { 62, "SEC_ERROR_" },
+    { 63, "SEC_ERROR_NEED_RANDOM" }
+};
+
+nscp_error_t nscp_libssl_errors[] = {
+    {  0, "SSL_ERROR_EXPORT_ONLY_SERVER" },
+    {  1, "SSL_ERROR_US_ONLY_SERVER" },
+    {  2, "SSL_ERROR_NO_CYPHER_OVERLAP" },
+    {  3, "SSL_ERROR_NO_CERTIFICATE" },
+    {  4, "SSL_ERROR_BAD_CERTIFICATE" },
+    {  5, "unused SSL error #5" },
+    {  6, "SSL_ERROR_BAD_CLIENT - the server has encountered bad data from the client." },
+    {  7, "SSL_ERROR_BAD_SERVER" },
+    {  8, "SSL_ERROR_UNSUPPORTED_CERTIFICATE_TYPE" },
+    {  9, "SSL_ERROR_UNSUPPORTED_VERSION" },
+    { 10, "unused SSL error #10" },
+    { 11, "SSL_ERROR_WRONG_CERTIFICATE" },
+    { 12, "SSL_ERROR_BAD_CERT_DOMAIN" },
+    { 13, "SSL_ERROR_POST_WARNING" },
+    { 14, "SSL_ERROR_SSL2_DISABLED" },
+    { 15, "SSL_ERROR_BAD_MAC_READ - SSL has received a record with an incorrect Message Authentication Code." },
+    { 16, "SSL_ERROR_BAD_MAC_ALERT - SSL has received an error indicating an incorrect Message Authentication Code." },
+    { 17, "SSL_ERROR_BAD_CERT_ALERT - the server cannot verify your certificate." },
+    { 18, "SSL_ERROR_REVOKED_CERT_ALERT - the server has rejected your certificate as revoked." },
+    { 19, "SSL_ERROR_EXPIRED_CERT_ALERT - the server has rejected your certificate as expired." },
+};
+
+const char *
+nscperror_lookup(int error)
+{
+    if ((error >= NSCP_NSPR_ERROR_BASE) && 
+        (error <= NSCP_NSPR_MAX_ERROR)) {
+        return nscp_nspr_errors[error-NSCP_NSPR_ERROR_BASE].errorString;
+    } else if ((error >= NSCP_LIBSEC_ERROR_BASE) &&
+        (error <= NSCP_LIBSEC_MAX_ERROR)) {
+        return nscp_libsec_errors[error-NSCP_LIBSEC_ERROR_BASE].errorString;
+    } else if ((error >= NSCP_LIBSSL_ERROR_BASE) &&
+        (error <= NSCP_LIBSSL_MAX_ERROR)) {
+        return nscp_libssl_errors[error-NSCP_LIBSSL_ERROR_BASE].errorString;
+    } else {
+        return (const char *)NULL;
+    }
+}
diff --git a/lib/base/nterrors.cpp b/lib/base/nterrors.cpp
new file mode 100644
index 00000000..2eaf29b3
--- /dev/null
+++ b/lib/base/nterrors.cpp
@@ -0,0 +1,83 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * nterrors.c: Conversion of error numbers to explanation strings
+ * 
+ * Aruna Victor 12/6/95
+ */
+
+
+#include <windows.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <netsite.h>
+#include <base/nterrors.h>

+#include <base/nterr.h>
+
+struct _NtHashedError {
+	int ErrorNumber;
+	char *ErrorString;
+	struct _NtHashedError *next;
+} ;
+
+typedef struct _NtHashedError NtHashedError;
+
+NtHashedError *hashedNtErrors[200];
+
+#define HASH_ERROR_MODULUS 199
+#define DEFAULT_ERROR_STRING "Error Number is unknown"
+
+char *
+FindError(int error)
+{
+    NtHashedError *tmp;
+
+    int hashValue = error % HASH_ERROR_MODULUS;
+    tmp = hashedNtErrors[hashValue];
+
+    while(tmp) {
+        if (tmp->ErrorNumber == error) {
+            return tmp->ErrorString;
+        }
+        tmp = tmp->next;
+    }
+    return(DEFAULT_ERROR_STRING);
+}
+
+void
+EnterError(NtHashedError *error)
+{
+    NtHashedError *tmp;
+    int hashValue;
+    int number = 199;
+
+    hashValue = error->ErrorNumber % HASH_ERROR_MODULUS;
+
+     if(!(tmp = hashedNtErrors[hashValue])){
+        hashedNtErrors[hashValue] = error;
+     } else {
+        while(tmp->next) {
+            tmp = tmp->next;
+        }
+        tmp->next = error;
+    }
+}
+

+void
+HashNtErrors()
+{
+    NtHashedError *error;
+    int i = 0;
+    
+    while(NtErrorStrings[i].ErrorString) {
+        error = (NtHashedError *)MALLOC(sizeof(NtHashedError));
+        error->ErrorNumber = NtErrorStrings[i].ErrorNumber;
+        error->ErrorString = NtErrorStrings[i++].ErrorString;
+        error->next = NULL;
+        EnterError(error);
+    }
+}
\ No newline at end of file
diff --git a/lib/base/plist.cpp b/lib/base/plist.cpp
new file mode 100644
index 00000000..fe9d909e
--- /dev/null
+++ b/lib/base/plist.cpp
@@ -0,0 +1,1154 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * MODULE:      plist.c
+ *
+ * DESCRIPTION:
+ *
+ *      This module implements property lists.  A property list is an
+ *      ordered array of property values.  Each property value has an
+ *      handle for some data item, and may have a reference to
+ *      another property list which describes the type of the data
+ *      item.  Each property value has a property index which specifies
+ *      its position in the property list.  A property value may also
+ *      have a name.  Since the data item associated with a property
+ *      value may reference another property list, it is possible to
+ *      construct arbitrary linked structures of property lists.
+ *
+ * IMPLEMENTATION NOTES:
+ */
+
+#include "netsite.h"
+#include "base/plist.h"
+#include "plist_pvt.h"
+
+int plistHashSizes[] = PLSTSIZES;
+
+/*
+ * FUNCTION:    PListAssignValue
+ *
+ * DESCRIPTION:
+ *
+ *      This function sets the value and/or type of a defined property
+ *      in given property list.  If the property type is specified as
+ *      NULL, it is unchanged.  However, the property value is always
+ *      set to the specified value.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pname                   - the property name
+ *      pvalue                  - the new property value
+ *      ptype                   - the new property type, or NULL
+ *
+ * RETURNS:
+ *
+ *      If successful, the property index of the referenced property is
+ *      returned as the function value.  Errors are indicated by a
+ *      negative return code as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListAssignValue(PList_t plist, const char *pname,
+                 const void *pvalue, PList_t ptype)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t *pv;
+    int pindex;
+    int i;
+
+    if (!plist) return ERRPLUNDEF;
+
+    /* Got a symbol table for this property list? */
+    if (pl->pl_symtab) {
+
+        /* Yes, compute hash of specified name */
+        i = PListHashName(pl->pl_symtab, pname);
+
+        /* Search hash collision list for matching name */
+        for (pv = pl->pl_symtab->pt_hash[i]; pv; pv = pv->pv_next) {
+
+            if (!strcmp(pname, pv->pv_name)) {
+
+                /* Name match, get property index */
+                pindex = pv->pv_pi;
+
+                /* Set the new value */
+                pv->pv_value = (char *)pvalue;
+
+                /* Set type if type is given */
+                if (ptype) pv->pv_type = (PListStruct_t *)ptype;
+
+                /* Return the property index */
+                return pindex;
+            }
+        }
+    }
+
+    /* Error - specified property name is undefined */
+    return ERRPLUNDEF;
+}
+
+/*
+ * FUNCTION:    PListCreate
+ *
+ * DESCRIPTION:
+ *
+ *      This function creates a new property list and returns a handle for
+ *      it.  It allows the caller to reserve a specified number of
+ *      property indices at the beginning of the list, and also to limit
+ *      the total number of property values that may be added to the list.
+ *
+ * ARGUMENTS:
+ *
+ *      mempool                 - handle for a memory pool to be associated
+ *                                with the new property list
+ *      resvprop                - number of reserved property indices
+ *      maxprop                 - maximum number of properties in list
+ *                                (zero or negative imposes no limit)
+ *      flags                   - unused, reserved, must be zero
+ *
+ * RETURNS:
+ *
+ *      If successful, the function return value is a handle for the new
+ *      property list.  Otherwise NULL is returned.
+ */
+
+NSAPI_PUBLIC PList_t
+PListCreate(pool_handle_t *mempool, int resvprop, int maxprop, int flags)
+{
+    PListStruct_t *plist;       /* pointer to property list structure */
+    int i;
+
+    plist = (PListStruct_t *)pool_malloc(mempool, sizeof(PListStruct_t));
+    if (plist) {
+
+        /* Negative maxprop is the same as zero, i.e. no limit */
+        if (maxprop < 0) maxprop = 0;
+
+        /* If resvprop and maxprop are both specified, limit resvprop */
+        if (resvprop > 0) {
+            if (maxprop && (resvprop > maxprop)) resvprop = maxprop;
+        }
+        else resvprop = 0;
+
+        /* Initialize property list structure */
+        plist->pl_mempool = mempool;
+        plist->pl_symtab = NULL;
+        plist->pl_maxprop = maxprop;
+        plist->pl_resvpi = resvprop;
+        plist->pl_initpi = resvprop;
+        plist->pl_lastpi = resvprop;
+
+        /* Set initialize size for array of property value pointers */
+        plist->pl_cursize = (resvprop) ? resvprop : PLIST_DEFSIZE;
+
+        /* Allocate the initial array of property value pointers */
+        plist->pl_ppval = (pb_entry **)pool_malloc(mempool,
+                                   	           (plist->pl_cursize *
+                                                    sizeof(PLValueStruct_t *)));
+        if (!plist->pl_ppval) {
+
+            /* Failed - insufficient memory */
+            pool_free(mempool, (void *)plist);
+            plist = NULL;
+        }
+        else {
+            /* NULL out pointers in the reserved index range, if any */
+            for (i = 0; i < plist->pl_lastpi; ++i) {
+                plist->pl_ppval[i] = 0;
+            }
+        }
+    }
+
+    return (PList_t)plist;
+}
+
+/*
+ * FUNCTION:    PListDefProp
+ *
+ * DESCRIPTION:
+ *
+ *      This function creates a new property in a specified property list.
+ *      The 'pindex' argument may be used to request a particular property
+ *      index for the new property.  If 'pindex' is greater than zero,
+ *      the specified value is used as the new property's index, provided
+ *      there is no property at that index already.  If 'pindex' is zero,
+ *      then the next available property index is assigned to the new
+ *      property.  A name may optionally be specified for the new property.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - new property index (or zero)
+ *      pname                   - new property name (or NULL)
+ *
+ * RETURNS:
+ *
+ *      If successful, the index of the new property is returned as the
+ *      function value.  Errors are indicated by a negative return code
+ *      as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListDefProp(PList_t plist, int pindex, const char *pname, const int flags)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+    int cursize;
+    int i;
+    int wrapped;
+
+    if (!plist) return ERRPLUNDEF;
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Is pindex specified? */
+    if (pindex > 0) {
+
+        /* Yes, is it in the reserved range? */
+        if (flags != PLFLG_IGN_RES && pindex > pl->pl_resvpi) {
+            /* No, error */
+            return ERRPLINVPI;
+        }
+
+        i = pindex - 1;
+
+        if (ppval[i]) {
+            /* Error - property already exists at specified index */
+            return ERRPLEXIST;
+        }
+    }
+    else {
+
+        /*
+         * Look for a free property index, starting at pl_lastpi + 1.
+         * (Note that i is the property index - 1)
+         */
+        for (wrapped = 0, i = pl->pl_lastpi; ;) {
+
+            /* Are we in an initialized part of the array? */
+            if (i < pl->pl_initpi) {
+
+                /* Yes, use this index if it's free */
+                if (ppval[i] == 0) break;
+
+                /* Otherwise step to the next one */
+                ++i;
+            }
+            else {
+
+                /* Have we reached the end yet? */
+                if (i < pl->pl_cursize) {
+
+                    /*
+                     * We are above the highest initialized index, but
+                     * still within the allocated size.  An index in
+                     * this range can be used with no further checks.
+                     */
+                    ppval[i] = 0;
+                }
+                else {
+
+                    /*
+                     * It's looking like time to grow the array, but
+                     * first go back and look for an unused, unreserved
+                     * index that might have been freed.
+                     */
+                    if (!wrapped) {
+
+                        i = pl->pl_resvpi;
+                        wrapped = 1;
+                        continue;
+                    }
+
+                    /*
+                     * Grow the array unless there is a specified maximum
+                     * size and we've reached it.
+                     */
+                    i = pl->pl_cursize;
+                    if (pl->pl_maxprop && (i > pl->pl_maxprop)) {
+
+                        /* Error - property list is full */
+                        return ERRPLFULL;
+                    }
+
+                    /* Increase planned size of list */
+                    cursize = i + PLIST_DEFGROW;
+
+                    /* Reallocate the array of property value pointers */
+                    ppval = (PLValueStruct_t **)pool_realloc(pl->pl_mempool,
+                                   (void *)ppval,
+                                   (cursize * sizeof(PLValueStruct_t *)));
+                    if (!ppval) {
+
+                        /* Error - insufficient memory */
+                        return ERRPLNOMEM;
+                    }
+
+                    /* Initialize the first new entry and select it */
+                    ppval[i] = NULL;
+                    pl->pl_ppval = (pb_entry **)ppval;
+                    pl->pl_cursize = cursize;
+                }
+
+                /* Update the highest initialized index value */
+                pl->pl_initpi = i + 1;
+                break;
+            }
+        }
+
+        /* Set the starting point for the next allocation */
+        pl->pl_lastpi = i + 1;
+    }
+
+    /* We have a property index (i + 1).  Create a new property value */
+    pv = (PLValueStruct_t *)pool_calloc(pl->pl_mempool,
+                                        1, sizeof(PLValueStruct_t));
+    if (!pv) {
+
+        /* Error - insufficient memory */
+        return ERRPLNOMEM;
+    }
+
+    pv->pv_pbentry.param = &pv->pv_pbparam;
+    pv->pv_pi = i + 1;
+    ppval[i] = pv;
+
+    /* Name the property if the name was specified */
+    if (pname) {
+
+        /* XXX Maybe should delete property if naming fails */
+        return PListNameProp(plist, i + 1, pname);
+    }
+
+    /* Return the property index of the new property */
+    return i + 1;
+}
+
+/*
+ * FUNCTION:    PListDeleteProp
+ *
+ * DESCRIPTION:
+ *
+ *      This function deletes a property from a specified property list.
+ *      The property can be specified by its property index, using a
+ *      pindex value greater than zero, or by its name, by specifying
+ *      pindex as zero and pname as the property name.  This does not
+ *      have any effect on the data referenced by the property value,
+ *      if any, nor does it have any effect on the property list that
+ *      describes the property value's type, if any.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - the property index, or zero
+ *      pname                   - the property name, or NULL
+ */
+
+NSAPI_PUBLIC const void *
+PListDeleteProp(PList_t plist, int pindex, const char *pname_in)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t **pvp;
+    PLValueStruct_t *pv = NULL;
+    int i;
+    const void *pvalue = NULL;
+    char *pname = (char *)pname_in;
+
+    if (!plist) return NULL;
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Check for valid property index */
+    if ((pindex > 0) && (pindex <= pl->pl_initpi)) {
+
+        /* Get the pointer to the property structure */
+        pv = ppval[pindex - 1];
+	pname = 0;
+	if (pv) {
+	    pname = pv->pv_name;
+	}
+    }
+
+    if (pname && pl->pl_symtab) {
+
+        /* Compute hash of specified property name */
+        i = PListHashName(pl->pl_symtab, pname);
+
+        /* Search hash collision list for matching name */
+        for (pvp = &pl->pl_symtab->pt_hash[i]; *pvp; pvp = &(*pvp)->pv_next) {
+
+            pv = *pvp;
+            if (!strcmp(pname, pv->pv_name)) {
+
+                /* Found it.  Get its index and remove it. */
+                pindex = pv->pv_pi;
+                *pvp = pv->pv_next;
+                break;
+            }
+        }
+    }
+
+    /* Found the indicated property by index or name? */
+    if (pv) {
+
+        /* Yes, remove it from the property list */
+        ppval[pindex - 1] = NULL;
+
+        /* Free the property name, if any */
+        if (pv->pv_name) {
+            pool_free(pl->pl_mempool, (void *)(pv->pv_name));
+        }
+        pvalue = pv->pv_value;
+
+        /* Free the property */
+        pool_free(pl->pl_mempool, (void *)pv);
+    }
+    return(pvalue);
+}
+
+/*
+ * FUNCTION:    PListFindValue
+ *
+ * DESCRIPTION:
+ *
+ *      This function retrieves the value and type of a property with a
+ *      specified property name.  If the pvalue argument is non-NULL,
+ *      it specifies a location in which to return the property value.
+ *      Similarly, if ptype is non-NULL, it specifies where the property
+ *      list describing the property type is to be returned.  If a
+ *      property has no value, the value returned for pvalue is NULL.
+ *      If a property has no type, the value returned for ptype is NULL.
+ *      A property can have a value, a type, both, or neither.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pname                   - pointer to property name string
+ *      pvalue                  - property value return pointer
+ *      ptype                   - property type return pointer
+ *
+ * RETURNS:
+ *
+ *      If successful, the index of the referenced property is returned
+ *      as the function value.  Errors are indicated by a negative
+ *      return code as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListFindValue(PList_t plist, const char *pname, void **pvalue, PList_t *ptype)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t *pv;
+    int pindex;
+    int i;
+
+    if (!plist) return ERRPLUNDEF;
+
+    /* Got a symbol table for this property list? */
+    if (pl->pl_symtab) {
+
+        /* Yes, compute hash of specified name */
+        i = PListHashName(pl->pl_symtab, pname);
+
+        /* Search hash collision list for matching name */
+        for (pv = pl->pl_symtab->pt_hash[i]; pv; pv = pv->pv_next) {
+
+            if (!strcmp(pname, pv->pv_name)) {
+
+                /* Name match, get property index */
+                pindex = pv->pv_pi;
+
+                /* Return the value if requested */
+                if (pvalue) *pvalue = (void *)(pv->pv_value);
+
+                /* Return the type if requested */
+                if (ptype) *ptype = (PList_t)(pv->pv_type);
+
+                /* Return the property index */
+                return pindex;
+            }
+        }
+    }
+
+    /* Error - specified property name is undefined */
+    return ERRPLUNDEF;
+}
+
+/*
+ * FUNCTION:    PListInitProp
+ *
+ * DESCRIPTION:
+ *
+ *      This function combines the functions of PListDefProp() and
+ *      PListSetValue(), defining a new property and assigning it an
+ *      initial value and optionally a type and/or a name.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - a reserved property index, or zero
+ *      pname                   - the new property name, or NULL
+ *      pvalue                  - the new property value
+ *      ptype                   - the new property type, or NULL
+ *
+ * RETURNS:
+ *
+ *      If successful, the property index (pindex) is returned as the
+ *      function value.  Errors are indicated by a negative return code
+ *      as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListInitProp(PList_t plist, int pindex, const char *pname,
+              const void *pvalue, PList_t ptype)
+{
+    int rv;
+
+    if (!plist) return ERRPLUNDEF;
+
+    /* Create the property */
+    rv = PListDefProp(plist, pindex, pname, PLFLG_USE_RES);
+    if (rv > 0) {
+
+        /* If that worked, set the value and type */
+        rv = PListSetValue(plist, rv, pvalue, ptype);
+    }
+
+    return rv;
+}
+
+/*
+ * FUNCTION:    PListNew
+ *
+ * DESCRIPTION:
+ *
+ *      This function creates a new property list, using the specified
+ *      memory pool for allocating the internal data structures used to
+ *      represent it.  If the mempool argument is NULL, the default
+ *      memory pool is used.
+ *
+ * ARGUMENTS:
+ *
+ *      mempool                 - handle for a memory pool to be associated
+ *                                with the new property list
+ *
+ * RETURNS:
+ *
+ *      If successful, the function return value is a handle for the new
+ *      property list.  Otherwise NULL is returned.
+ */
+
+NSAPI_PUBLIC PList_t
+PListNew(pool_handle_t *mempool)
+{
+    /* Just call PListCreate with default parameters */
+    return PListCreate(mempool, 0, 0, 0);
+}
+
+/*
+ * FUNCTION:    PListDestroy
+ *
+ * DESCRIPTION:
+ *
+ *      This function destroys a specified property list.  This means
+ *      that any dynamic memory which was allocated as a result of calls
+ *      to the property list API is freed to the memory pool from which
+ *      it was allocated.  Property value data is not freed, nor are
+ *      any property lists associated with property types.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ */
+
+void
+PListDestroy(PList_t plist)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+    int i;
+
+    if (!plist) return;
+
+    /* Free the property name symbol table if any */
+    if (pl->pl_symtab) {
+        pool_free(pl->pl_mempool, (void *)(pl->pl_symtab));
+    }
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Loop over the initialized property indices */
+    for (i = 0; i < pl->pl_initpi; ++i) {
+
+        /* Got a property here? */
+        pv = ppval[i];
+        if (pv) {
+
+            /* Free the property name string if any */
+            if (pv->pv_name) {
+                pool_free(pl->pl_mempool, (void *)(pv->pv_name));
+            }
+
+            /* Free the property value structure */
+            pool_free(pl->pl_mempool, (void *)pv);
+        }
+    }
+
+    /* Free the array of pointers to property values */
+    pool_free(pl->pl_mempool, (void *)ppval);
+
+    /* Free the property list head */
+    pool_free(pl->pl_mempool, (void *)pl);
+}
+
+/*
+ * FUNCTION:    PListGetValue
+ *
+ * DESCRIPTION:
+ *
+ *      This function retrieves the value and type of the property with
+ *      the property index given by pindex in the specified property
+ *      list.  The pindex argument must specify the index of a defined
+ *      property.  If the pvalue argument is non-NULL, it specifies a
+ *      location in which to return the property value.  Similarly, if
+ *      ptype is non-NULL, it specifies where the property list
+ *      describing the property type is to be returned.  If a property
+ *      has no value, the value returned for pvalue is NULL.  If a
+ *      property has no type, the value returned for ptype is NULL. A
+ *      property can have a value, a type, both, or neither.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - the property index
+ *      pvalue                  - property value return pointer
+ *      ptype                   - property type return pointer
+ *
+ * RETURNS:
+ *
+ *      If successful, the property index (pindex) is returned as the
+ *      function value.  Errors are indicated by a negative return code
+ *      as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListGetValue(PList_t plist, int pindex, void **pvalue, PList_t *ptype)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+
+    if (!plist) return ERRPLUNDEF;
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Check for valid property index */
+    if ((pindex > 0) && (pindex <= pl->pl_initpi)) {
+
+        /* Does the property exist? */
+        pv = ppval[pindex - 1];
+        if (pv) {
+
+            /* Yes, return the value if requested */
+            if (pvalue) *pvalue = (void *)(pv->pv_value);
+
+            /* Return the type if requested */
+            if (ptype) *ptype = (PList_t)(pv->pv_type);
+
+            /* Successful return */
+            return pindex;
+        }
+    }
+
+    /* Error - invalid property index or non-existent property */
+    return ERRPLINVPI;
+}
+
+/*
+ * FUNCTION:    PListHashName
+ *
+ * DESCRIPTION:
+ *
+ *      This function hashes a given property name for a specified
+ *      symbol table.  It produces a value that can be used as an
+ *      index in the pt_hash array associated with the symbol table.
+ *
+ * ARGUMENTS:
+ *
+ *      symtab                  - pointer to the symbol table
+ *      pname                   - pointer to the property name string
+ *
+ * RETURNS:
+ *
+ *      The hash index is returned as the function value.
+ */
+
+int
+PListHashName(PLSymbolTable_t *symtab, const char *pname)
+{
+    unsigned int hashval = 0;           /* hash value */
+
+    while (*pname) {
+        hashval = (hashval<<5) ^ (*pname++ & 0x7f);
+    }
+
+    return hashval % PLSIZENDX(symtab->pt_sizendx);
+}
+
+/*
+ * FUNCTION:    PListNameProp
+ *
+ * DESCRIPTION:
+ *
+ *      This function assigns a name to a defined property with the
+ *      property index, pindex.  If the property has an existing name,
+ *      it will be replaced with the name specified by pname.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - the property index
+ *      pname                   - the new property name
+ *
+ * RETURNS:
+ *
+ *      If successful, the property index (pindex) is returned as the
+ *      function value.  Errors are indicated by a negative return code
+ *      as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListNameProp(PList_t plist, int pindex, const char *pname)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t *pv;
+    PLSymbolTable_t *pt;
+    int i;
+
+    if (!plist) return ERRPLUNDEF;
+
+    pt = pl->pl_symtab;
+
+    /* Check for valid property index */
+    if ((pindex > 0) && (pindex <= pl->pl_initpi)) {
+
+        /* Does the property exist? */
+        pv = ((PLValueStruct_t **)(pl->pl_ppval))[pindex - 1];
+        if (pv) {
+
+            /* If it has a name already, unname it */
+            if (pv->pv_name) {
+                PLValueStruct_t **pvp;
+
+                /* Get hash bucket index */
+                i = PListHashName(pt, pv->pv_name);
+
+                /* Seach hash collision list for this property */
+                for (pvp = &pt->pt_hash[i];
+                     *pvp; pvp = &(*pvp)->pv_next) {
+
+                    if (*pvp == pv) {
+
+                        /* Remove it from the list */
+                        *pvp = pv->pv_next;
+                        break;
+                    }
+                }
+
+                /* Free the current name string */
+                pool_free(pl->pl_mempool, (void *)(pv->pv_name));
+            }
+
+            /* Got a new name? */
+            if (pname) {
+
+                /* Yes, is there a hash table? */
+                if (!pt) {
+
+                    /* No, create one */
+                    pt = (PLSymbolTable_t *)pool_calloc(pl->pl_mempool, 1,
+                                                        PLHASHSIZE(0));
+                    if (!pt) {
+                        return ERRPLNOMEM;
+                    }
+
+                    pl->pl_symtab = pt;
+                }
+                else {
+
+                    /* Is it time to grow the hash table? */
+                    i = PLSIZENDX(pt->pt_sizendx);
+                    if ((pt->pt_sizendx < PLMAXSIZENDX) &&
+                        pt->pt_nsyms >= (i + i)) {
+
+                        PLSymbolTable_t *npt;
+
+                        /* Yes, allocate the new table */
+                        npt = (PLSymbolTable_t *)pool_calloc(pl->pl_mempool, 1,
+                                              PLHASHSIZE(pt->pt_sizendx+1));
+                        if (npt) {
+                            PLValueStruct_t *opv;
+                            PLValueStruct_t *npv;
+                            int j;
+
+                            npt->pt_sizendx = pt->pt_sizendx + 1;
+                            npt->pt_nsyms = pt->pt_nsyms;
+
+                            /* Rehash all the names into the new table */
+                            for (i = 0; i < PLSIZENDX(pt->pt_sizendx); ++i) {
+                                for (opv = pt->pt_hash[i]; opv; opv = npv) {
+                                    npv = opv->pv_next;
+                                    j = PListHashName(npt, opv->pv_name);
+                                    opv->pv_next = npt->pt_hash[j];
+                                    npt->pt_hash[j] = opv;
+                                }
+                            }
+
+                            pl->pl_symtab = npt;
+
+                            /* Free the old symbol table */
+                            pool_free(pl->pl_mempool, (void *)pt);
+                            pt = npt;
+                        }
+                    }
+                }
+
+                /* Duplicate the name string */
+                pv->pv_name = pool_strdup(pl->pl_mempool, (char *)pname);
+
+                /* Add name to symbol table */
+                i = PListHashName(pt, pname);
+                pv->pv_next = pt->pt_hash[i];
+                pt->pt_hash[i] = pv;
+            }
+
+            /* Successful return */
+            return pindex;
+        }
+    }
+
+    /* Error - invalid property index or non-existent property */
+    return ERRPLINVPI;
+}
+
+/*
+ * FUNCTION:    PListSetType
+ *
+ * DESCRIPTION:
+ *
+ *      This function sets the property type of the defined property
+ *      with the property index, pindex.  The property list describing
+ *      the property type is specified by ptype.  If ptype is NULL,
+ *      the property type will be set to be undefined (NULL).
+ *
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - the property index
+ *      ptype                   - the new property type, or NULL
+ *
+ * RETURNS:
+ *
+ *      If successful, the property index (pindex) is returned as the
+ *      function value.  Errors are indicated by a negative return code
+ *      as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListSetType(PList_t plist, int pindex, PList_t ptype)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+
+    if (!plist) return ERRPLUNDEF;
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Check for valid property index */
+    if ((pindex > 0) && (pindex <= pl->pl_initpi)) {
+
+        /* Does the property exist? */
+        pv = ppval[pindex - 1];
+        if (pv) {
+
+            /* Yes, set the new type */
+            pv->pv_type = ptype;
+
+            /* Successful return */
+            return pindex;
+        }
+    }
+
+    /* Error - invalid property index or non-existent property */
+    return ERRPLINVPI;
+}
+
+/*
+ * FUNCTION:    PListSetValue
+ *
+ * DESCRIPTION:
+ *
+ *      This function sets the value and optionally the type of a
+ *      defined property in a given property list.  The pindex argument
+ *      specifies the property index, which must be greater than zero.
+ *      The ptype argument specifies a property list that describes the
+ *      property type.  If ptype is NULL, the property type, if any, is
+ *      unchanged by this function.  However, the property value is
+ *      always set to the value given by pvalue.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      pindex                  - the property index
+ *      pvalue                  - the new property value
+ *      ptype                   - the new property type, or NULL
+ *
+ * RETURNS:
+ *
+ *      If successful, the property index (pindex) is returned as the
+ *      function value.  Errors are indicated by a negative return code
+ *      as defined in plist.h.
+ */
+
+NSAPI_PUBLIC int
+PListSetValue(PList_t plist, int pindex, const void *pvalue, PList_t ptype)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+
+    if (!plist) return ERRPLUNDEF;
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Check for valid property index */
+    if ((pindex > 0) && (pindex <= pl->pl_initpi)) {
+
+        /* Does the property exist? */
+        pv = ppval[pindex - 1];
+        if (pv) {
+
+            /* Yes, set the new value */
+            pv->pv_value = (char *)pvalue;
+
+            /* Set type if type is given */
+            if (ptype) pv->pv_type = (PListStruct_t *)ptype;
+
+            /* Successful return */
+            return pindex;
+        }
+    }
+
+    /* Error - invalid property index or non-existent property */
+    return ERRPLINVPI;
+}
+
+/*
+ * FUNCTION:    PListEnumerate
+ *
+ * DESCRIPTION:
+ *
+ *      This function walks through a specified property list
+ *	calling a user supplied function with the property
+ *	name and value as parameters.  
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      user_func               - handle for the user function 
+ */
+
+NSAPI_PUBLIC void
+PListEnumerate(PList_t plist, PListFunc_t *user_func, void *user_data)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+    int i;
+
+    if (!plist) return;
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Loop over the initialized property indices */
+    for (i = 0; i < pl->pl_initpi; ++i) {
+
+        /* Got a property here? */
+        pv = ppval[i];
+        if (pv) {
+            (*user_func)(pv->pv_name, pv->pv_value, user_data);
+        }
+
+    }
+
+}
+
+/*
+ * FUNCTION:    PListCreateDuplicate
+ *
+ * DESCRIPTION:
+ *
+ *      This function creates a new property list and returns a handle for
+ *      it.  The source plist provides the new plists parameters.
+ *
+ * ARGUMENTS:
+ *
+ *	src_plist		- source plist to duplicate
+ *      mempool                 - handle for a memory pool to be associated
+ *                                with the new property list, only
+ *				  used if flags is set to PLFLG_NEW_MPOOL
+ *      flags                   - if PLFLG_NEW_MPOOL uses new_mempool
+ *				  parameter
+ *
+ * RETURNS:
+ *
+ *      If successful, the function return value is a handle for the new
+ *      property list.  Otherwise NULL is returned.
+ */
+
+static PList_t
+PListCreateDuplicate(PList_t src_plist, pool_handle_t *new_mempool, int flags)
+{
+    PListStruct_t *plist;       /* pointer to property list structure */
+    int i;
+    pool_handle_t *mempool;
+
+    mempool = (flags == PLFLG_NEW_MPOOL) ? new_mempool : src_plist->pl_mempool;
+
+    plist = (PListStruct_t *)pool_malloc(mempool, sizeof(PListStruct_t));
+    if (plist) {
+
+        /* Initialize property list structure */
+        plist->pl_mempool = mempool;
+        plist->pl_symtab = NULL;
+        plist->pl_maxprop = src_plist->pl_maxprop;
+        plist->pl_resvpi = src_plist->pl_resvpi;
+        plist->pl_initpi = src_plist->pl_initpi;
+        plist->pl_lastpi = src_plist->pl_lastpi;
+
+        /* Set initialize size for array of property value pointers */
+        plist->pl_cursize = src_plist->pl_cursize; 
+
+        /* Allocate the initial array of property value pointers */
+        plist->pl_ppval = (pb_entry **)pool_malloc(mempool,
+                                                   (plist->pl_cursize *
+                                                    sizeof(PLValueStruct_t *)));
+        if (!plist->pl_ppval) {
+
+            /* Failed - insufficient memory */
+            pool_free(mempool, (void *)plist);
+            plist = NULL;
+        }
+        else {
+            /* NULL out pointers in the reserved index range, if any */
+            for (i = 0; i < plist->pl_lastpi; ++i) {
+                plist->pl_ppval[i] = 0;
+            }
+        }
+    }
+
+    return (PList_t)plist;
+}
+
+
+/*
+ * FUNCTION:    PListDuplicate
+ *
+ * DESCRIPTION:
+ *
+ *      This function duplicates a specified PList_t.  
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *      mempool                 - handle for a memory pool to be associated
+ *                                with the new property list
+ *      resvprop                - number of reserved property indices
+ *      maxprop                 - maximum number of properties in list
+ *                                (zero or negative imposes no limit)
+ *      flags                   - unused, reserved, must be zero
+ *
+ * RETURNS:
+ *
+ *      If successful, the function return value is a handle for the new
+ *      property list.  Otherwise NULL is returned.
+ */
+
+NSAPI_PUBLIC PList_t
+PListDuplicate(PList_t plist, pool_handle_t *new_mempool, int flags)
+{
+    PListStruct_t *pl = (PListStruct_t *)plist;
+    PLValueStruct_t **ppval;
+    PLValueStruct_t *pv;
+    int i;
+    int rv = 0;
+    PList_t new_plist;
+
+    if (!plist) return NULL;
+
+    new_plist = PListCreateDuplicate(plist, new_mempool, flags);
+    if (new_plist == NULL) {
+        return(NULL);
+    }
+
+    ppval = (PLValueStruct_t **)(pl->pl_ppval);
+
+    /* Loop over the initialized property indices */
+    for (i = 0; i < pl->pl_initpi; ++i) {
+
+        /* Got a property here? */
+        pv = ppval[i];
+        if (pv) {
+            /* Create the property */
+            rv = PListDefProp(new_plist, i + 1, pv->pv_name, PLFLG_IGN_RES);
+            if (rv > 0) {
+        
+                /* If that worked, set the value and type */
+                rv = PListSetValue(new_plist, rv, pv->pv_value, pv->pv_type);
+            }
+        
+            if ( rv <= 0 ) {
+                PListDestroy(new_plist);
+                return(NULL);
+            }
+        }
+
+    }
+
+    return(new_plist);
+}
+
+/*
+ * FUNCTION:    PListGetPool
+ *
+ * DESCRIPTION:
+ *
+ *      This function returns the memory pool the PList is allocated from.
+ *
+ * ARGUMENTS:
+ *
+ *      plist                   - handle for the property list
+ *
+ * RETURNS:
+ *
+ *      The memory pool address, which can be NULL.
+ */
+
+NSAPI_PUBLIC pool_handle_t *
+PListGetPool(PList_t plist)
+{
+    if (!plist) return NULL;
+
+    return(plist->pl_mempool);
+}
+
diff --git a/lib/base/plist_pvt.h b/lib/base/plist_pvt.h
new file mode 100644
index 00000000..e4b861c5
--- /dev/null
+++ b/lib/base/plist_pvt.h
@@ -0,0 +1,122 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+#ifndef _PLIST_PVT_H
+#define _PLIST_PVT_H
+
+/*
+ * FILE:        plist_pvt.h
+ *
+ * DESCRIPTION:
+ *
+ *      This file contains private definitions for the property list
+ *      utility implementation.
+ */
+
+#include "base/pool.h"
+
+/* Forward declarations */
+typedef struct PLValueStruct_s PLValueStruct_t;
+typedef struct PLSymbol_s PLSymbol_t;
+typedef struct PLSymbolTable_s PLSymbolTable_t;
+typedef struct PListStruct_s PListStruct_t;
+
+/*
+ * TYPE:        PLValueStruct_t
+ *
+ * DESCRIPTION:
+ *
+ *      This type represents a property value. It is dynamically
+ *      allocated when a new property is added to a property list.
+ *      It contains a reference to a property list that contains
+ *      information about the property value, and a reference to
+ *      the property value data.
+ */
+
+#ifndef PBLOCK_H
+#include "base/pblock.h"
+#endif /* PBLOCK_H */
+#include <stddef.h>
+
+struct PLValueStruct_s {
+    pb_entry pv_pbentry;	/* used for pblock compatibility */
+    pb_param pv_pbparam;	/* property name and value pointers */
+    PLValueStruct_t *pv_next;   /* property name hash collision link */
+    PListStruct_t *pv_type;     /* property value type reference */
+    int pv_pi;                  /* property index */
+    int pv_flags;               /* bit flags */
+};
+
+#define pv_name pv_pbparam.name
+#define pv_value pv_pbparam.value
+
+/* pv_flags definitions */
+#define PVF_MALLOC              0x1     /* allocated via MALLOC */
+
+/* Offset to pv_pbparam in PLValueStruct_t */
+#define PVPBOFFSET offsetof(struct PLValueStruct_s,pv_pbparam)
+
+/* Convert pb_param pointer to PLValueStruct_t pointer */
+#define PATOPV(p) ((PLValueStruct_t *)((char *)(p) - PVPBOFFSET))
+
+/*
+ * TYPE:        PLSymbolTable_t
+ *
+ * DESCRIPTION:
+ *
+ *      This type represents a symbol table that maps property names
+ *      to properties.  It is dynamically allocated the first time a
+ *      property is named.
+ */
+
+#define PLSTSIZES       {7, 19, 31, 67, 123, 257, 513}
+#define PLMAXSIZENDX    (sizeof(plistHashSizes)/sizeof(plistHashSizes[0]))
+
+struct PLSymbolTable_s {
+    int pt_sizendx;             /* pt_hash size, as an index in PLSTSIZES */
+    int pt_nsyms;               /* number of symbols in table */
+    PLValueStruct_t *pt_hash[1];/* variable-length array */
+};
+
+/*
+ * TYPE:        PListStruct_t
+ *
+ * DESCRIPTION:
+ *
+ *      This type represents the top-level of a property list structure.
+ *      It is dynamically allocated when a property list is created, and
+ *      freed when the property list is destroyed.  It references a
+ *      dynamically allocated array of pointers to property value
+ *      structures (PLValueStruct_t).
+ */
+
+#define PLIST_DEFSIZE   8       /* default initial entries in pl_ppval */
+#define PLIST_DEFGROW   16      /* default incremental entries for pl_ppval */
+
+struct PListStruct_s {
+    pblock pl_pb;		/* pblock subset of property list head */
+    PLSymbolTable_t *pl_symtab; /* property name to index symbol table */
+    pool_handle_t *pl_mempool;  /* associated memory pool handle */
+    int pl_maxprop;             /* maximum number of properties */
+    int pl_resvpi;              /* number of reserved property indices */
+    int pl_lastpi;              /* last allocated property index */
+    int pl_cursize;             /* current size of pl_ppval in entries */
+};
+
+#define pl_initpi pl_pb.hsize    /* number of pl_ppval entries initialized */
+#define pl_ppval pl_pb.ht	/* pointer to array of value pointers */
+
+/* Convert pblock pointer to PListStruct_t pointer */
+#define PBTOPL(p) ((PListStruct_t *)(p))
+
+#define PLSIZENDX(i) (plistHashSizes[i])
+#define PLHASHSIZE(i) (sizeof(PLSymbolTable_t) + \
+                       (PLSIZENDX(i) - 1)*sizeof(PLValueStruct_t *))
+
+extern int plistHashSizes[7];
+
+extern int PListHashName(PLSymbolTable_t *symtab, const char *pname);
+
+#endif /* _PLIST_PVT_H */
diff --git a/lib/base/pool.cpp b/lib/base/pool.cpp
new file mode 100644
index 00000000..56232e3f
--- /dev/null
+++ b/lib/base/pool.cpp
@@ -0,0 +1,654 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * Generic pool handling routines.
+ *
+ * Hopefully these reduce the number of malloc/free calls.
+ *
+ *
+ * Thread warning:
+ *	This implementation is thread safe.  However, simultaneous 
+ *	mallocs/frees to the same "pool" are not safe.  If you wish to
+ *	use this module across multiple threads, you should define
+ *	POOL_LOCKING which will make the malloc pools safe. 
+ *
+ * Mike Belshe
+ * 11-20-95
+ *
+ */
+
+#include "netsite.h"
+#include "base/systems.h"
+#include "base/systhr.h"
+
+#ifdef MALLOC_POOLS
+#include "base/pool.h"
+#include "base/ereport.h"
+#include "base/session.h"
+#include "frame/req.h"
+#include "frame/http.h"
+#include "base/util.h"
+#include "base/crit.h"
+
+#include "base/dbtbase.h"
+
+#ifdef DEBUG
+#define POOL_ZERO_DEBUG
+#endif
+#undef POOL_LOCKING
+
+#define BLOCK_SIZE		(32 * 1024)
+#define MAX_FREELIST_SIZE	(BLOCK_SIZE * 32)
+
+/* WORD SIZE 8 sets us up for 8 byte alignment. */
+#define WORD_SIZE	8   
+#undef	ALIGN
+#define ALIGN(x)	( (x + WORD_SIZE-1) & (~(WORD_SIZE-1)) )
+
+/* block_t
+ * When the user allocates space, a BLOCK_SIZE (or larger) block is created in 
+ * the pool.  This block is used until all the space is eaten within it.
+ * When all the space is gone, a new block is created.
+ *
+ */
+typedef struct block_t {
+	char		*data;		/* the real alloc'd space */
+	char		*start;		/* first free byte in block */
+	char		*end;		/* ptr to end of block */
+	struct block_t	*next;		/* ptr to next block */
+} block_t;
+
+/* pool_t
+ * A pool is a collection of blocks.  The blocks consist of multiple 
+ * allocations of memory, but a single allocation cannot be freed by
+ * itself.  Once the memory is allocated it is allocated until the
+ * entire pool is freed.
+ */
+typedef struct pool_t {
+#ifdef DEBUG_CACHES
+	time_t		time_created;
+#endif
+#ifdef POOL_LOCKING
+	CRITICAL	lock;		/* lock for modifying the pool */
+#endif
+	block_t		*curr_block;	/* current block being used */
+	block_t		*used_blocks;	/* blocks that are all used up */
+	long		size;		/* size of memory in pool */
+	struct pool_t	*next;		/* known_pools list */
+} pool_t;
+
+/* known_pools
+ * Primarily for debugging, keep a list of all active malloc pools.
+ */
+static pool_t *known_pools = NULL;
+static CRITICAL known_pools_lock = NULL;
+static unsigned long pool_blocks_created = 0;
+static unsigned long pool_blocks_freed = 0;
+
+/* freelist
+ * Internally we maintain a list of free blocks which we try to pull from
+ * whenever possible.  This list will never have more than MAX_FREELIST_SIZE
+ * bytes within it.
+ */
+static CRITICAL freelist_lock = NULL;
+static block_t	*freelist = NULL;
+static unsigned long	freelist_size = 0;
+static unsigned long	freelist_max = MAX_FREELIST_SIZE;
+static int pool_disable = 0;
+
+int 
+pool_internal_init()
+{
+	if (pool_disable == 0) {
+		if (known_pools_lock == NULL) {
+			known_pools_lock = crit_init();
+			freelist_lock = crit_init();
+		}
+	} else
+		ereport(LOG_INFORM, XP_GetAdminStr(DBT_poolInitMemoryPoolsDisabled_));
+
+	return 0;
+}
+
+NSAPI_PUBLIC int
+pool_init(pblock *pb, Session *sn, Request *rq)
+{
+	char *str_free_size = pblock_findval("free-size", pb);
+	char *str_pool_disable = pblock_findval("disable", pb);
+
+	if (str_free_size != NULL) {
+		if ( (freelist_max = atoi(str_free_size)) <= 0) {	
+			ereport(LOG_WARN, XP_GetAdminStr(DBT_poolInitFreeSize0UsingD_),
+				MAX_FREELIST_SIZE);
+			freelist_max = MAX_FREELIST_SIZE;
+		}
+	}
+
+	if (str_pool_disable && strcasecmp(str_pool_disable, "false") ) 
+		pool_disable = 1;
+	else
+		pool_disable = 0;
+
+	if (known_pools_lock == NULL) {
+		known_pools_lock = crit_init();
+		freelist_lock = crit_init();
+	}
+
+	return REQ_PROCEED;
+}
+
+
+static block_t *
+_create_block(int size)
+{
+	block_t *newblock = NULL;
+	long bytes = ALIGN(size);
+	block_t	*free_ptr,
+		*last_free_ptr = NULL;
+
+	/* check freelist for large enough block first */
+
+	crit_enter(freelist_lock);
+	free_ptr = freelist;
+	while(free_ptr && ((free_ptr->end - free_ptr->data) < bytes)) {
+		last_free_ptr = free_ptr;
+		free_ptr = free_ptr->next;
+	}
+
+	if (free_ptr) {
+		newblock = free_ptr;
+		if (last_free_ptr)
+			last_free_ptr->next = free_ptr->next;
+		else
+			freelist = free_ptr->next;
+		freelist_size -= (newblock->end - newblock->data);
+		crit_exit(freelist_lock);
+		bytes = free_ptr->end - free_ptr->data;
+	}
+	else {
+                pool_blocks_created++;
+		crit_exit(freelist_lock);
+		if (((newblock = (block_t *)PERM_MALLOC(sizeof(block_t))) == NULL) || 
+		    ((newblock->data = (char *)PERM_MALLOC(bytes)) == NULL)) {
+			ereport(LOG_CATASTROPHE, XP_GetAdminStr(DBT_poolCreateBlockOutOfMemory_));
+			if (newblock)
+				PERM_FREE(newblock);
+			return NULL;
+		}
+	}
+	newblock->start	= newblock->data;
+	newblock->end	= newblock->data + bytes;
+	newblock->next	= NULL;
+
+	return newblock;
+}
+
+/* Caller must hold lock for the pool */
+static void 
+_free_block(block_t *block)
+{
+
+#ifdef POOL_ZERO_DEBUG
+	memset(block->data, 0xa, block->end-block->data);
+#endif /* POOL_ZERO_DEBUG */
+
+	if ((freelist_size + block->end - block->data) > freelist_max) {
+		/* Just have to delete the whole block! */
+
+		crit_enter(freelist_lock);
+                pool_blocks_freed++;
+		crit_exit(freelist_lock);
+
+		PERM_FREE(block->data);
+#ifdef POOL_ZERO_DEBUG
+		memset(block, 0xa, sizeof(block));
+#endif /* POOL_ZERO_DEBUG */
+
+		PERM_FREE(block);
+		return;
+	}
+	crit_enter(freelist_lock);
+	freelist_size += (block->end - block->data);
+	block->start = block->data;
+
+	block->next = freelist;
+	freelist = block;
+	crit_exit(freelist_lock);
+}
+
+/* ptr_in_pool()
+ * Checks to see if the given pointer is in the given pool.
+ * If true, returns a ptr to the block_t containing the ptr;
+ * otherwise returns NULL
+ */
+block_t * 
+_ptr_in_pool(pool_t *pool, void *ptr)
+{
+	block_t *block_ptr = NULL;
+
+	/* try to find a block which contains this ptr */
+
+	if (	((char *)ptr < (char *)pool->curr_block->end) && 
+		((char *)ptr >= (char *)pool->curr_block->data) ) 
+		block_ptr = pool->curr_block;
+	else 
+		for(	block_ptr = pool->used_blocks; 
+			block_ptr && 
+			(((char *)ptr >= (char *)block_ptr->end) && 
+			 ((char *)ptr < (char *)block_ptr->data)); 
+			block_ptr = block_ptr->next);
+
+	return block_ptr;
+}
+
+
+NSAPI_PUBLIC pool_handle_t *
+pool_create()
+{
+	pool_t *newpool;
+
+	if (pool_disable)
+		return NULL;
+
+	newpool = (pool_t *)PERM_MALLOC(sizeof(pool_t));
+
+	if (newpool) {
+		/* Have to initialize now, as pools get created sometimes
+		 * before pool_init can be called...
+		 */
+		if (known_pools_lock == NULL) {
+			known_pools_lock = crit_init();
+			freelist_lock = crit_init();
+		}
+
+		if ( (newpool->curr_block =_create_block(BLOCK_SIZE)) == NULL) {
+			ereport(LOG_CATASTROPHE, XP_GetAdminStr(DBT_poolCreateOutOfMemory_));
+			PERM_FREE(newpool);
+			return NULL;
+		}
+		newpool->used_blocks = NULL;
+		newpool->size = 0;
+		newpool->next = NULL;
+#ifdef POOL_LOCKING
+		newpool->lock = crit_init();
+#endif
+#ifdef DEBUG_CACHES
+		newpool->time_created = time(NULL);
+#endif
+
+		/* Add to known pools list */
+		crit_enter(known_pools_lock);
+		newpool->next = known_pools;
+		known_pools = newpool;
+		crit_exit(known_pools_lock);
+	}
+	else 
+		ereport(LOG_CATASTROPHE, XP_GetAdminStr(DBT_poolCreateOutOfMemory_1));
+
+	return (pool_handle_t *)newpool;
+}
+
+NSAPI_PUBLIC void
+pool_destroy(pool_handle_t *pool_handle)
+{
+	pool_t *pool = (pool_t *)pool_handle;
+	block_t *tmp_blk;
+	pool_t *last, *search;
+
+	if (pool_disable)
+		return;
+
+	crit_enter(known_pools_lock);
+#ifdef POOL_LOCKING
+	crit_enter(pool->lock);
+#endif
+
+	if (pool->curr_block)
+		_free_block(pool->curr_block);
+
+	while(pool->used_blocks) {
+		tmp_blk = pool->used_blocks;
+		pool->used_blocks = pool->used_blocks->next;
+		_free_block(tmp_blk);
+	}
+
+	/* Remove from the known pools list */
+	for (last = NULL, search = known_pools; search; 
+		last = search, search = search->next)
+		if (search == pool) 
+			break;
+	if (search) {
+		if(last) 
+			last->next = search->next;
+		else
+			known_pools = search->next;
+	
+	}
+
+#ifdef POOL_LOCKING
+	crit_exit(pool->lock);
+	crit_terminate(pool->lock);
+#endif
+	crit_exit(known_pools_lock);
+
+#ifdef POOL_ZERO_DEBUG
+	memset(pool, 0xa, sizeof(pool));
+#endif /* POOL_ZERO_DEBUG */
+
+	PERM_FREE(pool);
+
+	return;
+}
+
+
+NSAPI_PUBLIC void *
+pool_malloc(pool_handle_t *pool_handle, size_t size)
+{
+	pool_t *pool = (pool_t *)pool_handle;
+	long reqsize, blocksize;
+	char *ptr;
+
+	if (pool == NULL || pool_disable) {
+		return PERM_MALLOC(size);
+	}
+
+#ifdef DEBUG
+	if (size == 0)
+		return NULL;
+#endif
+
+#ifdef POOL_LOCKING
+	crit_enter(pool->lock);
+#endif
+
+        reqsize = ALIGN(size);
+	ptr = pool->curr_block->start;
+	pool->curr_block->start += reqsize;
+
+	/* does this fit into the last allocated block? */
+	if (pool->curr_block->start > pool->curr_block->end) {
+
+		/* Did not fit; time to allocate a new block */
+
+		pool->curr_block->start -= reqsize;  /* keep structs in tact */
+
+		pool->curr_block->next = pool->used_blocks;
+		pool->used_blocks = pool->curr_block;
+	
+		/* Allocate a chunk of memory which is a multiple of BLOCK_SIZE
+		 * bytes 
+		 */
+		blocksize = ( (size + BLOCK_SIZE-1) / BLOCK_SIZE ) * BLOCK_SIZE;
+		if ( (pool->curr_block = _create_block(blocksize)) == NULL) {
+			ereport(LOG_CATASTROPHE, XP_GetAdminStr(DBT_poolMallocOutOfMemory_));
+#ifdef POOL_LOCKING
+			crit_exit(pool->lock);
+#endif
+			return NULL;
+		}
+
+                ptr = pool->curr_block->start;
+		reqsize = ALIGN(size);
+		pool->curr_block->start += reqsize;
+	}
+
+	pool->size += reqsize;
+
+#ifdef POOL_LOCKING
+	crit_exit(pool->lock);
+#endif
+	return ptr;
+}
+
+void _pool_free_error()
+{
+	ereport(LOG_WARN, XP_GetAdminStr(DBT_freeUsedWherePermFreeShouldHaveB_));
+
+	return;
+}
+
+NSAPI_PUBLIC void
+pool_free(pool_handle_t *pool_handle, void *ptr)
+{
+	if (pool_handle == NULL || pool_disable) {
+		PERM_FREE(ptr);
+		return;
+	}
+
+#ifdef DEBUG
+	/* Just to be nice, check to see if the ptr was allocated in a pool.
+	 * If not, issue a warning and do a REAL free just to make sure that
+	 * we don't leak memory.
+	 */
+	if ( !_ptr_in_pool((pool_t *)pool_handle, ptr) ) {
+		_pool_free_error();
+
+		PERM_FREE(ptr);
+	}
+#endif
+	return;
+}
+
+NSAPI_PUBLIC void *
+pool_calloc(pool_handle_t *pool_handle, size_t nelem, size_t elsize)
+{
+	void *ptr;
+
+	if (pool_handle == NULL || pool_disable)
+		return PERM_CALLOC(elsize * nelem);
+
+	ptr = pool_malloc(pool_handle, elsize * nelem);
+	if (ptr)
+		memset(ptr, 0, elsize * nelem);
+	return ptr;
+}
+
+NSAPI_PUBLIC void *
+pool_realloc(pool_handle_t *pool_handle, void *ptr, size_t size)
+{
+	pool_t *pool = (pool_t *)pool_handle;
+	void *newptr;
+	block_t *block_ptr;
+	int oldsize;
+
+	if (pool_handle == NULL || pool_disable)
+		return PERM_REALLOC(ptr, size);
+
+	if ( (newptr = pool_malloc(pool_handle, size)) == NULL) 
+		return NULL;
+
+	/* With our structure we don't know exactly where the end
+	 * of the original block is.  But we do know an upper bound
+	 * which is a valid ptr.  Search the outstanding blocks
+	 * for the block which contains this ptr, and copy...
+	 */
+#ifdef POOL_LOCKING
+	crit_enter(pool->lock);
+#endif
+
+	if ( !(block_ptr = _ptr_in_pool(pool, ptr)) ) {
+		/* User is trying to realloc nonmalloc'd space! */
+		return newptr;
+	}
+
+	oldsize = block_ptr->end - (char *)ptr ;
+	if (oldsize > size)
+		oldsize = size;
+	memmove((char *)newptr, (char *)ptr, oldsize);
+#ifdef POOL_LOCKING
+	crit_exit(pool->lock);
+#endif
+
+	return newptr;
+}
+
+NSAPI_PUBLIC char *
+pool_strdup(pool_handle_t *pool_handle, const char *orig_str)
+{
+	char *new_str;
+	int len = strlen(orig_str);
+
+	if (pool_handle == NULL || pool_disable)
+		return PERM_STRDUP(orig_str);
+
+	new_str = (char *)pool_malloc(pool_handle, len+1);
+
+	if (new_str) 
+		memcpy(new_str, orig_str, len+1);
+
+	return new_str;
+}
+
+NSAPI_PUBLIC long
+pool_space(pool_handle_t *pool_handle)
+{
+	pool_t *pool = (pool_t *)pool_handle;
+
+	return pool->size;
+}
+
+NSAPI_PUBLIC int pool_enabled()
+{
+#ifndef THREAD_ANY
+	/* we don't have USE_NSPR defined so systhread_getdata is undef'ed */
+	return 0;
+#else
+	if (pool_disable || (getThreadMallocKey() == -1) )
+		return 0;
+
+	if (!systhread_getdata(getThreadMallocKey()))
+		return 0;
+
+	return 1;
+#endif
+}
+
+
+/* pool_service_debug()
+ * NSAPI service routine to print state information about the existing 
+ * pools.  Hopefully useful in debugging.
+ *
+ */
+#define MAX_DEBUG_LINE	1024
+#ifdef DEBUG_CACHES  /* XXXrobm causes entanglement in install and admserv cgis */
+NSAPI_PUBLIC int
+pool_service_debug(pblock *pb, Session *sn, Request *rq) 
+{
+	char tmp_buf[MAX_DEBUG_LINE];
+	char cbuf[DEF_CTIMEBUF];
+	int len;
+	pool_t *pool_ptr;
+	block_t *block_ptr;
+	int pool_cnt, block_cnt;
+
+	param_free(pblock_remove("content-type", rq->srvhdrs));
+	pblock_nvinsert("content-type", "text/html", rq->srvhdrs);
+
+	protocol_status(sn, rq, PROTOCOL_OK, NULL);
+	protocol_start_response(sn, rq);
+
+	len = util_sprintf(tmp_buf, "<H2>Memory pool status report</H2>\n");
+	net_write(sn->csd, tmp_buf, len);
+
+	len = util_sprintf(tmp_buf, "Note: The 0 block in each pool is \
+the currently used block <P>\n");
+	net_write(sn->csd, tmp_buf, len);
+
+	len = util_sprintf(tmp_buf, "Freelist size: %d/%d<P>", freelist_size,
+		freelist_max);
+	net_write(sn->csd, tmp_buf, len);
+
+	len = util_sprintf(tmp_buf, "Pool disabled: %d<P>", pool_disable);
+	net_write(sn->csd, tmp_buf, len);
+
+	len = util_sprintf(tmp_buf, "Blocks created: %d<P> Blocks freed: %d", 
+		pool_blocks_created, pool_blocks_freed);
+	net_write(sn->csd, tmp_buf, len);
+
+	/* Create an HTML table */
+	len = util_sprintf(tmp_buf, "<UL><TABLE BORDER=4>\n"); 
+	net_write(sn->csd, tmp_buf, len);
+	len = util_sprintf(tmp_buf, "<TH>Pool #</TH>\n");
+	net_write(sn->csd, tmp_buf, len);
+	len = util_sprintf(tmp_buf, "<TH>Pool size #</TH>\n");
+	net_write(sn->csd, tmp_buf, len);
+#ifdef DEBUG_CACHES
+	len = util_sprintf(tmp_buf, "<TH>Time Created</TH>\n");
+	net_write(sn->csd, tmp_buf, len);
+#endif
+	len = util_sprintf(tmp_buf, "<TH>Blocks</TH>\n");
+	net_write(sn->csd, tmp_buf, len);
+
+	crit_enter(known_pools_lock);
+	for (pool_cnt = 0, pool_ptr = known_pools; pool_ptr; 
+		pool_ptr = pool_ptr->next, pool_cnt++) {
+
+#ifdef POOL_LOCKING
+		crit_enter(pool_ptr->lock);
+#endif
+		len = util_snprintf(tmp_buf, MAX_DEBUG_LINE, 
+#ifndef DEBUG_CACHES
+"<tr align=right> <td>%d</td> <td>%d</td> <td> <TABLE BORDER=2> <TH>Block #</TH><TH>data</TH><TH>curr size</TH> <TH>max size</TH>\n", 
+#else
+"<tr align=right> <td>%d</td> <td>%d</td> <td>%s</td> <td> <TABLE BORDER=2> <TH>Block #</TH><TH>data</TH><TH>curr size</TH> <TH>max size</TH>\n", 
+#endif
+			pool_cnt, pool_space((pool_handle_t *)pool_ptr)
+#ifdef DEBUG_CACHES
+			, util_ctime(&(pool_ptr->time_created), cbuf, DEF_CTIMEBUF));
+#else
+			);
+#endif
+		net_write(sn->csd, tmp_buf, len);
+
+		/* Print the first block */
+		len = util_snprintf(tmp_buf, MAX_DEBUG_LINE, "\
+<tr align=right> \
+<td>%d</td> \
+<td>%d</td> \
+<td>%d</td> \
+<td>%d</td> \
+</tr>\n",
+			0, pool_ptr->curr_block->data, 
+			pool_ptr->curr_block->start -pool_ptr->curr_block->data,
+			pool_ptr->curr_block->end - pool_ptr->curr_block->data);
+
+		net_write(sn->csd, tmp_buf, len);
+
+		for (block_cnt = 1, block_ptr = pool_ptr->used_blocks; block_ptr; 
+			block_ptr = block_ptr->next, block_cnt++) {
+
+			len = util_snprintf(tmp_buf, MAX_DEBUG_LINE, "\
+<tr align=right> \
+<td>%d</td> \
+<td>%d</td> \
+<td>%d</td> \
+<td>%d</td> \
+</tr>\n",
+				block_cnt, block_ptr->data, 
+				block_ptr->start - block_ptr->data, 
+				block_ptr->end - block_ptr->data);
+
+			net_write(sn->csd, tmp_buf, len);
+		}
+#ifdef POOL_LOCKING
+		crit_exit(pool_ptr->lock);
+#endif
+
+		len = util_snprintf(tmp_buf, MAX_DEBUG_LINE, "</TABLE></TD></TR>");
+		
+		net_write(sn->csd, tmp_buf, len);
+	}
+	crit_exit(known_pools_lock);
+
+	len = util_sprintf(tmp_buf, "</TABLE></UL>\n");
+	net_write(sn->csd, tmp_buf, len);
+	
+	return REQ_PROCEED;
+
+}
+#endif /* 0 */
+#endif /* MALLOC_POOLS */
+
diff --git a/lib/base/rwlock.cpp b/lib/base/rwlock.cpp
new file mode 100644
index 00000000..1b99e062
--- /dev/null
+++ b/lib/base/rwlock.cpp
@@ -0,0 +1,131 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+#include <stdlib.h>
+#include "crit.h"
+#include "rwlock.h"
+
+/*
+ * rwLock.c
+ *    Implements a shared/exclusive lock package atop the
+ * critical section/condition variables. It allows multiple
+ * shared lock holders and only one exclusive lock holder
+ * on a lock variable.
+ *
+ * NOTE : It currently favors writers over readers and writers
+ *  may starve readers. It is usually preferable to allow updates
+ *  if they are not as frequent. We may have to change this if
+ *  the common usage pattern differs from this.
+ */
+
+typedef struct {
+    CRITICAL crit;           /* Short term crit to synchronize lock ops */
+    CONDVAR  readFree;       /* Indicates lock is free for readers */
+    CONDVAR  writeFree;      /* Indicates lock is free for the writer */
+    int      numReaders;     /* Number of read locks held */
+    int      write;          /* Flag to indicate write lock held */
+    int      numWriteWaiters;/* Number of threads waiting for write lock */
+} rwLock_t;
+
+/* 
+ * rwlock_init()
+ *   Allocate and initialize the rwlock structure and return
+ *  to the caller.
+ */
+RWLOCK rwlock_Init()
+{
+    rwLock_t *rwLockP;
+
+    rwLockP = (rwLock_t *)PERM_MALLOC(sizeof(rwLock_t));
+    rwLockP->numReaders = 0;
+    rwLockP->write = 0;
+    rwLockP->numWriteWaiters = 0;
+    rwLockP->crit = crit_init();
+    rwLockP->readFree = condvar_init(rwLockP->crit);
+    rwLockP->writeFree = condvar_init(rwLockP->crit);
+    return((RWLOCK)rwLockP);
+}
+
+/* 
+ * rwlock_terminate()
+ *   Terminate the associated condvars and critical sections
+ */
+void rwlock_Terminate(RWLOCK lockP)
+{
+    rwLock_t   *rwLockP = (rwLock_t *)lockP;
+    
+    crit_terminate(rwLockP->crit);
+    condvar_terminate(rwLockP->readFree);
+    condvar_terminate(rwLockP->writeFree);
+    PERM_FREE(rwLockP);
+}
+
+/*
+ * rwlock_ReadLock -- Obtain a shared lock. The caller would
+ *  block if there are writers or writeWaiters.
+ */
+void rwlock_ReadLock(RWLOCK lockP)
+{
+    rwLock_t *rwLockP = (rwLock_t *)lockP;
+
+    crit_enter(rwLockP->crit);                 
+    while (rwLockP->write || rwLockP->numWriteWaiters != 0)
+        condvar_wait(rwLockP->readFree);
+    rwLockP->numReaders++;                              
+    crit_exit(rwLockP->crit);                 
+}
+
+/*
+ * rwlock_writeLock -- Obtain an exclusive lock. The caller would
+ * block if there are other readers or a writer.
+ */
+void rwlock_WriteLock(RWLOCK lockP)
+{
+    rwLock_t *rwLockP = (rwLock_t *)lockP;
+
+    crit_enter(rwLockP->crit);                 
+    rwLockP->numWriteWaiters++;                                
+    while (rwLockP->numReaders != 0 || rwLockP->write)             
+        condvar_wait(rwLockP->writeFree);      
+    rwLockP->numWriteWaiters--;                                
+    rwLockP->write = 1;                                   
+    crit_exit(rwLockP->crit);                 
+}
+
+/*
+ * rw_Unlock -- Releases the lock. 
+ */
+void rwlock_Unlock(RWLOCK lockP)
+{
+    rwLock_t *rwLockP = (rwLock_t *)lockP;
+                                                         
+    crit_enter(rwLockP->crit);                 
+    if (rwLockP->write)                                      
+        rwLockP->write = 0;                              
+    else                                                 
+        rwLockP->numReaders--;                                 
+    if (rwLockP->numReaders == 0)                              
+        if (rwLockP->numWriteWaiters != 0)                     
+            condvar_notify(rwLockP->writeFree);             
+        else                                             
+            condvar_notifyAll(rwLockP->readFree);           
+    crit_exit(rwLockP->crit);                 
+}
+                                                         
+/*
+ * rwlock_DemoteLock -- Change an exclusive lock on the given lock
+ * variable into a shared lock.  
+ */
+void rwlock_DemoteLock(RWLOCK lockP)
+{
+    rwLock_t *rwLockP = (rwLock_t *)lockP;
+                                                         
+    crit_enter(rwLockP->crit);                 
+    rwLockP->numReaders = 1;
+    rwLockP->write = 0;
+    if (rwLockP->numWriteWaiters == 0)
+        condvar_notifyAll(rwLockP->readFree);
+    crit_exit(rwLockP->crit);                 
+}
diff --git a/lib/base/shexp.cpp b/lib/base/shexp.cpp
new file mode 100644
index 00000000..8cb2aae4
--- /dev/null
+++ b/lib/base/shexp.cpp
@@ -0,0 +1,290 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * shexp.c: shell-like wildcard match routines
+ *
+ *
+ * See shexp.h for public documentation.
+ *
+ * Rob McCool
+ * 
+ */
+
+#include "shexp.h"
+#include <ctype.h>    /* isalpha, tolower */
+
+
+/* ----------------------------- shexp_valid ------------------------------ */
+
+
+int valid_subexp(char *exp, char stop) 
+{
+    register int x,y,t;
+    int nsc,np,tld;
+
+    x=0;nsc=0;tld=0;
+
+    while(exp[x] && (exp[x] != stop)) {
+        switch(exp[x]) {
+          case '~':
+            if(tld) return INVALID_SXP;
+            else ++tld;
+          case '*':
+          case '?':
+          case '^':
+          case '$':
+            ++nsc;
+            break;
+          case '[':
+            ++nsc;
+            if((!exp[++x]) || (exp[x] == ']'))
+                return INVALID_SXP;
+            for(++x;exp[x] && (exp[x] != ']');++x)
+                if(exp[x] == '\\')
+                    if(!exp[++x])
+                        return INVALID_SXP;
+            if(!exp[x])
+                return INVALID_SXP;
+            break;
+          case '(':
+            ++nsc;
+            while(1) {
+                if(exp[++x] == ')')
+                    return INVALID_SXP;
+                for(y=x;(exp[y]) && (exp[y] != '|') && (exp[y] != ')');++y)
+                    if(exp[y] == '\\')
+                        if(!exp[++y])
+                            return INVALID_SXP;
+                if(!exp[y])
+                    return INVALID_SXP;
+                t = valid_subexp(&exp[x],exp[y]);
+                if(t == INVALID_SXP)
+                    return INVALID_SXP;
+                x+=t;
+                if(exp[x] == ')') {
+                    break;
+                }
+            }
+            break;
+          case ')':
+          case ']':
+            return INVALID_SXP;
+          case '\\':
+            if(!exp[++x])
+                return INVALID_SXP;
+          default:
+            break;
+        }
+        ++x;
+    }
+    if((!stop) && (!nsc))
+        return NON_SXP;
+    return ((exp[x] == stop) ? x : INVALID_SXP);
+}
+
+NSAPI_PUBLIC int shexp_valid(char *exp) {
+    int x;
+
+    x = valid_subexp(exp, '\0');
+    return (x < 0 ? x : VALID_SXP);
+}
+
+
+/* ----------------------------- shexp_match ----------------------------- */
+
+
+#define MATCH 0
+#define NOMATCH 1
+#define ABORTED -1
+
+int _shexp_match(char *str, char *exp);
+
+int handle_union(char *str, char *exp) 
+{
+    char *e2 = (char *) MALLOC(sizeof(char)*strlen(exp));
+    register int t,p2,p1 = 1;
+    int cp;
+
+    while(1) {
+        for(cp=1;exp[cp] != ')';cp++)
+            if(exp[cp] == '\\')
+                ++cp;
+        for(p2 = 0;(exp[p1] != '|') && (p1 != cp);p1++,p2++) {
+            if(exp[p1] == '\\')
+                e2[p2++] = exp[p1++];
+            e2[p2] = exp[p1];
+        }
+        for(t=cp+1;(e2[p2] = exp[t]);++t,++p2);
+        if(_shexp_match(str,e2) == MATCH) {
+            FREE(e2);
+            return MATCH;
+        }
+        if(p1 == cp) {
+            FREE(e2);
+            return NOMATCH;
+        }
+        else ++p1;
+    }
+}
+
+
+int _shexp_match(char *str, char *exp) 
+{
+    register int x,y;
+    int ret,neg;
+
+    ret = 0;
+    for(x=0,y=0;exp[y];++y,++x) {
+        if((!str[x]) && (exp[y] != '(') && (exp[y] != '$') && (exp[y] != '*'))
+            ret = ABORTED;
+        else {
+            switch(exp[y]) {
+              case '$':
+                if( (str[x]) )
+                    ret = NOMATCH;
+                else
+                    --x;             /* we don't want loop to increment x */
+                break;
+              case '*':
+                while(exp[++y] == '*');
+                if(!exp[y])
+                    return MATCH;
+                while(str[x]) {
+                    switch(_shexp_match(&str[x++],&exp[y])) {
+                    case NOMATCH:
+                        continue;
+                    case ABORTED:
+                        ret = ABORTED;
+                        break;
+                    default:
+                        return MATCH;
+                    }
+                    break;
+                }
+                if((exp[y] == '$') && (exp[y+1] == '\0') && (!str[x]))
+                    return MATCH;
+                else
+                    ret = ABORTED;
+                break;
+              case '[':
+                if((neg = ((exp[++y] == '^') && (exp[y+1] != ']'))))
+                    ++y;
+                
+                if((isalnum(exp[y])) && (exp[y+1] == '-') && 
+                   (isalnum(exp[y+2])) && (exp[y+3] == ']'))
+                    {
+                        int start = exp[y], end = exp[y+2];
+                        
+                        /* Droolproofing for pinheads not included */
+                        if(neg ^ ((str[x] < start) || (str[x] > end))) {
+                            ret = NOMATCH;
+                            break;
+                        }
+                        y+=3;
+                    }
+                else {
+                    int matched;
+                    
+                    for(matched=0;exp[y] != ']';y++)
+                        matched |= (str[x] == exp[y]);
+                    if(neg ^ (!matched))
+                        ret = NOMATCH;
+                }
+                break;
+              case '(':
+                return handle_union(&str[x],&exp[y]);
+                break;
+              case '?':
+                break;
+              case '\\':
+                ++y;
+              default:
+#ifdef XP_UNIX
+                if(str[x] != exp[y])
+#else /* XP_WIN32 */
+                if(strnicmp(str + x, exp + y, 1))
+#endif /* XP_WIN32 */
+                    ret = NOMATCH;
+                break;
+            }
+        }
+        if(ret)
+            break;
+    }
+    return (ret ? ret : (str[x] ? NOMATCH : MATCH));
+}
+
+NSAPI_PUBLIC int shexp_match(char *str, char *xp) {
+    register int x;
+    char *exp = STRDUP(xp);
+
+    for(x=strlen(exp)-1;x;--x) {
+        if((exp[x] == '~') && (exp[x-1] != '\\')) {
+            exp[x] = '\0';
+            if(_shexp_match(str,&exp[++x]) == MATCH)
+                goto punt;
+            break;
+        }
+    }
+    if(_shexp_match(str,exp) == MATCH) {
+        FREE(exp);
+        return 0;
+    }
+
+  punt:
+    FREE(exp);
+    return 1;
+}
+
+
+/* ------------------------------ shexp_cmp ------------------------------- */
+
+
+NSAPI_PUBLIC int shexp_cmp(char *str, char *exp)
+{
+    switch(shexp_valid(exp)) {
+      case INVALID_SXP:
+        return -1;
+      case NON_SXP:
+#ifdef XP_UNIX
+        return (strcmp(exp,str) ? 1 : 0);
+#else  /* XP_WIN32 */
+        return (stricmp(exp,str) ? 1 : 0);
+#endif /* XP_WIN32 */
+      default:
+        return shexp_match(str, exp);
+    }
+}
+
+
+/* ---------------------------- shexp_casecmp ----------------------------- */
+
+
+NSAPI_PUBLIC int shexp_casecmp(char *str, char *exp)
+{
+    char *lstr = STRDUP(str), *lexp = STRDUP(exp), *t;
+    int ret;
+
+    for(t = lstr; *t; t++)
+        if(isalpha(*t)) *t = tolower(*t);
+    for(t = lexp; *t; t++)
+        if(isalpha(*t)) *t = tolower(*t);
+
+    switch(shexp_valid(lexp)) {
+      case INVALID_SXP:
+        ret = -1;
+        break;
+      case NON_SXP:
+        ret = (strcmp(lexp, lstr) ? 1 : 0);
+        break;
+      default:
+        ret = shexp_match(lstr, lexp);
+    }
+    FREE(lstr);
+    FREE(lexp);
+    return ret;
+}
+
diff --git a/lib/base/shmem.cpp b/lib/base/shmem.cpp
new file mode 100644
index 00000000..1ddd76d3
--- /dev/null
+++ b/lib/base/shmem.cpp
@@ -0,0 +1,127 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * shmem.h: Portable abstraction for memory shared among a server's workers
+ * 
+ * Rob McCool
+ */
+
+
+#include "shmem.h"
+
+#if defined (SHMEM_UNIX_MMAP)
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <private/pprio.h>  /* for nspr20 binary release */
+
+NSPR_BEGIN_EXTERN_C
+#include <sys/mman.h>
+NSPR_END_EXTERN_C
+
+NSAPI_PUBLIC shmem_s *shmem_alloc(char *name, int size, int expose)
+{
+    shmem_s *ret = (shmem_s *) PERM_MALLOC(sizeof(shmem_s));
+    char *growme;
+
+    if( (ret->fd = PR_Open(name, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE, 0666)) == NULL) {
+        PERM_FREE(ret);
+        return NULL;
+    }
+    growme = (char *) PERM_MALLOC(size);
+    ZERO(growme, size);
+    if(PR_Write(ret->fd, (char *)growme, size) < 0) {
+        PR_Close(ret->fd);
+        PERM_FREE(growme);
+        PERM_FREE(ret);
+        return NULL;
+    }
+    PERM_FREE(growme);
+    PR_Seek(ret->fd, 0, PR_SEEK_SET);
+    if( (ret->data = (char *)mmap(NULL, size, PROT_READ | PROT_WRITE,
+                          SHMEM_MMAP_FLAGS, PR_FileDesc2NativeHandle(ret->fd), 0)) == (caddr_t) -1)
+    {
+        PR_Close(ret->fd);
+        PERM_FREE(ret);
+        return NULL;
+    }
+    if(!expose) {
+        ret->name = NULL;
+        unlink(name);
+    }
+    else
+        ret->name = STRDUP(name);
+    ret->size = size;
+    return ret;
+}
+
+
+NSAPI_PUBLIC void shmem_free(shmem_s *region)
+{
+    if(region->name) {
+        unlink(region->name);
+        PERM_FREE(region->name);
+    }
+    munmap((char *)region->data, region->size);  /* CLEARLY, C++ SUCKS */
+    PR_Close(region->fd);
+    PERM_FREE(region);
+}
+
+#elif defined (SHMEM_WIN32_MMAP)
+
+#define PAGE_SIZE	(1024*8)
+#define ALIGN(x)	( (x+PAGE_SIZE-1) & (~(PAGE_SIZE-1)) )
+NSAPI_PUBLIC shmem_s *shmem_alloc(char *name, int size, int expose)
+{
+    shmem_s *ret = (shmem_s *) PERM_MALLOC(sizeof(shmem_s));
+    HANDLE fHandle;
+
+    ret->fd = 0; /* not used on NT */
+  
+    size = ALIGN(size);
+    if( !(ret->fdmap = CreateFileMapping(
+                           (HANDLE)0xffffffff,
+                           NULL, 
+                           PAGE_READWRITE,
+                           0, 
+                           size, 
+                           name)) )
+    {
+        int err = GetLastError();
+        PERM_FREE(ret);
+        return NULL;
+    }
+    if( !(ret->data = (char *)MapViewOfFile (
+                               ret->fdmap, 
+                               FILE_MAP_ALL_ACCESS,
+                               0, 
+                               0, 
+                               0)) )
+    {
+        CloseHandle(ret->fdmap);
+        PERM_FREE(ret);
+        return NULL;
+    }
+    ret->size = size;
+    ret->name = NULL;
+
+    return ret;
+}
+
+
+NSAPI_PUBLIC void shmem_free(shmem_s *region)
+{
+    if(region->name) {
+        DeleteFile(region->name);
+        PERM_FREE(region->name);
+    }
+    UnmapViewOfFile(region->data);
+    CloseHandle(region->fdmap);
+    PERM_FREE(region);
+}
+
+#endif /* SHMEM_WIN32_MMAP */
diff --git a/lib/base/system.cpp b/lib/base/system.cpp
new file mode 100644
index 00000000..e58538b4
--- /dev/null
+++ b/lib/base/system.cpp
@@ -0,0 +1,264 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * system.c: A grab bag of system-level abstractions
+ * 
+ * Many authors
+ */
+
+#include "netsite.h"
+#include "base/nsassert.h"
+#include "base/ereport.h"
+
+#ifdef XP_WIN32
+#include <windows.h>
+static char *version = "Netscape Server/2.0";
+#endif
+
+#include "base/systems.h"	/* find out if we have malloc pools */
+
+static int thread_malloc_key = -1;
+
+#if defined(MALLOC_POOLS) && defined(MCC_HTTPD) && defined(THREAD_ANY)
+#include "base/pool.h"
+#include "base/systhr.h"
+
+#define MALLOC_KEY \
+    ((pool_handle_t *)(thread_malloc_key != -1 ? systhread_getdata(thread_malloc_key) : NULL))
+
+#endif
+
+
+#ifdef MCC_DEBUG
+#define DEBUG_MALLOC
+#endif
+
+#ifdef DEBUG_MALLOC
+
+/* The debug malloc routines provide several functions:
+ *
+ *  - detect allocated memory overflow/underflow
+ *  - detect multiple frees
+ *  - intentionally clobbers malloc'd buffers
+ *  - intentionally clobbers freed buffers
+ */
+#define DEBUG_MAGIC 0x12345678
+#define DEBUG_MARGIN 32
+#define DEBUG_MARGIN_CHAR '*'
+#define DEBUG_MALLOC_CHAR '.'
+#define DEBUG_FREE_CHAR   'X'
+#endif /* DEBUG_MALLOC */
+
+/* On NT, the server version string is not statically encoded based
+ * upon a product compile define but dynamically set by the server
+ * exe at startup.
+ */
+
+NSAPI_PUBLIC char *system_version()
+{
+#ifdef XP_WIN32
+    return version;
+#else /* XP_UNIX */
+    return MAGNUS_VERSION_STRING;
+#endif /* XP_UNIX */
+}
+
+NSAPI_PUBLIC void system_version_set(char *server_version)
+{
+#ifdef XP_WIN32
+    version = PERM_STRDUP(server_version);
+#endif
+}
+
+
+NSAPI_PUBLIC void *system_malloc(int size)
+{
+#if defined(MALLOC_POOLS) && defined(MCC_HTTPD) && defined(THREAD_ANY)
+    return pool_malloc(MALLOC_KEY, size);
+#else
+    return malloc(size);
+#endif
+}
+
+
+NSAPI_PUBLIC void *system_calloc(int size)
+{
+    void *ret;
+#if defined(MALLOC_POOLS) && defined(MCC_HTTPD) && defined(THREAD_ANY)
+    ret = pool_malloc(MALLOC_KEY, size);
+#else
+    ret = malloc(size);
+#endif
+    if(ret)
+        ZERO(ret, size);
+    return ret;
+}
+
+
+NSAPI_PUBLIC void *system_realloc(void *ptr, int size)
+{
+#if defined(MALLOC_POOLS) && defined(MCC_HTTPD) && defined(THREAD_ANY)
+    return pool_realloc(MALLOC_KEY, ptr, size);
+#else
+    return realloc(ptr, size);
+#endif
+}
+
+
+NSAPI_PUBLIC void system_free(void *ptr)
+{
+#if defined(MALLOC_POOLS) && defined(MCC_HTTPD) && defined(THREAD_ANY)
+    pool_free(MALLOC_KEY, ptr);
+#else
+    NS_ASSERT(ptr);
+    free(ptr);
+#endif
+}
+
+NSAPI_PUBLIC char *system_strdup(const char *ptr)
+{
+    NS_ASSERT(ptr);
+#if defined(MALLOC_POOLS) && defined(MCC_HTTPD) && defined(THREAD_ANY)
+    return pool_strdup(MALLOC_KEY, ptr);
+#else
+    return strdup(ptr);
+#endif
+}
+
+
+NSAPI_PUBLIC void *system_malloc_perm(int size)
+{
+#ifndef DEBUG_MALLOC
+    return malloc(size);
+#else
+    char *ptr = (char *)malloc(size + 2*DEBUG_MARGIN+2*sizeof(int));
+    char *real_ptr;
+    int *magic;
+    int *length;
+  
+    magic = (int *)ptr;
+    *magic = DEBUG_MAGIC;
+    ptr += sizeof(int);
+    length = (int *)ptr;
+    *length = size;
+    ptr += sizeof(int);
+    memset(ptr, DEBUG_MARGIN_CHAR, DEBUG_MARGIN);
+    ptr += DEBUG_MARGIN;
+    memset(ptr, DEBUG_MALLOC_CHAR, size);
+    real_ptr = ptr;
+    ptr += size;
+    memset(ptr, DEBUG_MARGIN_CHAR, DEBUG_MARGIN);
+
+    return real_ptr;
+#endif
+}
+
+NSAPI_PUBLIC void *system_calloc_perm(int size)
+{
+    void *ret = system_malloc_perm(size);
+    if(ret)
+        ZERO(ret, size);
+    return ret;
+}
+
+NSAPI_PUBLIC void *system_realloc_perm(void *ptr, int size)
+{
+#ifndef DEBUG_MALLOC
+    return realloc(ptr, size);
+#else
+    int *magic, *length;
+    char *baseptr;
+    char *cptr;
+
+    cptr = (char *)ptr - DEBUG_MARGIN - 2 * sizeof(int);
+    magic = (int *)cptr;
+    if (*magic == DEBUG_MAGIC) {
+        cptr += sizeof(int);
+        length = (int *)cptr;
+        if (*length < size) {
+            char *newptr = (char *)system_malloc_perm(size);
+            memcpy(newptr, ptr, *length);
+            system_free_perm(ptr);
+
+            return newptr;
+        }else {
+            return ptr;
+        }
+    } else {
+        ereport(LOG_WARN, "realloc: attempt to realloc to smaller size");
+        return realloc(ptr, size);
+    }
+
+#endif
+}
+
+NSAPI_PUBLIC void system_free_perm(void *ptr)
+{
+#ifdef DEBUG_MALLOC
+    int *length, *magic;
+    char *baseptr, *cptr;
+    int index;
+
+    NS_ASSERT(ptr);
+
+    cptr = baseptr = ((char *)ptr) - DEBUG_MARGIN - 2*sizeof(int);
+
+    magic = (int *)cptr;
+    if (*magic == DEBUG_MAGIC) {
+        cptr += sizeof(int);
+
+        length = (int *)cptr;
+
+        cptr += sizeof(int); 
+        for (index=0; index<DEBUG_MARGIN; index++)
+            if (cptr[index] != DEBUG_MARGIN_CHAR) {
+                ereport(LOG_CATASTROPHE, "free: corrupt memory (prebounds overwrite)");
+                break;
+            }
+
+        cptr += DEBUG_MARGIN + *length;
+        for (index=0; index<DEBUG_MARGIN; index++)
+            if (cptr[index] != DEBUG_MARGIN_CHAR) {
+                ereport(LOG_CATASTROPHE, "free: corrupt memory (prebounds overwrite)");
+                break;
+            }
+
+        memset(baseptr, DEBUG_FREE_CHAR, *length + 2*DEBUG_MARGIN+sizeof(int));
+    } else {
+        ereport(LOG_CATASTROPHE, "free: freeing unallocated memory");
+    }
+    free(baseptr);
+#else
+    free(ptr);
+#endif
+}
+
+NSAPI_PUBLIC char *system_strdup_perm(const char *ptr)
+{
+#ifndef DEBUG_MALLOC
+    NS_ASSERT(ptr);
+    return strdup(ptr);
+#else
+    int len = strlen(ptr);
+    char *nptr = (char *)system_malloc_perm(len+1);
+    memcpy(nptr, ptr, len);
+    nptr[len] = '\0';
+    return nptr;
+#endif
+}
+
+NSAPI_PUBLIC int 
+getThreadMallocKey(void)
+{
+    return thread_malloc_key;
+}
+
+void
+setThreadMallocKey(int key)
+{
+    thread_malloc_key = key;
+}
+
diff --git a/lib/base/systhr.cpp b/lib/base/systhr.cpp
new file mode 100644
index 00000000..ac29121a
--- /dev/null
+++ b/lib/base/systhr.cpp
@@ -0,0 +1,256 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * systhr.c: Abstracted threading mechanisms
+ * 
+ * Rob McCool
+ */
+
+#include "systhr.h"
+#include "ereport.h"
+
+#define USE_NSPR
+#ifdef USE_NSPR
+#include "nspr.h"
+#include "private/prpriv.h"
+extern "C" {
+int32 PR_GetSysfdTableMax(void);
+int32 PR_SetSysfdTableSize(int table_size);
+}
+#endif
+#include "systems.h"
+
+#ifdef THREAD_WIN32
+#include <process.h>
+
+typedef struct {
+    HANDLE hand;
+    DWORD id;
+} sys_thread_s;
+
+#endif
+
+
+
+#if defined (USE_NSPR)
+
+
+#define DEFAULT_STACKSIZE (64*1024)
+
+static unsigned long _systhr_stacksize = DEFAULT_STACKSIZE;
+
+NSAPI_PUBLIC 
+void systhread_set_default_stacksize(unsigned long size)
+{
+	_systhr_stacksize = size;
+}
+
+NSPR_BEGIN_EXTERN_C
+
+NSAPI_PUBLIC SYS_THREAD
+#ifdef UnixWare /* for ANSI C++ standard, see base/systrh.h */
+systhread_start(int prio, int stksz, ArgFn_systhread_start fn, void *arg)
+#else
+systhread_start(int prio, int stksz, void (*fn)(void *), void *arg)
+#endif
+{
+#if (defined(Linux) || defined(SNI) || defined(UnixWare)) && !defined(USE_PTHREADS)
+    prio /= 8; /* quick and dirty fix for user thread priority scale problem */
+    if (prio > 3) prio = 3;
+#endif
+
+    PRThread *ret = PR_CreateThread(PR_USER_THREAD, (void (*)(void *))fn,
+				    (void *)arg, (PRThreadPriority)prio, 
+				    PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD,
+                                    stksz ? stksz : _systhr_stacksize);
+    return (void *) ret;
+}
+
+NSPR_END_EXTERN_C
+
+
+NSAPI_PUBLIC SYS_THREAD systhread_current(void)
+{
+    return PR_GetCurrentThread();
+}
+
+NSAPI_PUBLIC void systhread_yield(void)
+{
+  /* PR_Yield(); */
+  PR_Sleep(PR_INTERVAL_NO_WAIT);
+}
+
+
+NSAPI_PUBLIC void systhread_timerset(int usec)
+{
+   /* This is an interesting problem.  If you ever do turn on interrupts
+    * on the server, you're in for lots of fun with NSPR Threads
+   PR_StartEvents(usec); */
+}
+
+
+NSAPI_PUBLIC 
+SYS_THREAD systhread_attach(void)
+{
+    PRThread *ret;
+    ret = PR_AttachThread(PR_USER_THREAD, PR_PRIORITY_NORMAL, NULL);
+
+    return (void *) ret;
+}
+
+NSAPI_PUBLIC
+void systhread_detach(SYS_THREAD thr)
+{
+    /* XXXMB - this is not correct! */
+    PR_DetachThread();
+}
+
+NSAPI_PUBLIC void systhread_terminate(SYS_THREAD thr)
+{
+
+    /* Should never be here. PR_DestroyThread is no 
+     * longer used. */
+    PR_ASSERT(0);
+  
+    /* PR_DestroyThread((PRThread *) thr); */
+}
+
+NSAPI_PUBLIC void systhread_sleep(int milliseconds)
+{
+    PR_Sleep(milliseconds);
+}
+
+NSAPI_PUBLIC void systhread_init(char *name)
+{
+    PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 256);
+#ifdef XP_UNIX
+    /* XXXrobm allocate all the fd's we can... */
+    PR_SetSysfdTableSize(PR_GetSysfdTableMax());
+#endif
+}
+
+
+NSAPI_PUBLIC int systhread_newkey()
+{
+    uintn newkey;
+
+    PR_NewThreadPrivateIndex(&newkey, NULL);
+    return (newkey);
+}
+
+NSAPI_PUBLIC void *systhread_getdata(int key)
+{
+    return PR_GetThreadPrivate(key);
+}
+
+NSAPI_PUBLIC void systhread_setdata(int key, void *data)
+{
+    PR_SetThreadPrivate(key, data);
+}
+
+/* 
+ * Drag in the Java code, so our dynamic library full of it works 
+ * i.e. force these symbols to load.
+ */
+NSAPI_PUBLIC void systhread_dummy(void)
+{
+
+#ifndef NSPR20
+    /* nspr/gc.c */
+    PR_InitGC(0,0);
+    /* nspr/prsystem.c */
+    PR_GetSystemInfo(PR_SI_SYSNAME, 0, 0);
+    /* nspr/linker.c */
+    PR_GetLibName(0, 0);
+    /* nspr/file.c */
+    PR_Mkdir(0, 0);
+    /* nspr/prnetdb.c */
+    PR_gethostbyname(0, 0, 0, 0, 0);
+    /* nspr/longlong.c */
+    LL_TO_S(LL_ZERO, 0, NULL, 0);
+#endif /* NSPR20 */
+}
+
+#elif defined(THREAD_WIN32)
+
+#include <nspr/prthread.h>
+#define DEFAULT_STACKSIZE 262144
+
+NSPR_BEGIN_EXTERN_C
+
+NSAPI_PUBLIC 
+SYS_THREAD systhread_start(int prio, int stksz, void (*fn)(void *), void *arg)
+{
+    sys_thread_s *ret = (sys_thread_s *) MALLOC(sizeof(sys_thread_s));
+
+    if ((ret->hand = (HANDLE)_beginthreadex(NULL, stksz, (unsigned (__stdcall *)(void *))fn, 
+	                                        arg, 0, &ret->id)) == 0) {
+        FREE(ret);
+        return NULL;
+    }
+    return (void *)ret;
+}
+
+NSPR_END_EXTERN_C
+
+NSAPI_PUBLIC SYS_THREAD systhread_current(void)
+{
+    /* XXXrobm this is busted.... */
+    return GetCurrentThread();
+}
+
+NSAPI_PUBLIC void systhread_timerset(int usec)
+{
+}
+
+NSAPI_PUBLIC SYS_THREAD systhread_attach(void)
+{
+    return NULL;
+}
+
+NSAPI_PUBLIC void systhread_yield(void)
+{
+    systhread_sleep(0);
+}
+
+NSAPI_PUBLIC void systhread_terminate(SYS_THREAD thr)
+{
+    TerminateThread(((sys_thread_s *)thr)->hand, 0);
+}
+
+
+NSAPI_PUBLIC void systhread_sleep(int milliseconds)
+{
+    /* XXXrobm there must be a better way to do this */
+    HANDLE sem = CreateSemaphore(NULL, 1, 4, "sleeper");
+    WaitForSingleObject(sem, INFINITE);
+    WaitForSingleObject(sem, milliseconds);
+    CloseHandle(sem);
+}
+
+NSAPI_PUBLIC void systhread_init(char *name)
+{
+    PR_Init(PR_USER_THREAD, 1, 0);
+}
+
+
+NSAPI_PUBLIC int systhread_newkey()
+{
+    return TlsAlloc();
+}
+
+NSAPI_PUBLIC void *systhread_getdata(int key)
+{
+    return (void *)TlsGetValue(key);
+}
+
+NSAPI_PUBLIC void systhread_setdata(int key, void *data)
+{
+    TlsSetValue(key, data);
+}
+
+#endif
+
diff --git a/lib/base/util.cpp b/lib/base/util.cpp
new file mode 100644
index 00000000..55d6ca56
--- /dev/null
+++ b/lib/base/util.cpp
@@ -0,0 +1,1449 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2001 Sun Microsystems, Inc.
+ * Portions copyright 1999, 2001-2003 Netscape Communications Corporation.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+/*
+ * util.c: A hodge podge of utility functions and standard functions which 
+ *         are unavailable on certain systems
+ * 
+ * Rob McCool
+ */
+
+#ifdef XP_UNIX
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include "prthread.h"
+#endif /* XP_UNIX */
+
+#include "base/util.h"
+
+#include "base/dbtbase.h"
+#include "base/ereport.h"
+
+
+#ifdef XP_UNIX
+#include <sys/types.h>
+#endif /* WIN32 */
+
+/* ----------------------------- util_getline ----------------------------- */
+
+#define LF 10
+#define CR 13
+
+NSAPI_PUBLIC int util_getline(filebuf_t *buf, int lineno, int maxlen, char *l) {
+    int i, x;
+
+    x = 0;
+    while(1) {
+	i = filebuf_getc(buf);
+        switch(i) {
+          case IO_EOF:
+            l[x] = '\0';
+            return 1;
+          case LF:
+            if(x && (l[x-1] == '\\')) {
+                --x;
+                continue;
+            }
+            l[x] = '\0';
+            return 0;
+          case IO_ERROR:
+            util_sprintf(l, "I/O error reading file at line %d", lineno);
+            return -1;
+          case CR:
+            continue;
+          default:
+            l[x] = (char) i;
+            if(++x == maxlen) {
+                util_sprintf(l, "line %d is too long", lineno);
+                return -1;
+            }
+            break;
+        }
+    }
+}
+
+
+/* ---------------------------- util_can_exec ----------------------------- */
+
+#ifdef XP_UNIX
+NSAPI_PUBLIC int util_can_exec(struct stat *fi, uid_t uid, gid_t gid) 
+{
+    if(!uid)
+       return 1;
+    if((fi->st_mode & S_IXOTH) || 
+       ((gid == fi->st_gid) && (fi->st_mode & S_IXGRP)) ||
+       ((uid == fi->st_uid) && (fi->st_mode & S_IXUSR)))
+        return 1;
+    return 0;
+}
+#endif /* XP_UNIX */
+
+
+/* --------------------------- util_env_create ---------------------------- */
+
+
+NSAPI_PUBLIC char **util_env_create(char **env, int n, int *pos)
+{
+    int x;
+
+    if(!env) {
+        *pos = 0;
+        return (char **) MALLOC((n + 1)*sizeof(char *));
+    }
+    else {
+        for(x = 0; (env[x]); x++);
+        env = (char **) REALLOC(env, (n + x + 1)*(sizeof(char *)));
+        *pos = x;
+        return env;
+    }
+}
+
+
+/* ---------------------------- util_env_free ----------------------------- */
+
+
+NSAPI_PUBLIC void util_env_free(char **env)
+{
+    register char **ep = env;
+
+    for(ep = env; *ep; ep++)
+        FREE(*ep);
+    FREE(env);
+}
+
+/* ----------------------------- util_env_str ----------------------------- */
+
+
+NSAPI_PUBLIC char *util_env_str(char *name, char *value) {
+    char *t,*tp;
+
+    t = (char *) MALLOC(strlen(name)+strlen(value)+2); /* 2: '=' and '\0' */
+
+    for(tp=t; (*tp = *name); tp++,name++);
+    for(*tp++ = '='; (*tp = *value); tp++,value++);
+    return t;
+}
+
+
+/* --------------------------- util_env_replace --------------------------- */
+
+
+NSAPI_PUBLIC void util_env_replace(char **env, char *name, char *value)
+{
+    int x, y, z;
+    char *i;
+
+    for(x = 0; env[x]; x++) {
+        i = strchr(env[x], '=');
+        *i = '\0';
+        if(!strcmp(env[x], name)) {
+            y = strlen(env[x]);
+            z = strlen(value);
+
+            env[x] = (char *) REALLOC(env[x], y + z + 2);
+            util_sprintf(&env[x][y], "=%s", value);
+            return;
+        }
+        *i = '=';
+    }
+}
+
+
+/* ---------------------------- util_env_find ----------------------------- */
+
+
+NSAPI_PUBLIC char *util_env_find(char **env, char *name)
+{
+    char *i;
+    int x, r;
+
+    for(x = 0; env[x]; x++) {
+        i = strchr(env[x], '=');
+        *i = '\0';
+        r = !strcmp(env[x], name);
+        *i = '=';
+        if(r)
+            return i + 1;
+    }
+    return NULL;
+}
+
+
+/* ---------------------------- util_env_copy ----------------------------- */
+
+
+NSAPI_PUBLIC char **util_env_copy(char **src, char **dst)
+{
+    char **src_ptr;
+    int src_cnt;
+    int index;
+
+    if (!src)
+        return NULL;
+
+    for (src_cnt = 0, src_ptr = src; *src_ptr; src_ptr++, src_cnt++);
+
+    if (!src_cnt)
+        return NULL;
+
+    dst = util_env_create(dst, src_cnt, &index);
+
+    for (src_ptr = src, index=0; *src_ptr; index++, src_ptr++)
+        dst[index] = STRDUP(*src_ptr);
+    dst[index] = NULL;
+    
+    return dst;
+}
+
+/* ---------------------------- util_hostname ----------------------------- */
+
+
+/*
+ * MOVED TO NET.C TO AVOID INTERDEPENDENCIES
+ */
+
+
+/* --------------------------- util_chdir2path ---------------------------- */
+
+
+NSAPI_PUBLIC int util_chdir2path(char *path) 
+{  
+	/* use FILE_PATHSEP to accomodate WIN32 */
+    char *t = strrchr(path, FILE_PATHSEP);
+    int ret;
+
+    if(!t)
+        return -1;
+
+    *t = '\0';
+#ifdef XP_UNIX
+    ret = chdir(path);
+#else /* WIN32 */
+	ret = SetCurrentDirectory(path);
+#endif /* XP_UNIX */
+
+	/* use FILE_PATHSEP instead of chdir to accomodate WIN32 */
+    *t = FILE_PATHSEP;
+
+    return ret;
+}
+
+
+/* --------------------------- util_is_mozilla ---------------------------- */
+
+
+NSAPI_PUBLIC int util_is_mozilla(char *ua, char *major, char *minor)
+{
+    if((!ua) || strncasecmp(ua, "Mozilla/", 8))
+        return 0;
+
+    /* Major version. I punted on supporting versions like 10.0 */
+    if(ua[8] > major[0])
+        return 1;
+    else if((ua[8] < major[0]) || (ua[9] != '.'))
+        return 0;
+
+    /* Minor version. Support version numbers like 0.96 */
+    if(ua[10] < minor[0])
+        return 0;
+    else if((ua[10] > minor[0]) || (!minor[1]))
+        return 1;
+
+    if((!isdigit(ua[11])) || (ua[11] < minor[1]))
+        return 0;
+    else
+        return 1;
+}
+
+
+/* ----------------------------- util_is_url ------------------------------ */
+
+
+#include <ctype.h>     /* isalpha */
+
+NSAPI_PUBLIC int util_is_url(char *url)
+{
+    char *t = url;
+
+    while(*t) {
+        if(*t == ':')
+            return 1;
+        if(!isalpha(*t))
+            return 0;
+        ++t;
+    }
+    return 0;
+}
+
+
+/* --------------------------- util_later_than ---------------------------- */
+
+
+int _mstr2num(char *str) {
+    if(!strcasecmp(str, "Jan")) return 0;
+    if(!strcasecmp(str, "Feb")) return 1;
+    if(!strcasecmp(str, "Mar")) return 2;
+    if(!strcasecmp(str, "Apr")) return 3;
+    if(!strcasecmp(str, "May")) return 4;
+    if(!strcasecmp(str, "Jun")) return 5;
+    if(!strcasecmp(str, "Jul")) return 6;
+    if(!strcasecmp(str, "Aug")) return 7;
+    if(!strcasecmp(str, "Sep")) return 8;
+    if(!strcasecmp(str, "Oct")) return 9;
+    if(!strcasecmp(str, "Nov")) return 10;
+    if(!strcasecmp(str, "Dec")) return 11;
+    return -1;
+}
+
+int _time_compare(struct tm *lms, char *ims, int later_than_op)
+{
+    int y = 0, mnum = 0, d = 0, h = 0, m = 0, s = 0, x;
+    char t[128];
+
+    /* Supported formats start with weekday (which we don't care about) */
+    /* The sizeof(t) is to avoid buffer overflow with t */
+    if((!(ims = strchr(ims,' '))) || (strlen(ims) > (sizeof(t) - 2)))
+        return 0;
+
+    while(*ims && isspace(*ims)) ++ims;
+    if((!(*ims)) || (strlen(ims) < 2))
+        return 0;
+
+    /* Standard HTTP (RFC 850) starts with dd-mon-yy */
+    if(ims[2] == '-') {
+        sscanf(ims, "%s %d:%d:%d", t, &h, &m, &s);
+        if(strlen(t) < 6)
+            return 0;
+        t[2] = '\0';
+        t[6] = '\0';
+        d = atoi(t);
+        mnum = _mstr2num(&t[3]);
+        x = atoi(&t[7]);
+        /* Postpone wraparound until 2070 */
+        y = x + (x < 70 ? 2000 : 1900);
+    }
+    /* The ctime format starts with a month name */
+    else if(isalpha(*ims)) {
+        sscanf(ims,"%s %d %d:%d:%d %*s %d", t, &d, &h, &m, &s, &y);
+        mnum = _mstr2num(t);
+    }
+    /* RFC 822 */
+    else {
+        sscanf(ims, "%d %s %d %d:%d:%d", &d, t, &y, &h, &m, &s);
+        mnum = _mstr2num(t);
+    }
+
+    if (later_than_op) {
+	if( (x = (1900 + lms->tm_year) - y) )
+	    return x < 0;
+
+	if(mnum == -1)
+	    return 0;
+
+	/* XXXMB - this will fail if you check if december 31 1996 is later
+	 * than january 1 1997
+	 */
+	if((x = lms->tm_mon - mnum) || (x = lms->tm_mday - d) || 
+	   (x = lms->tm_hour - h) || (x = lms->tm_min - m) || 
+	   (x = lms->tm_sec - s))
+	  return x < 0;
+
+	return 1;
+    }
+    else {
+	return (mnum != -1 &&
+		1900 + lms->tm_year == y    &&
+		lms->tm_mon         == mnum &&
+		lms->tm_mday        == d    &&
+		lms->tm_hour        == h    &&
+		lms->tm_min         == m    &&
+		lms->tm_sec         == s);
+    }
+}
+
+
+/* Returns 0 if lms later than ims
+ * Returns 1 if equal
+ * Returns 1 if ims later than lms
+ */
+NSAPI_PUBLIC int util_later_than(struct tm *lms, char *ims)
+{
+    return _time_compare(lms, ims, 1);
+}
+
+
+NSAPI_PUBLIC int util_time_equal(struct tm *lms, char *ims)
+{
+    return _time_compare(lms, ims, 0);
+}
+
+/* util_str_time_equal()
+ *
+ * Function to compare if two time strings are equal
+ *
+ * Acceptible date formats:
+ *      Saturday, 17-Feb-96 19:41:34 GMT        <RFC850>
+ *      Sat, 17 Mar 1996 19:41:34 GMT           <RFC1123>
+ *
+ * Argument t1 MUST be RFC1123 format.
+ *
+ * Note- it is not the intention of this routine to *always* match
+ *       There are cases where we would return != when the strings might
+ *       be equal (especially with case).  The converse should not be true.
+ *
+ * Return 0 if equal, -1 if not equal.
+ */
+#define MINIMUM_LENGTH  18
+#define RFC1123_DAY      5
+#define RFC1123_MONTH    8
+#define RFC1123_YEAR     12
+#define RFC1123_HOUR     17
+#define RFC1123_MINUTE   20
+#define RFC1123_SECOND   23
+NSAPI_PUBLIC int util_str_time_equal(char *t1, char *t2)
+{
+    int index;
+
+    /* skip over leading whitespace... */
+    while(*t1 && isspace(*t1)) ++t1;
+    while(*t2 && isspace(*t2)) ++t2;
+
+    /* Check weekday */
+    if ( (t1[0] != t2[0]) || (t1[1] != t2[1]) )
+        return -1;
+
+    /* Skip to date */
+    while(*t2 && !isspace(*t2)) ++t2;
+    t2++;
+
+    /* skip if not strings not long enough */
+    if ( (strlen(t1) < MINIMUM_LENGTH) || (strlen(t2) < MINIMUM_LENGTH) )
+        return -1;
+
+    if ( (t1[RFC1123_DAY] != t2[0]) || (t1[RFC1123_DAY+1] != t2[1]) )
+        return -1;
+
+    /* Skip to the month */
+    t2 += 3;
+
+    if ( (t1[RFC1123_MONTH] != t2[0]) || (t1[RFC1123_MONTH+1] != t2[1]) ||
+        (t1[RFC1123_MONTH+2] != t2[2]) )
+        return -1;
+
+    /* Skip to year */
+    t2 += 4;
+
+    if ( (t1[RFC1123_YEAR] != t2[0]) ) {
+        /* Assume t2 is RFC 850 format */
+        if ( (t1[RFC1123_YEAR+2] != t2[0]) || (t1[RFC1123_YEAR+3] != t2[1]) )
+            return -1;
+
+        /* skip to hour */
+        t2 += 3;
+    } else {
+        /* Assume t2 is RFC 1123 format */
+        if ( (t1[RFC1123_YEAR+1] != t2[1]) || (t1[RFC1123_YEAR+2] != t2[2]) ||
+            (t1[RFC1123_YEAR+3] != t2[3]) )
+            return -1;
+
+        /* skip to hour */
+        t2 += 5;
+    }
+
+    /* check date */
+    for (index=0; index<8; index++) {
+        if ( t1[RFC1123_HOUR+index] != t2[index] )
+            return -1;
+    }
+
+    /* Ignore timezone */
+
+    return 0;
+}
+
+
+/* --------------------------- util_uri_is_evil --------------------------- */
+
+
+NSAPI_PUBLIC int util_uri_is_evil(char *t)
+{
+    register int x;
+
+    for(x = 0; t[x]; ++x) {
+        if(t[x] == '/') {
+            if(t[x+1] == '/')
+                return 1;
+            if(t[x+1] == '.') {
+                switch(t[x+2]) {
+                case '.':
+                    if((!t[x+3]) || (t[x+3] == '/'))
+                        return 1;
+                case '/':
+                case '\0':
+                    return 1;
+                }
+            }
+        }
+#ifdef XP_WIN32
+        /* On NT, the directory "abc...." is the same as "abc"
+         * The only cheap way to catch this globally is to disallow
+         * names with the trailing "."s.  Hopefully this is not over
+         * restrictive
+         */
+        if ((t[x] == '.') && ( (t[x+1] == '/') || (t[x+1] == '\0') )) {
+            return 1;
+        }
+#endif
+    }
+    return 0;
+}
+
+/* ---------------------------- util_uri_parse ---------------------------- */
+
+NSAPI_PUBLIC void util_uri_parse(char *uri)  
+{
+    int spos = 0, tpos = 0;
+    int l = strlen(uri);
+
+    while(uri[spos])  {
+        if(uri[spos] == '/')  {
+            if((spos != l) && (uri[spos+1] == '.'))  {
+                if(uri[spos+2] == '/')
+                    spos += 2;
+                else
+                    if((spos <= (l-3)) && 
+                       (uri[spos+2] == '.') && (uri[spos+3] == '/'))  {
+                        spos += 3;
+                        while((tpos > 0) && (uri[--tpos] != '/'))    
+                            uri[tpos] = '\0';
+                    }  else
+                        uri[tpos++] = uri[spos++];
+            }  else  {
+                if(uri[spos+1] != '/')
+                    uri[tpos++] = uri[spos++];
+                else 
+                    spos++;
+            }
+        }  else
+            uri[tpos++] = uri[spos++];
+    }
+    uri[tpos] = '\0';
+}
+
+
+/* -------------------- util_uri_unescape_and_normalize -------------------- */
+
+#ifdef XP_WIN32
+/* The server calls this function to unescape the URI and also normalize 
+ * the uri.  Normalizing the uri converts all "\" characters in the URI
+ * and pathinfo portion to "/".  Does not touch "\" in query strings.
+ */
+void util_uri_unescape_and_normalize(char *s)
+{
+    char *t, *u;
+
+    for(t = s, u = s; *t; ++t, ++u) {
+        if((*t == '%') && t[1] && t[2]) {
+            *u = ((t[1] >= 'A' ? ((t[1] & 0xdf) - 'A')+10 : (t[1] - '0'))*16) +
+                  (t[2] >= 'A' ? ((t[2] & 0xdf) - 'A')+10 : (t[2] - '0'));
+            t += 2;
+        }
+        else
+            if(u != t)
+                *u = *t;
+        if (*u == '\\')		/* normalize */
+            *u = '/';
+    }
+    *u = *t;
+}
+#endif /* XP_WIN32 */
+
+/* -------------------------- util_uri_unescape --------------------------- */
+
+NSAPI_PUBLIC void util_uri_unescape(char *s)
+{
+    char *t, *u;
+
+    for(t = s, u = s; *t; ++t, ++u) {
+        if((*t == '%') && t[1] && t[2]) {
+            *u = ((t[1] >= 'A' ? ((t[1] & 0xdf) - 'A')+10 : (t[1] - '0'))*16) +
+                  (t[2] >= 'A' ? ((t[2] & 0xdf) - 'A')+10 : (t[2] - '0'));
+            t += 2;
+        }
+        else
+            if(u != t)
+                *u = *t;
+    }
+    *u = *t;
+}
+
+
+/* --------------------------- util_uri_escape ---------------------------- */
+
+
+NSAPI_PUBLIC char *util_uri_escape(char *od, char *s)
+{
+    char *d;
+
+    if(!od)
+        od = (char *) MALLOC((strlen(s)*3) + 1);
+    d = od;
+
+    while(*s) {
+        if(strchr("% ?#:+&*\"<>\r\n", *s)) {
+            sprintf(d, "%%%2x", *s);
+            ++s; d += 3;
+        }
+        else
+            *d++ = *s++;
+    }
+    *d = '\0';
+    return od;
+}
+
+
+/* --------------------------- util_url_escape ---------------------------- */
+
+
+NSAPI_PUBLIC char *util_url_escape(char *od, char *s)
+{
+    char *d;
+
+    if(!od)
+        od = (char *) MALLOC((strlen(s)*3) + 1);
+    d = od;
+
+    while(*s) {
+        if(strchr("% +*\"<>\r\n", *s)) {
+            sprintf(d, "%%%.2x", *s);
+            ++s; d += 3;
+        }
+        else
+            *d++ = *s++;
+    }
+    *d = '\0';
+    return od;
+}
+
+
+/* ------------------------- util_mime_separator -------------------------- */
+
+
+NSAPI_PUBLIC int util_mime_separator(char *sep)
+{
+    srand(time(NULL));
+    return util_sprintf(sep, "%c%c--%d%d%d", CR, LF, rand(), rand(), rand());
+}
+
+
+/* ------------------------------ util_itoa ------------------------------- */
+
+
+/* 
+ * Assumption: Reversing the digits will be faster in the general case 
+ * than doing a log10 or some nasty trick to find the # of digits.
+ */
+
+NSAPI_PUBLIC int util_itoa(int i, char *a)
+{
+    register int x, y, p;
+    register char c;
+    int negative;
+
+    negative = 0;
+    if(i < 0) {
+        *a++ = '-';
+        negative = 1;
+        i = -i;
+    }
+    p = 0;
+    while(i > 9) {
+        a[p++] = (i%10) + '0';
+        i /= 10;
+    }
+    a[p++] = i + '0';
+
+    if(p > 1) {
+        for(x = 0, y = p - 1; x < y; ++x, --y) {
+            c = a[x];
+            a[x] = a[y];
+            a[y] = c;
+        }
+    }
+    a[p] = '\0';
+    return p + negative;
+}
+
+
+/* ----------------------------- util_sprintf ----------------------------- */
+
+
+#include "prprf.h"
+
+/* 
+   XXXrobm the NSPR interfaces don't allow me to just pass in a buffer 
+   without a size
+ */
+#define UTIL_PRF_MAXSIZE 1048576
+
+NSAPI_PUBLIC int util_vsnprintf(char *s, int n, register const char *fmt, 
+                                va_list args)
+{
+    return PR_vsnprintf(s, n, fmt, args);
+}
+
+NSAPI_PUBLIC int util_snprintf(char *s, int n, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    return PR_vsnprintf(s, n, fmt, args);
+}
+
+NSAPI_PUBLIC int util_vsprintf(char *s, register const char *fmt, va_list args)
+{
+    return PR_vsnprintf(s, UTIL_PRF_MAXSIZE, fmt, args);
+}
+
+NSAPI_PUBLIC int util_sprintf(char *s, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    return PR_vsnprintf(s, UTIL_PRF_MAXSIZE, fmt, args);
+}
+
+/* ---------------------------- util_sh_escape ---------------------------- */
+
+
+NSAPI_PUBLIC char *util_sh_escape(char *s)
+{
+    char *ns = (char *) MALLOC(strlen(s) * 2 + 1);   /* worst case */
+    register char *t, *u;
+
+    for(t = s, u = ns; *t; ++t, ++u) {
+        if(strchr("&;`'\"|*?~<>^()[]{}$\\ #!", *t))
+            *u++ = '\\';
+        *u = *t;
+    }
+    *u = '\0';
+    return ns;
+}
+
+/* --------------------------- util_strcasecmp ---------------------------- */
+
+
+#ifdef NEED_STRCASECMP
+/* These are stolen from mcom/lib/xp */
+NSAPI_PUBLIC 
+int util_strcasecmp(CASECMPARG_T char *one, CASECMPARG_T char *two)
+{
+    CASECMPARG_T char *pA;
+    CASECMPARG_T char *pB;
+
+    for(pA=one, pB=two; *pA && *pB; pA++, pB++)
+      {
+        int tmp = tolower(*pA) - tolower(*pB);
+        if (tmp)
+            return tmp;
+      }
+    if (*pA)
+        return 1;
+    if (*pB)
+        return -1;
+    return 0;
+}
+#endif /* NEED_STRCASECMP */
+
+#ifdef NEED_STRNCASECMP
+NSAPI_PUBLIC 
+int util_strncasecmp(CASECMPARG_T char *one, CASECMPARG_T char *two, int n)
+{
+    CASECMPARG_T char *pA;
+    CASECMPARG_T char *pB;
+
+    for(pA=one, pB=two;; pA++, pB++)
+      {
+        int tmp;
+        if (pA == one+n)
+            return 0;
+        if (!(*pA && *pB))
+            return *pA - *pB;
+        tmp = tolower(*pA) - tolower(*pB);
+        if (tmp)
+            return tmp;
+      }
+}
+#endif /* NEED_STRNCASECMP */
+
+#ifdef XP_WIN32
+
+
+/* util_delete_directory()
+ * This routine deletes all the files in a directory.  If delete_directory is 
+ * TRUE it will also delete the directory itself.
+ */
+VOID
+util_delete_directory(char *FileName, BOOL delete_directory)
+{
+    HANDLE firstFile;
+    WIN32_FIND_DATA findData;
+    char *TmpFile, *NewFile;
+
+    if (FileName == NULL)
+        return;
+
+    TmpFile = (char *)MALLOC(strlen(FileName) + 5);
+    sprintf(TmpFile, "%s\\*.*", FileName);
+    firstFile = FindFirstFile(TmpFile, &findData);
+    FREE(TmpFile);
+
+    if (firstFile == INVALID_HANDLE_VALUE) 
+        return;
+
+    if(strcmp(findData.cFileName, ".") &&
+        strcmp(findData.cFileName, "..")) {
+            NewFile = (char *)MALLOC(strlen(FileName) + 1 +
+                strlen(findData.cFileName) + 1);
+            sprintf(NewFile, "%s\\%s",FileName, findData.cFileName);
+            DeleteFile(NewFile);
+            FREE(NewFile);
+    }
+    while (TRUE) {
+        if(!(FindNextFile(firstFile, &findData))) {
+            if (GetLastError() != ERROR_NO_MORE_FILES) {
+                ereport(LOG_WARN, XP_GetAdminStr(DBT_couldNotRemoveTemporaryDirectory_), FileName, GetLastError());
+            } else {
+                FindClose(firstFile);
+				if (delete_directory)
+					if(!RemoveDirectory(FileName)) {
+						ereport(LOG_WARN,
+							XP_GetAdminStr(DBT_couldNotRemoveTemporaryDirectory_1),
+							FileName, GetLastError());
+					}
+                return;
+            }
+        } else {
+            if(strcmp(findData.cFileName, ".") &&
+                strcmp(findData.cFileName, "..")) {
+                NewFile = (char *)MALLOC(strlen(FileName) + 5 +
+                    strlen(findData.cFileName) + 1);
+                sprintf(NewFile,"%s\\%s", FileName, findData.cFileName);
+                DeleteFile(NewFile);
+                FREE(NewFile);
+            }
+        }
+    }
+}
+#endif
+
+/* ------------------------------ util_strftime --------------------------- */
+/*
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)strftime.c	5.11 (Berkeley) 2/24/91";
+#endif /* LIBC_SCCS and not lint */
+
+#ifdef XP_UNIX
+#include <sys/types.h>
+#include <sys/time.h>
+#include <string.h>
+#include <stdio.h>
+#endif
+
+static char *afmt[] = {
+	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
+};
+static char *Afmt[] = {
+	"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
+	"Saturday",
+};
+
+static char *bfmt[] = {
+	"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
+	"Oct", "Nov", "Dec",
+};
+static char *Bfmt[] = {
+	"January", "February", "March", "April", "May", "June", "July",
+	"August", "September", "October", "November", "December",
+};
+
+#define TM_YEAR_BASE 1900
+
+static void _util_strftime_conv(char *, int, int, char);
+
+#define _util_strftime_add(str) for (;(*pt = *str++); pt++);
+#define _util_strftime_copy(str, len) memcpy(pt, str, len); pt += len;
+#define _util_strftime_fmt util_strftime
+
+/* util_strftime()
+ * This is an optimized version of strftime for speed.  Avoids the thread
+ * unsafeness of BSD strftime calls. 
+ */
+int
+util_strftime(char *pt, const char *format, const struct tm *t)
+{
+    char *start = pt;
+	char *scrap;
+
+	for (; *format; ++format) {
+		if (*format == '%')
+			switch(*++format) {
+			case 'a': /* abbreviated weekday name */
+				*pt++ = afmt[t->tm_wday][0];
+				*pt++ = afmt[t->tm_wday][1];
+				*pt++ = afmt[t->tm_wday][2];
+				continue;
+			case 'd': /* day of month */
+				_util_strftime_conv(pt, t->tm_mday, 2, '0');
+				pt += 2;
+				continue;
+			case 'S':
+				 _util_strftime_conv(pt, t->tm_sec, 2, '0');
+				pt += 2;
+				continue;
+			case 'M':
+				 _util_strftime_conv(pt, t->tm_min, 2, '0');
+				pt += 2;
+				continue;
+			case 'H':
+				_util_strftime_conv(pt, t->tm_hour, 2, '0');
+				pt += 2;
+				continue;
+			case 'Y':
+				if (t->tm_year < 100) {
+					*pt++ = '1';
+					*pt++ = '9';
+					_util_strftime_conv(pt, t->tm_year, 2, '0');
+				} else {
+					/* will fail after 2100; but who cares? */
+					*pt++ = '2';
+					*pt++ = '0';
+					_util_strftime_conv(pt, t->tm_year-100, 2, '0');
+				}
+				pt += 2;
+				continue;
+			case 'b': /* abbreviated month name */
+			case 'h':
+				*pt++ = bfmt[t->tm_mon][0];
+				*pt++ = bfmt[t->tm_mon][1];
+				*pt++ = bfmt[t->tm_mon][2];
+				continue;
+			case 'T':
+			case 'X':
+				pt += _util_strftime_fmt(pt, "%H:%M:%S", t);
+				continue;
+			case '\0':
+				--format;
+				break;
+			case 'A':
+				if (t->tm_wday < 0 || t->tm_wday > 6)
+					return(0);
+				scrap = Afmt[t->tm_wday];
+				_util_strftime_add(scrap);
+				continue;
+			case 'B':
+				if (t->tm_mon < 0 || t->tm_mon > 11)
+					return(0);
+				scrap = Bfmt[t->tm_mon];
+				_util_strftime_add(scrap);
+				continue;
+			case 'C':
+				pt += _util_strftime_fmt(pt, "%a %b %e %H:%M:%S %Y", t);
+				continue;
+			case 'c':
+				pt += _util_strftime_fmt(pt, "%m/%d/%y %H:%M:%S", t);
+				continue;
+			case 'D':
+				pt += _util_strftime_fmt(pt, "%m/%d/%y", t);
+				continue;
+			case 'e':
+				_util_strftime_conv(pt, t->tm_mday, 2, ' ');
+				pt += 2;
+				continue;
+			case 'I':
+				_util_strftime_conv(pt, t->tm_hour % 12 ?
+				    t->tm_hour % 12 : 12, 2, '0');
+				pt += 2;
+				continue;
+			case 'j':
+				_util_strftime_conv(pt, t->tm_yday + 1, 3, '0');
+				pt += 3;
+				continue;
+			case 'k':
+				_util_strftime_conv(pt, t->tm_hour, 2, ' ');
+				pt += 2;
+				continue;
+			case 'l':
+				 _util_strftime_conv(pt, t->tm_hour % 12 ?
+				    t->tm_hour % 12 : 12, 2, ' ');
+				pt += 2;
+				continue;
+			case 'm':
+				 _util_strftime_conv(pt, t->tm_mon + 1, 2, '0');
+				pt += 2;
+				continue;
+			case 'n':
+				*pt = '\n';
+				pt++;
+				continue;
+			case 'p':
+				if (t->tm_hour >= 12) {
+					*pt = 'P';
+					pt++;
+				} else {
+					*pt = 'A';
+					pt++;
+				}
+				*pt = 'M';
+				pt++;
+				continue;
+			case 'R':
+				pt += _util_strftime_fmt(pt, "%H:%M", t);
+				continue;
+			case 'r':
+				pt += _util_strftime_fmt(pt, "%I:%M:%S %p", t);
+				continue;
+			case 't':
+				*pt = '\t';
+				pt++;
+				continue;
+			case 'U':
+				 _util_strftime_conv(pt, (t->tm_yday + 7 - t->tm_wday) / 7,
+				    2, '0');
+				pt += 2;
+				continue;
+			case 'W':
+				 _util_strftime_conv(pt, (t->tm_yday + 7 -
+				    (t->tm_wday ? (t->tm_wday - 1) : 6))
+				    / 7, 2, '0');
+				pt += 2;
+				continue;
+			case 'w':
+				 _util_strftime_conv(pt, t->tm_wday, 1, '0');
+				pt += 1;
+				continue;
+			case 'x':
+				pt += _util_strftime_fmt(pt, "%m/%d/%y", t);
+				continue;
+			case 'y':
+				 _util_strftime_conv(pt, (t->tm_year + TM_YEAR_BASE)
+				    % 100, 2, '0');
+				pt += 2;
+				continue;
+			case '%':
+			/*
+			 * X311J/88-090 (4.12.3.5): if conversion char is
+			 * undefined, behavior is undefined.  Print out the
+			 * character itself as printf(3) does.
+			 */
+			default:
+				break;
+		}
+		*pt = *format;
+		pt++;
+	}
+
+    start[pt-start] = '\0';
+
+	return pt - start;
+}
+
+static void
+_util_strftime_conv(char *pt, int n, int digits, char pad)
+{
+	static char buf[10];
+	register char *p;
+
+	if (n >= 100) {
+		p = buf + sizeof(buf)-2;
+		for (; n > 0 && p > buf; n /= 10, --digits)
+			*p-- = n % 10 + '0';
+    	while (p > buf && digits-- > 0)
+		  	*p-- = pad;
+		p++;
+		_util_strftime_add(p);
+    } else {
+		int tens;
+		int ones = n;
+
+        tens = 0;
+        if ( ones >= 10 ) {
+            while ( ones >= 10 ) {
+                tens++;
+                ones = ones - 10;
+            }
+            *pt++ = '0'+tens;
+            digits--;
+        }
+		else 
+			*pt++ = '0';
+        *pt++ = '0'+ones;
+        digits--;
+		while(digits--)
+			*pt++ = pad;
+    }
+	return;
+}
+
+
+#ifdef XP_UNIX
+/*
+ * Local Thread Safe version of waitpid.  This prevents the process
+ * from blocking in the system call.
+ */
+NSAPI_PUBLIC pid_t 
+util_waitpid(pid_t pid, int *statptr, int options)
+{
+    pid_t rv;
+
+    for(rv = 0; !rv; PR_Sleep(500)) {
+	rv = waitpid(pid, statptr, options | WNOHANG);
+	if (rv == -1) {
+	    if (errno == EINTR)
+		rv = 0; /* sleep and try again */
+	    else
+		ereport(LOG_WARN, "waitpid failed for pid %d:%s", pid, system_errmsg());
+	}
+    }
+    return rv;
+}
+#endif
+
+/*
+ * Various reentrant routines by mikep.  See util.h and systems.h
+ */
+
+/*
+ * These are only necessary if we turn on interrupts in NSPR
+ */
+#ifdef NEED_RELOCKS
+#include "crit.h"
+#define RE_LOCK(name) \
+    static CRITICAL name##_crit = 0; \
+    if (name##_crit == 0) name##_crit = crit_init(); \
+    crit_enter(name##_crit)
+
+#define RE_UNLOCK(name)  crit_exit(name##_crit)
+
+#else
+#define RE_LOCK(name) /* nada */
+#define RE_UNLOCK(name) /* nil */
+#endif
+
+
+NSAPI_PUBLIC char *
+util_strtok(register char *s, 
+			register const char *delim, 
+			register char **lasts)
+{
+#ifdef HAVE_STRTOK_R
+    return strtok_r(s, delim, lasts);
+#else
+	/*
+ 	 * THIS IS THE THREAD SAFE VERSION OF strtok captured from
+	 * public NetBSD. Note that no locks are needed
+	 */
+    register char *spanp;
+    register int c, sc;
+    char *tok;
+
+    if (s == NULL && (s = *lasts) == NULL)
+        return (NULL);
+
+    /*
+     * Skip (span) leading delimiters (s += strspn(s, delim), 
+	 * sort of).
+     */
+
+cont:
+    c = *s++;
+    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
+        if (c == sc)
+            goto cont;
+    }
+
+    if (c == 0) {       /* no non-delimiter characters */
+        *lasts = NULL;
+        return (NULL);
+    }
+    tok = s - 1;
+
+    /*
+     * Scan token (scan for delimiters: s += strcspn(s, delim), 
+	 * sort of).
+     * Note that delim must have one NUL; we stop if we see that, too.
+     */
+    for (;;) {
+        c = *s++;
+        spanp = (char *)delim;
+        do {
+            if ((sc = *spanp++) == c) {
+                if (c == 0)
+                    s = NULL;
+                else
+                    s[-1] = 0;
+                *lasts = s;
+                return (tok);
+            }
+        } while (sc != 0);
+    }
+    /* NOTREACHED */
+#endif /* no strtok_r */
+}
+
+#ifndef XP_WIN32
+NSAPI_PUBLIC struct passwd *
+util_getpwnam(const char *name, struct passwd *result, char *buffer, 
+	int buflen)
+{
+#ifdef HAVE_PW_R
+
+#ifdef AIX
+#if OSVERSION >= 4320
+    return ((int)getpwnam_r(name, result, buffer, buflen, 0) == 0 ? result : NULL);
+#else
+    return ((int)getpwnam_r(name, result, buffer, buflen) == 0 ? result : NULL);
+#endif
+#else
+    return getpwnam_r(name, result, buffer, buflen);
+#endif /* AIX */
+
+#else
+    char *lastp;
+    struct passwd *r;
+    RE_LOCK(pw);
+    r = getpwnam(name);
+    if (!r) 
+	return r;
+
+    result->pw_gid = r->pw_gid;
+    result->pw_uid = r->pw_uid;
+    /* Hope this buffer is long enough */
+    if (buffer)
+        util_snprintf(buffer, buflen, "%s:%s:%d:%d:%s:%s:%s", r->pw_name, r->pw_passwd,
+		r->pw_uid, r->pw_gid, r->pw_gecos, r->pw_dir, r->pw_shell);
+    RE_UNLOCK(pw);
+
+    result->pw_name = util_strtok(buffer, ":", &lastp);
+    result->pw_passwd = util_strtok(NULL, ":", &lastp);
+    (void) util_strtok(NULL, ":", &lastp);
+    (void) util_strtok(NULL, ":", &lastp);
+    result->pw_gecos = util_strtok(NULL, ":", &lastp);
+    result->pw_dir = util_strtok(NULL, ":", &lastp);
+    result->pw_shell = util_strtok(NULL, ":", &lastp);
+    return result;
+#endif
+}
+#endif
+
+NSAPI_PUBLIC struct tm *
+util_localtime(const time_t *clock, struct tm *res)
+{
+#ifdef HAVE_TIME_R
+    return localtime_r(clock, res);
+#else
+    struct tm *rv;
+    time_t zero = 0x7fffffff;
+
+    RE_LOCK(localtime);
+    RE_UNLOCK(localtime);
+    rv = localtime(clock);
+    if (!rv)
+        rv = localtime(&zero);
+    if (rv)
+        *res = *rv;
+    else
+        return NULL;
+    return res;
+#endif
+}
+
+
+NSAPI_PUBLIC char *
+util_ctime(const time_t *clock, char *buf, int buflen)
+{
+/* 
+ * From cgi-src/restore.c refering to XP_WIN32:
+ * 	MLM - gross, but it works, better now FLC
+ */
+#if !defined(HAVE_TIME_R) || defined(XP_WIN32)
+    RE_LOCK(ctime);
+    strncpy(buf, ctime(clock), buflen);
+    buf[buflen - 1] = '\0';
+    RE_UNLOCK(ctime);
+    return buf;
+#elif HAVE_TIME_R == 2
+    return ctime_r(clock, buf);
+#else /* HAVE_TIME_R == 3 */
+    return ctime_r(clock, buf, buflen);
+#endif
+}
+
+NSAPI_PUBLIC struct tm *
+util_gmtime(const time_t *clock, struct tm *res)
+{
+#ifdef HAVE_TIME_R
+    return gmtime_r(clock, res);
+#else
+    struct tm *rv;
+    time_t zero = 0x7fffffff;
+
+    RE_LOCK(gmtime);
+    rv = gmtime(clock);
+    RE_UNLOCK(gmtime);
+    if (!rv)
+        rv = gmtime(&zero);
+    if (rv)
+        *res = *rv;
+    else 
+        return NULL;
+    
+    return res;
+#endif
+}
+
+NSAPI_PUBLIC char *
+util_asctime(const struct tm *tm, char *buf, int buflen)
+{
+#if HAVE_TIME_R == 2
+    return asctime_r(tm, buf);
+#elif HAVE_TIME_R == 3
+    return asctime_r(tm, buf, buflen);
+#else
+    RE_LOCK(asctime);
+    strncpy(buf, asctime(tm), buflen);
+    buf[buflen - 1] = '\0';
+    RE_UNLOCK(asctime);
+    return buf;
+#endif
+}
+
+NSAPI_PUBLIC char *
+util_strerror(int errnum, char *msg, int buflen)
+{
+#ifdef HAVE_STRERROR_R
+    /* More IBM real-genius */
+    return ((int)strerror_r(errnum, msg, buflen) > 0) ? msg : NULL;
+#else
+    /* RE_LOCK(strerror); I don't think this is worth the trouble */
+    (void)strncpy(msg, strerror(errnum), buflen);
+    msg[buflen - 1] = '\0';
+    return msg;
+    /* RE_UNLOCK(strerror); */
+#endif
+}
+
+
+
+/* ------------------------------- OLD CODE ------------------------------- */
+
+
+#if 0
+
+NSAPI_PUBLIC int util_vsnprintf(char *s, int n, register char *fmt, 
+                                va_list args)
+{
+    register int pos = 0, max = (n > 2 ? n-2 : -1), boundson;
+    register char c, *t;
+
+    if((max == -1) && (n != -1))
+        goto punt;
+
+    boundson = (n != -1);
+    while(*fmt) {
+        if(boundson && (pos > max))
+            break;
+        c = *fmt++;
+        switch(c) {
+          case '%':
+            switch(*fmt++) {
+              case 'd':
+                if(boundson && ((pos + 10) > max))
+                    goto punt;
+                pos += util_itoa(va_arg(args, int), &s[pos]);
+                break;
+              case 's':
+                t = va_arg(args, char *);
+                while(*t) {
+                    s[pos++] = *t++;
+                    if(boundson && (pos > max))
+                        goto punt;
+                }
+                break;
+              case 'c':
+                s[pos++] = (char) va_arg(args, int);
+                break;
+              case '%':
+                s[pos++] = '%';
+                break;
+            }
+            break;
+          case '\\':
+            if( (s[pos++] = *fmt) )
+                ++fmt;
+            break;
+          default:
+            s[pos++] = c;
+        }
+    }
+  punt:
+    s[pos] = '\0';
+
+    va_end(args);
+    return pos;
+}
+
+NSAPI_PUBLIC int util_snprintf(char *s, int n, char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    return util_vsnprintf(s, n, fmt, args);
+}
+
+NSAPI_PUBLIC int util_vsprintf(char *s, register char *fmt, va_list args)
+{
+    return util_vsnprintf(s, -1, fmt, args);
+}
+
+NSAPI_PUBLIC int util_sprintf(char *s, char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    return util_vsnprintf(s, -1, fmt, args);
+}
+#endif