aboutsummaryrefslogtreecommitdiff
path: root/iconv/gconv_conf.c
diff options
context:
space:
mode:
authorUlrich Drepper <drepper@redhat.com>1998-12-17 20:59:54 +0000
committerUlrich Drepper <drepper@redhat.com>1998-12-17 20:59:54 +0000
commit8c4796197c60fc8aa380d8995f0d744faf4d8c4a (patch)
tree8747f959e3e829d8bb70971f7e7017f73696b828 /iconv/gconv_conf.c
parentc5b0e13e208bbc4722be3f45283e75d1333b4957 (diff)
downloadglibc-8c4796197c60fc8aa380d8995f0d744faf4d8c4a.tar
glibc-8c4796197c60fc8aa380d8995f0d744faf4d8c4a.tar.gz
glibc-8c4796197c60fc8aa380d8995f0d744faf4d8c4a.tar.bz2
glibc-8c4796197c60fc8aa380d8995f0d744faf4d8c4a.zip
Update.
* iconv/gconv_int.h (gconv_module): Add new element from_regex_mem. * iconv/gconv_conf.c (module_compare): Make s1 and s2 const. (detect_conflict): New function. (add_alias): Call detect_conflict to see whether there is already a module for the new name. (add_module): Make sure there is no alias for the new name. (read_conf_file): Call add_alias with new argument. (__gconv_read_conf): Don't destroy module tree immediately after walking it. We need it to test the internal conversions for conflicts. * iconv/gconv_db.c (find_derivation): Don't allocate memory for regular expression. There is now room in the module descriptor. (free_mem): Don't free memory for regular expression.
Diffstat (limited to 'iconv/gconv_conf.c')
-rw-r--r--iconv/gconv_conf.c115
1 files changed, 107 insertions, 8 deletions
diff --git a/iconv/gconv_conf.c b/iconv/gconv_conf.c
index 1b0f5b81d4..d3f516effa 100644
--- a/iconv/gconv_conf.c
+++ b/iconv/gconv_conf.c
@@ -87,8 +87,8 @@ builtin_aliases[] =
static int
module_compare (const void *p1, const void *p2)
{
- struct gconv_module *s1 = (struct gconv_module *) p1;
- struct gconv_module *s2 = (struct gconv_module *) p2;
+ const struct gconv_module *s1 = (const struct gconv_module *) p1;
+ const struct gconv_module *s2 = (const struct gconv_module *) p2;
int result;
if (s1->from_pattern == NULL)
@@ -110,9 +110,78 @@ module_compare (const void *p1, const void *p2)
}
+/* This function is used to test for a conflict which could be introduced
+ if adding a new alias.
+
+ This function is a *very* ugly hack. The action-function is not
+ supposed to alter the parameter. But we have to do this. We will if
+ necessary compile the regular expression so that we can see whether it
+ matches the alias name. This is safe in this environment and for the
+ sake of performance we do it this way. The alternative would be to
+ compile all regular expressions right from the start or to forget about
+ the compilation though we might need it later.
+
+ The second ugliness is that we have no possibility to pass parameters
+ to the function. Therefore we use a global variable. This is no problem
+ since we are for sure alone even in multi-threaded applications. */
+
+/* This is alias we want to check. */
+static const char *alias_to_test;
+
+/* This variable is set to a nonzero value once we have found a matching
+ entry. */
+static int abort_conflict_search;
+
+static void
+detect_conflict (const void *p, VISIT value, int level)
+{
+ struct gconv_module *s = *(struct gconv_module **) p;
+
+ if ((value != endorder && value != leaf) || s->from_constpfx == NULL
+ || abort_conflict_search)
+ return;
+
+ /* Before we test the whole expression (if this is a regular expression)
+ make sure the constant prefix matches. In case this is no regular
+ expression this is the whole string. */
+ if (strcmp (alias_to_test, s->from_constpfx) == 0)
+ {
+ if (s->from_pattern == NULL)
+ /* This is a simple string and therefore we have a conflict. */
+ abort_conflict_search = 1;
+ else
+ {
+ /* Make sure the regular expression is compiled (if possible). */
+ if (s->from_regex == NULL)
+ {
+ /* Beware, this is what I warned you about in the comment
+ above. We are modifying the object. */
+ if (__regcomp (&s->from_regex_mem, s->from_pattern,
+ REG_EXTENDED | REG_ICASE) != 0)
+ /* Something is wrong. Remember this. */
+ s->from_regex = (regex_t *) -1L;
+ else
+ s->from_regex = &s->from_regex_mem;
+ }
+
+ if (s->from_regex != (regex_t *) -1L)
+ {
+ regmatch_t match[1];
+
+ if (__regexec (s->from_regex, alias_to_test, 1, match, 0) == 0
+ && match[0].rm_so == 0
+ && alias_to_test[match[0].rm_eo] == '\0')
+ /* The whole string matched. This is also a conflict. */
+ abort_conflict_search = 1;
+ }
+ }
+ }
+}
+
+
/* Add new alias. */
static inline void
-add_alias (char *rp)
+add_alias (char *rp, void *modules)
{
/* We now expect two more string. The strings are normalized
(converted to UPPER case) and strored in the alias database. */
@@ -138,6 +207,16 @@ add_alias (char *rp)
return;
*wp++ = '\0';
+ /* Test whether this alias conflicts with any available module. See
+ the comment before the function `detect_conflict' for a description
+ of this ugly hack. */
+ alias_to_test = from;
+ abort_conflict_search = 0;
+ __twalk (modules, detect_conflict);
+ if (abort_conflict_search)
+ /* It does conflict, don't add the alias. */
+ return;
+
new_alias = (struct gconv_alias *)
malloc (sizeof (struct gconv_alias) + (wp - from));
if (new_alias != NULL)
@@ -290,6 +369,25 @@ add_module (char *rp, const char *directory, size_t dir_len, void **modules,
if (need_ext)
memcpy (tmp - 1, gconv_module_ext, sizeof (gconv_module_ext));
+ /* See whether we have already an alias with this name defined.
+ We do allow regular expressions matching this any alias since
+ this expression can also match other names and we test for aliases
+ before testing for modules. */
+ if (! from_is_regex)
+ {
+ struct gconv_alias fake_alias;
+
+ fake_alias.fromname = new_module->from_constpfx;
+
+ if (__tfind (&fake_alias, &__gconv_alias_db, __gconv_alias_compare)
+ != NULL)
+ {
+ /* This module duplicates an alias. */
+ free (new_module);
+ return;
+ }
+ }
+
if (__tfind (new_module, modules, module_compare) == NULL)
{
if (__tsearch (new_module, modules, module_compare) == NULL)
@@ -364,7 +462,7 @@ read_conf_file (const char *filename, const char *directory, size_t dir_len,
if (rp - word == sizeof ("alias") - 1
&& memcmp (word, "alias", sizeof ("alias") - 1) == 0)
- add_alias (rp);
+ add_alias (rp, *modules);
else if (rp - word == sizeof ("module") - 1
&& memcmp (word, "module", sizeof ("module") - 1) == 0)
add_module (rp, directory, dir_len, modules, nmodules, modcounter++);
@@ -449,9 +547,6 @@ __gconv_read_conf (void)
/* Insert all module entries into the array. */
__twalk (modules, insert_module);
- /* No remove the tree data structure. */
- __tdestroy (modules, nothing);
-
/* Finally insert the builtin transformations. */
for (cnt = 0; cnt < (sizeof (builtin_modules)
/ sizeof (struct gconv_module)); ++cnt)
@@ -464,8 +559,12 @@ __gconv_read_conf (void)
while (cnt > 0)
{
char *copy = strdupa (builtin_aliases[--cnt]);
- add_alias (copy);
+ add_alias (copy, modules);
}
+
+ if (nmodules != 0)
+ /* Now remove the tree data structure. */
+ __tdestroy (modules, nothing);
/* Restore the error number. */
__set_errno (save_errno);