- add a data entry, not a map, to the map cache when we encounter entries at

  startup

2 files changed, 139 insertions, 341 deletions

diff --git a/src/back-nis.c b/src/back-nis.c
index 00b824e..5597255 100644
--- a/src/back-nis.c
+++ b/src/back-nis.c
@@ -54,7 +54,7 @@
 #define NIS_MAP_CONFIGURATION_FILTER "(&(objectClass=*)(" NIS_MAP_CONFIGURATION_BASE_ATTR "=*)(" NIS_MAP_CONFIGURATION_DOMAIN_ATTR "=*)(" NIS_MAP_CONFIGURATION_MAP_ATTR "=*))"
 
 /* The data we ask the map cache to keep, for us, for each map. */
-struct backend_map_data {
+struct backend_set_data {
 	struct plugin_state *state;
 	char *domain, *map, **bases, *entry_filter;
 	char **key_formats, **keys_formats, *value_format;
@@ -69,145 +69,77 @@ struct backend_map_data {
 void
 backend_free_master_name(struct plugin_state *state, char *master)
 {
-	free(master);
+	backend_shr_free_server_name(state, master);
 }
 int
 backend_read_master_name(struct plugin_state *state, char **master)
 {
-	Slapi_DN *config_dn;
-	Slapi_Entry *config;
-	Slapi_ValueSet *values;
-	Slapi_Value *value;
-	char *attrs[] = {"nsslapd-localhost", NULL}, *actual_attr;
-	const char *cvalue;
-	int disposition, buffer_flags;
-	*master = NULL;
-	/* Try to read our name from the top-level configuration node. */
-	config_dn = slapi_sdn_new_dn_byval("cn=config");
-	if (config_dn == NULL) {
-		slapi_log_error(SLAPI_LOG_PLUGIN,
-				state->plugin_desc->spd_id,
-				"backend_master_name: "
-				"error parsing \"cn=config\"\n");
-		return -1;
-	}
-	config = NULL;
-	slapi_search_internal_get_entry(config_dn, attrs, &config,
-					state->plugin_identity);
-	if (config == NULL) {
-		slapi_log_error(SLAPI_LOG_PLUGIN,
-				state->plugin_desc->spd_id,
-				"backend_master_name: failure reading entry "
-				"\"cn=config\"\n");
-		slapi_sdn_free(&config_dn);
-		return -1;
-	}
-	slapi_sdn_free(&config_dn);
-	/* Pull out the attribute. */
-	if (slapi_vattr_values_get(config, attrs[0], &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		if (slapi_valueset_first_value(values, &value) == 0) {
-			cvalue = slapi_value_get_string(value);
-			if (cvalue != NULL) {
-				*master = strdup(cvalue);
-			}
-		} else {
-			slapi_log_error(SLAPI_LOG_PLUGIN,
-					state->plugin_desc->spd_id,
-					"backend_master_name: no \"%s\" value "
-					"for \"cn=config\"",
-					attrs[0]);
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	slapi_entry_free(config);
-	return (*master != NULL) ? 0 : -1;
+	return backend_shr_read_server_name(state, master);
 }
-static void
-backend_free_strlist(char **strlist)
+
+/* Manipulate map configuration data. */
+struct plugin_state *
+backend_set_config_get_state(struct backend_set_data *set_data)
 {
-	if (strlist) {
-		free(strlist);
-	}
+	return set_data->state;
 }
-
-/* Manipulate string lists. */
-static char **
-backend_dup_strlist_n(char **strlist, int n)
+char **
+backend_set_config_get_bases(struct backend_set_data *set_data)
 {
-	int i, l;
-	char **ret, *s;
-	/* Handle the NULL case. */
-	if (strlist == NULL) {
-		return NULL;
-	}
-	/* No strings = no list. */
-	if (n == 0) {
-		return NULL;
-	}
-	/* Count the amount of space needed for the strings. */
-	for (i = 0, l = 0; i < n; i++) {
-		l += (strlen(strlist[i]) + 1);
-	}
-	/* Allocate space for the array of pointers (with NULL terminator) and
-	 * then the string data. */
-	ret = malloc(((n + 1) * sizeof(char *)) + l);
-	if (ret != NULL) {
-		/* Figure out where the string data will start. */
-		s = (char *) ret;
-		s += ((n + 1) * sizeof(char *));
-		for (i = 0; i < n; i++) {
-			/* Set the address of this string, copy the data
-			 * around, and then prepare the address of the next
-			 * string. */
-			ret[i] = s;
-			strcpy(s, strlist[i]);
-			s += (strlen(strlist[i]) + 1);
-		}
-		/* NULL-terminate the array. */
-		ret[i] = NULL;
-	}
-	return ret;
+	return set_data->bases;
 }
-static char **
-backend_dup_strlist(char **strlist)
+char *
+backend_set_config_get_filter(struct backend_set_data *set_data)
 {
-	int i;
-	for (i = 0; (strlist != NULL) && (strlist[i] != NULL); i++) {
-		continue;
-	}
-	return backend_dup_strlist_n(strlist, i);
+	return set_data->entry_filter;
+}
+char *
+backend_set_config_get_group(struct backend_set_data *set_data)
+{
+	return set_data->domain;
+}
+char *
+backend_set_config_get_set(struct backend_set_data *set_data)
+{
+	return set_data->map;
+}
+struct format_inref_attr **
+backend_set_config_get_inref_attrs(struct backend_set_data *set_data)
+{
+	return set_data->inref_attrs;
+}
+char **
+backend_set_config_get_ref_attrs(struct backend_set_data *set_data)
+{
+	return set_data->ref_attrs;
 }
-
-/* Manipulate map data. */
 static void
-backend_free_map_data_contents(void *data)
+backend_free_set_data_contents(void *data)
 {
-	struct backend_map_data *map_data = data;
-	if (map_data != NULL) {
-		free(map_data->domain);
-		free(map_data->map);
-		free(map_data->bases);
-		free(map_data->disallowed_chars);
-		format_free_attr_list(map_data->ref_attrs);
-		format_free_inref_attrs(map_data->inref_attrs);
-		free(map_data->entry_filter);
-		backend_free_strlist(map_data->key_formats);
-		backend_free_strlist(map_data->keys_formats);
-		free(map_data->value_format);
+	struct backend_set_data *set_data = data;
+	if (set_data != NULL) {
+		free(set_data->domain);
+		free(set_data->map);
+		free(set_data->bases);
+		free(set_data->disallowed_chars);
+		format_free_attr_list(set_data->ref_attrs);
+		format_free_inref_attrs(set_data->inref_attrs);
+		free(set_data->entry_filter);
+		backend_shr_free_strlist(set_data->key_formats);
+		backend_shr_free_strlist(set_data->keys_formats);
+		free(set_data->value_format);
 	}
 }
-static void
-backend_free_map_data(void *data)
+void
+backend_set_config_free_config(struct backend_set_data *data)
 {
-	backend_free_map_data_contents(data);
+	backend_free_set_data_contents(data);
 	free(data);
 }
-static struct backend_map_data *
-backend_copy_map_data(const struct backend_map_data *data)
+static struct backend_set_data *
+backend_copy_set_data(const struct backend_set_data *data)
 {
-	struct backend_map_data *ret;
+	struct backend_set_data *ret;
 	ret = malloc(sizeof(*ret));
 	if (ret == NULL) {
 		return NULL;
@@ -215,7 +147,7 @@ backend_copy_map_data(const struct backend_map_data *data)
 	ret->state = data->state;
 	ret->domain = strdup(data->domain);
 	ret->map = strdup(data->map);
-	ret->bases = backend_dup_strlist(data->bases);
+	ret->bases = backend_shr_dup_strlist(data->bases);
 	ret->disallowed_chars = data->disallowed_chars ?
 				strdup(data->disallowed_chars) : NULL;
 	ret->ref_attrs = data->ref_attrs ?
@@ -225,8 +157,8 @@ backend_copy_map_data(const struct backend_map_data *data)
 			   format_dup_inref_attrs(data->inref_attrs) :
 			   NULL;
 	ret->entry_filter = strdup(data->entry_filter);
-	ret->key_formats = backend_dup_strlist(data->key_formats);
-	ret->keys_formats = backend_dup_strlist(data->keys_formats);
+	ret->key_formats = backend_shr_dup_strlist(data->key_formats);
+	ret->keys_formats = backend_shr_dup_strlist(data->keys_formats);
 	ret->n_key_formats = data->n_key_formats;
 	ret->n_keys_formats = data->n_keys_formats;
 	ret->value_format = strdup(data->value_format);
@@ -236,7 +168,7 @@ backend_copy_map_data(const struct backend_map_data *data)
 	    (ret->entry_filter == NULL) ||
 	    ((ret->key_formats == NULL) && (ret->keys_formats == NULL)) ||
 	    (ret->value_format == NULL)) {
-		backend_free_map_data(ret);
+		backend_set_config_free_config(ret);
 		return NULL;
 	}
 	return ret;
@@ -245,13 +177,11 @@ backend_copy_map_data(const struct backend_map_data *data)
 /* Given a map-entry directory entry, determine which keys it should have,
  * determine which value should be associated with those keys, and add them to
  * the map cache. */
-static int
-backend_map_config_entry_add_one_cb(Slapi_Entry *e, void *callback_data)
+void
+backend_set_entry_one(Slapi_Entry *e, struct backend_set_data *data)
 {
-	struct backend_map_data *data;
 	char **keys, ***key_sets, **all_keys, *value, *ndn, *plugin_id;
 	int i, j, k, n_key_sets;
-	data = callback_data;
 	plugin_id = data->state->plugin_desc->spd_id;
 	/* Pull out the NDN of this entry. */
 	ndn = slapi_entry_get_ndn(e);
@@ -285,7 +215,7 @@ backend_map_config_entry_add_one_cb(Slapi_Entry *e, void *callback_data)
 					format_free_data(keys[k]);
 				}
 				free(keys);
-				return 0;
+				return;
 			}
 		}
 		keys[j] = NULL;
@@ -389,49 +319,6 @@ backend_map_config_entry_add_one_cb(Slapi_Entry *e, void *callback_data)
 		}
 		free(keys);
 	}
-	return 0;
-}
-
-static int
-backend_map_config_entry_set_one_cb(Slapi_Entry *e, void *cbdata)
-{
-	backend_map_config_entry_add_one_cb(e, cbdata);
-	return 0;
-}
-
-static void
-backend_map_config_entry_set_one(Slapi_Entry *e,
-				 struct backend_map_data *map_data)
-{
-	backend_map_config_entry_set_one_cb(e, map_data);
-}
-
-static void
-backend_map_config_entry_set_one_dn(struct plugin_state *state, const char *dn,
-				    struct backend_map_data *map_data)
-{
-	Slapi_DN *sdn;
-	Slapi_Entry *entry;
-	sdn = slapi_sdn_new_dn_byval(dn);
-	if (sdn == NULL) {
-		slapi_log_error(SLAPI_LOG_PLUGIN,
-				state->plugin_desc->spd_id,
-				"error parsing DN \"%s\"\n", dn);
-		return;
-	} else {
-		entry = NULL;
-		slapi_search_internal_get_entry(sdn, NULL, &entry,
-						state->plugin_identity);
-		if (entry == NULL) {
-			slapi_log_error(SLAPI_LOG_PLUGIN,
-					state->plugin_desc->spd_id,
-					"failure reading entry \"%s\"\n", dn);
-		} else {
-			backend_map_config_entry_set_one(entry, map_data);
-			slapi_entry_free(entry);
-		}
-		slapi_sdn_free(&sdn);
-	}
 }
 
 /*
@@ -500,13 +387,14 @@ backend_map_config_filter(const char *format,
 	return ret;
 }
 
-/* Given an entry, read the map configuration for the given domain and map
- * name. */
-static void
-backend_map_config_read_config(struct plugin_state *state, Slapi_Entry *e,
+/* Given an entry, read the rest of the map configuration for the given domain
+ * and map name. */
+void
+backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 			       const char *domain, const char *map,
-			       bool_t *secure, struct backend_map_data *ret)
+			       bool_t *secure, struct backend_set_data **pret)
 {
+	struct backend_set_data ret;
 	const char *default_filter, *default_key_format, *default_keys_format;
 	const char *default_value_format, *default_disallowed_chars;
 	char **bases, *entry_filter;
@@ -655,21 +543,21 @@ backend_map_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 						     default_filter,
 						     domain, map);
 	use_key_formats = key_formats ?
-			  backend_dup_strlist(key_formats) :
+			  backend_shr_dup_strlist(key_formats) :
 			  default_key_format ?
-			  backend_dup_strlist_n((char **) &default_key_format,
-			 		        1) :
+			  backend_shr_dup_strlist_n((char **) &default_key_format,
+			 			    1) :
 			  NULL;
 	use_keys_formats = keys_formats ?
-			   backend_dup_strlist(keys_formats) :
+			   backend_shr_dup_strlist(keys_formats) :
 			   default_keys_format ?
-			   backend_dup_strlist_n((char **) &default_keys_format,
-			  			 1) :
+			   backend_shr_dup_strlist_n((char **) &default_keys_format,
+			   			     1) :
 			   NULL;
 	use_value_format = value_format ?
 			   strdup(value_format) :
 			   strdup(default_value_format);
-	use_bases = backend_dup_strlist(bases);
+	use_bases = backend_shr_dup_strlist(bases);
 	use_disallowed_chars = disallowed_chars ?
 			       disallowed_chars :
 			       (default_disallowed_chars ?
@@ -677,25 +565,25 @@ backend_map_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 				NULL);
 	/* Free the values we read from the entry. */
 	free(value_format);
-	backend_free_strlist(key_formats);
-	backend_free_strlist(keys_formats);
+	backend_shr_free_strlist(key_formats);
+	backend_shr_free_strlist(keys_formats);
 	free(entry_filter);
-	backend_free_strlist(bases);
+	backend_shr_free_strlist(bases);
 	/* Populate the returned structure. */
-	ret->state = state;
-	ret->domain = strdup(domain);
-	ret->map = strdup(map);
-	ret->bases = use_bases;
-	ret->disallowed_chars = use_disallowed_chars;
-	ret->entry_filter = use_entry_filter;
-	ret->key_formats = use_key_formats;
-	ret->n_key_formats = 0;
-	ret->keys_formats = use_keys_formats;
-	ret->n_keys_formats = 0;
-	ret->value_format = use_value_format;
-	ret->ref_attrs = NULL;
-	ret->inref_attrs = NULL;
-	ret->n_key_formats = 0;
+	ret.state = state;
+	ret.domain = strdup(domain);
+	ret.map = strdup(map);
+	ret.bases = use_bases;
+	ret.disallowed_chars = use_disallowed_chars;
+	ret.entry_filter = use_entry_filter;
+	ret.key_formats = use_key_formats;
+	ret.n_key_formats = 0;
+	ret.keys_formats = use_keys_formats;
+	ret.n_keys_formats = 0;
+	ret.value_format = use_value_format;
+	ret.ref_attrs = NULL;
+	ret.inref_attrs = NULL;
+	ret.n_key_formats = 0;
 	for (i = 0;
 	     (use_key_formats != NULL) && (use_key_formats[i] != NULL);
 	     i++) {
@@ -708,7 +596,7 @@ backend_map_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 				map, domain,
 				use_entry_filter,
 				use_key_formats[i], use_value_format);
-		ret->n_key_formats++;
+		ret.n_key_formats++;
 	}
 	for (i = 0;
 	     (use_keys_formats != NULL) && (use_keys_formats[i] != NULL);
@@ -722,77 +610,24 @@ backend_map_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 				map, domain,
 				use_entry_filter,
 				use_keys_formats[i], use_value_format);
-		ret->n_keys_formats++;
+		ret.n_keys_formats++;
 	}
-}
-
-/* Given a directory server entry which represents a map's configuration, set
- * up and populate the map. */
-static int
-backend_map_config_entry_add_one(struct plugin_state *state, Slapi_Entry *e,
-				 const char *domain, const char *map)
-{
-	Slapi_PBlock *pb;
-	int i;
-	bool_t secure;
-	struct backend_map_data cb_data, *map_cb_data;
-
-	pb = slapi_pblock_new();
-	secure = FALSE;
-	backend_map_config_read_config(state, e, domain, map, &secure,
-				       &cb_data);
-	map_cb_data = backend_copy_map_data(&cb_data);
-	backend_free_map_data_contents(&cb_data);
-	if (map_cb_data == NULL) {
-		slapi_log_error(SLAPI_LOG_PLUGIN,
-				state->plugin_desc->spd_id,
-				"incomplete map definition %s in %s (2)\n",
-				map, domain);
-		slapi_pblock_destroy(pb);
-		return 0;
-	}
-	slapi_log_error(SLAPI_LOG_PLUGIN,
-			state->plugin_desc->spd_id,
-			"initializing map %s in %s, secure=%s (2)\n",
-			map, domain, secure ? "yes" : "no");
-	map_data_set_map(state, domain, map, secure,
-			 map_cb_data, &backend_free_map_data);
-	map_data_clear_map(state, domain, map);
-	/* Search under each base in turn, adding the matching directory
-	 * entries to the NIS maps. */
-	for (i = 0;
-	     (map_cb_data->bases != NULL) && (map_cb_data->bases[i] != NULL);
-	     i++) {
-		slapi_log_error(SLAPI_LOG_PLUGIN,
-				state->plugin_desc->spd_id,
-				"searching '%s' for '%s'\n",
-				map_cb_data->bases[i],
-				map_cb_data->entry_filter);
-		slapi_search_internal_set_pb(pb,
-					     map_cb_data->bases[i],
-					     LDAP_SCOPE_SUB,
-					     map_cb_data->entry_filter,
-					     NULL, FALSE,
-					     NULL,
-					     NULL,
-					     state->plugin_identity,
-					     0);
-		slapi_search_internal_callback_pb(pb, map_cb_data,
-						  NULL,
-						  backend_map_config_entry_add_one_cb,
-						  NULL);
-		slapi_free_search_results_internal(pb);
-	}
-	/* Clean up. */
-	slapi_pblock_destroy(pb);
-	return 0;
+	*pret = backend_copy_set_data(&ret);
+	free(ret.domain);
+	free(ret.map);
+	backend_shr_free_strlist(ret.bases);
+	free(ret.disallowed_chars);
+	free(ret.entry_filter);
+	backend_shr_free_strlist(ret.key_formats);
+	backend_shr_free_strlist(ret.keys_formats);
+	free(ret.value_format);
 }
 
 /* Process a map configuration directory entry.  Pull out the domain and map
  * names which are valid for this configuration and configure such a map for
  * each in turn. */
-static int
-backend_map_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
+int
+backend_set_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 {
 	char **domains, **maps, *actual_attr;
 	const char *cvalue;
@@ -838,9 +673,9 @@ backend_map_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 	}
 	for (i = 0; (domains != NULL) && (domains[i] != NULL); i++) {
 		for (j = 0; (maps != NULL) && (maps[j] != NULL); j++) {
-			ret = backend_map_config_entry_add_one(state, e,
-							       domains[i],
-							       maps[j]);
+			ret = backend_shr_set_config_entry_add_one(state, e,
+								   domains[i],
+								   maps[j]);
 		}
 	}
 	if (domains != NULL) {
@@ -859,8 +694,8 @@ backend_map_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 }
 
 /* Update/initialize parameters stored in the plugin's configuration entry. */
-static void
-backend_read_params(struct plugin_state *state)
+void
+backend_update_params(struct plugin_state *state)
 {
 	Slapi_DN *our_dn;
 	Slapi_Entry *our_entry;
@@ -882,7 +717,7 @@ backend_read_params(struct plugin_state *state)
 	if (our_dn == NULL) {
 		slapi_log_error(SLAPI_LOG_PLUGIN,
 				state->plugin_desc->spd_id,
-				"backend_read_params: "
+				"backend_update_params: "
 				"error parsing %s%s%s\n",
 				state->plugin_base ? "\"" : "",
 				state->plugin_base ?
@@ -897,7 +732,7 @@ backend_read_params(struct plugin_state *state)
 	if (our_entry == NULL) {
 		slapi_log_error(SLAPI_LOG_PLUGIN,
 				state->plugin_desc->spd_id,
-				"backend_read_params: failure reading entry "
+				"backend_update_params: failure reading entry "
 				"\"%s\"\n", state->plugin_base);
 		return;
 	}
@@ -920,7 +755,7 @@ backend_read_params(struct plugin_state *state)
 					}
 					slapi_log_error(SLAPI_LOG_PLUGIN,
 							state->plugin_desc->spd_id,
-							"backend_read_params: "
+							"backend_update_params: "
 							"setting max value "
 							"size %u\n",
 							state->max_value_size);
@@ -935,7 +770,7 @@ backend_read_params(struct plugin_state *state)
 					}
 					slapi_log_error(SLAPI_LOG_PLUGIN,
 							state->plugin_desc->spd_id,
-							"backend_read_params: "
+							"backend_update_params: "
 							"setting max dgram "
 							"size %u\n",
 							state->max_dgram_size);
@@ -965,7 +800,7 @@ backend_read_params(struct plugin_state *state)
 		} else {
 			slapi_log_error(SLAPI_LOG_PLUGIN,
 					state->plugin_desc->spd_id,
-					"backend_read_params: no \"%s\" value "
+					"backend_update_params: no \"%s\" value "
 					"for \"%s\", using default\n", attrs[i],
 					state->plugin_base);
 		}
@@ -973,64 +808,20 @@ backend_read_params(struct plugin_state *state)
 	slapi_entry_free(our_entry);
 }
 
-/* Scan for the list of configured domains and maps. */
-void
-backend_startup(struct plugin_state *state)
-{
-	Slapi_PBlock *pb;
-
-	backend_read_params(state);
-
-	pb = slapi_pblock_new();
-	slapi_log_error(SLAPI_LOG_PLUGIN,
-			state->plugin_desc->spd_id,
-			"searching \"%s\" for maps\n", state->plugin_base);
-	slapi_search_internal_set_pb(pb,
-				     state->plugin_base,
-				     LDAP_SCOPE_ONE,
-				     NIS_MAP_CONFIGURATION_FILTER,
-				     NULL, FALSE,
-				     NULL,
-				     NULL,
-				     state->plugin_identity,
-				     0);
-	map_wrlock();
-	slapi_search_internal_callback_pb(pb, state,
-					  NULL,
-					  backend_map_config_entry_add_cb,
-					  NULL);
-	map_unlock();
-	slapi_free_search_results_internal(pb);
-	slapi_pblock_destroy(pb);
-}
-
 /* Process a map configuration directory entry.  Pull out the domain and map
  * names which are specified in the entry and delete each in turn. */
-static int
-backend_map_config_entry_delete_cb(Slapi_Entry *e, void *callback_data)
+int
+backend_set_config_entry_delete_cb(Slapi_Entry *e, void *callback_data)
 {
-	char **domains, **maps;
-	int i, j;
 	struct plugin_state *state;
-
 	state = callback_data;
-	domains = slapi_entry_attr_get_charray(e,
-					       NIS_MAP_CONFIGURATION_DOMAIN_ATTR);
-	maps = slapi_entry_attr_get_charray(e, NIS_MAP_CONFIGURATION_MAP_ATTR);
-	for (i = 0; (domains != NULL) && (domains[i] != NULL); i++) {
-		for (j = 0; (maps != NULL) && (maps[j] != NULL); j++) {
-			slapi_log_error(SLAPI_LOG_PLUGIN,
-					state->plugin_desc->spd_id,
-					"removing map %s in %s\n",
-					maps[j], domains[i]);
-			map_data_unset_map(state, domains[i], maps[j]);
-		}
-	}
-	slapi_ch_array_free(maps);
-	slapi_ch_array_free(domains);
-	return 0;
+	return backend_shr_set_config_entry_delete(state, e,
+						   NIS_MAP_CONFIGURATION_DOMAIN_ATTR,
+						   NIS_MAP_CONFIGURATION_MAP_ATTR);
 }
 
+/* Read enough of the map configuration for the formatting code to be able to
+ * resolver references correctly. */
 struct backend_get_map_config_cb {
 	struct plugin_state *state;
 	char **bases;
@@ -1040,7 +831,7 @@ struct backend_get_map_config_cb {
 void
 backend_free_map_config(char **bases, char *entry_filter)
 {
-	backend_free_strlist(bases);
+	backend_shr_free_strlist(bases);
 	free(entry_filter);
 }
 
@@ -1161,12 +952,10 @@ backend_get_map_config(struct plugin_state *state,
 	free(filter);
 }
 
-/* Our postoperation callbacks. */
-
 /* Given a map configuration, return true if the entry is supposed to be in the
  * map. */
-static bool_t
-backend_entry_matches_map(struct backend_map_data *map_data,
+bool_t
+backend_entry_matches_set(struct backend_set_data *set_data,
 			  Slapi_PBlock *pb, Slapi_Entry *e)
 {
 	Slapi_DN *base_sdn;
@@ -1181,9 +970,9 @@ backend_entry_matches_map(struct backend_map_data *map_data,
 	} else {
 		/* Check each base in turn. */
 		for (i = 0;
-		     (map_data->bases != NULL) && (map_data->bases[i] != NULL);
+		     (set_data->bases != NULL) && (set_data->bases[i] != NULL);
 		     i++) {
-			base_sdn = slapi_sdn_new_dn_byval(map_data->bases[i]);
+			base_sdn = slapi_sdn_new_dn_byval(set_data->bases[i]);
 			if (base_sdn == NULL) {
 				return FALSE;
 			} else {
@@ -1201,12 +990,12 @@ backend_entry_matches_map(struct backend_map_data *map_data,
 			}
 		}
 		/* If we ran out of bases to check, it doesn't match. */
-		if ((map_data->bases == NULL) || (map_data->bases[i] == NULL)) {
+		if ((set_data->bases == NULL) || (set_data->bases[i] == NULL)) {
 			return FALSE;
 		}
 	}
 	/* If it's contained by a search base, compare it to the filter. */
-	filter = slapi_str2filter(map_data->entry_filter);
+	filter = slapi_str2filter(set_data->entry_filter);
 	if (filter == NULL) {
 		return FALSE;
 	} else {
@@ -1279,7 +1068,14 @@ backend_entry_is_a_set(struct plugin_state *state,
 	return ret;
 }
 
-/* Set our post-op callbacks. */
+/* Scan for the list of configured domains and maps. */
+void
+backend_startup(struct plugin_state *state)
+{
+	backend_shr_startup(state, NIS_MAP_CONFIGURATION_FILTER);
+}
+
+/* Set up our post-op callbacks. */
 void
 backend_init(Slapi_PBlock *pb, struct plugin_state *state)
 {
diff --git a/src/back-shr.c b/src/back-shr.c
index 2c6f358..26cfa30 100644
--- a/src/back-shr.c
+++ b/src/back-shr.c
@@ -279,7 +279,7 @@ backend_shr_set_config_entry_add_one(struct plugin_state *state, Slapi_Entry *e,
 	}
 	slapi_log_error(SLAPI_LOG_PLUGIN,
 			state->plugin_desc->spd_id,
-			"initializing %s in %s, %s (2)\n",
+			"initializing %s in %s, flag=%s (2)\n",
 			set, group, flag ? "yes" : "no");
 	map_data_set_map(state, group, set, flag,
 			 set_data, &backend_shr_set_config_free_config);
@@ -302,7 +302,7 @@ backend_shr_set_config_entry_add_one(struct plugin_state *state, Slapi_Entry *e,
 					     0);
 		slapi_search_internal_callback_pb(pb, set_data,
 						  NULL,
-						  backend_set_config_entry_add_cb,
+						  backend_shr_set_entry_one_cb,
 						  NULL);
 		slapi_free_search_results_internal(pb);
 	}
@@ -317,6 +317,8 @@ backend_shr_startup(struct plugin_state *state, const char *filter)
 {
 	Slapi_PBlock *pb;
 
+	backend_update_params(state);
+
 	pb = slapi_pblock_new();
 	slapi_log_error(SLAPI_LOG_PLUGIN,
 			state->plugin_desc->spd_id,