- update for new length-setting formatting API

- use shared vattr-aware attribute reading functions to cut down the amount of
  code we use to read the configuration

2 files changed, 137 insertions, 538 deletions

diff --git a/src/back-nis.c b/src/back-nis.c
index 63d5a44..f938e4a 100644
--- a/src/back-nis.c
+++ b/src/back-nis.c
@@ -51,6 +51,8 @@
 #include "plugin.h"
 #include "map.h"
 
+/* The filter which we use to identify map configurations.  It lists the
+ * required attributes. */
 #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. */
@@ -112,13 +114,13 @@ backend_copy_set_data(const struct backend_set_data *data)
 	ret->common.group = strdup(data->common.group);
 	ret->common.set = strdup(data->common.set);
 	ret->common.bases = backend_shr_dup_strlist(data->common.bases);
+	ret->common.entry_filter = strdup(data->common.entry_filter);
 	ret->common.ref_attrs = data->common.ref_attrs ?
 				format_dup_attr_list(data->common.ref_attrs) :
 				NULL;
 	ret->common.inref_attrs = data->common.inref_attrs ?
 				  format_dup_inref_attrs(data->common.inref_attrs) :
 				  NULL;
-	ret->common.entry_filter = strdup(data->common.entry_filter);
 	ret->disallowed_chars = data->disallowed_chars ?
 				strdup(data->disallowed_chars) : NULL;
 	ret->key_formats = backend_shr_dup_strlist(data->key_formats);
@@ -146,16 +148,21 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 {
 	char **keys, ***key_sets, **all_keys, *value, *ndn, *plugin_id;
 	int i, j, k, n_key_sets;
+	unsigned int *key_lengths, **key_length_sets, *all_key_lengths;
+	unsigned int value_len;
 	plugin_id = data->common.state->plugin_desc->spd_id;
 	/* Pull out the NDN of this entry. */
 	ndn = slapi_entry_get_ndn(e);
 	/* Pull out the keys and value for the entry. */
 	if (data->n_key_formats > 0) {
 		keys = malloc((data->n_key_formats + 1) * sizeof(char *));
+		key_lengths = malloc((data->n_key_formats + 1) *
+				     sizeof(unsigned int));
 	} else {
 		keys = NULL;
+		key_lengths = NULL;
 	}
-	if (keys != NULL) {
+	if ((keys != NULL) && (key_lengths != NULL)) {
 		for (i = 0, j = 0; i < data->n_key_formats; i++) {
 			keys[j] = format_get_data(data->common.state, e,
 						  data->common.group,
@@ -163,8 +170,9 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 						  data->key_formats[i],
 						  data->disallowed_chars,
 						  &data->common.ref_attrs,
-						  &data->common.inref_attrs);
-			if (keys[j] != NULL) {
+						  &data->common.inref_attrs,
+						  &key_lengths[j]);
+			if ((keys[j] != NULL) && (key_lengths[j] > 0)) {
 				j++;
 			} else {
 				slapi_log_error(SLAPI_LOG_PLUGIN, plugin_id,
@@ -189,8 +197,11 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 	}
 	if (data->n_keys_formats > 0) {
 		key_sets = malloc((data->n_keys_formats + 1) * sizeof(char **));
+		key_length_sets = malloc((data->n_keys_formats + 1) *
+					 sizeof(unsigned int *));
 	} else {
 		key_sets = NULL;
+		key_length_sets = NULL;
 	}
 	n_key_sets = 0;
 	if (key_sets != NULL) {
@@ -201,19 +212,23 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 							  data->keys_formats[i],
 							  data->disallowed_chars,
 							  &data->common.ref_attrs,
-							  &data->common.inref_attrs);
-			if (key_sets[j] != NULL) {
+							  &data->common.inref_attrs,
+							  &key_length_sets[j]);
+			if ((key_sets[j] != NULL) &&
+			    (key_length_sets[j] != NULL)) {
 				j++;
 			}
 		}
 		key_sets[j] = NULL;
+		key_length_sets[j] = NULL;
 		n_key_sets = j;
 	}
 	value = format_get_data(data->common.state, e,
 				data->common.group, data->common.set,
 			        data->value_format, data->disallowed_chars,
 			        &data->common.ref_attrs,
-				&data->common.inref_attrs);
+				&data->common.inref_attrs,
+				&value_len);
 	/* Build one big list of all of the keys and key sets. */
 	k = 0;
 	if (keys != NULL) {
@@ -232,11 +247,13 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 	}
 	if (k > 0) {
 		all_keys = malloc(sizeof(char *) * (k + 1));
-		if (all_keys != NULL) {
+		all_key_lengths = malloc(sizeof(unsigned int) * (k + 1));
+		if ((all_keys != NULL) && (all_key_lengths != NULL)) {
 			k = 0;
 			if (keys != NULL) {
 				for (i = 0; keys[i] != NULL; i++) {
 					all_keys[k++] = keys[i];
+					all_key_lengths[k++] = key_lengths[i];
 				}
 			}
 			if (key_sets != NULL) {
@@ -245,13 +262,17 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 					     key_sets[i][j] != NULL;
 					     j++) {
 						all_keys[k++] = key_sets[i][j];
+						all_key_lengths[k++] =
+							key_length_sets[i][j];
 					}
 				}
 			}
 			all_keys[k] = NULL;
+			all_key_lengths[k] = 0;
 		}
 	} else {
 		all_keys = NULL;
+		all_key_lengths = NULL;
 	}
 	/* If we actually generated a value, then set it, otherwise clear it in
 	 * case there was one set before. */
@@ -259,13 +280,15 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 		for (i = 0; all_keys[i] != NULL; i++) {
 			slapi_log_error(SLAPI_LOG_PLUGIN, plugin_id,
 					"setting domain/map/key/value "
-					"\"%s\"/\"%s\"/\"%s\"(\"%s\")=\"%s\"\n",
+					"\"%s\"/\"%s\"/\"%s\"(\"%s\")="
+					"\"%.*s\"\n",
 					data->common.group, data->common.set,
-					all_keys[i], ndn, value);
+					all_keys[i], ndn, value_len, value);
 		}
 		map_data_set_entry(data->common.state,
 				   data->common.group, data->common.set, ndn,
-				   NULL, all_keys, -1, value, NULL, NULL);
+				   all_key_lengths, all_keys,
+				   value_len, value, NULL, NULL);
 	} else {
 		slapi_log_error(SLAPI_LOG_PLUGIN, plugin_id,
 				"no value for %s, unsetting domain/map/id"
@@ -275,18 +298,21 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 				     data->common.group, data->common.set, ndn);
 	}
 	format_free_data(value);
+	free(all_key_lengths);
 	free(all_keys);
 	if (key_sets != NULL) {
 		for (i = 0; key_sets[i] != NULL; i++) {
-			format_free_data_set(key_sets[i]);
+			format_free_data_set(key_sets[i], key_length_sets[i]);
 		}
 		free(key_sets);
+		free(key_length_sets);
 	}
 	if (keys != NULL) {
 		for (i = 0; i < data->n_key_formats; i++) {
 			format_free_data(keys[i]);
 		}
 		free(keys);
+		free(key_lengths);
 	}
 }
 
@@ -367,7 +393,7 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 	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;
+	char **bases, *entry_filter, *tmp;
 	char **key_formats, **keys_formats, *value_format, *actual_attr;
 	char *disallowed_chars;
 	char **use_bases, *use_entry_filter;
@@ -383,127 +409,21 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 				&default_value_format,
 				&default_disallowed_chars);
 	/* Read the values from the configuration entry. */
-	bases = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_BASE_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		bases = malloc(sizeof(char *) * (count + 1));
-		if (bases != NULL) {
-			i = 0;
-			for (j = slapi_valueset_first_value(values, &value);
-			     j != -1;
-			     j = slapi_valueset_next_value(values, j, &value)) {
-				cvalue = slapi_value_get_string(value);
-				bases[i++] = strdup(cvalue);
-			}
-			bases[i] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	entry_filter = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_FILTER_ATTR,
-				   &values, &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			if (strlen(cvalue) > 1) {
-				if ((cvalue[0] != '(') ||
-				    (cvalue[strlen(cvalue) - 1] != ')')) {
-					entry_filter = malloc(strlen(cvalue) +
-							      3);
-					if (entry_filter != NULL) {
-						sprintf(entry_filter, "(%s)",
-							cvalue);
-					}
-				}
-			}
-			if (entry_filter == NULL) {
-				entry_filter = strdup(cvalue);
-			}
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	key_formats = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_KEY_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		key_formats = malloc((slapi_valueset_count(values) + 1) *
-				     sizeof (char *));
-		if (key_formats != NULL) {
-			i = 0;
-			for (j = slapi_valueset_first_value(values, &value);
-			     j != -1;
-			     j = slapi_valueset_next_value(values, j, &value)) {
-				cvalue = slapi_value_get_string(value);
-				key_formats[i++] = strdup(cvalue);
-			}
-			key_formats[i] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr,
-					buffer_flags);
-	}
-	keys_formats = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_KEYS_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		keys_formats = malloc((slapi_valueset_count(values) + 1) *
-				      sizeof (char *));
-		if (keys_formats != NULL) {
-			i = 0;
-			for (j = slapi_valueset_first_value(values, &value);
-			     j != -1;
-			     j = slapi_valueset_next_value(values, j, &value)) {
-				cvalue = slapi_value_get_string(value);
-				keys_formats[i++] = strdup(cvalue);
-			}
-			keys_formats[i] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr,
-					buffer_flags);
-	}
-	value_format = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_VALUE_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			value_format = strdup(cvalue);
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	disallowed_chars = NULL;
-	if (slapi_vattr_values_get(e,
-				   NIS_MAP_CONFIGURATION_DISALLOWED_CHARS_ATTR,
-				   &values, &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			disallowed_chars = strdup(cvalue);
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	*secure = FALSE;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_SECURE_ATTR,
-				   &values, &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			/* FIXME: use nl_langinfo(YESEXPR) here? */
-			if ((strcasecmp(cvalue, "yes") == 0) ||
-			    (strcasecmp(cvalue, "on") == 0) ||
-			    (strcasecmp(cvalue, "1") == 0)) {
-				*secure = TRUE;
-			} else {
-				*secure = FALSE;
-			}
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
+	bases = backend_shr_get_vattr_strlist(state, e,
+					      NIS_MAP_CONFIGURATION_BASE_ATTR);
+	entry_filter = backend_shr_get_vattr_filter(state, e,
+						    NIS_MAP_CONFIGURATION_FILTER_ATTR);
+	key_formats = backend_shr_get_vattr_strlist(state, e,
+						    NIS_MAP_CONFIGURATION_KEY_ATTR);
+	keys_formats = backend_shr_get_vattr_strlist(state, e,
+						     NIS_MAP_CONFIGURATION_KEYS_ATTR);
+	value_format = backend_shr_get_vattr_str(state, e,
+						 NIS_MAP_CONFIGURATION_VALUE_ATTR);
+	disallowed_chars = backend_shr_get_vattr_str(state, e,
+						     NIS_MAP_CONFIGURATION_DISALLOWED_CHARS_ATTR);
+	*secure = backend_shr_get_vattr_boolean(state, e,
+						NIS_MAP_CONFIGURATION_DISALLOWED_CHARS_ATTR,
+						FALSE);
 	/* Build a filter, using either the configured value or the default as
 	 * a template, we need to do this because RFC2307bis sometimes stores
 	 * the map name in each entry, so it's useful to be able to filter on
@@ -529,11 +449,12 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 			   strdup(default_value_format);
 	use_bases = backend_shr_dup_strlist(bases);
 	use_disallowed_chars = disallowed_chars ?
-			       disallowed_chars :
+			       strdup(disallowed_chars) :
 			       (default_disallowed_chars ?
 			        strdup(default_disallowed_chars) :
 				NULL);
 	/* Free the values we read from the entry. */
+	free(disallowed_chars);
 	free(value_format);
 	backend_shr_free_strlist(key_formats);
 	backend_shr_free_strlist(keys_formats);
@@ -606,40 +527,10 @@ backend_set_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 	struct plugin_state *state;
 
 	state = callback_data;
-	domains = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_DOMAIN_ATTR,
-				   &values, &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		domains = malloc(sizeof(char *) * (count + 1));
-		if (domains != NULL) {
-			for (i = slapi_valueset_first_value(values, &value);
-			     i != -1;
-			     i = slapi_valueset_next_value(values, i, &value)) {
-				cvalue = slapi_value_get_string(value);
-				domains[i] = strdup(cvalue);
-			}
-			domains[count] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	maps = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_MAP_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		maps = malloc(sizeof(char *) * (count + 1));
-		if (maps != NULL) {
-			for (i = slapi_valueset_first_value(values, &value);
-			     i != -1;
-			     i = slapi_valueset_next_value(values, i, &value)) {
-				cvalue = slapi_value_get_string(value);
-				maps[i] = strdup(cvalue);
-			}
-			maps[count] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
+	domains = backend_shr_get_vattr_strlist(state, e,
+						NIS_MAP_CONFIGURATION_DOMAIN_ATTR);
+	maps = backend_shr_get_vattr_strlist(state, e,
+					     NIS_MAP_CONFIGURATION_MAP_ATTR);
 	for (i = 0; (domains != NULL) && (domains[i] != NULL); i++) {
 		for (j = 0; (maps != NULL) && (maps[j] != NULL); j++) {
 			ret = backend_shr_set_config_entry_add(state, e,
@@ -647,18 +538,8 @@ backend_set_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 							       maps[j]);
 		}
 	}
-	if (domains != NULL) {
-		for (i = 0; (domains != NULL) && (domains[i] != NULL); i++) {
-			free(domains[i]);
-		}
-		free(domains);
-	}
-	if (maps != NULL) {
-		for (i = 0; (maps != NULL) && (maps[i] != NULL); i++) {
-			free(maps[i]);
-		}
-		free(maps);
-	}
+	backend_shr_free_strlist(maps);
+	backend_shr_free_strlist(domains);
 	return 0;
 }
 
@@ -670,18 +551,8 @@ backend_update_params(struct plugin_state *state)
 	Slapi_Entry *our_entry;
 	Slapi_ValueSet *values;
 	Slapi_Value *value;
-	char *actual_attr;
-	const char *cvalue;
-	int disposition, buffer_flags, i, j;
-	unsigned int uvalue;
-	char *attrs[] = {
-		NIS_PLUGIN_CONFIGURATION_MAXVALUE_ATTR,
-		NIS_PLUGIN_CONFIGURATION_MAXDGRAM_ATTR,
-		NIS_PLUGIN_CONFIGURATION_PORT_ATTR,
-		NIS_PLUGIN_CONFIGURATION_SECURENET_ATTR,
-		NIS_PLUGIN_CONFIGURATION_TCPWRAPNAME_ATTR,
-		NULL,
-	};
+	char *tmp, **tmpv;
+	int i, j;
 	our_dn = slapi_sdn_new_dn_byval(state->plugin_base);
 	if (our_dn == NULL) {
 		slapi_log_error(SLAPI_LOG_PLUGIN,
@@ -694,7 +565,7 @@ backend_update_params(struct plugin_state *state)
 				state->plugin_base ? "\"" : "");
 		return;
 	}
-	slapi_search_internal_get_entry(our_dn, attrs, &our_entry,
+	slapi_search_internal_get_entry(our_dn, NULL, &our_entry,
 					state->plugin_identity);
 	slapi_sdn_free(&our_dn);
 	our_dn = NULL;
@@ -706,74 +577,27 @@ backend_update_params(struct plugin_state *state)
 		return;
 	}
 	/* Pull out the attribute values. */
-	for (i = 0; attrs[i] != NULL; i++) {
-		if (slapi_vattr_values_get(our_entry, attrs[i], &values,
-					   &disposition, &actual_attr,
-					   0, &buffer_flags) == 0) {
-			value = NULL;
-			j = slapi_valueset_first_value(values, &value);
-			if (j != -1) {
-				switch (i) {
-				case 0: /* max value size */
-					uvalue = slapi_value_get_uint(value);
-					if (uvalue != 0) {
-						state->max_value_size = uvalue;
-					} else {
-						state->max_value_size =
-							DEFAULT_MAX_VALUE_SIZE;
-					}
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"backend_update_params: "
-							"setting max value "
-							"size %u\n",
-							state->max_value_size);
-					break;
-				case 1: /* max dgram size */
-					uvalue = slapi_value_get_uint(value);
-					if (uvalue != 0) {
-						state->max_dgram_size = uvalue;
-					} else {
-						state->max_dgram_size =
-							DEFAULT_MAX_DGRAM_SIZE;
-					}
-					slapi_log_error(SLAPI_LOG_PLUGIN,
-							state->plugin_desc->spd_id,
-							"backend_update_params: "
-							"setting max dgram "
-							"size %u\n",
-							state->max_dgram_size);
-					break;
-				case 3: /* securenet entry */
-					dispatch_securenets_clear(state);
-					while (j != -1) {
-						cvalue = slapi_value_get_string(value);
-						dispatch_securenets_add(state,
-									cvalue);
-						j = slapi_valueset_next_value(values, j, &value);
-					}
-					break;
-				case 4: /* tcp-wrappers name */
-#ifdef HAVE_TCPD_H
-					cvalue = slapi_value_get_string(value);
-					request_set(state->request_info,
-						    RQ_DAEMON, cvalue);
-#endif
-					break;
-				default:
-					break;
-				}
-			}
-			slapi_vattr_values_free(&values, &actual_attr,
-						buffer_flags);
-		} else {
-			slapi_log_error(SLAPI_LOG_PLUGIN,
-					state->plugin_desc->spd_id,
-					"backend_update_params: no \"%s\" value "
-					"for \"%s\", using default\n", attrs[i],
-					state->plugin_base);
+	state->max_value_size = backend_shr_get_vattr_uint(state, our_entry,
+							   NIS_PLUGIN_CONFIGURATION_MAXVALUE_ATTR,
+							   DEFAULT_MAX_VALUE_SIZE);
+	state->max_dgram_size = backend_shr_get_vattr_uint(state, our_entry,
+							   NIS_PLUGIN_CONFIGURATION_MAXDGRAM_ATTR,
+							   DEFAULT_MAX_DGRAM_SIZE);
+	tmpv = backend_shr_get_vattr_strlist(state, our_entry,
+					     NIS_PLUGIN_CONFIGURATION_SECURENET_ATTR);
+	dispatch_securenets_clear(state);
+	if (tmpv != NULL) {
+		for (i = 0; tmpv[i] != NULL; i++) {
+			dispatch_securenets_add(state, tmpv[i]);
 		}
+		backend_shr_free_strlist(tmpv);
 	}
+#ifdef HAVE_TCPD_H
+	tmp = backend_shr_get_vattr_str(state, our_entry,
+					NIS_PLUGIN_CONFIGURATION_TCPWRAPNAME_ATTR);
+	request_set(state->request_info, RQ_DAEMON, tmp);
+	free(tmp);
+#endif
 	slapi_entry_free(our_entry);
 }
 
@@ -800,75 +624,24 @@ struct backend_get_set_config_cb {
 void
 backend_free_set_config(char **bases, char *entry_filter)
 {
-	int i;
-	if (bases != NULL) {
-		for (i = 0; bases[i] != NULL; i++) {
-			free(bases[i]);
-		}
-		free(bases);
-	}
+	backend_shr_free_strlist(bases);
 	free(entry_filter);
 }
 
 static bool_t
 backend_get_set_config_entry_cb(Slapi_Entry *e, void *callback_data)
 {
-	Slapi_ValueSet *values;
-	Slapi_Value *value;
 	struct backend_get_set_config_cb *cbdata;
-	char *actual_attr;
-	const char *cvalue;
-	int disposition, buffer_flags, i, count, len;
 
 	cbdata = callback_data;
 	slapi_log_error(SLAPI_LOG_PLUGIN,
 			cbdata->state->plugin_desc->spd_id,
 			"reading map configuration from \"%s\"\n",
 			slapi_entry_get_ndn(e));
-
-	values = NULL;
-	value = NULL;
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_BASE_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		cbdata->bases = malloc(sizeof(char *) * (count + 1));
-		if (cbdata->bases != NULL) {
-			for (i = slapi_valueset_first_value(values, &value);
-			     i != -1;
-			     i = slapi_valueset_next_value(values, i, &value)) {
-				cvalue = slapi_value_get_string(value);
-				cbdata->bases[i] = strdup(cvalue);
-			}
-			cbdata->bases[count] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	if (slapi_vattr_values_get(e, NIS_MAP_CONFIGURATION_FILTER_ATTR, &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		if (slapi_valueset_first_value(values, &value) != -1) {
-			cvalue = slapi_value_get_string(value);
-			if (cvalue != NULL) {
-				free(cbdata->entry_filter);
-				cbdata->entry_filter = NULL;
-				if ((cvalue[0] != '(') ||
-				    (cvalue[strlen(cvalue) - 1] != ')')) {
-					len = strlen(cvalue) + 3;
-					cbdata->entry_filter = malloc(len);
-					if (cbdata->entry_filter != NULL) {
-						sprintf(cbdata->entry_filter,
-							"(%s)", cvalue);
-					}
-				}
-				if (cbdata->entry_filter == NULL) {
-					cbdata->entry_filter = strdup(cvalue);
-				}
-			}
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-
+	cbdata->bases = backend_shr_get_vattr_strlist(cbdata->state, e,
+						      NIS_MAP_CONFIGURATION_BASE_ATTR);
+	cbdata->entry_filter = backend_shr_get_vattr_filter(cbdata->state, e,
+							    NIS_MAP_CONFIGURATION_FILTER_ATTR);
 	return TRUE;
 }
 
diff --git a/src/back-sch.c b/src/back-sch.c
index 29216c8..f93cb14 100644
--- a/src/back-sch.c
+++ b/src/back-sch.c
@@ -155,100 +155,17 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 	Slapi_Value *value;
 
 	/* Read the values from the configuration entry. */
-	bases = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_BASE_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		bases = malloc(sizeof(char *) * (count + 1));
-		if (bases != NULL) {
-			i = 0;
-			for (j = slapi_valueset_first_value(values, &value);
-			     j != -1;
-			     j = slapi_valueset_next_value(values, j, &value)) {
-				cvalue = slapi_value_get_string(value);
-				bases[i++] = strdup(cvalue);
-			}
-			bases[i] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	entry_filter = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_FILTER_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			if (strlen(cvalue) > 1) {
-				if ((cvalue[0] != '(') ||
-				    (cvalue[strlen(cvalue) - 1] != ')')) {
-					entry_filter = malloc(strlen(cvalue) +
-							      3);
-					if (entry_filter != NULL) {
-						sprintf(entry_filter, "(%s)",
-							cvalue);
-					}
-				}
-			}
-			if (entry_filter == NULL) {
-				entry_filter = strdup(cvalue);
-			}
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	rdn_format = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_RDN_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			rdn_format = strdup(cvalue);
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	check_access = TRUE;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_ACCESS_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		i = slapi_valueset_first_value(values, &value);
-		if (i != -1) {
-			cvalue = slapi_value_get_string(value);
-			/* FIXME: use nl_langinfo(YESEXPR) here? */
-			if ((strcasecmp(cvalue, "yes") == 0) ||
-			    (strcasecmp(cvalue, "on") == 0) ||
-			    (strcasecmp(cvalue, "1") == 0)) {
-				check_access = TRUE;
-			} else {
-				check_access = FALSE;
-			}
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	attributes = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_ATTR_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		attributes = malloc(sizeof(char *) * (count + 1));
-		if (attributes != NULL) {
-			i = 0;
-			for (j = slapi_valueset_first_value(values, &value);
-			     j != -1;
-			     j = slapi_valueset_next_value(values, j, &value)) {
-				cvalue = slapi_value_get_string(value);
-				attributes[i++] = strdup(cvalue);
-			}
-			attributes[i] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
+	bases = backend_shr_get_vattr_strlist(state, e,
+					      SCH_CONTAINER_CONFIGURATION_BASE_ATTR);
+	entry_filter = backend_shr_get_vattr_filter(state, e,
+						    SCH_CONTAINER_CONFIGURATION_FILTER_ATTR);
+	rdn_format = backend_shr_get_vattr_str(state, e,
+					       SCH_CONTAINER_CONFIGURATION_RDN_ATTR);
+	check_access = backend_shr_get_vattr_boolean(state, e,
+						     SCH_CONTAINER_CONFIGURATION_ACCESS_ATTR,
+						     TRUE);
+	attributes = backend_shr_get_vattr_strlist(state, e,
+						   SCH_CONTAINER_CONFIGURATION_ATTR_ATTR);
 	/* Populate the returned structure. */
 	ret.common.state = state;
 	ret.common.group = strdup(group);
@@ -265,20 +182,10 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 	*pret = backend_copy_set_config(&ret);
 	free(ret.common.group);
 	free(ret.common.set);
-	if (ret.common.bases != NULL) {
-		for (i = 0; ret.common.bases[i] != NULL; i++) {
-			free(ret.common.bases[i]);
-		}
-		free(ret.common.bases);
-	}
+	backend_shr_free_strlist(ret.common.bases);
 	free(ret.common.entry_filter);
 	slapi_sdn_free(&ret.container_sdn);
-	if (ret.attribute_format != NULL) {
-		for (i = 0; ret.attribute_format[i] != NULL; i++) {
-			free(ret.attribute_format[i]);
-		}
-		free(ret.attribute_format);
-	}
+	backend_shr_free_strlist(ret.attribute_format);
 	free(ret.rdn_format);
 }
 
@@ -312,11 +219,13 @@ void
 backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 {
 	char *dn, *rdn, *ndn, *ldif, *plugin_id, *keys[2], **ava, *val;
+	unsigned int rdn_len, *ava_lens;
 	const char *rdnstr;
 	int len, i, j;
 	Slapi_Entry *entry;
 	Slapi_DN *e_dn;
 	Slapi_RDN *srdn;
+	Slapi_Value *value;
 
 	plugin_id = data->common.state->plugin_desc->spd_id;
 	e_dn = slapi_entry_get_sdn(e);
@@ -326,13 +235,15 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 			      data->common.group, data->common.set,
 			      data->rdn_format, NULL,
 			      &data->common.ref_attrs,
-			      &data->common.inref_attrs);
+			      &data->common.inref_attrs,
+			      &rdn_len);
 	/* Now build the entry itself, and set the DN first. */
 	entry = slapi_entry_alloc();
 	dn = slapi_dn_plus_rdn(slapi_sdn_get_ndn(data->container_sdn), rdn);
 	slapi_entry_set_dn(entry, dn); /* NOTE: the entry now owns the dn */
 	/* Iterate through the set of attributes. */
 	if (data->attribute_format != NULL) {
+		value = slapi_value_new();
 		for (i = 0; data->attribute_format[i] != NULL; i++) {
 			ava = format_get_data_set(data->common.state, e,
 						  data->common.group,
@@ -340,21 +251,31 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 						  data->attribute_format[i],
 						  NULL,
 						  &data->common.ref_attrs,
-						  &data->common.inref_attrs);
-			if (ava != NULL) {
+						  &data->common.inref_attrs,
+						  &ava_lens);
+			if ((ava != NULL) &&
+			    (ava_lens != NULL) &&
+			    (value != NULL)) {
 				for (j = 0; ava[j] != NULL; j++) {
-					val = strchr(ava[j], '=');
+					val = memchr(ava[j], '=',
+						     ava_lens[j]);
 					if ((val != NULL) && (val[1] != '\0')) {
 						*val = '\0';
-						slapi_entry_add_string(entry,
-								       ava[j],
-								       val + 1);
+						slapi_value_set(value,
+								val + 1,
+								ava_lens[j] -
+								(val - ava[j]) -
+								1);
+						slapi_entry_add_value(entry,
+								      ava[j],
+								      value);
 						*val = '=';
 					}
 				}
-				format_free_data_set(ava);
+				format_free_data_set(ava, ava_lens);
 			}
 		}
+		slapi_value_free(&value);
 	}
 	/* Try to make the entry look "right". */
 	if (!slapi_entry_rdn_values_present(entry)) {
@@ -393,7 +314,8 @@ backend_set_entry(Slapi_Entry *e, struct backend_set_data *data)
 		keys[1] = NULL;
 		map_data_set_entry(data->common.state,
 				   data->common.group, data->common.set, ndn,
-				   NULL, keys, -1, slapi_entry_get_ndn(entry),
+				   &rdn_len, keys,
+				   -1, slapi_entry_get_ndn(entry),
 				   backend_entry_make_entry_data(e_dn, entry),
 				   backend_entry_free_entry_data);
 	} else {
@@ -423,42 +345,10 @@ backend_set_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 	struct plugin_state *state;
 
 	state = callback_data;
-	groups = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_GROUP_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		groups = malloc(sizeof(char *) * (count + 1));
-		if (groups != NULL) {
-			for (i = slapi_valueset_first_value(values, &value);
-			     i != -1;
-			     i = slapi_valueset_next_value(values, i, &value)) {
-				cvalue = slapi_value_get_string(value);
-				groups[i] = strdup(cvalue);
-			}
-			groups[count] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	containers = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_CONTAINER_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		containers = malloc(sizeof(char *) * (count + 1));
-		if (containers != NULL) {
-			for (i = slapi_valueset_first_value(values, &value);
-			     i != -1;
-			     i = slapi_valueset_next_value(values, i, &value)) {
-				cvalue = slapi_value_get_string(value);
-				containers[i] = strdup(cvalue);
-			}
-			containers[count] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
+	groups = backend_shr_get_vattr_strlist(state, e,
+					       SCH_CONTAINER_CONFIGURATION_GROUP_ATTR);
+	containers = backend_shr_get_vattr_strlist(state, e,
+						   SCH_CONTAINER_CONFIGURATION_CONTAINER_ATTR);
 	for (i = 0; (groups != NULL) && (groups[i] != NULL); i++) {
 		for (j = 0;
 		     (containers != NULL) && (containers[j] != NULL);
@@ -468,20 +358,8 @@ backend_set_config_entry_add_cb(Slapi_Entry *e, void *callback_data)
 							       containers[j]);
 		}
 	}
-	if (groups != NULL) {
-		for (i = 0; (groups != NULL) && (groups[i] != NULL); i++) {
-			free(groups[i]);
-		}
-		free(groups);
-	}
-	if (containers != NULL) {
-		for (i = 0;
-		     (containers != NULL) && (containers[i] != NULL);
-		     i++) {
-			free(containers[i]);
-		}
-		free(containers);
-	}
+	backend_shr_free_strlist(containers);
+	backend_shr_free_strlist(groups);
 	return 0;
 }
 
@@ -509,76 +387,24 @@ void
 backend_free_set_config(char **bases, char *entry_filter)
 {
 	int i;
-	if (bases != NULL) {
-		for (i = 0; bases[i] != NULL; i++) {
-			free(bases[i]);
-		}
-		free(bases);
-	}
+	backend_shr_free_strlist(bases);
 	free(entry_filter);
 }
 
 static bool_t
 backend_get_set_config_entry_cb(Slapi_Entry *e, void *callback_data)
 {
-	Slapi_ValueSet *values;
-	Slapi_Value *value;
 	struct backend_get_set_config_cb *cbdata;
-	char *actual_attr;
-	const char *cvalue;
-	int disposition, buffer_flags, i, count, len;
 
 	cbdata = callback_data;
 	slapi_log_error(SLAPI_LOG_PLUGIN,
 			cbdata->state->plugin_desc->spd_id,
 			"reading container configuration from \"%s\"\n",
 			slapi_entry_get_ndn(e));
-
-	values = NULL;
-	value = NULL;
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_BASE_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		count = slapi_valueset_count(values);
-		cbdata->bases = malloc(sizeof(char *) * (count + 1));
-		if (cbdata->bases != NULL) {
-			for (i = slapi_valueset_first_value(values, &value);
-			     i != -1;
-			     i = slapi_valueset_next_value(values, i, &value)) {
-				cvalue = slapi_value_get_string(value);
-				cbdata->bases[i] = strdup(cvalue);
-			}
-			cbdata->bases[count] = NULL;
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-	if (slapi_vattr_values_get(e, SCH_CONTAINER_CONFIGURATION_FILTER_ATTR,
-				   &values,
-				   &disposition, &actual_attr,
-				   0, &buffer_flags) == 0) {
-		if (slapi_valueset_first_value(values, &value) != -1) {
-			cvalue = slapi_value_get_string(value);
-			if (cvalue != NULL) {
-				free(cbdata->entry_filter);
-				cbdata->entry_filter = NULL;
-				if ((cvalue[0] != '(') ||
-				    (cvalue[strlen(cvalue) - 1] != ')')) {
-					len = strlen(cvalue) + 3;
-					cbdata->entry_filter = malloc(len);
-					if (cbdata->entry_filter != NULL) {
-						sprintf(cbdata->entry_filter,
-							"(%s)", cvalue);
-					}
-				}
-				if (cbdata->entry_filter == NULL) {
-					cbdata->entry_filter = strdup(cvalue);
-				}
-			}
-		}
-		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
-	}
-
+	cbdata->bases = backend_shr_get_vattr_strlist(cbdata->state, e,
+						      SCH_CONTAINER_CONFIGURATION_BASE_ATTR);
+	cbdata->entry_filter = backend_shr_get_vattr_filter(cbdata->state, e,
+							    SCH_CONTAINER_CONFIGURATION_BASE_ATTR);
 	return TRUE;
 }