Demangle pointers before use if necessary.
[kopensolaris-gnu/glibc.git] / iconv / gconv_db.c
1 /* Provide access to the collection of available transformation modules.
2    Copyright (C) 1997-2003, 2004, 2005 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <assert.h>
22 #include <limits.h>
23 #include <search.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/param.h>
27 #include <bits/libc-lock.h>
28 #include <locale/localeinfo.h>
29
30 #include <dlfcn.h>
31 #include <gconv_int.h>
32 #include <sysdep.h>
33
34
35 /* Simple data structure for alias mapping.  We have two names, `from'
36    and `to'.  */
37 void *__gconv_alias_db;
38
39 /* Array with available modules.  */
40 struct gconv_module *__gconv_modules_db;
41
42 /* We modify global data.   */
43 __libc_lock_define_initialized (, __gconv_lock)
44
45
46 /* Provide access to module database.  */
47 struct gconv_module *
48 __gconv_get_modules_db (void)
49 {
50   return __gconv_modules_db;
51 }
52
53 void *
54 __gconv_get_alias_db (void)
55 {
56   return __gconv_alias_db;
57 }
58
59
60 /* Function for searching alias.  */
61 int
62 __gconv_alias_compare (const void *p1, const void *p2)
63 {
64   const struct gconv_alias *s1 = (const struct gconv_alias *) p1;
65   const struct gconv_alias *s2 = (const struct gconv_alias *) p2;
66   return strcmp (s1->fromname, s2->fromname);
67 }
68
69
70 /* To search for a derivation we create a list of intermediate steps.
71    Each element contains a pointer to the element which precedes it
72    in the derivation order.  */
73 struct derivation_step
74 {
75   const char *result_set;
76   size_t result_set_len;
77   int cost_lo;
78   int cost_hi;
79   struct gconv_module *code;
80   struct derivation_step *last;
81   struct derivation_step *next;
82 };
83
84 #define NEW_STEP(result, hi, lo, module, last_mod) \
85   ({ struct derivation_step *newp = alloca (sizeof (struct derivation_step)); \
86      newp->result_set = result;                                               \
87      newp->result_set_len = strlen (result);                                  \
88      newp->cost_hi = hi;                                                      \
89      newp->cost_lo = lo;                                                      \
90      newp->code = module;                                                     \
91      newp->last = last_mod;                                                   \
92      newp->next = NULL;                                                       \
93      newp; })
94
95
96 /* If a specific transformation is used more than once we should not need
97    to start looking for it again.  Instead cache each successful result.  */
98 struct known_derivation
99 {
100   const char *from;
101   const char *to;
102   struct __gconv_step *steps;
103   size_t nsteps;
104 };
105
106 /* Compare function for database of found derivations.  */
107 static int
108 derivation_compare (const void *p1, const void *p2)
109 {
110   const struct known_derivation *s1 = (const struct known_derivation *) p1;
111   const struct known_derivation *s2 = (const struct known_derivation *) p2;
112   int result;
113
114   result = strcmp (s1->from, s2->from);
115   if (result == 0)
116     result = strcmp (s1->to, s2->to);
117   return result;
118 }
119
120 /* The search tree for known derivations.  */
121 static void *known_derivations;
122
123 /* Look up whether given transformation was already requested before.  */
124 static int
125 internal_function
126 derivation_lookup (const char *fromset, const char *toset,
127                    struct __gconv_step **handle, size_t *nsteps)
128 {
129   struct known_derivation key = { fromset, toset, NULL, 0 };
130   struct known_derivation **result;
131
132   result = __tfind (&key, &known_derivations, derivation_compare);
133
134   if (result == NULL)
135     return __GCONV_NOCONV;
136
137   *handle = (*result)->steps;
138   *nsteps = (*result)->nsteps;
139
140   /* Please note that we return GCONV_OK even if the last search for
141      this transformation was unsuccessful.  */
142   return __GCONV_OK;
143 }
144
145 /* Add new derivation to list of known ones.  */
146 static void
147 internal_function
148 add_derivation (const char *fromset, const char *toset,
149                 struct __gconv_step *handle, size_t nsteps)
150 {
151   struct known_derivation *new_deriv;
152   size_t fromset_len = strlen (fromset) + 1;
153   size_t toset_len = strlen (toset) + 1;
154
155   new_deriv = (struct known_derivation *)
156     malloc (sizeof (struct known_derivation) + fromset_len + toset_len);
157   if (new_deriv != NULL)
158     {
159       new_deriv->from = (char *) (new_deriv + 1);
160       new_deriv->to = memcpy (__mempcpy (new_deriv + 1, fromset, fromset_len),
161                               toset, toset_len);
162
163       new_deriv->steps = handle;
164       new_deriv->nsteps = nsteps;
165
166       if (__tsearch (new_deriv, &known_derivations, derivation_compare)
167           == NULL)
168         /* There is some kind of memory allocation problem.  */
169         free (new_deriv);
170     }
171   /* Please note that we don't complain if the allocation failed.  This
172      is not tragically but in case we use the memory debugging facilities
173      not all memory will be freed.  */
174 }
175
176 static void __libc_freeres_fn_section
177 free_derivation (void *p)
178 {
179   struct known_derivation *deriv = (struct known_derivation *) p;
180   size_t cnt;
181
182   for (cnt = 0; cnt < deriv->nsteps; ++cnt)
183     if (deriv->steps[cnt].__counter > 0
184         && deriv->steps[cnt].__end_fct != NULL)
185       {
186         assert (deriv->steps[cnt].__shlib_handle != NULL);
187
188         __gconv_end_fct end_fct = deriv->steps[cnt].__end_fct;
189 #ifdef PTR_DEMANGLE
190         PTR_DEMANGLE (end_fct);
191 #endif
192         DL_CALL_FCT (end_fct, (&deriv->steps[cnt]));
193       }
194
195   /* Free the name strings.  */
196   free ((char *) deriv->steps[0].__from_name);
197   free ((char *) deriv->steps[deriv->nsteps - 1].__to_name);
198
199   free ((struct __gconv_step *) deriv->steps);
200   free (deriv);
201 }
202
203
204 /* Decrement the reference count for a single step in a steps array.  */
205 void
206 internal_function
207 __gconv_release_step (struct __gconv_step *step)
208 {
209   /* Skip builtin modules; they are not reference counted.  */
210   if (step->__shlib_handle != NULL && --step->__counter == 0)
211     {
212       /* Call the destructor.  */
213       if (step->__end_fct != NULL)
214         {
215           assert (step->__shlib_handle != NULL);
216
217           __gconv_end_fct end_fct = step->__end_fct;
218 #ifdef PTR_DEMANGLE
219           PTR_DEMANGLE (end_fct);
220 #endif
221           DL_CALL_FCT (end_fct, (step));
222         }
223
224 #ifndef STATIC_GCONV
225       /* Release the loaded module.  */
226       __gconv_release_shlib (step->__shlib_handle);
227       step->__shlib_handle = NULL;
228 #endif
229     }
230   else
231     /* Builtin modules should not have end functions.  */
232     assert (step->__end_fct == NULL);
233 }
234
235 static int
236 internal_function
237 gen_steps (struct derivation_step *best, const char *toset,
238            const char *fromset, struct __gconv_step **handle, size_t *nsteps)
239 {
240   size_t step_cnt = 0;
241   struct __gconv_step *result;
242   struct derivation_step *current;
243   int status = __GCONV_NOMEM;
244
245   /* First determine number of steps.  */
246   for (current = best; current->last != NULL; current = current->last)
247     ++step_cnt;
248
249   result = (struct __gconv_step *) malloc (sizeof (struct __gconv_step)
250                                            * step_cnt);
251   if (result != NULL)
252     {
253       int failed = 0;
254
255       status = __GCONV_OK;
256       *nsteps = step_cnt;
257       current = best;
258       while (step_cnt-- > 0)
259         {
260           result[step_cnt].__from_name = (step_cnt == 0
261                                           ? __strdup (fromset)
262                                           : (char *)current->last->result_set);
263           result[step_cnt].__to_name = (step_cnt + 1 == *nsteps
264                                         ? __strdup (current->result_set)
265                                         : result[step_cnt + 1].__from_name);
266
267           result[step_cnt].__counter = 1;
268           result[step_cnt].__data = NULL;
269
270 #ifndef STATIC_GCONV
271           if (current->code->module_name[0] == '/')
272             {
273               /* Load the module, return handle for it.  */
274               struct __gconv_loaded_object *shlib_handle =
275                 __gconv_find_shlib (current->code->module_name);
276
277               if (shlib_handle == NULL)
278                 {
279                   failed = 1;
280                   break;
281                 }
282
283               result[step_cnt].__shlib_handle = shlib_handle;
284               result[step_cnt].__modname = shlib_handle->name;
285               result[step_cnt].__fct = shlib_handle->fct;
286               result[step_cnt].__init_fct = shlib_handle->init_fct;
287               result[step_cnt].__end_fct = shlib_handle->end_fct;
288
289               /* These settings can be overridden by the init function.  */
290               result[step_cnt].__btowc_fct = NULL;
291
292               /* Call the init function.  */
293               __gconv_init_fct init_fct = result[step_cnt].__init_fct;
294               if (init_fct != NULL)
295                 {
296                   assert (result[step_cnt].__shlib_handle != NULL);
297
298 # ifdef PTR_DEMANGLE
299                   PTR_DEMANGLE (init_fct);
300 # endif
301                   status = DL_CALL_FCT (init_fct, (&result[step_cnt]));
302
303                   if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
304                     {
305                       failed = 1;
306                       /* Make sure we unload this modules.  */
307                       --step_cnt;
308                       result[step_cnt].__end_fct = NULL;
309                       break;
310                     }
311
312 # ifdef PTR_MANGLE
313                   if (result[step_cnt].__btowc_fct != NULL)
314                     PTR_MANGLE (result[step_cnt].__btowc_fct);
315 # endif
316                 }
317             }
318           else
319 #endif
320             /* It's a builtin transformation.  */
321             __gconv_get_builtin_trans (current->code->module_name,
322                                        &result[step_cnt]);
323
324           current = current->last;
325         }
326
327       if (__builtin_expect (failed, 0) != 0)
328         {
329           /* Something went wrong while initializing the modules.  */
330           while (++step_cnt < *nsteps)
331             __gconv_release_step (&result[step_cnt]);
332           free (result);
333           *nsteps = 0;
334           *handle = NULL;
335           if (status == __GCONV_OK)
336             status = __GCONV_NOCONV;
337         }
338       else
339         *handle = result;
340     }
341   else
342     {
343       *nsteps = 0;
344       *handle = NULL;
345     }
346
347   return status;
348 }
349
350
351 #ifndef STATIC_GCONV
352 static int
353 internal_function
354 increment_counter (struct __gconv_step *steps, size_t nsteps)
355 {
356   /* Increment the user counter.  */
357   size_t cnt = nsteps;
358   int result = __GCONV_OK;
359
360   while (cnt-- > 0)
361     {
362       struct __gconv_step *step = &steps[cnt];
363
364       if (step->__counter++ == 0)
365         {
366           /* Skip builtin modules.  */
367           if (step->__modname != NULL)
368             {
369               /* Reopen a previously used module.  */
370               step->__shlib_handle = __gconv_find_shlib (step->__modname);
371               if (step->__shlib_handle == NULL)
372                 {
373                   /* Oops, this is the second time we use this module
374                      (after unloading) and this time loading failed!?  */
375                   --step->__counter;
376                   while (++cnt < nsteps)
377                     __gconv_release_step (&steps[cnt]);
378                   result = __GCONV_NOCONV;
379                   break;
380                 }
381
382               /* The function addresses defined by the module may
383                  have changed.  */
384               step->__fct = step->__shlib_handle->fct;
385               step->__init_fct = step->__shlib_handle->init_fct;
386               step->__end_fct = step->__shlib_handle->end_fct;
387
388               /* These settings can be overridden by the init function.  */
389               step->__btowc_fct = NULL;
390             }
391
392           /* Call the init function.  */
393           __gconv_init_fct init_fct = step->__init_fct;
394           if (init_fct != NULL)
395             {
396 #ifdef PTR_DEMANGLE
397               PTR_DEMANGLE (init_fct);
398 #endif
399               DL_CALL_FCT (init_fct, (step));
400
401 #ifdef PTR_MANGLE
402               if (step->__btowc_fct != NULL)
403                 PTR_MANGLE (step->__btowc_fct);
404 #endif
405             }
406         }
407     }
408   return result;
409 }
410 #endif
411
412
413 /* The main function: find a possible derivation from the `fromset' (either
414    the given name or the alias) to the `toset' (again with alias).  */
415 static int
416 internal_function
417 find_derivation (const char *toset, const char *toset_expand,
418                  const char *fromset, const char *fromset_expand,
419                  struct __gconv_step **handle, size_t *nsteps)
420 {
421   struct derivation_step *first, *current, **lastp, *solution = NULL;
422   int best_cost_hi = INT_MAX;
423   int best_cost_lo = INT_MAX;
424   int result;
425
426   /* Look whether an earlier call to `find_derivation' has already
427      computed a possible derivation.  If so, return it immediately.  */
428   result = derivation_lookup (fromset_expand ?: fromset, toset_expand ?: toset,
429                               handle, nsteps);
430   if (result == __GCONV_OK)
431     {
432 #ifndef STATIC_GCONV
433       result = increment_counter (*handle, *nsteps);
434 #endif
435       return result;
436     }
437
438   /* The task is to find a sequence of transformations, backed by the
439      existing modules - whether builtin or dynamically loadable -,
440      starting at `fromset' (or `fromset_expand') and ending at `toset'
441      (or `toset_expand'), and with minimal cost.
442
443      For computer scientists, this is a shortest path search in the
444      graph where the nodes are all possible charsets and the edges are
445      the transformations listed in __gconv_modules_db.
446
447      For now we use a simple algorithm with quadratic runtime behaviour.
448      A breadth-first search, starting at `fromset' and `fromset_expand'.
449      The list starting at `first' contains all nodes that have been
450      visited up to now, in the order in which they have been visited --
451      excluding the goal nodes `toset' and `toset_expand' which get
452      managed in the list starting at `solution'.
453      `current' walks through the list starting at `first' and looks
454      which nodes are reachable from the current node, adding them to
455      the end of the list [`first' or `solution' respectively] (if
456      they are visited the first time) or updating them in place (if
457      they have have already been visited).
458      In each node of either list, cost_lo and cost_hi contain the
459      minimum cost over any paths found up to now, starting at `fromset'
460      or `fromset_expand', ending at that node.  best_cost_lo and
461      best_cost_hi represent the minimum over the elements of the
462      `solution' list.  */
463
464   if (fromset_expand != NULL)
465     {
466       first = NEW_STEP (fromset_expand, 0, 0, NULL, NULL);
467       first->next = NEW_STEP (fromset, 0, 0, NULL, NULL);
468       lastp = &first->next->next;
469     }
470   else
471     {
472       first = NEW_STEP (fromset, 0, 0, NULL, NULL);
473       lastp = &first->next;
474     }
475
476   for (current = first; current != NULL; current = current->next)
477     {
478       /* Now match all the available module specifications against the
479          current charset name.  If any of them matches check whether
480          we already have a derivation for this charset.  If yes, use the
481          one with the lower costs.  Otherwise add the new charset at the
482          end.
483
484          The module database is organized in a tree form which allows
485          searching for prefixes.  So we search for the first entry with a
486          matching prefix and any other matching entry can be found from
487          this place.  */
488       struct gconv_module *node;
489
490       /* Maybe it is not necessary anymore to look for a solution for
491          this entry since the cost is already as high (or higher) as
492          the cost for the best solution so far.  */
493       if (current->cost_hi > best_cost_hi
494           || (current->cost_hi == best_cost_hi
495               && current->cost_lo >= best_cost_lo))
496         continue;
497
498       node = __gconv_modules_db;
499       while (node != NULL)
500         {
501           int cmpres = strcmp (current->result_set, node->from_string);
502           if (cmpres == 0)
503             {
504               /* Walk through the list of modules with this prefix and
505                  try to match the name.  */
506               struct gconv_module *runp;
507
508               /* Check all the modules with this prefix.  */
509               runp = node;
510               do
511                 {
512                   const char *result_set = (strcmp (runp->to_string, "-") == 0
513                                             ? (toset_expand ?: toset)
514                                             : runp->to_string);
515                   int cost_hi = runp->cost_hi + current->cost_hi;
516                   int cost_lo = runp->cost_lo + current->cost_lo;
517                   struct derivation_step *step;
518
519                   /* We managed to find a derivation.  First see whether
520                      we have reached one of the goal nodes.  */
521                   if (strcmp (result_set, toset) == 0
522                       || (toset_expand != NULL
523                           && strcmp (result_set, toset_expand) == 0))
524                     {
525                       /* Append to the `solution' list if there
526                          is no entry with this name.  */
527                       for (step = solution; step != NULL; step = step->next)
528                         if (strcmp (result_set, step->result_set) == 0)
529                           break;
530
531                       if (step == NULL)
532                         {
533                           step = NEW_STEP (result_set,
534                                            cost_hi, cost_lo,
535                                            runp, current);
536                           step->next = solution;
537                           solution = step;
538                         }
539                       else if (step->cost_hi > cost_hi
540                                || (step->cost_hi == cost_hi
541                                    && step->cost_lo > cost_lo))
542                         {
543                           /* A better path was found for the node,
544                              on the `solution' list.  */
545                           step->code = runp;
546                           step->last = current;
547                           step->cost_hi = cost_hi;
548                           step->cost_lo = cost_lo;
549                         }
550
551                       /* Update best_cost accordingly.  */
552                       if (cost_hi < best_cost_hi
553                           || (cost_hi == best_cost_hi
554                               && cost_lo < best_cost_lo))
555                         {
556                           best_cost_hi = cost_hi;
557                           best_cost_lo = cost_lo;
558                         }
559                     }
560                   else if (cost_hi < best_cost_hi
561                            || (cost_hi == best_cost_hi
562                                && cost_lo < best_cost_lo))
563                     {
564                       /* Append at the end of the `first' list if there
565                          is no entry with this name.  */
566                       for (step = first; step != NULL; step = step->next)
567                         if (strcmp (result_set, step->result_set) == 0)
568                           break;
569
570                       if (step == NULL)
571                         {
572                           *lastp = NEW_STEP (result_set,
573                                              cost_hi, cost_lo,
574                                              runp, current);
575                           lastp = &(*lastp)->next;
576                         }
577                       else if (step->cost_hi > cost_hi
578                                || (step->cost_hi == cost_hi
579                                    && step->cost_lo > cost_lo))
580                         {
581                           /* A better path was found for the node,
582                              on the `first' list.  */
583                           step->code = runp;
584                           step->last = current;
585
586                           /* Update the cost for all steps.  */
587                           for (step = first; step != NULL;
588                                step = step->next)
589                             /* But don't update the start nodes.  */
590                             if (step->code != NULL)
591                               {
592                                 struct derivation_step *back;
593                                 int hi, lo;
594
595                                 hi = step->code->cost_hi;
596                                 lo = step->code->cost_lo;
597
598                                 for (back = step->last; back->code != NULL;
599                                      back = back->last)
600                                   {
601                                     hi += back->code->cost_hi;
602                                     lo += back->code->cost_lo;
603                                   }
604
605                                 step->cost_hi = hi;
606                                 step->cost_lo = lo;
607                               }
608
609                           /* Likewise for the nodes on the solution list.
610                              Also update best_cost accordingly.  */
611                           for (step = solution; step != NULL;
612                                step = step->next)
613                             {
614                               step->cost_hi = (step->code->cost_hi
615                                                + step->last->cost_hi);
616                               step->cost_lo = (step->code->cost_lo
617                                                + step->last->cost_lo);
618
619                               if (step->cost_hi < best_cost_hi
620                                   || (step->cost_hi == best_cost_hi
621                                       && step->cost_lo < best_cost_lo))
622                                 {
623                                   best_cost_hi = step->cost_hi;
624                                   best_cost_lo = step->cost_lo;
625                                 }
626                             }
627                         }
628                     }
629
630                   runp = runp->same;
631                 }
632               while (runp != NULL);
633
634               break;
635             }
636           else if (cmpres < 0)
637             node = node->left;
638           else
639             node = node->right;
640         }
641     }
642
643   if (solution != NULL)
644     {
645       /* We really found a way to do the transformation.  */
646
647       /* Choose the best solution.  This is easy because we know that
648          the solution list has at most length 2 (one for every possible
649          goal node).  */
650       if (solution->next != NULL)
651         {
652           struct derivation_step *solution2 = solution->next;
653
654           if (solution2->cost_hi < solution->cost_hi
655               || (solution2->cost_hi == solution->cost_hi
656                   && solution2->cost_lo < solution->cost_lo))
657             solution = solution2;
658         }
659
660       /* Now build a data structure describing the transformation steps.  */
661       result = gen_steps (solution, toset_expand ?: toset,
662                           fromset_expand ?: fromset, handle, nsteps);
663     }
664   else
665     {
666       /* We haven't found a transformation.  Clear the result values.  */
667       *handle = NULL;
668       *nsteps = 0;
669     }
670
671   /* Add result in any case to list of known derivations.  */
672   add_derivation (fromset_expand ?: fromset, toset_expand ?: toset,
673                   *handle, *nsteps);
674
675   return result;
676 }
677
678
679 /* Control of initialization.  */
680 __libc_once_define (static, once);
681
682
683 static const char *
684 do_lookup_alias (const char *name)
685 {
686   struct gconv_alias key;
687   struct gconv_alias **found;
688
689   key.fromname = (char *) name;
690   found = __tfind (&key, &__gconv_alias_db, __gconv_alias_compare);
691   return found != NULL ? (*found)->toname : NULL;
692 }
693
694
695 int
696 internal_function
697 __gconv_compare_alias (const char *name1, const char *name2)
698 {
699   int result;
700
701   /* Ensure that the configuration data is read.  */
702   __libc_once (once, __gconv_read_conf);
703
704   if (__gconv_compare_alias_cache (name1, name2, &result) != 0)
705     result = strcmp (do_lookup_alias (name1) ?: name1,
706                      do_lookup_alias (name2) ?: name2);
707
708   return result;
709 }
710
711
712 int
713 internal_function
714 __gconv_find_transform (const char *toset, const char *fromset,
715                         struct __gconv_step **handle, size_t *nsteps,
716                         int flags)
717 {
718   const char *fromset_expand;
719   const char *toset_expand;
720   int result;
721
722   /* Ensure that the configuration data is read.  */
723   __libc_once (once, __gconv_read_conf);
724
725   /* Acquire the lock.  */
726   __libc_lock_lock (__gconv_lock);
727
728   result = __gconv_lookup_cache (toset, fromset, handle, nsteps, flags);
729   if (result != __GCONV_NODB)
730     {
731       /* We have a cache and could resolve the request, successful or not.  */
732       __libc_lock_unlock (__gconv_lock);
733       return result;
734     }
735
736   /* If we don't have a module database return with an error.  */
737   if (__gconv_modules_db == NULL)
738     {
739       __libc_lock_unlock (__gconv_lock);
740       return __GCONV_NOCONV;
741     }
742
743   /* See whether the names are aliases.  */
744   fromset_expand = do_lookup_alias (fromset);
745   toset_expand = do_lookup_alias (toset);
746
747   if (__builtin_expect (flags & GCONV_AVOID_NOCONV, 0)
748       /* We are not supposed to create a pseudo transformation (means
749          copying) when the input and output character set are the same.  */
750       && (strcmp (toset, fromset) == 0
751           || (toset_expand != NULL && strcmp (toset_expand, fromset) == 0)
752           || (fromset_expand != NULL
753               && (strcmp (toset, fromset_expand) == 0
754                   || (toset_expand != NULL
755                       && strcmp (toset_expand, fromset_expand) == 0)))))
756     {
757       /* Both character sets are the same.  */
758       __libc_lock_unlock (__gconv_lock);
759       return __GCONV_NOCONV;
760     }
761
762   result = find_derivation (toset, toset_expand, fromset, fromset_expand,
763                             handle, nsteps);
764
765   /* Release the lock.  */
766   __libc_lock_unlock (__gconv_lock);
767
768   /* The following code is necessary since `find_derivation' will return
769      GCONV_OK even when no derivation was found but the same request
770      was processed before.  I.e., negative results will also be cached.  */
771   return (result == __GCONV_OK
772           ? (*handle == NULL ? __GCONV_NOCONV : __GCONV_OK)
773           : result);
774 }
775
776
777 /* Release the entries of the modules list.  */
778 int
779 internal_function
780 __gconv_close_transform (struct __gconv_step *steps, size_t nsteps)
781 {
782   int result = __GCONV_OK;
783   size_t cnt;
784
785   /* Acquire the lock.  */
786   __libc_lock_lock (__gconv_lock);
787
788 #ifndef STATIC_GCONV
789   cnt = nsteps;
790   while (cnt-- > 0)
791     __gconv_release_step (&steps[cnt]);
792 #endif
793
794   /* If we use the cache we free a bit more since we don't keep any
795      transformation records around, they are cheap enough to
796      recreate.  */
797   __gconv_release_cache (steps, nsteps);
798
799   /* Release the lock.  */
800   __libc_lock_unlock (__gconv_lock);
801
802   return result;
803 }
804
805
806 /* Free the modules mentioned.  */
807 static void
808 internal_function __libc_freeres_fn_section
809 free_modules_db (struct gconv_module *node)
810 {
811   if (node->left != NULL)
812     free_modules_db (node->left);
813   if (node->right != NULL)
814     free_modules_db (node->right);
815   do
816     {
817       struct gconv_module *act = node;
818       node = node->same;
819       if (act->module_name[0] == '/')
820         free (act);
821     }
822   while (node != NULL);
823 }
824
825
826 /* Free all resources if necessary.  */
827 libc_freeres_fn (free_mem)
828 {
829   /* First free locale memory.  This needs to be done before freeing derivations,
830      as ctype cleanup functions dereference steps arrays which we free below.  */
831   _nl_locale_subfreeres ();
832
833   /* finddomain.c has similar problem.  */
834   extern void _nl_finddomain_subfreeres (void) attribute_hidden;
835   _nl_finddomain_subfreeres ();
836
837   if (__gconv_alias_db != NULL)
838     __tdestroy (__gconv_alias_db, free);
839
840   if (__gconv_modules_db != NULL)
841     free_modules_db (__gconv_modules_db);
842
843   if (known_derivations != NULL)
844     __tdestroy (known_derivations, free_derivation);
845 }