ldap/servers/slapd/back-ldbm/instance.c | 136 ++----
ldap/servers/slapd/back-ldbm/ldbm_attr.c | 323 +++++++--------
ldap/servers/slapd/back-ldbm/ldbm_config.h | 3
ldap/servers/slapd/back-ldbm/ldbm_index_config.c | 469 +++++++++++++++--------
ldap/servers/slapd/back-ldbm/ldif2ldbm.c | 50 --
ldap/servers/slapd/back-ldbm/perfctrs.c | 2
ldap/servers/slapd/back-ldbm/proto-back-ldbm.h | 2
7 files changed, 556 insertions(+), 429 deletions(-)
New commits:
commit d17fa78abb8ce467046be8c1b353f26fe248039c
Author: Mark Reynolds <mareynol(a)redhat.com>
Date: Fri Jan 27 17:36:38 2012 -0500
Revert "Ticket #55 - Limit of 1024 characters for nsMatchingRule"
This reverts commit 39870fe59195d54dd9d654b1d46737968683f48f.
diff --git a/ldap/servers/slapd/back-ldbm/instance.c b/ldap/servers/slapd/back-ldbm/instance.c
index 8cf79a3..0217e96 100644
--- a/ldap/servers/slapd/back-ldbm/instance.c
+++ b/ldap/servers/slapd/back-ldbm/instance.c
@@ -44,7 +44,7 @@
/* Forward declarations */
static void ldbm_instance_destructor(void **arg);
-Slapi_Entry *ldbm_instance_init_config_entry(char *cn_val, char *v1, char *v2, char *v3);
+
/* Creates and initializes a new ldbm_instance structure.
@@ -148,59 +148,13 @@ done:
return rc;
}
-/*
- * Take a bunch of strings, and create a index config entry
- */
-Slapi_Entry *
-ldbm_instance_init_config_entry(char *cn_val, char *type_val1, char *type_val2, char *type_val3){
- Slapi_Entry *e = slapi_entry_alloc();
- Slapi_Value *sval;
- Slapi_Attr *indextype_attr;
- Slapi_Attr *cn_attr;
- Slapi_Attr *attrs = slapi_attr_new();;
-
- cn_attr = slapi_attr_new();
- slapi_attr_init(cn_attr, "cn");
- sval = slapi_value_new_string(cn_val);
- slapi_attr_add_value(cn_attr,sval);
- attrlist_add(attrs,cn_attr);
- slapi_value_free(&sval);
-
- indextype_attr = slapi_attr_new();
- slapi_attr_init(indextype_attr, "nsIndexType");
- sval = slapi_value_new_string(type_val1);
- slapi_attr_add_value(indextype_attr,sval);
- attrlist_add(&attrs,indextype_attr);
- slapi_value_free(&sval);
-
- if(type_val2){
- indextype_attr = slapi_attr_new();
- slapi_attr_init(indextype_attr, "nsIndexType");
- sval = slapi_value_new_string(type_val2);
- slapi_attr_add_value(indextype_attr,sval);
- attrlist_add(&attrs,indextype_attr);
- slapi_value_free(&sval);
- }
- if(type_val3){
- indextype_attr = slapi_attr_new();
- slapi_attr_init(indextype_attr, "nsIndexType");
- sval = slapi_value_new_string(type_val3);
- slapi_attr_add_value(indextype_attr,sval);
- attrlist_add(&attrs,indextype_attr);
- slapi_value_free(&sval);
- }
-
- slapi_entry_init_ext(e, NULL, attrs);
- return e;
-}
-
/* create the default indexes separately
* (because when we're creating a new backend while the server is running,
* the DSE needs to be pre-seeded first.)
*/
int ldbm_instance_create_default_indexes(backend *be)
{
- Slapi_Entry *e;
+ char *argv[ 9 ];
ldbm_instance *inst = (ldbm_instance *)be->be_instance_info;
/* write the dse file only on the final index */
int flags = LDBM_INSTANCE_CONFIG_DONT_WRITE;
@@ -212,64 +166,76 @@ int ldbm_instance_create_default_indexes(backend *be)
* ACL routines.
*/
if (entryrdn_get_switch()) { /* subtree-rename: on */
- e = ldbm_instance_init_config_entry(LDBM_ENTRYDN_STR,"subtree", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = LDBM_ENTRYRDN_STR;
+ argv[ 1 ] = "subtree";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
} else {
- e = ldbm_instance_init_config_entry(LDBM_ENTRYDN_STR,"eq", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = LDBM_ENTRYDN_STR;
+ argv[ 1 ] = "eq";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
}
- e = ldbm_instance_init_config_entry(LDBM_PARENTID_STR,"eq", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = LDBM_PARENTID_STR;
+ argv[ 1 ] = "eq";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
- e = ldbm_instance_init_config_entry("objectclass","eq", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = "objectclass";
+ argv[ 1 ] = "eq";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
- e = ldbm_instance_init_config_entry("aci","pres", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = "aci";
+ argv[ 1 ] = "pres";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
#if 0 /* don't need copiedfrom */
- e = ldbm_instance_init_config_entry("copiedfrom","pres");
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = "copiedfrom";
+ argv[ 1 ] = "pres";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
#endif
- e = ldbm_instance_init_config_entry(LDBM_NUMSUBORDINATES_STR,"pres", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = LDBM_NUMSUBORDINATES_STR;
+ argv[ 1 ] = "pres";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
- e = ldbm_instance_init_config_entry(SLAPI_ATTR_UNIQUEID,"eq", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = SLAPI_ATTR_UNIQUEID;
+ argv[ 1 ] = "eq";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
/* For MMR, we need this attribute (to replace use of dncomp in delete). */
- e = ldbm_instance_init_config_entry(ATTR_NSDS5_REPLCONFLICT,"eq", "pres", 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
+ argv[ 0 ] = ATTR_NSDS5_REPLCONFLICT;
+ argv[ 1 ] = "eq,pres";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, flags);
/* write the dse file only on the final index */
- e = ldbm_instance_init_config_entry(SLAPI_ATTR_NSCP_ENTRYDN,"eq", 0, 0);
- ldbm_instance_config_add_index_entry(inst, e, flags);
- slapi_entry_free(e);
-
+ argv[ 0 ] = SLAPI_ATTR_NSCP_ENTRYDN;
+ argv[ 1 ] = "eq";
+ argv[ 2 ] = NULL;
+ ldbm_instance_config_add_index_entry(inst, 2, argv, 0);
+
+ argv[ 0 ] = LDBM_PSEUDO_ATTR_DEFAULT;
+ argv[ 1 ] = "none";
+ argv[ 2 ] = NULL;
/* ldbm_instance_config_add_index_entry(inst, 2, argv); */
- e = ldbm_instance_init_config_entry(LDBM_PSEUDO_ATTR_DEFAULT,"none", 0, 0);
- attr_index_config( be, "ldbm index init", 0, e, 1, 0 );
- slapi_entry_free(e);
+ attr_index_config( be, "ldbm index init", 0, 2, argv, 1 );
if (!entryrdn_get_noancestorid()) {
/*
* ancestorid is special, there is actually no such attr type
* but we still want to use the attr index file APIs.
*/
- e = ldbm_instance_init_config_entry(LDBM_ANCESTORID_STR,"eq", 0, 0);
- attr_index_config( be, "ldbm index init", 0, e, 1, 0 );
- slapi_entry_free(e);
+ argv[ 0 ] = LDBM_ANCESTORID_STR;
+ argv[ 1 ] = "eq";
+ argv[ 2 ] = NULL;
+ attr_index_config( be, "ldbm index init", 0, 2, argv, 1 );
}
return 0;
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_attr.c b/ldap/servers/slapd/back-ldbm/ldbm_attr.c
index 4890d60..d09413f 100644
--- a/ldap/servers/slapd/back-ldbm/ldbm_attr.c
+++ b/ldap/servers/slapd/back-ldbm/ldbm_attr.c
@@ -171,65 +171,64 @@ attr_index_config(
backend *be,
char *fname,
int lineno,
- Slapi_Entry *e,
- int init,
- int indextype_none
+ int argc,
+ char **argv,
+ int init
)
{
ldbm_instance *inst = (ldbm_instance *) be->be_instance_info;
- int j = 0;
+ int i, j;
+ char **attrs = NULL;
+ char **indexes = NULL;
char **index_rules = NULL;
struct attrinfo *a;
int return_value = -1;
int *substrlens = NULL;
- int need_compare_fn = 0;
- int hasIndexType = 0;
- const char *attrsyntax_oid = NULL;
- const struct berval *attrValue;
- Slapi_Value *sval;
- Slapi_Attr *attr;
-
- /* Get the cn */
- if (0 == slapi_entry_attr_find(e, "cn", &attr)) {
- slapi_attr_first_value(attr, &sval);
- attrValue = slapi_value_get_berval(sval);
- } else {
+
+ if ((argc == 0) || (argv == NULL)) {
LDAPDebug(LDAP_DEBUG_ANY, "attr_index_config: Missing indexing arguments\n", 0, 0, 0);
- return;
+ goto done;
}
- a = attrinfo_new();
- slapi_attr_init(&a->ai_sattr, attrValue->bv_val);
- /*
- * we can't just set a->ai_type to the type from a->ai_sattr
- * if the type has attroptions or subtypes, ai_sattr.a_type will
- * contain them - but for the purposes of indexing, we don't want them
- */
- a->ai_type = slapi_attr_basetype( attrValue->bv_val, NULL, 0 );
- attrsyntax_oid = attr_get_syntax_oid(&a->ai_sattr);
- a->ai_indexmask = 0;
-
- if(indextype_none){
- /* This is the same has having none for indexType, but applies to the whole entry */
- a->ai_indexmask = INDEX_OFFLINE;
- } else {
- slapi_entry_attr_find(e, "nsIndexType", &attr);
- for (j = slapi_attr_first_value(attr, &sval); j != -1;j = slapi_attr_next_value(attr, j, &sval)) {
- hasIndexType = 1;
- attrValue = slapi_value_get_berval(sval);
- if ( strncasecmp( attrValue->bv_val, "pres", 4 ) == 0 ) {
+ attrs = slapi_str2charray( argv[0], "," );
+ if ( argc > 1 ) {
+ indexes = slapi_str2charray( argv[1], "," );
+ if ( argc > 2 ) {
+ index_rules = slapi_str2charray( argv[2], "," );
+ }
+ }
+
+ if (!indexes) {
+ LDAPDebug(LDAP_DEBUG_ANY, "attr_index_config: Missing index\n", 0, 0, 0);
+ goto done;
+ }
+
+ for ( i = 0; attrs[i] != NULL; i++ ) {
+ int need_compare_fn = 0;
+ const char *attrsyntax_oid = NULL;
+ a = attrinfo_new();
+ slapi_attr_init(&a->ai_sattr, attrs[i]);
+ /* we can't just set a->ai_type to the type from a->ai_sattr
+ if the type has attroptions or subtypes, ai_sattr.a_type will
+ contain them - but for the purposes of indexing, we don't want
+ them */
+ a->ai_type = slapi_attr_basetype( attrs[i], NULL, 0 );
+ attrsyntax_oid = attr_get_syntax_oid(&a->ai_sattr);
+ a->ai_indexmask = 0;
+ for ( j = 0; indexes[j] != NULL; j++ ) {
+ if ( strncasecmp( indexes[j], "pres", 4 ) == 0 ) {
a->ai_indexmask |= INDEX_PRESENCE;
- } else if ( strncasecmp( attrValue->bv_val, "eq", 2 ) == 0 ) {
+ } else if ( strncasecmp( indexes[j], "eq", 2 ) == 0 ) {
a->ai_indexmask |= INDEX_EQUALITY;
- } else if ( strncasecmp( attrValue->bv_val, "approx", 6 ) == 0 ) {
+ } else if ( strncasecmp( indexes[j], "approx", 6 ) == 0 ) {
a->ai_indexmask |= INDEX_APPROX;
- } else if ( strncasecmp( attrValue->bv_val, "subtree", 7 ) == 0 ) {
+ } else if ( strncasecmp( indexes[j], "subtree", 7 ) == 0 ) {
/* subtree should be located before "sub" */
a->ai_indexmask |= INDEX_SUBTREE;
a->ai_dup_cmp_fn = entryrdn_compare_dups;
- } else if ( strncasecmp( attrValue->bv_val, "sub", 3 ) == 0 ) {
+ } else if ( strncasecmp( indexes[j], "sub", 3 ) == 0 ) {
a->ai_indexmask |= INDEX_SUB;
- } else if ( strncasecmp( attrValue->bv_val, "none", 4 ) == 0 ) {
+ } else if ( strncasecmp( indexes[j], "none", 4 ) == 0 ) {
if ( a->ai_indexmask != 0 ) {
LDAPDebug(LDAP_DEBUG_ANY,
"%s: line %d: index type \"none\" cannot be combined with other types\n",
@@ -239,81 +238,77 @@ attr_index_config(
} else {
LDAPDebug(LDAP_DEBUG_ANY,
"%s: line %d: unknown index type \"%s\" (ignored)\n",
- fname, lineno, attrValue->bv_val);
+ fname, lineno, indexes[j]);
LDAPDebug(LDAP_DEBUG_ANY,
"valid index types are \"pres\", \"eq\", \"approx\", or \"sub\"\n",
0, 0, 0);
}
}
- if(hasIndexType == 0){
- /* indexType missing, error out */
- LDAPDebug(LDAP_DEBUG_ANY, "attr_index_config: Missing index type\n", 0, 0, 0);
- return;
- }
- }
- /* compute a->ai_index_rules: */
- /* for index rules there are two uses:
- * 1) a simple way to define an ordered index to support <= and >= searches
- * for those attributes which do not have an ORDERING matching rule defined
- * for them in their schema definition. The index generated is not a :RULE:
- * index, it is a normal = EQUALITY index, with the keys ordered using the
- * comparison function provided by the syntax plugin for the attribute. For
- * example - the uidNumber attribute has INTEGER syntax, but the standard
- * definition of the attribute does not specify an ORDERING matching rule.
- * By default, this means that you cannot perform searches like
- * (uidNumber>=501) - but many users expect to be able to perform this type of
- * search. By specifying that you want an ordered index, using an integer
- * matching rule, you can support indexed seaches of this type.
- * 2) a RULE index - the index key prefix is :NAMEOROID: - this is used
- * to support extensible match searches like (cn:fr-CA.3:=gilles), which would
- * find the index key :fr-CA.3:gilles in the cn index.
- * We check first to see if this is a simple ordered index - user specified an
- * ordering matching rule compatible with the attribute syntax, and there is
- * a compare function. If not, we assume it is a RULE index definition.
- */
-
- if(0 == slapi_entry_attr_find(e, "nsMatchingRule", &attr)){
- char** official_rules = (char**)slapi_ch_malloc ((j + 1) * sizeof (char*));
- size_t k = 0;
- for (j = slapi_attr_first_value(attr, &sval); j != -1;j = slapi_attr_next_value(attr, j, &sval)) {
- /* Check that index_rules[j] is an official OID */
- char* officialOID = NULL;
- IFP mrINDEX = NULL;
- Slapi_PBlock* pb = NULL;
- int do_continue = 0; /* can we skip the RULE parsing stuff? */
- attrValue = slapi_value_get_berval(sval);
-
- if (strstr(index_rules[j], INDEX_ATTR_SUBSTRBEGIN)) {
- _set_attr_substrlen(INDEX_SUBSTRBEGIN, attrValue->bv_val, &substrlens);
- do_continue = 1; /* done with j - next j */
- } else if (strstr(index_rules[j], INDEX_ATTR_SUBSTRMIDDLE)) {
- _set_attr_substrlen(INDEX_SUBSTRMIDDLE, attrValue->bv_val, &substrlens);
- do_continue = 1; /* done with j - next j */
- } else if (strstr(index_rules[j], INDEX_ATTR_SUBSTREND)) {
- _set_attr_substrlen(INDEX_SUBSTREND, attrValue->bv_val, &substrlens);
- do_continue = 1; /* done with j - next j */
- /* check if this is a simple ordering specification
- for an attribute that has no ordering matching rule */
- } else if (slapi_matchingrule_is_ordering(attrValue->bv_val, attrsyntax_oid) &&
- slapi_matchingrule_can_use_compare_fn(attrValue->bv_val) &&
- !a->ai_sattr.a_mr_ord_plugin) { /* no ordering for this attribute */
- need_compare_fn = 1; /* get compare func for this attr */
- do_continue = 1; /* done with j - next j */
- }
+ /* compute a->ai_index_rules: */
+ /* for index rules there are two uses:
+ * 1) a simple way to define an ordered index to support <= and >= searches
+ * for those attributes which do not have an ORDERING matching rule defined
+ * for them in their schema definition. The index generated is not a :RULE:
+ * index, it is a normal = EQUALITY index, with the keys ordered using the
+ * comparison function provided by the syntax plugin for the attribute. For
+ * example - the uidNumber attribute has INTEGER syntax, but the standard
+ * definition of the attribute does not specify an ORDERING matching rule.
+ * By default, this means that you cannot perform searches like
+ * (uidNumber>=501) - but many users expect to be able to perform this type of
+ * search. By specifying that you want an ordered index, using an integer
+ * matching rule, you can support indexed seaches of this type.
+ * 2) a RULE index - the index key prefix is :NAMEOROID: - this is used
+ * to support extensible match searches like (cn:fr-CA.3:=gilles), which would
+ * find the index key :fr-CA.3:gilles in the cn index.
+ * We check first to see if this is a simple ordered index - user specified an
+ * ordering matching rule compatible with the attribute syntax, and there is
+ * a compare function. If not, we assume it is a RULE index definition.
+ */
+ j = 0;
+ if (index_rules != NULL) for (; index_rules[j] != NULL; ++j);
+ if (j > 0) { /* there are some candidates */
+ char** official_rules =
+ (char**)slapi_ch_malloc ((j + 1) * sizeof (char*));
+ size_t k = 0;
+ for (j = 0; index_rules[j] != NULL; ++j) {
+ /* Check that index_rules[j] is an official OID */
+ char* officialOID = NULL;
+ IFP mrINDEX = NULL;
+ Slapi_PBlock* pb = NULL;
+ int do_continue = 0; /* can we skip the RULE parsing stuff? */
+
+ if (strstr(index_rules[j], INDEX_ATTR_SUBSTRBEGIN)) {
+ _set_attr_substrlen(INDEX_SUBSTRBEGIN, index_rules[j],
+ &substrlens);
+ do_continue = 1; /* done with j - next j */
+ } else if (strstr(index_rules[j], INDEX_ATTR_SUBSTRMIDDLE)) {
+ _set_attr_substrlen(INDEX_SUBSTRMIDDLE, index_rules[j],
+ &substrlens);
+ do_continue = 1; /* done with j - next j */
+ } else if (strstr(index_rules[j], INDEX_ATTR_SUBSTREND)) {
+ _set_attr_substrlen(INDEX_SUBSTREND, index_rules[j],
+ &substrlens);
+ do_continue = 1; /* done with j - next j */
+ /* check if this is a simple ordering specification
+ for an attribute that has no ordering matching rule */
+ } else if (slapi_matchingrule_is_ordering(index_rules[j], attrsyntax_oid) &&
+ slapi_matchingrule_can_use_compare_fn(index_rules[j]) &&
+ !a->ai_sattr.a_mr_ord_plugin) { /* no ordering for this attribute */
+ need_compare_fn = 1; /* get compare func for this attr */
+ do_continue = 1; /* done with j - next j */
+ }
- if (do_continue) {
- continue; /* done with index_rules[j] */
- }
+ if (do_continue) {
+ continue; /* done with index_rules[j] */
+ }
- /* must be a RULE specification */
- pb = slapi_pblock_new();
- /*
- * next check if this is a RULE type index
- * try to actually create an indexer and see if the indexer
- * actually has a regular INDEX_FN or an INDEX_SV_FN
- */
- if (!slapi_pblock_set (pb, SLAPI_PLUGIN_MR_OID, attrValue->bv_val) &&
+ /* must be a RULE specification */
+ pb = slapi_pblock_new();
+ /* next check if this is a RULE type index
+ try to actually create an indexer and see if the indexer
+ actually has a regular INDEX_FN or an INDEX_SV_FN */
+ if (!slapi_pblock_set (pb, SLAPI_PLUGIN_MR_OID, index_rules[j]) &&
!slapi_pblock_set (pb, SLAPI_PLUGIN_MR_TYPE, a->ai_type) &&
!slapi_mr_indexer_create (pb) &&
((!slapi_pblock_get (pb, SLAPI_PLUGIN_MR_INDEX_FN, &mrINDEX) &&
@@ -322,70 +317,76 @@ attr_index_config(
mrINDEX != NULL)) &&
!slapi_pblock_get (pb, SLAPI_PLUGIN_MR_OID, &officialOID) &&
officialOID != NULL) {
- if (!strcasecmp (index_rules[j], officialOID)) {
- official_rules[k++] = slapi_ch_strdup (officialOID);
- } else {
- char* preamble = slapi_ch_smprintf("%s: line %d", fname, lineno);
- LDAPDebug (LDAP_DEBUG_ANY, "%s: use \"%s\" instead of \"%s\" (ignored)\n",
- preamble, officialOID, attrValue->bv_val);
- slapi_ch_free((void**)&preamble);
- }
- } else { /* we don't know what this is */
- LDAPDebug (LDAP_DEBUG_ANY, "%s: line %d: "
+ if (!strcasecmp (index_rules[j], officialOID)) {
+ official_rules[k++] = slapi_ch_strdup (officialOID);
+ } else {
+ char* preamble = slapi_ch_smprintf("%s: line %d", fname, lineno);
+ LDAPDebug (LDAP_DEBUG_ANY, "%s: use \"%s\" instead of \"%s\" (ignored)\n",
+ preamble, officialOID, index_rules[j] );
+ slapi_ch_free((void**)&preamble);
+ }
+ } else { /* we don't know what this is */
+ LDAPDebug (LDAP_DEBUG_ANY, "%s: line %d: "
"unknown or invalid matching rule \"%s\" in index configuration (ignored)\n",
- fname, lineno, attrValue->bv_val);
- }
-
- { /*
- * It would improve speed to save the indexer, for future use.
- * But, for simplicity, we destroy it now:
- */
- IFP mrDESTROY = NULL;
- if (!slapi_pblock_get (pb, SLAPI_PLUGIN_DESTROY_FN, &mrDESTROY) &&
- mrDESTROY != NULL) {
- mrDESTROY (pb);
+ fname, lineno, index_rules[j] );
+ }
+ {/* It would improve speed to save the indexer, for future use.
+ But, for simplicity, we destroy it now: */
+ IFP mrDESTROY = NULL;
+ if (!slapi_pblock_get (pb, SLAPI_PLUGIN_DESTROY_FN, &mrDESTROY) &&
+ mrDESTROY != NULL) {
+ mrDESTROY (pb);
+ }
}
+ slapi_pblock_destroy (pb);
+ }
+ official_rules[k] = NULL;
+ a->ai_substr_lens = substrlens;
+ if (k > 0) {
+ a->ai_index_rules = official_rules;
+ a->ai_indexmask |= INDEX_RULES;
+ } else {
+ slapi_ch_free((void**)&official_rules);
}
- slapi_pblock_destroy (pb);
- }
- official_rules[k] = NULL;
- a->ai_substr_lens = substrlens;
- if (k > 0) {
- a->ai_index_rules = official_rules;
- a->ai_indexmask |= INDEX_RULES;
- } else {
- slapi_ch_free((void**)&official_rules);
}
- }
- /* initialize the IDL code's private data */
- return_value = idl_init_private(be, a);
- if (0 != return_value) {
- /* fatal error, exit */
- LDAPDebug(LDAP_DEBUG_ANY,"%s: line %d:Fatal Error: Failed to initialize attribute structure\n",
+ /* initialize the IDL code's private data */
+ return_value = idl_init_private(be, a);
+ if (0 != return_value) {
+ /* fatal error, exit */
+ LDAPDebug(LDAP_DEBUG_ANY,"%s: line %d:Fatal Error: Failed to initialize attribute structure\n",
fname, lineno, 0);
- exit( 1 );
- }
+ exit( 1 );
+ }
- /* if user didn't specify an ordering rule in the index config,
- see if the schema def for the attr defines one */
- if (!need_compare_fn && a->ai_sattr.a_mr_ord_plugin) {
- need_compare_fn = 1;
- }
+ /* if user didn't specify an ordering rule in the index config,
+ see if the schema def for the attr defines one */
+ if (!need_compare_fn && a->ai_sattr.a_mr_ord_plugin) {
+ need_compare_fn = 1;
+ }
- if (need_compare_fn) {
- int rc = attr_get_value_cmp_fn( &a->ai_sattr, &a->ai_key_cmp_fn );
- if (rc != LDAP_SUCCESS) {
- LDAPDebug(LDAP_DEBUG_ANY,
+ if (need_compare_fn) {
+ int rc = attr_get_value_cmp_fn( &a->ai_sattr, &a->ai_key_cmp_fn );
+ if (rc != LDAP_SUCCESS) {
+ LDAPDebug(LDAP_DEBUG_ANY,
"The attribute [%s] does not have a valid ORDERING matching rule - error %d:s\n",
a->ai_type, rc, ldap_err2string(rc));
- a->ai_key_cmp_fn = NULL;
+ a->ai_key_cmp_fn = NULL;
+ }
}
- }
- if ( avl_insert( &inst->inst_attrs, a, ainfo_cmp, ainfo_dup ) != 0 ) {
- /* duplicate - existing version updated */
- attrinfo_delete(&a);
+ if ( avl_insert( &inst->inst_attrs, a, ainfo_cmp, ainfo_dup ) != 0 ) {
+ /* duplicate - existing version updated */
+ attrinfo_delete(&a);
+ }
+ }
+done:
+ charray_free( attrs );
+ if ( indexes != NULL ) {
+ charray_free( indexes );
+ }
+ if ( index_rules != NULL ) {
+ charray_free( index_rules );
}
}
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_config.h b/ldap/servers/slapd/back-ldbm/ldbm_config.h
index 36b8f60..e41b623 100644
--- a/ldap/servers/slapd/back-ldbm/ldbm_config.h
+++ b/ldap/servers/slapd/back-ldbm/ldbm_config.h
@@ -170,7 +170,8 @@ int ldbm_config_ignored_attr(char *attr_name);
/* Functions in ldbm_instance_config.c used in ldbm_config.c */
int ldbm_instance_config_load_dse_info(ldbm_instance *inst);
-int ldbm_instance_config_add_index_entry(ldbm_instance *inst, Slapi_Entry *e, int flags);
+int ldbm_instance_config_add_index_entry(ldbm_instance *inst, int argc,
+ char **argv, int flags);
int
ldbm_instance_index_config_enable_index(ldbm_instance *inst, Slapi_Entry* e);
int ldbm_instance_create_default_user_indexes(ldbm_instance *inst);
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_index_config.c b/ldap/servers/slapd/back-ldbm/ldbm_index_config.c
index 3786a44..aa47584 100644
--- a/ldap/servers/slapd/back-ldbm/ldbm_index_config.c
+++ b/ldap/servers/slapd/back-ldbm/ldbm_index_config.c
@@ -51,7 +51,7 @@
int ldbm_instance_index_config_add_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* e, int *returncode, char *returntext, void *arg);
int ldbm_instance_index_config_delete_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* e, int *returncode, char *returntext, void *arg);
-#define INDEXTYPE_NONE 1
+
@@ -104,28 +104,50 @@ static char *attrinfo2ConfIndexes (struct attrinfo *pai)
}
-/*
- * attrinfo2ConfMatchingRules: returns an array of matching rules
+/* attrinfo2ConfMatchingRules: converts attrinfo into matching rule oids, as
+ * seen in index entries within dse.ldif
*/
-static char **attrinfo2ConfMatchingRules (struct attrinfo *pai)
+static char *attrinfo2ConfMatchingRules (struct attrinfo *pai)
{
int i;
- char **value = NULL;
+ char buffer[1024];
+
+ buffer[0] = '\0';
if (pai->ai_index_rules) {
- for (i = 0; pai->ai_index_rules[i]; i++) {
- charray_add(&value,slapi_ch_strdup(pai->ai_index_rules[i]));
- }
+ strcat (buffer, "\t");
+ for (i = 0; pai->ai_index_rules[i]; i++) {
+ PL_strcatn (buffer, sizeof(buffer), pai->ai_index_rules[i]);
+ if (pai->ai_index_rules[i+1]) {
+ PL_strcatn (buffer, sizeof(buffer), ",");
+ }
+ }
}
- return (value);
+ return (slapi_ch_strdup (buffer) );
}
+
+/* used by the two callbacks below, to parse an index entry into something
+ * awkward that we can pass to attr_index_config().
+ */
+#define MAX_TMPBUF 1024
+#define ZCAT_SAFE(_buf, _x1, _x2) do { \
+ if (strlen(_buf) + strlen(_x1) + strlen(_x2) + 2 < MAX_TMPBUF) { \
+ strcat(_buf, _x1); \
+ strcat(_buf, _x2); \
+ } \
+} while (0)
static int ldbm_index_parse_entry(ldbm_instance *inst, Slapi_Entry *e,
- const char *trace_string, char **index_name)
+ const char *trace_string,
+ char **index_name)
{
+ char *arglist[] = { NULL, NULL, NULL, NULL };
+ int argc = 0, i;
+ int isFirst;
Slapi_Attr *attr;
const struct berval *attrValue;
Slapi_Value *sval;
+ char tmpBuf[MAX_TMPBUF];
/* Get the name of the attribute to index which will be the value
* of the cn attribute. */
@@ -143,28 +165,121 @@ static int ldbm_index_parse_entry(ldbm_instance *inst, Slapi_Entry *e,
slapi_entry_get_dn(e), 0, 0);
return LDAP_OPERATIONS_ERROR;
}
-
- if(index_name != NULL){
- *index_name = slapi_ch_strdup(attrValue->bv_val);
+ arglist[argc++] = slapi_ch_strdup(attrValue->bv_val);
+ if (index_name != NULL) {
+ *index_name = slapi_ch_strdup(attrValue->bv_val);
}
- /* check and see if we have the required indexType */
+ /* Get the list of index types from the entry. */
if (0 == slapi_entry_attr_find(e, "nsIndexType", &attr)) {
- slapi_attr_first_value(attr, &sval);
- attrValue = slapi_value_get_berval(sval);
- if (NULL == attrValue->bv_val || strlen(attrValue->bv_val) == 0) {
- /* missing the index type, error out */
+ tmpBuf[0] = 0;
+ isFirst = 1;
+ for (i = slapi_attr_first_value(attr, &sval); i != -1;
+ i = slapi_attr_next_value(attr, i, &sval)) {
+ attrValue = slapi_value_get_berval(sval);
+ if (NULL != attrValue->bv_val && strlen(attrValue->bv_val) > 0) {
+ if (isFirst) {
+ ZCAT_SAFE(tmpBuf, "", attrValue->bv_val);
+ isFirst = 0;
+ } else {
+ ZCAT_SAFE(tmpBuf, ",", attrValue->bv_val);
+ }
+ }
+ }
+ if (0 == tmpBuf[0]) {
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: malformed index entry %s -- empty nsIndexType\n",
slapi_entry_get_dn(e), 0, 0);
slapi_ch_free_string(index_name);
+ for (i = 0; i < argc; i++) {
+ slapi_ch_free((void **)&arglist[i]);
+ }
return LDAP_OPERATIONS_ERROR;
}
+ arglist[argc++] = slapi_ch_strdup(tmpBuf);
+ }
+
+ tmpBuf[0] = 0;
+ /* Get the list of matching rules from the entry. */
+ if (0 == slapi_entry_attr_find(e, "nsMatchingRule", &attr)) {
+ for (i = slapi_attr_first_value(attr, &sval); i != -1;
+ i = slapi_attr_next_value(attr, i, &sval)) {
+ attrValue = slapi_value_get_berval(sval);
+ if (NULL != attrValue->bv_val && strlen(attrValue->bv_val) > 0) {
+ if (0 == tmpBuf[0]) {
+ ZCAT_SAFE(tmpBuf, "", attrValue->bv_val);
+ } else {
+ ZCAT_SAFE(tmpBuf, ",", attrValue->bv_val);
+ }
+ }
+ }
}
- /* ok the entry is good to process, pass it to attr_index_config */
- attr_index_config(inst->inst_be, (char *)trace_string, 0, e, 0, 0);
+ /* Get the substr begin length. note: pick the first value. */
+ if (0 == slapi_entry_attr_find(e, INDEX_ATTR_SUBSTRBEGIN, &attr)) {
+ i = slapi_attr_first_value(attr, &sval);
+ if (-1 != i) {
+ attrValue = slapi_value_get_berval(sval);
+ if (NULL != attrValue->bv_val && strlen(attrValue->bv_val) > 0) {
+ if (0 == tmpBuf[0]) {
+ PR_snprintf(tmpBuf, MAX_TMPBUF, "%s=%s",
+ INDEX_ATTR_SUBSTRBEGIN, attrValue->bv_val);
+ } else {
+ int tmpbuflen = strlen(tmpBuf);
+ char *p = tmpBuf + tmpbuflen;
+ PR_snprintf(p, MAX_TMPBUF - tmpbuflen, ",%s=%s",
+ INDEX_ATTR_SUBSTRBEGIN, attrValue->bv_val);
+ }
+ }
+ }
+ }
+ /* Get the substr middle length. note: pick the first value. */
+ if (0 == slapi_entry_attr_find(e, INDEX_ATTR_SUBSTRMIDDLE, &attr)) {
+ i = slapi_attr_first_value(attr, &sval);
+ if (-1 != i) {
+ attrValue = slapi_value_get_berval(sval);
+ if (NULL != attrValue->bv_val && strlen(attrValue->bv_val) > 0) {
+ if (0 == tmpBuf[0]) {
+ PR_snprintf(tmpBuf, MAX_TMPBUF, "%s=%s",
+ INDEX_ATTR_SUBSTRMIDDLE, attrValue->bv_val);
+ } else {
+ int tmpbuflen = strlen(tmpBuf);
+ char *p = tmpBuf + tmpbuflen;
+ PR_snprintf(p, MAX_TMPBUF - tmpbuflen, ",%s=%s",
+ INDEX_ATTR_SUBSTRMIDDLE, attrValue->bv_val);
+ }
+ }
+ }
+ }
+
+ /* Get the substr end length. note: pick the first value. */
+ if (0 == slapi_entry_attr_find(e, INDEX_ATTR_SUBSTREND, &attr)) {
+ i = slapi_attr_first_value(attr, &sval);
+ if (-1 != i) {
+ attrValue = slapi_value_get_berval(sval);
+ if (NULL != attrValue->bv_val && strlen(attrValue->bv_val) > 0) {
+ if (0 == tmpBuf[0]) {
+ PR_snprintf(tmpBuf, MAX_TMPBUF, "%s=%s",
+ INDEX_ATTR_SUBSTREND, attrValue->bv_val);
+ } else {
+ int tmpbuflen = strlen(tmpBuf);
+ char *p = tmpBuf + tmpbuflen;
+ PR_snprintf(p, MAX_TMPBUF - tmpbuflen, ",%s=%s",
+ INDEX_ATTR_SUBSTREND, attrValue->bv_val);
+ }
+ }
+ }
+ }
+ if (0 != tmpBuf[0]) {
+ arglist[argc++] = slapi_ch_strdup(tmpBuf);
+ }
+
+ arglist[argc] = NULL;
+ attr_index_config(inst->inst_be, (char *)trace_string, 0, argc, arglist, 0);
+ for (i = 0; i < argc; i++) {
+ slapi_ch_free((void **)&arglist[i]);
+ }
return LDAP_SUCCESS;
}
@@ -179,7 +294,8 @@ ldbm_index_init_entry_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* en
ldbm_instance *inst = (ldbm_instance *) arg;
returntext[0] = '\0';
- *returncode = ldbm_index_parse_entry(inst, e, "from ldbm instance init", NULL);
+ *returncode = ldbm_index_parse_entry(inst, e, "from ldbm instance init",
+ NULL);
if (*returncode == LDAP_SUCCESS) {
return SLAPI_DSE_CALLBACK_OK;
} else {
@@ -202,15 +318,16 @@ ldbm_instance_index_config_add_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_
*returncode = ldbm_index_parse_entry(inst, e, "from DSE add", &index_name);
if (*returncode == LDAP_SUCCESS) {
struct attrinfo *ai = NULL;
+
/* if the index is a "system" index, we assume it's being added by
* by the server, and it's okay for the index to go online immediately.
* if not, we set the index "offline" so it won't actually be used
* until someone runs db2index on it.
*/
if (! ldbm_attribute_always_indexed(index_name)) {
- ainfo_get(inst->inst_be, index_name, &ai);
- PR_ASSERT(ai != NULL);
- ai->ai_indexmask |= INDEX_OFFLINE;
+ ainfo_get(inst->inst_be, index_name, &ai);
+ PR_ASSERT(ai != NULL);
+ ai->ai_indexmask |= INDEX_OFFLINE;
}
slapi_ch_free((void **)&index_name);
return SLAPI_DSE_CALLBACK_OK;
@@ -226,9 +343,11 @@ int
ldbm_instance_index_config_delete_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg)
{
ldbm_instance *inst = (ldbm_instance *) arg;
+ char *arglist[4];
Slapi_Attr *attr;
Slapi_Value *sval;
const struct berval *attrValue;
+ int argc = 0;
int rc = SLAPI_DSE_CALLBACK_OK;
struct attrinfo *ainfo = NULL;
@@ -239,7 +358,12 @@ ldbm_instance_index_config_delete_callback(Slapi_PBlock *pb, Slapi_Entry* e, Sla
slapi_attr_first_value(attr, &sval);
attrValue = slapi_value_get_berval(sval);
- attr_index_config(inst->inst_be, "From DSE delete", 0, e, 0, INDEXTYPE_NONE);
+ arglist[argc++] = slapi_ch_strdup(attrValue->bv_val);
+ arglist[argc++] = slapi_ch_strdup("none");
+ arglist[argc] = NULL;
+ attr_index_config(inst->inst_be, "From DSE delete", 0, argc, arglist, 0);
+ slapi_ch_free((void **)&arglist[0]);
+ slapi_ch_free((void **)&arglist[1]);
ainfo_get(inst->inst_be, attrValue->bv_val, &ainfo);
@@ -266,18 +390,15 @@ ldbm_instance_index_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry *e,
Slapi_Entry *entryAfter, int *returncode, char *returntext, void *arg)
{
ldbm_instance *inst = (ldbm_instance *)arg;
- Slapi_Entry *modEntry;
- Slapi_Attr *modAttr = NULL;
- Slapi_Attr *indexTypeAttr;
- Slapi_Attr *matchingRuleAttr;
Slapi_Attr *attr;
- Slapi_Value *modValue;
Slapi_Value *sval;
const struct berval *attrValue;
struct attrinfo *ainfo = NULL;
LDAPMod **mods;
+ char *arglist[4] = {0};
char *config_attr;
char *origIndexTypes = NULL;
+ char *origMatchingRules = NULL;
char **origIndexTypesArray = NULL;
char **origMatchingRulesArray = NULL;
char **addIndexTypesArray = NULL;
@@ -286,6 +407,7 @@ ldbm_instance_index_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry *e,
char **deleteMatchingRulesArray = NULL;
int i, j;
int dodeletes = 0;
+ char tmpBuf[MAX_TMPBUF];
int rc = SLAPI_DSE_CALLBACK_OK;
returntext[0] = '\0';
@@ -308,13 +430,23 @@ ldbm_instance_index_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry *e,
goto out;
}
+ origMatchingRules = attrinfo2ConfMatchingRules(ainfo);
+ if (NULL == origMatchingRules) {
+ rc = SLAPI_DSE_CALLBACK_ERROR;
+ goto out;
+ }
+
origIndexTypesArray = slapi_str2charray(origIndexTypes, ",");
if (NULL == origIndexTypesArray) {
rc = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- origMatchingRulesArray = attrinfo2ConfMatchingRules(ainfo);
+ origMatchingRulesArray = slapi_str2charray(origMatchingRules, ",");
+ if (NULL == origMatchingRulesArray) {
+ rc = SLAPI_DSE_CALLBACK_ERROR;
+ goto out;
+ }
for (i = 0; mods[i] != NULL; i++) {
config_attr = (char *)mods[i]->mod_type;
@@ -424,53 +556,48 @@ ldbm_instance_index_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry *e,
}
if (dodeletes) {
- attr_index_config(inst->inst_be, "from DSE modify", 0, e, 0, INDEXTYPE_NONE);
- }
+ i = 0;
+ arglist[i++] = slapi_ch_strdup(attrValue->bv_val);
+ arglist[i++] = slapi_ch_strdup("none");
+ arglist[i] = NULL;
+ attr_index_config(inst->inst_be, "from DSE modify", 0, i, arglist, 0);
- /* create a new entry with the correct attr values */
- modEntry = slapi_entry_alloc();
+ /* Free args */
+ slapi_ch_free((void **)&arglist[0]);
+ slapi_ch_free((void **)&arglist[1]);
+ }
- /* index types */
+ i = 0;
+ arglist[i++] = slapi_ch_strdup(attrValue->bv_val);
if (origIndexTypesArray && origIndexTypesArray[0]) {
- indexTypeAttr = slapi_attr_new();
- slapi_attr_init(indexTypeAttr, "nsIndexType");
- for (j = 0; origIndexTypesArray[j] != NULL; j++) {
- /* add attr value */
- modValue = slapi_value_new_string(origIndexTypesArray[j]);
- slapi_attr_add_value(indexTypeAttr,modValue);
- slapi_value_free(&modValue);
- }
+ tmpBuf[0] = 0;
+ ZCAT_SAFE(tmpBuf, "", origIndexTypesArray[0]);
+ for (j = 1; origIndexTypesArray[j] != NULL; j++) {
+ ZCAT_SAFE(tmpBuf, ",", origIndexTypesArray[j]);
+ }
+ arglist[i++] = slapi_ch_strdup(tmpBuf);
} else {
- indexTypeAttr = slapi_attr_new();
- slapi_attr_init(indexTypeAttr, "nsIndexType");
- modValue = slapi_value_new_string("none");
- slapi_attr_add_value(indexTypeAttr,modValue);
- slapi_value_free(&modValue);
+ arglist[i++] = slapi_ch_strdup("none");
}
- /* add indexType attribute values */
- attrlist_add(&modAttr,indexTypeAttr);
-
- /* matching rules */
if (origMatchingRulesArray && origMatchingRulesArray[0]) {
- matchingRuleAttr = slapi_attr_new();
- slapi_attr_init(matchingRuleAttr, "nsMatchingRule");
- for (j = 0; origMatchingRulesArray[j] != NULL; j++) {
- /* add attr value */
- modValue = slapi_value_new_string(origMatchingRulesArray[j]);
- slapi_attr_add_value(matchingRuleAttr,modValue);
- slapi_value_free(&modValue);
+ tmpBuf[0] = 0;
+ ZCAT_SAFE(tmpBuf, "", origMatchingRulesArray[0]);
+ for (j = 1; origMatchingRulesArray[j] != NULL; j++) {
+ ZCAT_SAFE(tmpBuf, ",", origMatchingRulesArray[j]);
}
-
- /* add the matchingRule attribute values */
- attrlist_add(&modAttr,matchingRuleAttr);
+ arglist[i++] = slapi_ch_strdup(tmpBuf);
}
- slapi_entry_init_ext(modEntry, NULL, modAttr);
- attr_index_config(inst->inst_be, "from DSE modify", 0, modEntry, 0, 0);
- slapi_entry_free(modEntry);
+ arglist[i] = NULL;
+ attr_index_config(inst->inst_be, "from DSE modify", 0, i, arglist, 0);
out:
+ /* Free args */
+ for (i=0; arglist[i]; i++) {
+ slapi_ch_free((void **)&arglist[i]);
+ }
+
if(origIndexTypesArray) {
charray_free(origIndexTypesArray);
}
@@ -492,6 +619,9 @@ out:
if (origIndexTypes) {
slapi_ch_free ((void **)&origIndexTypes);
}
+ if (origMatchingRules) {
+ slapi_ch_free ((void **)&origMatchingRules);
+ }
return rc;
}
@@ -499,92 +629,90 @@ out:
/* add index entries to the per-instance DSE (used only from instance.c) */
int ldbm_instance_config_add_index_entry(
ldbm_instance *inst,
- Slapi_Entry *e,
+ int argc,
+ char **argv,
int flags
)
{
+ char **attrs = NULL;
+ char **indexes = NULL;
+ char **matchingRules = NULL;
char *eBuf;
+ int i = 0;
int j = 0;
char *basetype = NULL;
+ char tmpAttrsStr[256];
+ char tmpIndexesStr[256];
+ char tmpMatchingRulesStr[1024];
struct ldbminfo *li = inst->inst_li;
char *dn = NULL;
- Slapi_Attr *attr;
- const struct berval *attrValue;
- Slapi_Value *sval;
int rc = 0;
- /* get the cn value */
- if (slapi_entry_attr_find(e, "cn", &attr) != 0) {
- LDAPDebug(LDAP_DEBUG_ANY, "Warning: malformed index entry %s\n",
- slapi_entry_get_dn(e), 0, 0);
- return -1;
+ if ((argc < 2) || (NULL == argv) || (NULL == argv[0]) ||
+ (NULL == argv[1])) {
+ return(-1);
}
- slapi_attr_first_value(attr, &sval);
- attrValue = slapi_value_get_berval(sval);
- if (NULL == attrValue->bv_val || 0 == strlen(attrValue->bv_val)) {
- LDAPDebug(LDAP_DEBUG_ANY,
- "Warning: malformed index entry %s -- empty index name\n",
- slapi_entry_get_dn(e), 0, 0);
- return -1;
+ PL_strncpyz(tmpAttrsStr,argv[0], sizeof(tmpAttrsStr));
+ attrs = slapi_str2charray( tmpAttrsStr, "," );
+ PL_strncpyz(tmpIndexesStr,argv[1], sizeof(tmpIndexesStr));
+ indexes = slapi_str2charray( tmpIndexesStr, ",");
+
+ if(argc > 2) {
+ PL_strncpyz(tmpMatchingRulesStr,argv[2], sizeof(tmpMatchingRulesStr));
+ matchingRules = slapi_str2charray( tmpMatchingRulesStr, ",");
}
- basetype = slapi_attr_basetype(attrValue->bv_val, NULL, 0);
- dn = slapi_create_dn_string("cn=%s,cn=index,cn=%s,cn=%s,cn=plugins,cn=config",
+ for(i=0; attrs && attrs[i] !=NULL; i++)
+ {
+ if('\0' == attrs[i][0]) continue;
+ basetype = slapi_attr_basetype(attrs[i], NULL, 0);
+ dn = slapi_create_dn_string("cn=%s,cn=index,cn=%s,cn=%s,cn=plugins,cn=config",
basetype, inst->inst_name, li->li_plugin->plg_name);
- if (NULL == dn) {
- LDAPDebug(LDAP_DEBUG_ANY,
- "ldbm_instance_config_add_index_entry: "
- "failed create index dn with type %s for plugin %s, "
- "instance %s\n",
- basetype, inst->inst_li->li_plugin->plg_name,
- inst->inst_name);
- slapi_ch_free((void**)&basetype);
- return -1;
- }
-
- eBuf = PR_smprintf(
- "dn: %s\n"
- "objectclass: top\n"
- "objectclass: nsIndex\n"
- "cn: %s\n"
- "nsSystemIndex: %s\n",
+ if (NULL == dn) {
+ LDAPDebug(LDAP_DEBUG_ANY,
+ "ldbm_instance_config_add_index_entry: "
+ "failed create index dn with type %s for plugin %s, "
+ "instance %s\n",
+ basetype, inst->inst_li->li_plugin->plg_name,
+ inst->inst_name);
+ slapi_ch_free((void**)&basetype);
+ rc = -1;
+ goto done;
+ }
+ eBuf = PR_smprintf(
+ "dn: %s\n"
+ "objectclass: top\n"
+ "objectclass: nsIndex\n"
+ "cn: %s\n"
+ "nsSystemIndex: %s\n",
dn, basetype,
(ldbm_attribute_always_indexed(basetype)?"true":"false"));
- slapi_ch_free_string(&dn);
-
- /* get nsIndexType and its values, and add them */
- if( 0 == slapi_entry_attr_find(e, "nsIndexType", &attr)){
- for (j = slapi_attr_first_value(attr, &sval); j != -1;j = slapi_attr_next_value(attr, j, &sval)) {
- attrValue = slapi_value_get_berval(sval);
- eBuf = PR_sprintf_append(eBuf, "nsIndexType: %s\n", attrValue->bv_val);
- }
- } else {
- LDAPDebug(LDAP_DEBUG_ANY,
- "ldbm_instance_config_add_index_entry: "
- "failed create index dn with type %s for plugin %s, "
- "instance %s. Missing nsIndexType\n",
- basetype, inst->inst_li->li_plugin->plg_name,
- inst->inst_name);
- slapi_ch_free((void**)&basetype);
- return -1;
- }
+ slapi_ch_free_string(&dn);
+ for(j=0; indexes && indexes[j] != NULL; j++)
+ {
+ eBuf = PR_sprintf_append(eBuf, "nsIndexType:%s\n", indexes[j]);
+ }
+ if((argc>2)&&(argv[2]))
+ {
+ for(j=0; matchingRules && matchingRules[j] != NULL; j++)
+ {
+ eBuf = PR_sprintf_append(eBuf, "nsMatchingRule:%s\n", matchingRules[j]);
+ }
+ }
- /* get nsMatchingRule and its values, and add them */
- if(0 == slapi_entry_attr_find(e, "nsMatchingRule", &attr)) {
- for (j = slapi_attr_first_value(attr, &sval); j != -1;j = slapi_attr_next_value(attr, j, &sval)) {
- attrValue = slapi_value_get_berval(sval);
- eBuf = PR_sprintf_append(eBuf, "nsMatchingRule: %s\n", attrValue->bv_val);
- }
- }
-
- ldbm_config_add_dse_entry(li, eBuf, flags);
- if (eBuf) {
- PR_smprintf_free(eBuf);
- }
+ ldbm_config_add_dse_entry(li, eBuf, flags);
+ if (eBuf) {
+ PR_smprintf_free(eBuf);
+ }
- slapi_ch_free((void**)&basetype);
+ slapi_ch_free((void**)&basetype);
+ }
+done:
+ charray_free(attrs);
+ charray_free(indexes);
+ charray_free(matchingRules);
return rc;
}
@@ -596,9 +724,10 @@ ldbm_instance_index_config_enable_index(ldbm_instance *inst, Slapi_Entry* e)
rc=ldbm_index_parse_entry(inst, e, "from DSE add", &index_name);
if (rc == LDAP_SUCCESS) {
- /* Assume the caller knows if it is OK to go online immediately */
struct attrinfo *ai = NULL;
+ /* Assume the caller knows if it is OK to go online immediatly */
+
ainfo_get(inst->inst_be, index_name, &ai);
PR_ASSERT(ai != NULL);
ai->ai_indexmask &= ~INDEX_OFFLINE;
@@ -607,19 +736,30 @@ ldbm_instance_index_config_enable_index(ldbm_instance *inst, Slapi_Entry* e)
return rc;
}
+
/*
-** Create the default user-defined indexes
-**
-** Search for user-defined default indexes and add them
-** to the backend instance being created.
+** create the default user-defined indexes
*/
int ldbm_instance_create_default_user_indexes(ldbm_instance *inst)
{
+
+ /*
+ ** Search for user-defined default indexes and add them
+ ** to the backend instance beeing created.
+ */
+
Slapi_PBlock *aPb;
Slapi_Entry **entries = NULL;
Slapi_Attr *attr;
+ Slapi_Value *sval = NULL;
+ const struct berval *attrValue;
+ char *argv[ 8 ];
+ char tmpBuf[MAX_TMPBUF];
+ char tmpBuf2[MAX_TMPBUF];
+ int argc;
char *basedn = NULL;
+
struct ldbminfo *li;
/* write the dse file only on the final index */
@@ -632,6 +772,7 @@ int ldbm_instance_create_default_user_indexes(ldbm_instance *inst)
}
li = inst->inst_li;
+ strcpy(tmpBuf,"");
/* Construct the base dn of the subtree that holds the default user indexes. */
basedn = slapi_create_dn_string("cn=default indexes,cn=config,cn=%s,cn=plugins,cn=config",
@@ -651,27 +792,69 @@ int ldbm_instance_create_default_user_indexes(ldbm_instance *inst)
slapi_search_internal_pb (aPb);
slapi_pblock_get(aPb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
if (entries!=NULL) {
- int i;
+ int i,j;
for (i=0; entries[i]!=NULL; i++) {
- /*
- * Get the name of the attribute to index which will be the value
- * of the cn attribute.
- */
+
+ /* Get the name of the attribute to index which will be the value
+ * of the cn attribute. */
+
if (slapi_entry_attr_find(entries[i], "cn", &attr) != 0) {
LDAPDebug(LDAP_DEBUG_ANY,"Warning: malformed index entry %s. Index ignored.\n",
slapi_entry_get_dn(entries[i]), 0, 0);
continue;
}
+ slapi_attr_first_value(attr, &sval);
+ attrValue = slapi_value_get_berval(sval);
+ argv[0] = attrValue->bv_val;
+ argc=1;
+
+ /* Get the list of index types from the entry. */
+
+ if (0 == slapi_entry_attr_find(entries[i], "nsIndexType", &attr)) {
+ for (j = slapi_attr_first_value(attr, &sval); j != -1;
+ j = slapi_attr_next_value(attr, j, &sval)) {
+ attrValue = slapi_value_get_berval(sval);
+ if (0 == j) {
+ tmpBuf[0] = 0;
+ ZCAT_SAFE(tmpBuf, "", attrValue->bv_val);
+ } else {
+ ZCAT_SAFE(tmpBuf, ",", attrValue->bv_val);
+ }
+ }
+ argv[argc]=tmpBuf;
+ argc++;
+ }
+
+ /* Get the list of matching rules from the entry. */
+
+ if (0 == slapi_entry_attr_find(entries[i], "nsMatchingRule", &attr)) {
+ for (j = slapi_attr_first_value(attr, &sval); j != -1;
+ j = slapi_attr_next_value(attr, j, &sval)) {
+ attrValue = slapi_value_get_berval(sval);
+ if (0 == j) {
+ tmpBuf2[0] = 0;
+ ZCAT_SAFE(tmpBuf2, "", attrValue->bv_val);
+ } else {
+ ZCAT_SAFE(tmpBuf2, ",", attrValue->bv_val);
+ }
+ }
+ argv[argc]=tmpBuf2;
+ argc++;
+ }
+
+ argv[argc]=NULL;
/* Create the index entry in the backend */
+
if (entries[i+1] == NULL) {
/* write the dse file only on the final index */
flags = 0;
}
- ldbm_instance_config_add_index_entry(inst, entries[i], flags);
+ ldbm_instance_config_add_index_entry(inst, argc, argv, flags);
/* put the index online */
+
ldbm_instance_index_config_enable_index(inst, entries[i]);
}
}
diff --git a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
index 2e18c53..b430f9a 100644
--- a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
+++ b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
@@ -2474,56 +2474,32 @@ db2index_add_indexed_attr(backend *be, char *attrString)
{
char *iptr = NULL;
char *mptr = NULL;
- Slapi_Entry *e;
- Slapi_Value *sval;
- Slapi_Attr *indextype_attr;
- Slapi_Attr *cn_attr;
- Slapi_Attr *mr_attr;
- Slapi_Attr *attrs;
+ char *nsslapd_index_value[4];
+ int argc = 0;
+ int i;
if (NULL == (iptr = strchr(attrString, ':'))) {
return(0);
}
- e = slapi_entry_alloc();
- attrs = slapi_attr_new();
iptr[0] = '\0';
iptr++;
-
- /* set the index name */
- cn_attr = slapi_attr_new();
- slapi_attr_init(cn_attr, "cn");
- sval = slapi_value_new_string(slapi_ch_strdup(attrString+1));
- slapi_attr_add_value(cn_attr,sval);
- attrlist_add(&attrs,cn_attr);
- slapi_value_free(&sval);
-
+
+ nsslapd_index_value[argc++] = slapi_ch_strdup(attrString+1);
+
if (NULL != (mptr = strchr(iptr, ':'))) {
mptr[0] = '\0';
mptr++;
}
-
- /* set the index type */
- indextype_attr = slapi_attr_new();
- slapi_attr_init(indextype_attr, "nsIndexType");
- sval = slapi_value_new_string(slapi_ch_strdup(iptr));
- slapi_attr_add_value(indextype_attr,sval);
- attrlist_add(&attrs,indextype_attr);
- slapi_value_free(&sval);
-
+ nsslapd_index_value[argc++] = slapi_ch_strdup(iptr);
if (NULL != mptr) {
- /* set the matching rule */
- mr_attr = slapi_attr_new();
- slapi_attr_init(mr_attr, "nsMatchingRule");
- sval = slapi_value_new_string(slapi_ch_strdup(mptr));
- slapi_attr_add_value(mr_attr,sval);
- attrlist_add(&attrs,mr_attr);
- slapi_value_free(&sval);
+ nsslapd_index_value[argc++] = slapi_ch_strdup(mptr);
}
+ nsslapd_index_value[argc] = NULL;
+ attr_index_config(be, "from db2index()", 0, argc, nsslapd_index_value, 0);
- slapi_entry_init_ext(e, NULL, attrs);
- attr_index_config(be, "from db2index()", 0, e, 0, 0);
- slapi_entry_free(e);
-
+ for ( i=0; i<argc; i++ ) {
+ slapi_ch_free_string(&nsslapd_index_value[i]);
+ }
return(0);
}
diff --git a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h
index 0734162..f286377 100644
--- a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h
+++ b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h
@@ -55,7 +55,7 @@ void attr_masks( backend *be, char *type, int *indexmask,
void attr_masks_ex( backend *be, char *type, int *indexmask,
int *syntaxmask, struct attrinfo **at );
void attr_index_config( backend *be, char *fname, int lineno,
- Slapi_Entry *e, int init, int none );
+ int argc, char **argv, int init );
int ldbm_compute_init();
void attrinfo_deletetree(ldbm_instance *inst);
void attr_create_empty(backend *be,char *type,struct attrinfo **ai);
commit dbde3135242ff72759d1633d72c3180c3859e30b
Author: Mark Reynolds <mareynol(a)redhat.com>
Date: Fri Jan 27 17:35:56 2012 -0500
Revert "Ticket #140 - incorrect memset parameters"
This reverts commit 2f86ad935e00209a3ea06b9a1463fab575ee89b7.
diff --git a/ldap/servers/slapd/back-ldbm/perfctrs.c b/ldap/servers/slapd/back-ldbm/perfctrs.c
index 86b3bb1..27efb7d 100644
--- a/ldap/servers/slapd/back-ldbm/perfctrs.c
+++ b/ldap/servers/slapd/back-ldbm/perfctrs.c
@@ -101,7 +101,7 @@ static void init_shared_memory(perfctrs_private *priv)
{
performance_counters *perf = (performance_counters*)priv->memory;
if (NULL != perf) {
- memset(perf,sizeof(performance_counters),0);
+ memset(perf,0,sizeof(performance_counters));
}
}
