Fixed bug 479. Not a real good fix but a reliable one which limits possible
[gnupg.git] / util / simple-gettext.c
1 /* simple-gettext.c  - a simplified version of gettext.
2  * Copyright (C) 1995, 1996, 1997, 1999,
3  *               2005 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 /* This is a simplified version of gettext written by Ulrich Drepper.
24  * It is used for the Win32 version of GnuPG beucase all the overhead
25  * of gettext is not needed and we have to do some special Win32 stuff.
26  * I decided that this is far easier than to tweak gettext for the special
27  * cases (I tried it but it is a lot of code).  wk 15.09.99
28  */
29
30 #include <config.h>
31 #ifdef USE_SIMPLE_GETTEXT
32 #if !defined (_WIN32) && !defined (__CYGWIN32__)
33 #error This file can only be used under Windows or Cygwin32
34 #endif
35
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <ctype.h>
40 #include <errno.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include "types.h"
44 #include "util.h"
45
46
47 /* The magic number of the GNU message catalog format.  */
48 #define MAGIC         0x950412de
49 #define MAGIC_SWAPPED 0xde120495
50
51 /* Revision number of the currently used .mo (binary) file format.  */
52 #define MO_REVISION_NUMBER 0
53
54
55 /* Header for binary .mo file format.  */
56 struct mo_file_header
57 {
58   /* The magic number.  */
59   u32 magic;
60   /* The revision number of the file format.  */
61   u32 revision;
62   /* The number of strings pairs.  */
63   u32 nstrings;
64   /* Offset of table with start offsets of original strings.  */
65   u32 orig_tab_offset;
66   /* Offset of table with start offsets of translation strings.  */
67   u32 trans_tab_offset;
68   /* Size of hashing table.  */
69   u32 hash_tab_size;
70   /* Offset of first hashing entry.  */
71   u32 hash_tab_offset;
72 };
73
74 struct string_desc
75 {
76   /* Length of addressed string.  */
77   u32 length;
78   /* Offset of string in file.  */
79   u32 offset;
80 };
81
82
83 struct overflow_space_s
84 {
85   struct overflow_space_s *next;
86   u32 idx;
87   char d[1];
88 };
89
90 struct loaded_domain
91 {
92   char *data;
93   int must_swap;
94   u32 nstrings;
95   char *mapped;  /* 0 = not yet mapped, 1 = mapped,
96                     2 = mapped to
97                     overflow space */
98   struct overflow_space_s *overflow_space;
99   struct string_desc *orig_tab;
100   struct string_desc *trans_tab;
101   u32 hash_size;
102   u32 *hash_tab;
103 };
104
105
106 static struct loaded_domain *the_domain;
107
108 static __inline__ u32
109 do_swap_u32( u32 i )
110 {
111   return (i << 24) | ((i & 0xff00) << 8) | ((i >> 8) & 0xff00) | (i >> 24);
112 }
113
114 #define SWAPIT(flag, data) ((flag) ? do_swap_u32(data) : (data) )
115
116
117 /* We assume to have `unsigned long int' value with at least 32 bits.  */
118 #define HASHWORDBITS 32
119
120 /* The so called `hashpjw' function by P.J. Weinberger
121    [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
122    1986, 1987 Bell Telephone Laboratories, Inc.]  */
123
124 static __inline__ ulong
125 hash_string( const char *str_param )
126 {
127     unsigned long int hval, g;
128     const char *str = str_param;
129
130     hval = 0;
131     while (*str != '\0')
132     {
133         hval <<= 4;
134         hval += (unsigned long int) *str++;
135         g = hval & ((unsigned long int) 0xf << (HASHWORDBITS - 4));
136         if (g != 0)
137         {
138           hval ^= g >> (HASHWORDBITS - 8);
139           hval ^= g;
140         }
141     }
142     return hval;
143 }
144
145
146 static struct loaded_domain *
147 load_domain( const char *filename )
148 {
149     FILE *fp;
150     size_t size;
151     struct stat st;
152     struct mo_file_header *data = NULL;
153     struct loaded_domain *domain = NULL;
154     size_t to_read;
155     char *read_ptr;
156
157     fp = fopen( filename, "rb" );
158     if( !fp )
159        return NULL; /* can't open the file */
160     /* we must know about the size of the file */
161     if( fstat( fileno(fp ), &st )
162         || (size = (size_t)st.st_size) != st.st_size
163         || size < sizeof (struct mo_file_header) ) {
164         fclose( fp );
165         return NULL;
166     }
167
168     data = malloc( size );
169     if( !data ) {
170         fclose( fp );
171         return NULL; /* out of memory */
172     }
173
174     to_read = size;
175     read_ptr = (char *) data;
176     do {
177         long int nb = fread( read_ptr, 1, to_read, fp );
178         if( nb < to_read ) {
179             fclose (fp);
180             free(data);
181             return NULL; /* read error */
182         }
183         read_ptr += nb;
184         to_read -= nb;
185     } while( to_read > 0 );
186     fclose (fp);
187
188     /* Using the magic number we can test whether it really is a message
189      * catalog file.  */
190     if( data->magic != MAGIC && data->magic != MAGIC_SWAPPED ) {
191         /* The magic number is wrong: not a message catalog file.  */
192         free( data );
193         return NULL;
194     }
195
196     domain = calloc( 1, sizeof *domain );
197     if( !domain )  {
198         free( data );
199         return NULL;
200     }
201     domain->data = (char *) data;
202     domain->must_swap = data->magic != MAGIC;
203
204     /* Fill in the information about the available tables.  */
205     switch( SWAPIT(domain->must_swap, data->revision) ) {
206       case 0:
207         domain->nstrings = SWAPIT(domain->must_swap, data->nstrings);
208         domain->orig_tab = (struct string_desc *)
209           ((char *) data + SWAPIT(domain->must_swap, data->orig_tab_offset));
210         domain->trans_tab = (struct string_desc *)
211           ((char *) data + SWAPIT(domain->must_swap, data->trans_tab_offset));
212         domain->hash_size = SWAPIT(domain->must_swap, data->hash_tab_size);
213         domain->hash_tab = (u32 *)
214           ((char *) data + SWAPIT(domain->must_swap, data->hash_tab_offset));
215       break;
216
217       default: /* This is an invalid revision.  */
218         free( data );
219         free( domain );
220         return NULL;
221     }
222
223     /* Allocate an array to keep track of code page mappings. */
224     domain->mapped = calloc( 1, domain->nstrings );
225     if( !domain->mapped ) {
226         free( data );
227         free( domain );
228         return NULL;
229     }
230
231     return domain;
232 }
233
234
235 /****************
236  * Set the file used for translations. Pass a NULL to disable
237  * translation.  A new filename may be set at anytime.  If REGKEY is
238  * not NULL, the function tries to selected the language the registry
239  * key "Lang" below that key.  WARNING: After changing the filename you
240  * should not access any data retrieved by gettext().
241  */
242 int
243 set_gettext_file ( const char *filename, const char *regkey )
244 {
245     struct loaded_domain *domain = NULL;
246
247     if( filename && *filename ) {
248         if( filename[0] == '/'
249 #ifdef HAVE_DRIVE_LETTERS
250             || ( isalpha(filename[0])
251                  && filename[1] == ':'
252                  && (filename[2] == '/' || filename[2] == '\\') )
253 #endif
254            ) {
255             /* absolute path - use it as is */
256             domain = load_domain( filename );
257         }
258         else if (regkey) { /* Standard.  */
259             char *instdir, *langid, *fname;
260             char *p;
261
262             instdir = read_w32_registry_string ("HKEY_LOCAL_MACHINE",
263                                                 regkey,
264                                                 "Install Directory");
265             if (!instdir)
266                 return -1;
267             langid = read_w32_registry_string (NULL, /* HKCU then HKLM */
268                                                regkey,
269                                                "Lang");
270             if (!langid) {
271                 free (instdir);
272                 return -1;
273             }
274             /* Strip stuff after a dot in case the user tried to enter
275              * the entire locale synatcs as usual for POSIX. */
276             p = strchr (langid, '.');
277             if (p)
278                 *p = 0;
279                 
280             /* Build the key: "<instdir>/<domain>.nls/<langid>.mo" We
281                use a directory below the installation directory with
282                the domain included in case the software has been
283                insalled with other software altogether at the same
284                place. */
285             fname = malloc (strlen (instdir) + 1 + strlen (filename) + 5
286                             + strlen (langid) + 3 + 1);
287             if (!fname) {
288                 free (instdir);
289                 free (langid);
290                 return -1;
291             }
292             strcpy (stpcpy (stpcpy (stpcpy (stpcpy ( stpcpy (fname,
293                    instdir),"\\"), filename), ".nls\\"), langid), ".mo");
294             free (instdir);
295             free (langid);
296
297             /* Better make sure that we don't mix forward and
298                backward slashes.  It seems that some Windoze
299                versions don't accept this. */
300             for (p=fname; *p; p++) {
301                 if (*p == '/')
302                     *p = '\\';
303             }
304             domain = load_domain (fname);
305             free(fname);
306         }
307
308         if (!domain)
309             return -1;
310     }
311
312     if( the_domain ) {
313         struct overflow_space_s *os, *os2;
314         free( the_domain->data );
315         free( the_domain->mapped );
316         for (os=the_domain->overflow_space; os; os = os2) {
317             os2 = os->next;
318             free (os);
319         }
320         free( the_domain );
321         the_domain = NULL;
322     }
323     the_domain = domain;
324     return 0;
325 }
326
327
328 static const char*
329 get_string( struct loaded_domain *domain, u32 idx )
330 {
331   struct overflow_space_s *os;
332   char *p;
333
334   p = domain->data + SWAPIT(domain->must_swap, domain->trans_tab[idx].offset);
335   if (!domain->mapped[idx]) 
336     {
337       size_t plen, buflen;
338       char *buf;
339
340       domain->mapped[idx] = 1;
341
342       plen = strlen (p);
343       buf = utf8_to_native (p, plen, -1);
344       buflen = strlen (buf);
345       if (buflen <= plen)
346         strcpy (p, buf);
347       else
348         {
349           /* There is not enough space for the translation - store it
350              in the overflow_space else and mark that in the mapped
351              array.  Because we expect that this won't happen too
352              often, we use a simple linked list.  */
353           os = malloc (sizeof *os + buflen);
354           if (os)
355             {
356               os->idx = idx;
357               strcpy (os->d, buf);
358               os->next = domain->overflow_space;
359               domain->overflow_space = os;
360               p = os->d;
361             }
362           else
363             p = "ERROR in GETTEXT MALLOC";
364         }
365       xfree (buf);
366     }
367   else if (domain->mapped[idx] == 2) 
368     { /* We need to get the string from the overflow_space. */
369       for (os=domain->overflow_space; os; os = os->next)
370         if (os->idx == idx)
371           return (const char*)os->d;
372       p = "ERROR in GETTEXT\n";
373     }
374   return (const char*)p;
375 }
376
377
378
379 const char *
380 gettext( const char *msgid )
381 {
382     struct loaded_domain *domain;
383     size_t act = 0;
384     size_t top, bottom;
385
386     if( !(domain = the_domain) )
387         goto not_found;
388
389     /* Locate the MSGID and its translation.  */
390     if( domain->hash_size > 2 && domain->hash_tab ) {
391         /* Use the hashing table.  */
392         u32 len = strlen (msgid);
393         u32 hash_val = hash_string (msgid);
394         u32 idx = hash_val % domain->hash_size;
395         u32 incr = 1 + (hash_val % (domain->hash_size - 2));
396         u32 nstr = SWAPIT (domain->must_swap, domain->hash_tab[idx]);
397
398         if ( !nstr ) /* Hash table entry is empty.  */
399             goto not_found;
400
401         if( SWAPIT(domain->must_swap,
402                     domain->orig_tab[nstr - 1].length) == len
403             && !strcmp( msgid,
404                        domain->data + SWAPIT(domain->must_swap,
405                                     domain->orig_tab[nstr - 1].offset)) )
406             return get_string( domain, nstr - 1 );
407
408         for(;;) {
409             if (idx >= domain->hash_size - incr)
410                 idx -= domain->hash_size - incr;
411             else
412                 idx += incr;
413
414             nstr = SWAPIT(domain->must_swap, domain->hash_tab[idx]);
415             if( !nstr )
416                 goto not_found; /* Hash table entry is empty.  */
417
418             if ( SWAPIT(domain->must_swap,
419                                 domain->orig_tab[nstr - 1].length) == len
420                  && !strcmp (msgid,
421                          domain->data + SWAPIT(domain->must_swap,
422                                            domain->orig_tab[nstr - 1].offset)))
423                 return get_string( domain, nstr-1 );
424         }
425         /* NOTREACHED */
426     }
427
428     /* Now we try the default method:  binary search in the sorted
429        array of messages.  */
430     bottom = 0;
431     top = domain->nstrings;
432     while( bottom < top ) {
433         int cmp_val;
434
435         act = (bottom + top) / 2;
436         cmp_val = strcmp(msgid, domain->data
437                                + SWAPIT(domain->must_swap,
438                                         domain->orig_tab[act].offset));
439         if (cmp_val < 0)
440             top = act;
441         else if (cmp_val > 0)
442             bottom = act + 1;
443         else
444             return get_string( domain, act );
445     }
446
447   not_found:
448     return msgid;
449 }
450
451 #if 0
452        unsigned int cp1, cp2;
453
454        cp1 = GetConsoleCP();
455        cp2 = GetConsoleOutputCP();
456
457        log_info("InputCP=%u  OutputCP=%u\n", cp1, cp2 );
458
459        if( !SetConsoleOutputCP( 1252 ) )
460             log_info("SetConsoleOutputCP failed: %s\n", w32_strerror (0));
461
462        cp1 = GetConsoleCP();
463        cp2 = GetConsoleOutputCP();
464        log_info("InputCP=%u  OutputCP=%u after switch1\n", cp1, cp2 );
465 #endif
466
467 #endif /* USE_SIMPLE_GETTEXT */