- make the shared parts of the configuration actually shared so that we can

  drop accessors for reading the shared parts

1 files changed, 67 insertions, 99 deletions

diff --git a/src/back-nis.c b/src/back-nis.c
index 67606f9..ced47db 100644
--- a/src/back-nis.c
+++ b/src/back-nis.c
@@ -55,11 +55,7 @@
 
 /* The data we ask the map cache to keep, for us, for each map. */
 struct backend_set_data {
-	/* Common data. */
-	struct plugin_state *state;
-	char *domain, *map, **bases, *entry_filter;
-	char **ref_attrs;
-	struct format_inref_attr **inref_attrs;
+	struct backend_shr_set_data common;
 	/* NIS-specific data. */
 	char **key_formats, **keys_formats, *value_format;
 	int n_key_formats, n_keys_formats;
@@ -80,65 +76,30 @@ backend_read_master_name(struct plugin_state *state, char **master)
 }
 
 /* Manipulate map configuration data. */
-struct plugin_state *
-backend_set_config_get_state(struct backend_set_data *set_data)
-{
-	return set_data->state;
-}
-char **
-backend_set_config_get_bases(struct backend_set_data *set_data)
-{
-	return set_data->bases;
-}
-char *
-backend_set_config_get_filter(struct backend_set_data *set_data)
-{
-	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;
-}
 static void
 backend_free_set_data_contents(void *data)
 {
 	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->common.group);
+		free(set_data->common.set);
+		free(set_data->common.bases);
+		format_free_attr_list(set_data->common.ref_attrs);
+		format_free_inref_attrs(set_data->common.inref_attrs);
+		free(set_data->common.entry_filter);
 		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);
 	}
 }
 void
-backend_set_config_free_config(struct backend_set_data *data)
+backend_set_config_free_config(struct backend_shr_set_data *data)
 {
-	backend_free_set_data_contents(data);
+	backend_free_set_data_contents(data->self);
 	free(data);
 }
-static struct backend_set_data *
+static struct backend_shr_set_data *
 backend_copy_set_data(const struct backend_set_data *data)
 {
 	struct backend_set_data *ret;
@@ -146,34 +107,35 @@ backend_copy_set_data(const struct backend_set_data *data)
 	if (ret == NULL) {
 		return NULL;
 	}
-	ret->state = data->state;
-	ret->domain = strdup(data->domain);
-	ret->map = strdup(data->map);
-	ret->bases = backend_shr_dup_strlist(data->bases);
+	ret->common.self = ret;
+	ret->common.state = data->common.state;
+	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.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->ref_attrs = data->ref_attrs ?
-			 format_dup_attr_list(data->ref_attrs) :
-			 NULL;
-	ret->inref_attrs = data->inref_attrs ?
-			   format_dup_inref_attrs(data->inref_attrs) :
-			   NULL;
-	ret->entry_filter = strdup(data->entry_filter);
 	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);
-	if ((ret->domain == NULL) ||
-	    (ret->map == NULL) ||
-	    (ret->bases == NULL) ||
-	    (ret->entry_filter == NULL) ||
+	if ((ret->common.group == NULL) ||
+	    (ret->common.set == NULL) ||
+	    (ret->common.bases == NULL) ||
+	    (ret->common.entry_filter == NULL) ||
 	    ((ret->key_formats == NULL) && (ret->keys_formats == NULL)) ||
 	    (ret->value_format == NULL)) {
-		backend_set_config_free_config(ret);
+		backend_set_config_free_config(&ret->common);
 		return NULL;
 	}
-	return ret;
+	return &ret->common;
 }
 
 /* Given a map-entry directory entry, determine which keys it should have,
@@ -184,7 +146,7 @@ backend_set_entry_one(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;
-	plugin_id = data->state->plugin_desc->spd_id;
+	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. */
@@ -195,12 +157,13 @@ backend_set_entry_one(Slapi_Entry *e, struct backend_set_data *data)
 	}
 	if (keys != NULL) {
 		for (i = 0, j = 0; i < data->n_key_formats; i++) {
-			keys[j] = format_get_data(data->state, e,
-						  data->domain, data->map,
+			keys[j] = format_get_data(data->common.state, e,
+						  data->common.group,
+						  data->common.set,
 						  data->key_formats[i],
 						  data->disallowed_chars,
-						  &data->ref_attrs,
-						  &data->inref_attrs);
+						  &data->common.ref_attrs,
+						  &data->common.inref_attrs);
 			if (keys[j] != NULL) {
 				j++;
 			} else {
@@ -209,9 +172,11 @@ backend_set_entry_one(Slapi_Entry *e, struct backend_set_data *data)
 						"unsetting domain/map/id"
 						"\"%s\"/\"%s\"/(\"%s\")\n",
 						data->key_formats[i],
-						data->domain, data->map, ndn);
-				map_data_unset_entry_id(data->state,
-							data->domain, data->map,
+						data->common.group,
+						data->common.set, ndn);
+				map_data_unset_entry_id(data->common.state,
+							data->common.group,
+							data->common.set,
 							ndn);
 				for (k = 0; k < j; k++) {
 					format_free_data(keys[k]);
@@ -230,13 +195,13 @@ backend_set_entry_one(Slapi_Entry *e, struct backend_set_data *data)
 	n_key_sets = 0;
 	if (key_sets != NULL) {
 		for (i = 0, j = 0; i < data->n_keys_formats; i++) {
-			key_sets[j] = format_get_data_set(data->state, e,
-							  data->domain,
-							  data->map,
+			key_sets[j] = format_get_data_set(data->common.state, e,
+							  data->common.group,
+							  data->common.set,
 							  data->keys_formats[i],
 							  data->disallowed_chars,
-							  &data->ref_attrs,
-							  &data->inref_attrs);
+							  &data->common.ref_attrs,
+							  &data->common.inref_attrs);
 			if (key_sets[j] != NULL) {
 				j++;
 			}
@@ -244,9 +209,11 @@ backend_set_entry_one(Slapi_Entry *e, struct backend_set_data *data)
 		key_sets[j] = NULL;
 		n_key_sets = j;
 	}
-	value = format_get_data(data->state, e, data->domain, data->map,
+	value = format_get_data(data->common.state, e,
+				data->common.group, data->common.set,
 			        data->value_format, data->disallowed_chars,
-			        &data->ref_attrs, &data->inref_attrs);
+			        &data->common.ref_attrs,
+				&data->common.inref_attrs);
 	/* Build one big list of all of the keys and key sets. */
 	k = 0;
 	if (keys != NULL) {
@@ -293,18 +260,19 @@ backend_set_entry_one(Slapi_Entry *e, struct backend_set_data *data)
 			slapi_log_error(SLAPI_LOG_PLUGIN, plugin_id,
 					"setting domain/map/key/value "
 					"\"%s\"/\"%s\"/\"%s\"(\"%s\")=\"%s\"\n",
-					data->domain, data->map,
+					data->common.group, data->common.set,
 					all_keys[i], ndn, value);
 		}
-		map_data_set_entry(data->state, data->domain, data->map, ndn,
+		map_data_set_entry(data->common.state,
+				   data->common.group, data->common.set, ndn,
 				   NULL, all_keys, -1, value, NULL, NULL);
 	} else {
 		slapi_log_error(SLAPI_LOG_PLUGIN, plugin_id,
 				"no value for %s, unsetting domain/map/id"
 				"\"%s\"/\"%s\"/(\"%s\")\n",
-				ndn, data->domain, data->map, ndn);
-		map_data_unset_entry_id(data->state,
-					data->domain, data->map,
+				ndn, data->common.group, data->common.set, ndn);
+		map_data_unset_entry_id(data->common.state,
+					data->common.group, data->common.set,
 					ndn);
 	}
 	format_free_data(value);
@@ -394,7 +362,8 @@ backend_map_config_filter(const char *format,
 void
 backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 			       const char *domain, const char *map,
-			       bool_t *secure, struct backend_set_data **pret)
+			       bool_t *secure,
+			       struct backend_shr_set_data **pret)
 {
 	struct backend_set_data ret;
 	const char *default_filter, *default_key_format, *default_keys_format;
@@ -572,20 +541,19 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 	free(entry_filter);
 	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.common.state = state;
+	ret.common.group = strdup(domain);
+	ret.common.set = strdup(map);
+	ret.common.bases = use_bases;
+	ret.common.entry_filter = use_entry_filter;
+	ret.common.ref_attrs = NULL;
+	ret.common.inref_attrs = NULL;
 	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++) {
@@ -615,11 +583,11 @@ backend_set_config_read_config(struct plugin_state *state, Slapi_Entry *e,
 		ret.n_keys_formats++;
 	}
 	*pret = backend_copy_set_data(&ret);
-	free(ret.domain);
-	free(ret.map);
-	backend_shr_free_strlist(ret.bases);
+	free(ret.common.group);
+	free(ret.common.set);
+	backend_shr_free_strlist(ret.common.bases);
 	free(ret.disallowed_chars);
-	free(ret.entry_filter);
+	free(ret.common.entry_filter);
 	backend_shr_free_strlist(ret.key_formats);
 	backend_shr_free_strlist(ret.keys_formats);
 	free(ret.value_format);