int
syntax_matching_rule_plugin_init(
Slapi_PBlock *pb,
struct mr_plugin_def mr_plugin_table[],
size_t mr_plugin_table_size
)
{
int ii;
char **argv = NULL;
int rc = -1;
struct mr_plugin_def *mrpd = NULL;
slapi_pblock_get(pb, SLAPI_PLUGIN_ARGV, &argv);
if (!argv || !argv[0]) {
slapi_log_error(SLAPI_LOG_FATAL, "syntax_matching_rule_plugin_init",
"Error: matching rule plugin name not specified\n");
return rc;
}
for (ii = 0; ii < mr_plugin_table_size; ++ii) {
/* get the arguments - argv[0] is our plugin name */
/* find the plugin name in the table */
if (!strcmp(mr_plugin_table[ii].mr_def_entry.mr_name, argv[0])) {
mrpd = &mr_plugin_table[ii];
rc = slapi_pblock_set(pb, SLAPI_PLUGIN_VERSION, SLAPI_PLUGIN_VERSION_01);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_DESCRIPTION, &mrpd->mr_plg_desc);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_FILTER_CREATE_FN, mrpd->mr_filter_create);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_INDEXER_CREATE_FN, mrpd->mr_indexer_create);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_FILTER_AVA, mrpd->mr_filter_ava);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_FILTER_SUB, mrpd->mr_filter_sub);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_VALUES2KEYS, mrpd->mr_values2keys);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_ASSERTION2KEYS_AVA, mrpd->mr_assertion2keys_ava);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_ASSERTION2KEYS_SUB, mrpd->mr_assertion2keys_sub);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_NAMES, mrpd->mr_names);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_COMPARE, mrpd->mr_compare);
rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_MR_NORMALIZE, mrpd->mr_normalize);
break;
}
}
if (!mrpd) {
slapi_log_error(SLAPI_LOG_FATAL, "syntax_matching_rule_plugin_init",
"Error: matching rule plugin name [%s] not found\n",
argv[0]);
} else {
rc = slapi_matchingrule_register(&mrpd->mr_def_entry);
}
return rc;
}
int
collation_config (size_t cargc, char** cargv,
const char* fname, size_t lineno)
/* Process one line from a configuration file.
Return 0 if it's OK, -1 if it's not recognized.
Any other return value is a process exit code.
*/
{
if (cargc <= 0) { /* Bizarre. Oh, well... */
} else if (!strcasecmp (cargv[0], "NLS")) {
/* ignore - not needed anymore with ICU - was used to get path for NLS_Initialize */
} else if (!strcasecmp (cargv[0], "collation")) {
if ( cargc < 7 ) {
slapi_log_err(SLAPI_LOG_ERR, COLLATE_PLUGIN_SUBSYSTEM,
"collation_config - %s: line %lu ignored: only %lu arguments (expected "
"collation language country variant strength decomposition oid ...)\n",
fname, (unsigned long)lineno, (unsigned long)cargc );
} else {
auto size_t arg;
auto coll_profile_t* profile = (coll_profile_t*) slapi_ch_calloc (1, sizeof (coll_profile_t));
if (*cargv[1]) profile->language = slapi_ch_strdup (cargv[1]);
if (*cargv[2]) profile->country = slapi_ch_strdup (cargv[2]);
if (*cargv[3]) profile->variant = slapi_ch_strdup (cargv[3]);
switch (atoi(cargv[4])) {
case 1: profile->strength = UCOL_PRIMARY; break;
case 2: profile->strength = UCOL_SECONDARY; /* no break here? fall through? wtf? */
case 3: profile->strength = UCOL_TERTIARY; break;
case 4: profile->strength = UCOL_IDENTICAL; break;
default: profile->strength = UCOL_SECONDARY;
slapi_log_err(SLAPI_LOG_ERR, COLLATE_PLUGIN_SUBSYSTEM,
"collation_config - %s: line %lu: strength \"%s\" not supported (will use 2)\n",
fname, (unsigned long)lineno, cargv[4]);
break;
}
switch (atoi(cargv[5])) {
case 1: profile->decomposition = UCOL_OFF; break;
case 2: profile->decomposition = UCOL_DEFAULT; /* no break here? fall through? wtf? */
case 3: profile->decomposition = UCOL_ON; break;
default: profile->decomposition = UCOL_DEFAULT;
slapi_log_err(SLAPI_LOG_ERR, COLLATE_PLUGIN_SUBSYSTEM,
"collation_config - %s: line %lu: decomposition \"%s\" not supported (will use 2)\n",
fname, (unsigned long)lineno, cargv[5]);
break;
}
{
char descStr[256];
char nameOrder[256];
char nameSubstring[256];
char oidString[256];
char *tmpStr=NULL;
Slapi_MatchingRuleEntry *mrentry=slapi_matchingrule_new();
if(UCOL_PRIMARY == profile->strength) {
strcpy(nameOrder,"caseIgnoreOrderingMatch");
strcpy(nameSubstring,"caseIgnoreSubstringMatch");
}
else {
strcpy(nameOrder,"caseExactOrderingMatch");
strcpy(nameSubstring,"caseExactSubstringMatch");
}
/* PAR: this looks broken
the "extra" text based oids that are actually used
to form the name and description are always derived
from the language and country fields so there should
be no need to have two separate code paths to
set the name and description fields of the schema
as language is always available, and if country is
not, it is not in the name anyway.
Is it safe to assume all matching rules will follow
this convention? The answer, or lack of it, probably
explains the reasoning for doing things the way they
are currently.
*/
if(cargc > 7) {
PL_strcatn(nameOrder,sizeof(nameOrder),"-");
PL_strcatn(nameOrder,sizeof(nameOrder),cargv[7]);
PL_strcatn(nameSubstring,sizeof(nameSubstring),"-");
PL_strcatn(nameSubstring,sizeof(nameSubstring),cargv[7]);
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)slapi_ch_strdup(nameOrder));
}
else {
if(0 != cargv[1][0]) {
PL_strcatn(nameOrder,sizeof(nameOrder),"-");
PL_strcatn(nameSubstring,sizeof(nameSubstring),"-");
} else {
nameOrder[0] = 0;
nameSubstring[0] = 0;
}
PL_strcatn(nameOrder,sizeof(nameOrder),cargv[1]);
PL_strcatn(nameSubstring,sizeof(nameSubstring),cargv[1]);
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)slapi_ch_strdup(nameOrder));
}
PL_strncpyz(oidString,cargv[6], sizeof(oidString));
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_OID,
(void *)slapi_ch_strdup(oidString));
if(0 != cargv[2][0]) {
PR_snprintf(descStr, sizeof(descStr), "%s-%s",cargv[1],cargv[2]);
}
else {
PL_strncpyz(descStr,cargv[1], sizeof(descStr));
}
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_DESC,
(void *)slapi_ch_strdup(descStr));
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_SYNTAX,
(void *)slapi_ch_strdup(DIRSTRING_SYNTAX_OID));
slapi_matchingrule_register(mrentry);
slapi_matchingrule_get(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)&tmpStr);
slapi_ch_free((void **)&tmpStr);
slapi_matchingrule_get(mrentry,SLAPI_MATCHINGRULE_OID,
(void *)&tmpStr);
slapi_ch_free((void **)&tmpStr);
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_NAME,
(void *)slapi_ch_strdup(nameSubstring));
PL_strcatn(oidString,sizeof(oidString),".6");
slapi_matchingrule_set(mrentry,SLAPI_MATCHINGRULE_OID,
(void *)slapi_ch_strdup(oidString));
slapi_matchingrule_register(mrentry);
slapi_matchingrule_free(&mrentry,1);
}
for (arg = 6; arg < cargc; ++arg) {
auto coll_id_t* id = (coll_id_t*) slapi_ch_malloc (sizeof (coll_id_t));
id->oid = slapi_ch_strdup (cargv[arg]);
id->profile = profile;
if (collation_ids <= 0) {
collation_id = (const coll_id_t**) slapi_ch_malloc (2 * sizeof (coll_id_t*));
} else {
collation_id = (const coll_id_t**) slapi_ch_realloc
((void*)collation_id, (collation_ids + 2) * sizeof (coll_id_t*));
}
collation_id [collation_ids++] = id;
collation_id [collation_ids] = NULL;
}
}
} else {
return -1; /* unrecognized */
}
return 0; /* success */
}
