Stuart Lynne's UNTESTED thread patch (p1)

include/lthread_rdwr.h

+#ifndef _LTHREAD_RDWR_H
+#define _LTHREAD_RDWR_H 1
+
+/********************************************************
+ * An example source module to accompany...
+ *
+ * "Using POSIX Threads: Programming with Pthreads"
+ *     by Brad nichols, Dick Buttlar, Jackie Farrell
+ *     O'Reilly & Associates, Inc.
+ *
+ ********************************************************
+ * 
+ * Include file for reader/writer locks
+ * 
+ */
+
+typedef struct rdwr_var {
+	int readers_reading;
+	int writer_writing;
+	pthread_mutex_t mutex;
+	pthread_cond_t lock_free;
+} pthread_rdwr_t;
+
+typedef void * pthread_rdwrattr_t;
+
+#define pthread_rdwrattr_default NULL;
+
+int pthread_rdwr_init_np(pthread_rdwr_t *rdwrp, pthread_rdwrattr_t *attrp);
+int pthread_rdwr_rlock_np(pthread_rdwr_t *rdwrp);
+int pthread_rdwr_runlock_np(pthread_rdwr_t *rdwrp);
+int pthread_rdwr_wlock_np(pthread_rdwr_t *rdwrp);
+int pthread_rdwr_wunlock_np(pthread_rdwr_t *rdwrp);
+
+#ifdef LDAP_DEBUG
+int pthread_rdwr_rchk_np(pthread_rdwr_t *rdwrp);
+int pthread_rdwr_wchk_np(pthread_rdwr_t *rdwrp);
+int pthread_rdwr_rwchk_np(pthread_rdwr_t *rdwrp);
+#endif /* LDAP_DEBUG */
+
+#endif /* _LTHREAD_RDWR_H */

libraries/liblthread/Make-template

@@ -15,8 +15,8 @@
 
 LDAPSRC	= ../..
 
-SRCS	= thread.c stack.c
-OBJS	= thread.o stack.o
+SRCS	= rdwr.c thread.c stack.c
+OBJS	= rdwr.o thread.o stack.o
 
 HDIR	= ../../include
 
@@ -60,10 +60,3 @@ depend:	FORCE
 links:
 	@$(LN) .src/*.[ch] .
 
-# DO NOT DELETE THIS LINE -- mkdep uses it.
-# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
-
-thread.o: thread.c ../../include/lthread.h
-stack.o: stack.c ../../include/lber.h ../../include/ldap.h
-
-# IF YOU PUT ANYTHING HERE IT WILL GO AWAY

libraries/liblthread/rdwr.c

+/*
+** This basic implementation of Reader/Writer locks does not
+** protect writers from starvation.  That is, if a writer is
+** currently waiting on a reader, any new reader will get
+** the lock before the writer.
+*/
+
+/********************************************************
+ * An example source module to accompany...
+ *
+ * "Using POSIX Threads: Programming with Pthreads"
+ *		 by Brad nichols, Dick Buttlar, Jackie Farrell
+ *		 O'Reilly & Associates, Inc.
+ *
+ ********************************************************
+ * rdwr.c --
+ * 
+ * Library of functions implementing reader/writer locks
+ */
+#include <stdlib.h>
+#include <lthread.h>
+#include <lthread_rdwr.h>
+
+int pthread_rdwr_init_np(pthread_rdwr_t *rdwrp, pthread_rdwrattr_t *attrp)
+{
+	rdwrp->readers_reading = 0;
+	rdwrp->writer_writing = 0;
+	pthread_mutex_init(&(rdwrp->mutex), NULL);
+	pthread_cond_init(&(rdwrp->lock_free), NULL);
+	return 0;
+}
+
+int pthread_rdwr_rlock_np(pthread_rdwr_t *rdwrp){
+	pthread_mutex_lock(&(rdwrp->mutex));
+	while(rdwrp->writer_writing) {
+		pthread_cond_wait(&(rdwrp->lock_free), &(rdwrp->mutex));
+	}
+	rdwrp->readers_reading++;
+	pthread_mutex_unlock(&(rdwrp->mutex));
+	return 0;
+}
+
+int pthread_rdwr_runlock_np(pthread_rdwr_t *rdwrp)
+{
+	pthread_mutex_lock(&(rdwrp->mutex));
+	if (rdwrp->readers_reading == 0) {
+		pthread_mutex_unlock(&(rdwrp->mutex));
+		return -1;
+	}
+	else {
+		rdwrp->readers_reading--;
+		if (rdwrp->readers_reading == 0) {
+			pthread_cond_signal(&(rdwrp->lock_free));
+		}
+		pthread_mutex_unlock(&(rdwrp->mutex));
+		return 0;
+	}
+}
+
+int pthread_rdwr_wlock_np(pthread_rdwr_t *rdwrp)
+{
+	pthread_mutex_lock(&(rdwrp->mutex));
+	while(rdwrp->writer_writing || rdwrp->readers_reading) {
+		pthread_cond_wait(&(rdwrp->lock_free), &(rdwrp->mutex));
+	}
+	rdwrp->writer_writing++;
+	pthread_mutex_unlock(&(rdwrp->mutex));
+	return 0;
+}
+
+int pthread_rdwr_wunlock_np(pthread_rdwr_t *rdwrp)
+{
+	pthread_mutex_lock(&(rdwrp->mutex));
+	if (rdwrp->writer_writing == 0) {
+		pthread_mutex_unlock(&(rdwrp->mutex));
+		return -1;
+	}
+	else {
+		rdwrp->writer_writing = 0;
+		pthread_cond_broadcast(&(rdwrp->lock_free));
+		pthread_mutex_unlock(&(rdwrp->mutex));
+		return 0;
+	}
+}
+
+#ifdef LDAP_DEBUG
+
+/* just for testing, 
+ * return 0 if false, suitable for assert(pthread_rdwr_Xchk(rdwr))
+ * 
+ * Currently they don't check if the calling thread is the one 
+ * that has the lock, just that there is a reader or writer.
+ *
+ * Basically sufficent for testing that places that should have
+ * a lock are caught.
+ */
+
+int pthread_rdwr_rchk_np(pthread_rdwr_t *rdwrp)
+{
+	return(rdwrp->readers_reading!=0);
+}
+
+int pthread_rdwr_wchk_np(pthread_rdwr_t *rdwrp)
+{
+	return(rdwrp->writer_writing!=0);
+}
+int pthread_rdwr_rwchk_np(pthread_rdwr_t *rdwrp)
+{
+	return(pthread_rdwr_rchk_np(rdwrp) || pthread_rdwr_wchk_np(rdwrp));
+}
+
+#endif LDAP_DEBUG

servers/slapd/acl.c

@@ -6,15 +6,11 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netdb.h>
-#ifdef sunos5
-#include "regexpr.h"
-#else
-#include "regex.h"
-#endif
+#include <regex.h>
+
 #include "slap.h"
 
 extern Attribute	*attr_find();
-extern char		*re_comp();
 extern struct acl	*global_acl;
 extern int		global_default_access;
 extern char		*access2str();
@@ -26,7 +22,9 @@ struct acl	*acl_get_applicable();
 
 static int	regex_matches();
 
-extern pthread_mutex_t	regex_mutex;
+static string_expand(char *newbuf, int bufsiz, char *pattern,
+	char *match, regmatch_t *matches);
+
 
 /*
  * access_allowed - check whether dn is allowed the requested access
@@ -51,15 +49,57 @@ access_allowed(
     int			access
 )
 {
-	int		rc;
-	struct acl	*a;
+	int				rc;
+	struct acl		*a;
+	char            *edn;
+
+	regmatch_t       matches[MAXREMATCHES];
+	int              i;
+	int              n;
 
 	if ( be == NULL ) {
 		return( 0 );
 	}
 
-	a = acl_get_applicable( be, op, e, attr );
-	rc = acl_access_allowed( a, be, conn, e, val, op, access );
+	edn = dn_normalize_case( strdup( e->e_dn ) );
+	Debug( LDAP_DEBUG_ACL, "\n=> access_allowed: entry (%s) attr (%s)\n",
+		e->e_dn, attr, 0 );
+
+	/* the lastmod attributes are ignored by ACL checking */
+	if ( strcasecmp( attr, "modifiersname" ) == 0 ||
+		strcasecmp( attr, "modifytimestamp" ) == 0 ||
+		strcasecmp( attr, "creatorsname" ) == 0 ||
+		strcasecmp( attr, "createtimestamp" ) == 0 )
+	{
+ 		Debug( LDAP_DEBUG_ACL, "LASTMOD attribute: %s access allowed\n",
+			attr, 0, 0 );
+		free( edn );
+		return(1);
+	}
+
+	memset(matches, 0, sizeof(matches));
+
+	a = acl_get_applicable( be, op, e, attr, edn, MAXREMATCHES, matches );
+
+	if (a) {
+		for (i = 0; i < MAXREMATCHES && matches[i].rm_so > 0; i++) {
+			Debug( LDAP_DEBUG_ARGS, "=> match[%d]: %d %d ",
+				i, matches[i].rm_so, matches[i].rm_eo );
+
+			if( matches[i].rm_so <= matches[0].rm_eo ) {
+				for ( n = matches[i].rm_so; n < matches[i].rm_eo; n++) {
+					Debug( LDAP_DEBUG_ARGS, "%c", edn[n], 0, 0 );
+				}
+			}
+			Debug( LDAP_DEBUG_ARGS, "\n", 0, 0, 0 );
+		}
+	}
+
+	rc = acl_access_allowed( a, be, conn, e, val, op, access, edn, matches );
+	free( edn );
+
+	Debug( LDAP_DEBUG_ACL, "\n=> access_allowed: exit (%s) attr (%s)\n",
+		e->e_dn, attr, 0);
 
 	return( rc );
 }
@@ -75,15 +115,17 @@ acl_get_applicable(
     Backend		*be,
     Operation		*op,
     Entry		*e,
-    char		*attr
+    char		*attr,
+    char		*edn,
+    int			nmatch,
+    regmatch_t	*matches
 )
 {
-	int		i;
+	int		i, j;
 	struct acl	*a;
-	char		*edn;
 
-	Debug( LDAP_DEBUG_ACL, "=> acl_get: entry (%s) attr (%s)\n", e->e_dn,
-	    attr, 0 );
+	Debug( LDAP_DEBUG_ACL, "\n=> acl_get: entry (%s) attr (%s)\n",
+		e->e_dn, attr, 0 );
 
 	if ( be_isroot( be, op->o_dn ) ) {
 		Debug( LDAP_DEBUG_ACL,
@@ -92,55 +134,73 @@ acl_get_applicable(
 		return( NULL );
 	}
 
+	Debug( LDAP_DEBUG_ARGS, "=> acl_get: edn %s\n", edn, 0, 0 );
+
 	/* check for a backend-specific acl that matches the entry */
 	for ( i = 1, a = be->be_acl; a != NULL; a = a->acl_next, i++ ) {
-		if ( a->acl_dnpat != NULL ) {
-			edn = dn_normalize_case( strdup( e->e_dn ) );
-			if ( ! regex_matches( a->acl_dnpat, edn ) ) {
-				free( edn );
+		if (a->acl_dnpat != NULL) {
+			Debug( LDAP_DEBUG_TRACE, "=> dnpat: [%d] %s nsub: %d\n", 
+				i, a->acl_dnpat, a->acl_dnre.re_nsub);
+
+			if (regexec(&a->acl_dnre, edn, nmatch, matches, 0))
 				continue;
-			}
-			free( edn );
+			else
+				Debug( LDAP_DEBUG_TRACE, "=> acl_get:[%d]  backend ACL match\n",
+					i, 0, 0);
 		}
+
 		if ( a->acl_filter != NULL ) {
-			if ( test_filter( NULL, NULL, NULL, e, a->acl_filter )
-			    != 0 ) {
+			if ( test_filter( NULL, NULL, NULL, e, a->acl_filter ) != 0 ) {
 				continue;
 			}
 		}
+
+        Debug( LDAP_DEBUG_ARGS, "=> acl_get: [%d] check attr %s\n", i, attr, 0);
+
 		if ( attr == NULL || a->acl_attrs == NULL ||
-		    charray_inlist( a->acl_attrs, attr ) ) {
-			Debug( LDAP_DEBUG_ACL, "<= acl_get: backend acl #%d\n",
-			    i, e->e_dn, attr );
+			charray_inlist( a->acl_attrs, attr ) )
+		{
+			Debug( LDAP_DEBUG_ACL, "<= acl_get: [%d] backend acl %s attr: %s\n",
+				i, e->e_dn, attr );
 			return( a );
 		}
+		matches[0].rm_so = matches[0].rm_eo = -1;
 	}
 
 	/* check for a global acl that matches the entry */
 	for ( i = 1, a = global_acl; a != NULL; a = a->acl_next, i++ ) {
-		if ( a->acl_dnpat != NULL ) {
-			edn = dn_normalize_case( strdup( e->e_dn ) );
-			if ( ! regex_matches( a->acl_dnpat, edn ) ) {
-				free( edn );
+		if (a->acl_dnpat != NULL) {
+			Debug( LDAP_DEBUG_TRACE, "=> dnpat: [%d] %s nsub: %d\n", 
+				i, a->acl_dnpat, a->acl_dnre.re_nsub);
+
+			if (regexec(&a->acl_dnre, edn, nmatch, matches, 0)) {
 				continue;
+			} else {
+				Debug( LDAP_DEBUG_TRACE, "=> acl_get: [%d] global ACL match\n",
+					i, 0, 0);
 			}
-			free( edn );
 		}
+
 		if ( a->acl_filter != NULL ) {
-			if ( test_filter( NULL, NULL, NULL, e, a->acl_filter )
-			    != 0 ) {
+			if ( test_filter( NULL, NULL, NULL, e, a->acl_filter ) != 0 ) {
 				continue;
 			}
 		}
-		if ( attr == NULL || a->acl_attrs == NULL || charray_inlist(
-		    a->acl_attrs, attr ) ) {
-			Debug( LDAP_DEBUG_ACL, "<= acl_get: global acl #%d\n",
-			    i, e->e_dn, attr );
+
+		Debug( LDAP_DEBUG_ARGS, "=> acl_get: [%d] check attr\n", i, 0, 0);
+
+		if ( attr == NULL || a->acl_attrs == NULL ||
+			charray_inlist( a->acl_attrs, attr ) )
+		{
+			Debug( LDAP_DEBUG_ACL, "<= acl_get: [%d] global acl %s attr: %s\n",
+				i, e->e_dn, attr );
 			return( a );
 		}
+
+		matches[0].rm_so = matches[0].rm_eo = -1;
 	}
-	Debug( LDAP_DEBUG_ACL, "<= acl_get: no match\n", 0, 0, 0 );
 
+	Debug( LDAP_DEBUG_ACL, "<= acl_get: no match\n", 0, 0, 0 );
 	return( NULL );
 }
 
@@ -161,31 +221,40 @@ acl_access_allowed(
     Entry		*e,
     struct berval	*val,
     Operation		*op,
-    int			access
+    int			access,
+	char		*edn,
+	regmatch_t	*matches
 )
 {
 	int		i;
-	char		*edn, *odn;
+	char		*odn;
 	struct access	*b;
 	Attribute	*at;
 	struct berval	bv;
 	int		default_access;
 
-	Debug( LDAP_DEBUG_ACL, "=> acl: %s access to value \"%s\" by \"%s\"\n",
-	    access2str( access ), val ? val->bv_val : "any", op->o_dn ?
-	    op->o_dn : "" );
+	Debug( LDAP_DEBUG_ACL,
+		"\n=> acl_access_allowed: %s access to entry \"%s\"\n",
+		access2str( access ), e->e_dn, 0 );
+
+	Debug( LDAP_DEBUG_ACL,
+		"\n=> acl_access_allowed: %s access to value \"%s\" by \"%s\"\n",
+	    access2str( access ),
+		val ? val->bv_val : "any",
+		op->o_dn ?  op->o_dn : "" );
 
 	if ( be_isroot( be, op->o_dn ) ) {
-		Debug( LDAP_DEBUG_ACL, "<= acl: granted to database root\n",
+		Debug( LDAP_DEBUG_ACL,
+			"<= acl_access_allowed: granted to database root\n",
 		    0, 0, 0 );
 		return( 1 );
 	}
 
-	default_access = be->be_dfltaccess ? be->be_dfltaccess :
-	    global_default_access;
+	default_access = be->be_dfltaccess ? be->be_dfltaccess : global_default_access;
+
 	if ( a == NULL ) {
 		Debug( LDAP_DEBUG_ACL,
-		    "<= acl: %s by default (no matching to)\n",
+		    "<= acl_access_allowed: %s by default (no matching to)\n",
 		    default_access >= access ? "granted" : "denied", 0, 0 );
 		return( default_access >= access );
 	}
@@ -198,76 +267,81 @@ acl_access_allowed(
 	}
 	for ( i = 1, b = a->acl_access; b != NULL; b = b->a_next, i++ ) {
 		if ( b->a_dnpat != NULL ) {
+			Debug( LDAP_DEBUG_TRACE, "<= check a_dnpat: %s\n",
+				b->a_dnpat, 0, 0);
 			/*
 			 * if access applies to the entry itself, and the
 			 * user is bound as somebody in the same namespace as
 			 * the entry, OR the given dn matches the dn pattern
 			 */
-			if ( strcasecmp( b->a_dnpat, "self" ) == 0 && op->o_dn
-			    != NULL && *(op->o_dn) && e->e_dn != NULL ) {
-				edn = dn_normalize_case( strdup( e->e_dn ) );
+			if ( strcasecmp( b->a_dnpat, "self" ) == 0 && 
+				op->o_dn != NULL && *(op->o_dn) && e->e_dn != NULL ) 
+			{
 				if ( strcasecmp( edn, op->o_dn ) == 0 ) {
-					free( edn );
-					if ( odn ) free( odn );
 					Debug( LDAP_DEBUG_ACL,
-				    "<= acl: matched by clause #%d access %s\n",
+					"<= acl_access_allowed: matched by clause #%d access %s\n",
 					    i, (b->a_access & ~ACL_SELF) >=
 					    access ? "granted" : "denied", 0 );
 
-					return( (b->a_access & ~ACL_SELF)
-					    >= access );
+					if ( odn ) free( odn );
+					return( (b->a_access & ~ACL_SELF) >= access );
 				}
-				free( edn );
 			} else {
-				if ( regex_matches( b->a_dnpat, odn ) ) {
-					if ( odn ) free( odn );
+				if ( regex_matches( b->a_dnpat, odn, edn, matches ) ) {
 					Debug( LDAP_DEBUG_ACL,
-				    "<= acl: matched by clause #%d access %s\n",
+				    "<= acl_access_allowed: matched by clause #%d access %s\n",
 				    i, (b->a_access & ~ACL_SELF) >= access ?
 					    "granted" : "denied", 0 );
 
-					return( (b->a_access & ~ACL_SELF)
-					    >= access );
+					if ( odn ) free( odn );
+					return( (b->a_access & ~ACL_SELF) >= access );
 				}
 			}
 		}
 		if ( b->a_addrpat != NULL ) {
-			if ( regex_matches( b->a_addrpat, conn->c_addr ) ) {
-				if ( odn ) free( odn );
+			if ( regex_matches( b->a_addrpat, conn->c_addr, edn, matches ) ) {
 				Debug( LDAP_DEBUG_ACL,
-				    "<= acl: matched by clause #%d access %s\n",
+				    "<= acl_access_allowed: matched by clause #%d access %s\n",
 				    i, (b->a_access & ~ACL_SELF) >= access ?
 				    "granted" : "denied", 0 );
 
+				if ( odn ) free( odn );
 				return( (b->a_access & ~ACL_SELF) >= access );
 			}
 		}
 		if ( b->a_domainpat != NULL ) {
-			if ( regex_matches( b->a_domainpat, conn->c_domain ) ) {
-				if ( odn ) free( odn );
+			Debug( LDAP_DEBUG_ARGS, "<= check a_domainpath: %s\n",
+				b->a_domainpat, 0, 0 );
+			if ( regex_matches( b->a_domainpat, conn->c_domain, edn, matches ) ) 
+			{
 				Debug( LDAP_DEBUG_ACL,
-				    "<= acl: matched by clause #%d access %s\n",
+				    "<= acl_access_allowed: matched by clause #%d access %s\n",
 				    i, (b->a_access & ~ACL_SELF) >= access ?
 				    "granted" : "denied", 0 );
 
+				if ( odn ) free( odn );
 				return( (b->a_access & ~ACL_SELF) >= access );
 			}
 		}
 		if ( b->a_dnattr != NULL && op->o_dn != NULL ) {
+			Debug( LDAP_DEBUG_ARGS, "<= check a_dnattr: %s\n",
+				b->a_dnattr, 0, 0);
 			/* see if asker is listed in dnattr */
-			if ( (at = attr_find( e->e_attrs, b->a_dnattr ))
-			    != NULL && value_find( at->a_vals, &bv,
-			    at->a_syntax, 3 ) == 0 )
+
+                        /* aquire reader lock */
+			if ( (at = attr_find( e->e_attrs, b->a_dnattr )) != NULL && 
+				value_find( at->a_vals, &bv, at->a_syntax, 3 ) == 0 )
 			{
-				if ( (b->a_access & ACL_SELF) && (val == NULL
-				    || value_cmp( &bv, val, at->a_syntax,
-				    2 )) ) {
+                                /* free reader lock */
+				if ( (b->a_access & ACL_SELF) && 
+					(val == NULL || value_cmp( &bv, val, at->a_syntax, 2 )) )
+				{
 					continue;
 				}
 
 				if ( odn ) free( odn );
 				Debug( LDAP_DEBUG_ACL,
-				    "<= acl: matched by clause #%d access %s\n",
+				    "<= acl_acces_allowed: matched by clause #%d access %s\n",
 				    i, (b->a_access & ~ACL_SELF) >= access ?
 				    "granted" : "denied", 0 );
 
@@ -276,22 +350,49 @@ acl_access_allowed(
 
 			/* asker not listed in dnattr - check for self access */
 			if ( ! (b->a_access & ACL_SELF) || val == NULL ||
-			    value_cmp( &bv, val, at->a_syntax, 2 ) != 0 ) {
+				value_cmp( &bv, val, at->a_syntax, 2 ) != 0 )
+			{
 				continue;
 			}
 
 			if ( odn ) free( odn );
 			Debug( LDAP_DEBUG_ACL,
-			    "<= acl: matched by clause #%d (self) access %s\n",
+				"<= acl_access_allowed: matched by clause #%d (self) access %s\n",
 			    i, (b->a_access & ~ACL_SELF) >= access ? "granted"
 			    : "denied", 0 );
 
 			return( (b->a_access & ~ACL_SELF) >= access );
 		}
+#ifdef ACLGROUP
+		if ( b->a_group != NULL && op->o_dn != NULL ) {
+			char buf[512];
+
+			/* b->a_group is an unexpanded entry name, expanded it should be an 
+			 * entry with objectclass group* and we test to see if odn is one of
+			 * the values in the attribute uniquegroup
+			 */
+			Debug( LDAP_DEBUG_ARGS, "<= check a_group: %s\n",
+				b->a_group, 0, 0);
+			Debug( LDAP_DEBUG_ARGS, "<= check a_group: odn: %s\n",
+				odn, 0, 0);
+
+			/* see if asker is listed in dnattr */
+			string_expand(buf, sizeof(buf), b->a_group, edn, matches);
+
+			if (be_group(be, buf, odn) == 0) {
+				Debug( LDAP_DEBUG_ACL,
+					"<= acl_access_allowed: matched by clause #%d (group) access granted\n",
+					i, 0, 0 );
+				if ( odn ) free( odn );
+				return( (b->a_access & ~ACL_SELF) >= access );
+			}
+		}
+#endif /* ACLGROUP */
 	}
 
 	if ( odn ) free( odn );
-	Debug( LDAP_DEBUG_ACL, "<= acl: %s by default (no matching by)\n",
+	Debug( LDAP_DEBUG_ACL,
+		"<= acl_access_allowed: %s by default (no matching by)\n",
 	    default_access >= access ? "granted" : "denied", 0, 0 );
 
 	return( default_access >= access );
@@ -316,14 +417,26 @@ acl_check_mods(
 {
 	int		i;
 	struct acl	*a;
+	char            *edn;
+
+	edn = dn_normalize_case( strdup( e->e_dn ) );
 
 	for ( ; mods != NULL; mods = mods->mod_next ) {
+		regmatch_t       matches[MAXREMATCHES];
+
+		/* the lastmod attributes are ignored by ACL checking */
 		if ( strcasecmp( mods->mod_type, "modifiersname" ) == 0 ||
-		    strcasecmp( mods->mod_type, "modifytimestamp" ) == 0 ) {