X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fback-ldbm%2Fadd.c;h=65d1d11370d0c9e29b65da6c32f97e17fd5fbb3e;hb=4d36fd5a3ed407b0a53004d1431f1669222138b4;hp=fc592712db822e1f202398eb207842977a6c1252;hpb=72ba4cfb715001d30a6e48a2d7012f060f29d684;p=openldap

diff --git a/servers/slapd/back-ldbm/add.c b/servers/slapd/back-ldbm/add.c
index fc592712db..65d1d11370 100644
--- a/servers/slapd/back-ldbm/add.c
+++ b/servers/slapd/back-ldbm/add.c
@@ -1,4 +1,9 @@
 /* add.c - ldap ldbm back-end add routine */
+/* $OpenLDAP$ */
+/*
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
+ * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+ */
 
 #include "portable.h"
 
@@ -20,34 +25,48 @@ ldbm_back_add(
 )
 {
 	struct ldbminfo	*li = (struct ldbminfo *) be->be_private;
-	char		*dn, *pdn;
+	struct berval	pdn;
 	Entry		*p = NULL;
-	int			rootlock = 0;
-	int			rc = -1; 
-
-	dn = e->e_ndn;
-
-	Debug(LDAP_DEBUG_ARGS, "==> ldbm_back_add: %s\n", dn, 0, 0);
-
-	/* nobody else can add until we lock our parent */
-	ldap_pvt_thread_mutex_lock(&li->li_add_mutex);
-
-	if ( ( dn2id( be, dn ) ) != NOID ) {
-		ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
-		entry_free( e );
-		send_ldap_result( conn, op, LDAP_ALREADY_EXISTS, "", "" );
+	int			rc;
+	ID               id = NOID;
+	const char	*text = NULL;
+	AttributeDescription *children = slap_schema.si_ad_children;
+	char textbuf[SLAP_TEXT_BUFLEN];
+	size_t textlen = sizeof textbuf;
+
+#ifdef NEW_LOGGING
+	LDAP_LOG( BACK_LDBM, ENTRY, "ldbm_back_add: %s\n", e->e_dn, 0, 0 );
+#else
+	Debug(LDAP_DEBUG_ARGS, "==> ldbm_back_add: %s\n", e->e_dn, 0, 0);
+#endif
+
+	/* grab giant lock for writing */
+	ldap_pvt_thread_rdwr_wlock(&li->li_giant_rwlock);
+
+	if ( ( rc = dn2id( be, &e->e_nname, &id ) ) || id != NOID ) {
+		/* if (rc) something bad happened to ldbm cache */
+		ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+		send_ldap_result( conn, op, 
+			rc ? LDAP_OTHER : LDAP_ALREADY_EXISTS,
+			NULL, NULL, NULL, NULL );
 		return( -1 );
 	}
 
-	if ( global_schemacheck && oc_schema_check( e ) != 0 ) {
-		ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
+	rc = entry_schema_check( be, e, NULL, &text, textbuf, textlen );
 
-		Debug( LDAP_DEBUG_TRACE, "entry failed schema check\n",
-			0, 0, 0 );
+	if ( rc != LDAP_SUCCESS ) {
+		ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+		LDAP_LOG( BACK_LDBM, ERR, 
+			"ldbm_back_add: entry (%s) failed schema check.\n", e->e_dn, 0, 0 );
+#else
+		Debug( LDAP_DEBUG_TRACE, "entry failed schema check: %s\n",
+			text, 0, 0 );
+#endif
 
-		entry_free( e );
-		send_ldap_result( conn, op, LDAP_OBJECT_CLASS_VIOLATION, "",
-		    "" );
+		send_ldap_result( conn, op, rc,
+			NULL, text, NULL, NULL );
 		return( -1 );
 	}
 
@@ -57,168 +76,295 @@ ldbm_back_add(
 	 * add the entry.
 	 */
 
-	if ( (pdn = dn_parent( be, dn )) != NULL ) {
-		char *matched = NULL;
+	if ( be_issuffix( be, &e->e_nname ) ) {
+		pdn = slap_empty_bv;
+	} else {
+		dnParent( &e->e_nname, &pdn );
+	}
+
+	if( pdn.bv_len ) {
+		Entry *matched = NULL;
 
 		/* get parent with writer lock */
-		if ( (p = dn2entry_w( be, pdn, &matched )) == NULL ) {
-			ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
-			Debug( LDAP_DEBUG_TRACE, "parent does not exist\n", 0,
-			    0, 0 );
-			send_ldap_result( conn, op, LDAP_NO_SUCH_OBJECT,
-			    matched, "" );
+		if ( (p = dn2entry_w( be, &pdn, &matched )) == NULL ) {
+			char *matched_dn = NULL;
+			BerVarray refs;
 
 			if ( matched != NULL ) {
-				free( matched );
+				matched_dn = ch_strdup( matched->e_dn );
+				refs = is_entry_referral( matched )
+					? get_entry_referrals( be, conn, op, matched )
+					: NULL;
+				cache_return_entry_r( &li->li_cache, matched );
+
+			} else {
+				refs = referral_rewrite( default_referral,
+					NULL, &e->e_name, LDAP_SCOPE_DEFAULT );
 			}
 
-			entry_free( e );
-			free( pdn );
-			return -1;
-		}
+			ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
 
-		/* don't need the add lock anymore */
-		ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
+#ifdef NEW_LOGGING
+			LDAP_LOG( BACK_LDBM, ERR, 
+				"ldbm_back_add: Parent of (%s) does not exist.\n", 
+				e->e_dn, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_TRACE, "parent does not exist\n",
+				0, 0, 0 );
+#endif
 
-		free(pdn);
+			send_ldap_result( conn, op, LDAP_REFERRAL, matched_dn,
+				refs == NULL ? "parent does not exist" : "parent is referral",
+				refs, NULL );
 
-		if ( matched != NULL ) {
-			free( matched );
+			ber_bvarray_free( refs );
+			free( matched_dn );
+
+			return -1;
 		}
 
 		if ( ! access_allowed( be, conn, op, p,
-			"children", NULL, ACL_WRITE ) )
+			children, NULL, ACL_WRITE, NULL ) )
 		{
-			Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,
+			/* free parent and writer lock */
+			cache_return_entry_w( &li->li_cache, p ); 
+			ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+			LDAP_LOG( BACK_LDBM, ERR, 
+				"ldbm_back_add: No write access to parent (%s).\n", 
+				e->e_dn, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_TRACE, "no write access to parent\n", 0,
 			    0, 0 );
+#endif
+
 			send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
-			    "", "" );
+			    NULL, "no write access to parent", NULL, NULL );
+
+			return -1;
+		}
+
+		if ( is_entry_alias( p ) ) {
+			/* parent is an alias, don't allow add */
 
 			/* free parent and writer lock */
-			cache_return_entry_w( &li->li_cache, p ); 
+			cache_return_entry_w( &li->li_cache, p );
+			ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+			LDAP_LOG(BACK_LDBM, ERR, 
+				"ldbm_back_add:  Parent is an alias.\n", 0, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_TRACE, "parent is alias\n", 0,
+			    0, 0 );
+#endif
+
+
+			send_ldap_result( conn, op, LDAP_ALIAS_PROBLEM,
+			    NULL, "parent is an alias", NULL, NULL );
 
-			entry_free( e );
 			return -1;
 		}
 
-	} else {
-		/* no parent, must be adding entry to root */
-		if ( ! be_isroot( be, op->o_ndn ) ) {
-			ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
-			Debug( LDAP_DEBUG_TRACE, "no parent & not root\n", 0,
+		if ( is_entry_referral( p ) ) {
+			/* parent is a referral, don't allow add */
+			char *matched_dn = ch_strdup( p->e_dn );
+			BerVarray refs = is_entry_referral( p )
+				? get_entry_referrals( be, conn, op, p )
+				: NULL;
+
+			/* free parent and writer lock */
+			cache_return_entry_w( &li->li_cache, p );
+			ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+			LDAP_LOG( BACK_LDBM, ERR,
+				   "ldbm_back_add: Parent is referral.\n", 0, 0, 0 );
+#else
+			Debug( LDAP_DEBUG_TRACE, "parent is referral\n", 0,
 			    0, 0 );
-			send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
-			    "", "" );
+#endif
+
+			send_ldap_result( conn, op, LDAP_REFERRAL,
+			    matched_dn, NULL, refs, NULL );
 
-			entry_free( e );
+			ber_bvarray_free( refs );
+			free( matched_dn );
 			return -1;
 		}
 
-		/*
-		 * no parent, acquire the root write lock
-		 * and release the add lock.
-		 */
-		ldap_pvt_thread_mutex_lock(&li->li_root_mutex);
-		rootlock = 1;
-		ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
+	} else {
+		if(pdn.bv_val != NULL) {
+			assert( *pdn.bv_val == '\0' );
+		}
+
+		/* no parent, must be adding entry to root */
+		if ( !be_isroot( be, &op->o_ndn ) ) {
+			if ( be_issuffix( be, (struct berval *)&slap_empty_bv ) || be_isupdate( be, &op->o_ndn ) ) {
+				p = (Entry *)&slap_entry_root;
+				
+				rc = access_allowed( be, conn, op, p,
+					children, NULL, ACL_WRITE, NULL );
+				p = NULL;
+				
+				if ( ! rc ) {
+					ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+					LDAP_LOG( BACK_LDBM, ERR,
+						"ldbm_back_add: No write "
+						"access to parent (\"\").\n", 0, 0, 0 );
+#else
+					Debug( LDAP_DEBUG_TRACE, 
+						"no write access to parent\n", 
+						0, 0, 0 );
+#endif
+
+					send_ldap_result( conn, op, 
+						LDAP_INSUFFICIENT_ACCESS,
+			    			NULL, 
+						"no write access to parent", 
+						NULL, NULL );
+
+					return -1;
+				}
+
+			} else {
+				ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+				LDAP_LOG( BACK_LDBM, ERR,
+					   "ldbm_back_add: %s add denied.\n",
+					   pdn.bv_val == NULL ? "suffix" 
+					   : "entry at root", 0, 0 );
+#else
+				Debug( LDAP_DEBUG_TRACE, "%s add denied\n",
+						pdn.bv_val == NULL ? "suffix" 
+						: "entry at root", 0, 0 );
+#endif
+
+				send_ldap_result( conn, op, 
+						LDAP_INSUFFICIENT_ACCESS,
+			  			NULL, NULL, NULL, NULL );
+
+				return -1;
+			}
+		}
 	}
 
-	/* acquire required reader/writer lock */
-	if (entry_rdwr_lock(e, 1)) {
+	if ( next_id( be, &e->e_id ) ) {
 		if( p != NULL) {
 			/* free parent and writer lock */
 			cache_return_entry_w( &li->li_cache, p ); 
 		}
 
-		if ( rootlock ) {
-			/* release root lock */
-			ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
-		}
+		ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
 
-		Debug( LDAP_DEBUG_ANY, "add: could not lock entry\n",
+#ifdef NEW_LOGGING
+		LDAP_LOG( BACK_LDBM, ERR,
+			"ldbm_back_add: next_id failed.\n", 0, 0, 0 );
+#else
+		Debug( LDAP_DEBUG_ANY, "ldbm_add: next_id failed\n",
 			0, 0, 0 );
+#endif
 
-		entry_free(e);
+		send_ldap_result( conn, op, LDAP_OTHER,
+			NULL, "next_id add failed", NULL, NULL );
 
-		send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
 		return( -1 );
 	}
 
-	e->e_id = next_id( be );
-
 	/*
 	 * Try to add the entry to the cache, assign it a new dnid.
-	 * This should only fail if the entry already exists.
 	 */
+	rc = cache_add_entry_rw(&li->li_cache, e, CACHE_WRITE_LOCK);
 
-	if ( cache_add_entry_lock( &li->li_cache, e, ENTRY_STATE_CREATING ) != 0 ) {
+	if ( rc != 0 ) {
 		if( p != NULL) {
 			/* free parent and writer lock */
 			cache_return_entry_w( &li->li_cache, p ); 
 		}
-		if ( rootlock ) {
-			/* release root lock */
-			ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
-		}
 
+		ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
+
+#ifdef NEW_LOGGING
+		LDAP_LOG( BACK_LDBM, ERR,
+			"ldbm_back_add: cache_add_entry_lock failed.\n", 0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_ANY, "cache_add_entry_lock failed\n", 0, 0,
 		    0 );
-		next_id_return( be, e->e_id );
-                
-		entry_rdwr_unlock(e, 1);;
-		entry_free( e );
-
-		send_ldap_result( conn, op, LDAP_ALREADY_EXISTS, "", "" );
-		return( -1 );
-	}
+#endif
 
-	/*
-	 * add it to the id2children index for the parent
-	 */
-
-	if ( id2children_add( be, p, e ) != 0 ) {
-		Debug( LDAP_DEBUG_TRACE, "id2children_add failed\n", 0,
-		    0, 0 );
-		send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
+		send_ldap_result( conn, op,
+			rc > 0 ? LDAP_ALREADY_EXISTS : LDAP_OTHER,
+			NULL, rc > 0 ? NULL : "cache add failed", NULL, NULL );
 
-		goto return_results;
+		return( -1 );
 	}
 
-	/*
-	 * Add the entry to the attribute indexes, then add it to
-	 * the id2children index, dn2id index, and the id2entry index.
-	 */
+	rc = -1;
 
 	/* attribute indexes */
-	if ( index_add_entry( be, e ) != 0 ) {
-		Debug( LDAP_DEBUG_TRACE, "index_add_entry failed\n", 0,
+	if ( index_entry_add( be, e, e->e_attrs ) != LDAP_SUCCESS ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( BACK_LDBM, ERR,
+			"ldbm_back_add: index_entry_add failed.\n", 0, 0, 0 );
+#else
+		Debug( LDAP_DEBUG_TRACE, "index_entry_add failed\n", 0,
 		    0, 0 );
-		send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
+#endif
+		
+		send_ldap_result( conn, op, LDAP_OTHER,
+			NULL, "index generation failed", NULL, NULL );
 
 		goto return_results;
 	}
 
 	/* dn2id index */
-	if ( dn2id_add( be, dn, e->e_id ) != 0 ) {
+	if ( dn2id_add( be, &e->e_nname, e->e_id ) != 0 ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( BACK_LDBM, ERR,
+			"ldbm_back_add: dn2id_add failed.\n", 0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_TRACE, "dn2id_add failed\n", 0,
 		    0, 0 );
-		send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
+#endif
+		/* FIXME: delete attr indices? */
+
+		send_ldap_result( conn, op, LDAP_OTHER,
+			NULL, "DN index generation failed", NULL, NULL );
 
 		goto return_results;
 	}
 
 	/* id2entry index */
 	if ( id2entry_add( be, e ) != 0 ) {
+#ifdef NEW_LOGGING
+		LDAP_LOG( BACK_LDBM, ERR,
+			   "ldbm_back_add: id2entry_add failed.\n", 0, 0, 0 );
+#else
 		Debug( LDAP_DEBUG_TRACE, "id2entry_add failed\n", 0,
 		    0, 0 );
-		(void) dn2id_delete( be, dn );
-		send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
+#endif
+
+		/* FIXME: delete attr indices? */
+		(void) dn2id_delete( be, &e->e_nname, e->e_id );
+		
+		send_ldap_result( conn, op, LDAP_OTHER,
+			NULL, "entry store failed", NULL, NULL );
 
 		goto return_results;
 	}
 
-	send_ldap_result( conn, op, LDAP_SUCCESS, "", "" );
+	send_ldap_result( conn, op, LDAP_SUCCESS,
+		NULL, NULL, NULL, NULL );
+
+	/* marks the entry as committed, so it is added to the cache;
+	 * otherwise it is removed from the cache, but not destroyed;
+	 * it will be destroyed by the caller */
 	rc = 0;
+	cache_entry_commit( e );
 
 return_results:;
 	if (p != NULL) {
@@ -226,15 +372,15 @@ return_results:;
 		cache_return_entry_w( &li->li_cache, p ); 
 	}
 
-	if ( rootlock ) {
-		/* release root lock */
-		ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
+	if ( rc ) {
+		/*
+		 * in case of error, writer lock is freed 
+		 * and entry's private data is destroyed.
+		 * otherwise, this is done when entry is released
+		 */
+		cache_return_entry_w( &li->li_cache, e );
+		ldap_pvt_thread_rdwr_wunlock(&li->li_giant_rwlock);
 	}
 
-	cache_set_state( &li->li_cache, e, 0 );
-
-	/* free entry and writer lock */
-	cache_return_entry_w( &li->li_cache, e ); 
-
 	return( rc );
 }