Handle allow-header correctly.
[kopensolaris-gnu/glibc.git] / intl / bindtextdom.c
1 /* Implementation of the bindtextdomain(3) function
2    Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Library General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, USA.  */
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #if defined STDC_HEADERS || defined _LIBC
24 # include <stdlib.h>
25 #else
26 # ifdef HAVE_MALLOC_H
27 #  include <malloc.h>
28 # else
29 void free ();
30 # endif
31 #endif
32
33 #if defined HAVE_STRING_H || defined _LIBC
34 # include <string.h>
35 #else
36 # include <strings.h>
37 # ifndef memcpy
38 #  define memcpy(Dst, Src, Num) (bcopy (Src, Dst, Num), (Dst))
39 # endif
40 #endif
41
42 #ifdef _LIBC
43 # include <libintl.h>
44 #else
45 # include "libgettext.h"
46 #endif
47 #include "gettext.h"
48 #include "gettextP.h"
49
50 #ifdef _LIBC
51 /* We have to handle multi-threaded applications.  */
52 # include <bits/libc-lock.h>
53 #else
54 /* Provide dummy implementation if this is outside glibc.  */
55 # define __libc_rwlock_define(CLASS, NAME)
56 # define __libc_rwlock_wrlock(NAME)
57 # define __libc_rwlock_unlock(NAME)
58 #endif
59
60 /* The internal variables in the standalone libintl.a must have different
61    names than the internal variables in GNU libc, otherwise programs
62    using libintl.a cannot be linked statically.  */
63 #if !defined _LIBC
64 # define _nl_default_dirname _nl_default_dirname__
65 # define _nl_domain_bindings _nl_domain_bindings__
66 #endif
67
68 /* @@ end of prolog @@ */
69
70 /* Contains the default location of the message catalogs.  */
71 extern const char _nl_default_dirname[];
72
73 /* List with bindings of specific domains.  */
74 extern struct binding *_nl_domain_bindings;
75
76 /* Lock variable to protect the global data in the gettext implementation.  */
77 __libc_rwlock_define (extern, _nl_state_lock)
78
79
80 /* Names for the libintl functions are a problem.  They must not clash
81    with existing names and they should follow ANSI C.  But this source
82    code is also used in GNU C Library where the names have a __
83    prefix.  So we have to make a difference here.  */
84 #ifdef _LIBC
85 # define BINDTEXTDOMAIN __bindtextdomain
86 # define BIND_TEXTDOMAIN_CODESET __bind_textdomain_codeset
87 # ifndef strdup
88 #  define strdup(str) __strdup (str)
89 # endif
90 #else
91 # define BINDTEXTDOMAIN bindtextdomain__
92 # define BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset__
93 #endif
94
95 /* Prototypes for local functions.  */
96 static void set_binding_values (const char *domainname, const char **dirnamep,
97                                 const char **codesetp);
98      
99 /* Specifies the directory name *DIRNAMEP and the output codeset *CODESETP
100    to be used for the DOMAINNAME message catalog.
101    If *DIRNAMEP or *CODESETP is NULL, the corresponding attribute is not
102    modified, only the current value is returned.
103    If DIRNAMEP or CODESETP is NULL, the corresponding attribute is neither
104    modified nor returned.  */
105 static void
106 set_binding_values (domainname, dirnamep, codesetp)
107      const char *domainname;
108      const char **dirnamep;
109      const char **codesetp;
110 {
111   struct binding *binding;
112   int modified;
113
114   /* Some sanity checks.  */
115   if (domainname == NULL || domainname[0] == '\0')
116     {
117       if (dirnamep)
118         *dirnamep = NULL;
119       if (codesetp)
120         *codesetp = NULL;
121       return;
122     }
123
124   __libc_rwlock_wrlock (_nl_state_lock);
125
126   modified = 0;
127
128   for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
129     {
130       int compare = strcmp (domainname, binding->domainname);
131       if (compare == 0)
132         /* We found it!  */
133         break;
134       if (compare < 0)
135         {
136           /* It is not in the list.  */
137           binding = NULL;
138           break;
139         }
140     }
141
142   if (binding != NULL)
143     {
144       if (dirnamep)
145         {
146           const char *dirname = *dirnamep;
147
148           if (dirname == NULL)
149             /* The current binding has be to returned.  */
150             *dirnamep = binding->dirname;
151           else
152             {
153               /* The domain is already bound.  If the new value and the old
154                  one are equal we simply do nothing.  Otherwise replace the
155                  old binding.  */
156               char *result = binding->dirname;
157               if (strcmp (dirname, result) != 0)
158                 {
159                   if (strcmp (dirname, _nl_default_dirname) == 0)
160                     result = (char *) _nl_default_dirname;
161                   else
162                     {
163 #if defined _LIBC || defined HAVE_STRDUP
164                       result = strdup (dirname);
165 #else
166                       size_t len = strlen (dirname) + 1;
167                       result = (char *) malloc (len);
168                       if (__builtin_expect (result != NULL, 1))
169                         memcpy (result, dirname, len);
170 #endif
171                     }
172
173                   if (__builtin_expect (result != NULL, 1))
174                     {
175                       if (binding->dirname != _nl_default_dirname)
176                         free (binding->dirname);
177
178                       binding->dirname = result;
179                       modified = 1;
180                     }
181                 }
182               *dirnamep = result;
183             }
184         }
185
186       if (codesetp)
187         {
188           const char *codeset = *codesetp;
189
190           if (codeset == NULL)
191             /* The current binding has be to returned.  */
192             *codesetp = binding->codeset;
193           else
194             {
195               /* The domain is already bound.  If the new value and the old
196                  one are equal we simply do nothing.  Otherwise replace the
197                  old binding.  */
198               char *result = binding->codeset;
199               if (result == NULL || strcmp (codeset, result) != 0)
200                 {
201 #if defined _LIBC || defined HAVE_STRDUP
202                   result = strdup (codeset);
203 #else
204                   size_t len = strlen (codeset) + 1;
205                   result = (char *) malloc (len);
206                   if (__builtin_expect (result != NULL, 1))
207                     memcpy (result, codeset, len);
208 #endif
209
210                   if (__builtin_expect (result != NULL, 1))
211                     {
212                       if (binding->codeset != NULL)
213                         free (binding->codeset);
214
215                       binding->codeset = result;
216                       modified = 1;
217                     }
218                 }
219               *codesetp = result;
220             }
221         }
222     }
223   else if ((dirnamep == NULL || *dirnamep == NULL)
224            && (codesetp == NULL || *codesetp == NULL))
225     {
226       /* Simply return the default values.  */
227       if (dirnamep)
228         *dirnamep = _nl_default_dirname;
229       if (codesetp)
230         *codesetp = NULL;
231     }
232   else
233     {
234       /* We have to create a new binding.  */
235       size_t len = strlen (domainname) + 1;
236       struct binding *new_binding =
237         (struct binding *) malloc (sizeof (*new_binding) + len);
238
239       if (__builtin_expect (new_binding == NULL, 0))
240         goto failed;
241
242       memcpy (new_binding->domainname, domainname, len);
243
244       if (dirnamep)
245         {
246           const char *dirname = *dirnamep;
247
248           if (dirname == NULL)
249             /* The default value.  */
250             dirname = _nl_default_dirname;
251           else
252             {
253               if (strcmp (dirname, _nl_default_dirname) == 0)
254                 dirname = _nl_default_dirname;
255               else
256                 {
257                   char *result;
258 #if defined _LIBC || defined HAVE_STRDUP
259                   result = strdup (dirname);
260                   if (__builtin_expect (result == NULL, 0))
261                     goto failed_dirname;
262 #else
263                   size_t len = strlen (dirname) + 1;
264                   result = (char *) malloc (len);
265                   if (__builtin_expect (result == NULL, 0))
266                     goto failed_dirname;
267                   memcpy (result, dirname, len);
268 #endif
269                   dirname = result;
270                 }
271             }
272           *dirnamep = dirname;
273           new_binding->dirname = (char *) dirname;
274         }
275       else
276         /* The default value.  */
277         new_binding->dirname = (char *) _nl_default_dirname;
278
279       if (codesetp)
280         {
281           const char *codeset = *codesetp;
282
283           if (codeset != NULL)
284             {
285               char *result;
286
287 #if defined _LIBC || defined HAVE_STRDUP
288               result = strdup (codeset);
289               if (__builtin_expect (result == NULL, 0))
290                 goto failed_codeset;
291 #else
292               size_t len = strlen (codeset) + 1;
293               result = (char *) malloc (len);
294               if (__builtin_expect (result == NULL, 0))
295                 goto failed_codeset;
296               memcpy (result, codeset, len);
297 #endif
298               codeset = result;
299             }
300           *codesetp = codeset;
301           new_binding->codeset = (char *) codeset;
302         }
303       else
304         new_binding->codeset = NULL;
305
306       /* Now enqueue it.  */
307       if (_nl_domain_bindings == NULL
308           || strcmp (domainname, _nl_domain_bindings->domainname) < 0)
309         {
310           new_binding->next = _nl_domain_bindings;
311           _nl_domain_bindings = new_binding;
312         }
313       else
314         {
315           binding = _nl_domain_bindings;
316           while (binding->next != NULL
317                  && strcmp (domainname, binding->next->domainname) > 0)
318             binding = binding->next;
319
320           new_binding->next = binding->next;
321           binding->next = new_binding;
322         }
323
324       modified = 1;
325
326       /* Here we deal with memory allocation failures.  */
327       if (0)
328         {
329         failed_codeset:
330           if (new_binding->dirname != _nl_default_dirname)
331             free (new_binding->dirname);
332         failed_dirname:
333           free (new_binding);
334         failed:
335           if (dirnamep)
336             *dirnamep = NULL;
337           if (codesetp)
338             *codesetp = NULL;
339         }
340     }
341
342   /* If we modified any binding, we flush the caches.  */
343   if (modified)
344     ++_nl_msg_cat_cntr;
345
346   __libc_rwlock_unlock (_nl_state_lock);
347 }
348
349 /* Specify that the DOMAINNAME message catalog will be found
350    in DIRNAME rather than in the system locale data base.  */
351 char *
352 BINDTEXTDOMAIN (domainname, dirname)
353      const char *domainname;
354      const char *dirname;
355 {
356   set_binding_values (domainname, &dirname, NULL);
357   return (char *) dirname;
358 }
359
360 /* Specify the character encoding in which the messages from the
361    DOMAINNAME message catalog will be returned.  */
362 char *
363 BIND_TEXTDOMAIN_CODESET (domainname, codeset)
364      const char *domainname;
365      const char *codeset;
366 {
367   set_binding_values (domainname, NULL, &codeset);
368   return (char *) codeset;
369 }
370
371 #ifdef _LIBC
372 /* Aliases for function names in GNU C Library.  */
373 weak_alias (__bindtextdomain, bindtextdomain);
374 weak_alias (__bind_textdomain_codeset, bind_textdomain_codeset);
375 #endif