fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / iconv / gconv_trans.c
1 /* Transliteration using the locale's data.
2    Copyright (C) 2000 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 2000.
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 <dlfcn.h>
23 #include <search.h>
24 #include <stdint.h>
25 #include <string.h>
26 #include <stdlib.h>
27
28 #include <bits/libc-lock.h>
29 #include "gconv_int.h"
30 #include "../locale/localeinfo.h"
31
32
33 int
34 __gconv_transliterate (struct __gconv_step *step,
35                        struct __gconv_step_data *step_data,
36                        void *trans_data __attribute__ ((unused)),
37                        const unsigned char *inbufstart,
38                        const unsigned char **inbufp,
39                        const unsigned char *inbufend,
40                        unsigned char **outbufstart, size_t *irreversible)
41 {
42   /* Find out about the locale's transliteration.  */
43   uint_fast32_t size;
44   const uint32_t *from_idx;
45   const uint32_t *from_tbl;
46   const uint32_t *to_idx;
47   const uint32_t *to_tbl;
48   const uint32_t *winbuf;
49   const uint32_t *winbufend;
50   uint_fast32_t low;
51   uint_fast32_t high;
52
53   /* The input buffer.  There are actually 4-byte values.  */
54   winbuf = (const uint32_t *) *inbufp;
55   winbufend = (const uint32_t *) inbufend;
56
57   __gconv_fct fct = step->__fct;
58 #ifdef PTR_DEMANGLE
59   if (step->__shlib_handle != NULL)
60     PTR_DEMANGLE (fct);
61 #endif
62
63   /* If there is no transliteration information in the locale don't do
64      anything and return the error.  */
65   size = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_TRANSLIT_TAB_SIZE);
66   if (size == 0)
67     goto no_rules;
68
69   /* Get the rest of the values.  */
70   from_idx =
71     (const uint32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TRANSLIT_FROM_IDX);
72   from_tbl =
73     (const uint32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TRANSLIT_FROM_TBL);
74   to_idx =
75     (const uint32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TRANSLIT_TO_IDX);
76   to_tbl =
77     (const uint32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TRANSLIT_TO_TBL);
78
79   /* Test whether there is enough input.  */
80   if (winbuf + 1 > winbufend)
81     return (winbuf == winbufend
82             ? __GCONV_EMPTY_INPUT : __GCONV_INCOMPLETE_INPUT);
83
84   /* The array starting at FROM_IDX contains indeces to the string table
85      in FROM_TBL.  The indeces are sorted wrt to the strings.  I.e., we
86      are doing binary search.  */
87   low = 0;
88   high = size;
89   while (low < high)
90     {
91       uint_fast32_t med = (low + high) / 2;
92       uint32_t idx;
93       int cnt;
94
95       /* Compare the string at this index with the string at the current
96          position in the input buffer.  */
97       idx = from_idx[med];
98       cnt = 0;
99       do
100         {
101           if (from_tbl[idx + cnt] != winbuf[cnt])
102             /* Does not match.  */
103             break;
104           ++cnt;
105         }
106       while (from_tbl[idx + cnt] != L'\0' && winbuf + cnt < winbufend);
107
108       if (cnt > 0 && from_tbl[idx + cnt] == L'\0')
109         {
110           /* Found a matching input sequence.  Now try to convert the
111              possible replacements.  */
112           uint32_t idx2 = to_idx[med];
113
114           do
115             {
116               /* Determine length of replacement.  */
117               uint_fast32_t len = 0;
118               int res;
119               const unsigned char *toinptr;
120               unsigned char *outptr;
121
122               while (to_tbl[idx2 + len] != L'\0')
123                 ++len;
124
125               /* Try this input text.  */
126               toinptr = (const unsigned char *) &to_tbl[idx2];
127               outptr = *outbufstart;
128               res = DL_CALL_FCT (fct,
129                                  (step, step_data, &toinptr,
130                                   (const unsigned char *) &to_tbl[idx2 + len],
131                                   &outptr, NULL, 0, 0));
132               if (res != __GCONV_ILLEGAL_INPUT)
133                 {
134                   /* If the conversion succeeds we have to increment the
135                      input buffer.  */
136                   if (res == __GCONV_EMPTY_INPUT)
137                     {
138                       *inbufp += cnt * sizeof (uint32_t);
139                       ++*irreversible;
140                       res = __GCONV_OK;
141                     }
142                   *outbufstart = outptr;
143
144                   return res;
145                 }
146
147               /* Next replacement.  */
148               idx2 += len + 1;
149             }
150           while (to_tbl[idx2] != L'\0');
151
152           /* Nothing found, continue searching.  */
153         }
154       else if (cnt > 0)
155         /* This means that the input buffer contents matches a prefix of
156            an entry.  Since we cannot match it unless we get more input,
157            we will tell the caller about it.  */
158         return __GCONV_INCOMPLETE_INPUT;
159
160       if (winbuf + cnt >= winbufend || from_tbl[idx + cnt] < winbuf[cnt])
161         low = med + 1;
162       else
163         high = med;
164     }
165
166  no_rules:
167   /* Maybe the character is supposed to be ignored.  */
168   if (_NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_TRANSLIT_IGNORE_LEN) != 0)
169     {
170       int n = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_TRANSLIT_IGNORE_LEN);
171       const uint32_t *ranges =
172         (const uint32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TRANSLIT_IGNORE);
173       const uint32_t wc = *(const uint32_t *) (*inbufp);
174       int i;
175
176       /* Test whether there is enough input.  */
177       if (winbuf + 1 > winbufend)
178         return (winbuf == winbufend
179                 ? __GCONV_EMPTY_INPUT : __GCONV_INCOMPLETE_INPUT);
180
181       for (i = 0; i < n; ranges += 3, ++i)
182         if (ranges[0] <= wc && wc <= ranges[1]
183             && (wc - ranges[0]) % ranges[2] == 0)
184           {
185             /* Matches the range.  Ignore it.  */
186             *inbufp += 4;
187             ++*irreversible;
188             return __GCONV_OK;
189           }
190         else if (wc < ranges[0])
191           /* There cannot be any other matching range since they are
192              sorted.  */
193           break;
194     }
195
196   /* One last chance: use the default replacement.  */
197   if (_NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN) != 0)
198     {
199       const uint32_t *default_missing = (const uint32_t *)
200         _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TRANSLIT_DEFAULT_MISSING);
201       const unsigned char *toinptr = (const unsigned char *) default_missing;
202       uint32_t len = _NL_CURRENT_WORD (LC_CTYPE,
203                                        _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN);
204       unsigned char *outptr;
205       int res;
206
207       /* Test whether there is enough input.  */
208       if (winbuf + 1 > winbufend)
209         return (winbuf == winbufend
210                 ? __GCONV_EMPTY_INPUT : __GCONV_INCOMPLETE_INPUT);
211
212       outptr = *outbufstart;
213       res = DL_CALL_FCT (fct,
214                          (step, step_data, &toinptr,
215                           (const unsigned char *) (default_missing + len),
216                           &outptr, NULL, 0, 0));
217
218       if (res != __GCONV_ILLEGAL_INPUT)
219         {
220           /* If the conversion succeeds we have to increment the
221              input buffer.  */
222           if (res == __GCONV_EMPTY_INPUT)
223             {
224               /* This worked but is not reversible.  */
225               ++*irreversible;
226               *inbufp += 4;
227               res = __GCONV_OK;
228             }
229           *outbufstart = outptr;
230
231           return res;
232         }
233     }
234
235   /* Haven't found a match.  */
236   return __GCONV_ILLEGAL_INPUT;
237 }
238
239
240 /* Structure to represent results of found (or not) transliteration
241    modules.  */
242 struct known_trans
243 {
244   /* This structure must remain the first member.  */
245   struct trans_struct info;
246
247   char *fname;
248   void *handle;
249   int open_count;
250 };
251
252
253 /* Tree with results of previous calls to __gconv_translit_find.  */
254 static void *search_tree;
255
256 /* We modify global data.   */
257 __libc_lock_define_initialized (static, lock);
258
259
260 /* Compare two transliteration entries.  */
261 static int
262 trans_compare (const void *p1, const void *p2)
263 {
264   const struct known_trans *s1 = (const struct known_trans *) p1;
265   const struct known_trans *s2 = (const struct known_trans *) p2;
266
267   return strcmp (s1->info.name, s2->info.name);
268 }
269
270
271 /* Open (maybe reopen) the module named in the struct.  Get the function
272    and data structure pointers we need.  */
273 static int
274 open_translit (struct known_trans *trans)
275 {
276   __gconv_trans_query_fct queryfct;
277
278   trans->handle = __libc_dlopen (trans->fname);
279   if (trans->handle == NULL)
280     /* Not available.  */
281     return 1;
282
283   /* Find the required symbol.  */
284   queryfct = __libc_dlsym (trans->handle, "gconv_trans_context");
285   if (queryfct == NULL)
286     {
287       /* We cannot live with that.  */
288     close_and_out:
289       __libc_dlclose (trans->handle);
290       trans->handle = NULL;
291       return 1;
292     }
293
294   /* Get the context.  */
295   if (queryfct (trans->info.name, &trans->info.csnames, &trans->info.ncsnames)
296       != 0)
297     goto close_and_out;
298
299   /* Of course we also have to have the actual function.  */
300   trans->info.trans_fct = __libc_dlsym (trans->handle, "gconv_trans");
301   if (trans->info.trans_fct == NULL)
302     goto close_and_out;
303
304   /* Now the optional functions.  */
305   trans->info.trans_init_fct =
306     __libc_dlsym (trans->handle, "gconv_trans_init");
307   trans->info.trans_context_fct =
308     __libc_dlsym (trans->handle, "gconv_trans_context");
309   trans->info.trans_end_fct =
310     __libc_dlsym (trans->handle, "gconv_trans_end");
311
312   trans->open_count = 1;
313
314   return 0;
315 }
316
317
318 int
319 internal_function
320 __gconv_translit_find (struct trans_struct *trans)
321 {
322   struct known_trans **found;
323   const struct path_elem *runp;
324   int res = 1;
325
326   /* We have to have a name.  */
327   assert (trans->name != NULL);
328
329   /* Acquire the lock.  */
330   __libc_lock_lock (lock);
331
332   /* See whether we know this module already.  */
333   found = __tfind (trans, &search_tree, trans_compare);
334   if (found != NULL)
335     {
336       /* Is this module available?  */
337       if ((*found)->handle != NULL)
338         {
339           /* Maybe we have to reopen the file.  */
340           if ((*found)->handle != (void *) -1)
341             /* The object is not unloaded.  */
342             res = 0;
343           else if (open_translit (*found) == 0)
344             {
345               /* Copy the data.  */
346               *trans = (*found)->info;
347               (*found)->open_count++;
348               res = 0;
349             }
350         }
351     }
352   else
353     {
354       size_t name_len = strlen (trans->name) + 1;
355       int need_so = 0;
356       struct known_trans *newp;
357
358       /* We have to continue looking for the module.  */
359       if (__gconv_path_elem == NULL)
360         __gconv_get_path ();
361
362       /* See whether we have to append .so.  */
363       if (name_len <= 4 || memcmp (&trans->name[name_len - 4], ".so", 3) != 0)
364         need_so = 1;
365
366       /* Create a new entry.  */
367       newp = (struct known_trans *) malloc (sizeof (struct known_trans)
368                                             + (__gconv_max_path_elem_len
369                                                + name_len + 3)
370                                             + name_len);
371       if (newp != NULL)
372         {
373           char *cp;
374
375           /* Clear the struct.  */
376           memset (newp, '\0', sizeof (struct known_trans));
377
378           /* Store a copy of the module name.  */
379           newp->info.name = cp = (char *) (newp + 1);
380           cp = __mempcpy (cp, trans->name, name_len);
381
382           newp->fname = cp;
383
384           /* Search in all the directories.  */
385           for (runp = __gconv_path_elem; runp->name != NULL; ++runp)
386             {
387               cp = __mempcpy (__stpcpy ((char *) newp->fname, runp->name),
388                               trans->name, name_len);
389               if (need_so)
390                 memcpy (cp, ".so", sizeof (".so"));
391
392               if (open_translit (newp) == 0)
393                 {
394                   /* We found a module.  */
395                   res = 0;
396                   break;
397                 }
398             }
399
400           if (res)
401             newp->fname = NULL;
402
403           /* In any case we'll add the entry to our search tree.  */
404           if (__tsearch (newp, &search_tree, trans_compare) == NULL)
405             {
406               /* Yickes, this should not happen.  Unload the object.  */
407               res = 1;
408               /* XXX unload here.  */
409             }
410         }
411     }
412
413   __libc_lock_unlock (lock);
414
415   return res;
416 }