1 | /* Generate fastloading iconv module configuration files. |
2 | Copyright (C) 2000-2017 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | Contributed by Ulrich Drepper <drepper@redhat.com>, 2000. |
5 | |
6 | This program is free software; you can redistribute it and/or modify |
7 | it under the terms of the GNU General Public License as published |
8 | by the Free Software Foundation; version 2 of the License, or |
9 | (at your option) any later version. |
10 | |
11 | This program 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 |
14 | GNU General Public License for more details. |
15 | |
16 | You should have received a copy of the GNU General Public License |
17 | along with this program; if not, see <http://www.gnu.org/licenses/>. */ |
18 | |
19 | #include <argp.h> |
20 | #include <assert.h> |
21 | #include <error.h> |
22 | #include <errno.h> |
23 | #include <fcntl.h> |
24 | #include <libintl.h> |
25 | #include <locale.h> |
26 | #include <mcheck.h> |
27 | #include <search.h> |
28 | #include <stdint.h> |
29 | #include <stdbool.h> |
30 | #include <stdio.h> |
31 | #include <stdio_ext.h> |
32 | #include <stdlib.h> |
33 | #include <string.h> |
34 | #include <unistd.h> |
35 | #include <sys/cdefs.h> |
36 | #include <sys/uio.h> |
37 | |
38 | #include "iconvconfig.h" |
39 | |
40 | /* Get libc version number. */ |
41 | #include "../version.h" |
42 | |
43 | #define PACKAGE _libc_intl_domainname |
44 | |
45 | |
46 | /* The hashing function we use. */ |
47 | #include "../intl/hash-string.h" |
48 | |
49 | |
50 | /* Types used. */ |
51 | struct module |
52 | { |
53 | char *fromname; |
54 | struct Strent *fromname_strent; |
55 | char *filename; |
56 | struct Strent *filename_strent; |
57 | const char *directory; |
58 | struct Strent *directory_strent; |
59 | struct module *next; |
60 | int cost; |
61 | struct Strent *toname_strent; |
62 | char toname[0]; |
63 | }; |
64 | |
65 | struct alias |
66 | { |
67 | char *fromname; |
68 | struct Strent *froment; |
69 | struct module *module; |
70 | struct Strent *toent; |
71 | char toname[0]; |
72 | }; |
73 | |
74 | struct name |
75 | { |
76 | const char *name; |
77 | struct Strent *strent; |
78 | int module_idx; |
79 | uint32_t hashval; |
80 | }; |
81 | |
82 | struct name_info |
83 | { |
84 | const char *canonical_name; |
85 | struct Strent *canonical_strent; |
86 | |
87 | struct module *from_internal; |
88 | struct module *to_internal; |
89 | |
90 | struct other_conv_list |
91 | { |
92 | int dest_idx; |
93 | struct other_conv |
94 | { |
95 | gidx_t module_idx; |
96 | struct module *module; |
97 | struct other_conv *next; |
98 | } other_conv; |
99 | struct other_conv_list *next; |
100 | } *other_conv_list; |
101 | }; |
102 | |
103 | |
104 | /* Name and version of program. */ |
105 | static void print_version (FILE *stream, struct argp_state *state); |
106 | void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; |
107 | |
108 | /* Short description of program. */ |
109 | static const char doc[] = N_("\ |
110 | Create fastloading iconv module configuration file." ); |
111 | |
112 | /* Strings for arguments in help texts. */ |
113 | static const char args_doc[] = N_("[DIR...]" ); |
114 | |
115 | /* Prototype for option handler. */ |
116 | static error_t parse_opt (int key, char *arg, struct argp_state *state); |
117 | |
118 | /* Function to print some extra text in the help message. */ |
119 | static char *more_help (int key, const char *text, void *input); |
120 | |
121 | /* Definitions of arguments for argp functions. */ |
122 | #define OPT_PREFIX 300 |
123 | #define OPT_NOSTDLIB 301 |
124 | static const struct argp_option options[] = |
125 | { |
126 | { "prefix" , OPT_PREFIX, N_("PATH" ), 0, |
127 | N_("Prefix used for all file accesses" ) }, |
128 | { "output" , 'o', N_("FILE" ), 0, N_("\ |
129 | Put output in FILE instead of installed location\ |
130 | (--prefix does not apply to FILE)" ) }, |
131 | { "nostdlib" , OPT_NOSTDLIB, NULL, 0, |
132 | N_("Do not search standard directories, only those on the command line" ) }, |
133 | { NULL, 0, NULL, 0, NULL } |
134 | }; |
135 | |
136 | /* Data structure to communicate with argp functions. */ |
137 | static struct argp argp = |
138 | { |
139 | options, parse_opt, args_doc, doc, NULL, more_help |
140 | }; |
141 | |
142 | |
143 | /* The function doing the actual work. */ |
144 | static int handle_dir (const char *dir); |
145 | |
146 | /* Add all known builtin conversions and aliases. */ |
147 | static void add_builtins (void); |
148 | |
149 | /* Create list of all aliases without circular aliases. */ |
150 | static void get_aliases (void); |
151 | |
152 | /* Create list of all modules. */ |
153 | static void get_modules (void); |
154 | |
155 | /* Get list of all the names and thereby indexing them. */ |
156 | static void generate_name_list (void); |
157 | |
158 | /* Collect information about all the names. */ |
159 | static void generate_name_info (void); |
160 | |
161 | /* Write the output file. */ |
162 | static int write_output (void); |
163 | |
164 | |
165 | /* Prefix to be used for all file accesses. */ |
166 | static const char *prefix = "" ; |
167 | /* Its length. */ |
168 | static size_t prefix_len; |
169 | |
170 | /* Directory to place output file in. */ |
171 | static const char *output_file; |
172 | /* Its length. */ |
173 | static size_t output_file_len; |
174 | |
175 | /* If true, omit the GCONV_PATH directories and require some arguments. */ |
176 | static bool nostdlib; |
177 | |
178 | /* Search tree of the modules we know. */ |
179 | static void *modules; |
180 | |
181 | /* Search tree of the aliases we know. */ |
182 | static void *aliases; |
183 | |
184 | /* Search tree for name to index mapping. */ |
185 | static void *names; |
186 | |
187 | /* Number of names we know about. */ |
188 | static int nnames; |
189 | |
190 | /* List of all aliases. */ |
191 | static struct alias **alias_list; |
192 | static size_t nalias_list; |
193 | static size_t nalias_list_max; |
194 | |
195 | /* List of all modules. */ |
196 | static struct module **module_list; |
197 | static size_t nmodule_list; |
198 | static size_t nmodule_list_max; |
199 | |
200 | /* Names and information about them. */ |
201 | static struct name_info *name_info; |
202 | static size_t nname_info; |
203 | |
204 | /* Number of translations not from or to INTERNAL. */ |
205 | static size_t ; |
206 | |
207 | |
208 | /* Names and aliases for the builtin transformations. */ |
209 | static struct |
210 | { |
211 | const char *from; |
212 | const char *to; |
213 | } builtin_alias[] = |
214 | { |
215 | #define BUILTIN_ALIAS(alias, real) \ |
216 | { .from = alias, .to = real }, |
217 | #define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, BtowcFct, \ |
218 | MinF, MaxF, MinT, MaxT) |
219 | #include <gconv_builtin.h> |
220 | }; |
221 | #undef BUILTIN_ALIAS |
222 | #undef BUILTIN_TRANSFORMATION |
223 | #define nbuiltin_alias (sizeof (builtin_alias) / sizeof (builtin_alias[0])) |
224 | |
225 | static struct |
226 | { |
227 | const char *from; |
228 | const char *to; |
229 | const char *module; |
230 | int cost; |
231 | } builtin_trans[] = |
232 | { |
233 | #define BUILTIN_ALIAS(alias, real) |
234 | #define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, BtowcFct, \ |
235 | MinF, MaxF, MinT, MaxT) \ |
236 | { .from = From, .to = To, .module = Name, .cost = Cost }, |
237 | #include <gconv_builtin.h> |
238 | }; |
239 | #undef BUILTIN_ALIAS |
240 | #undef BUILTIN_TRANSFORMATION |
241 | #define nbuiltin_trans (sizeof (builtin_trans) / sizeof (builtin_trans[0])) |
242 | |
243 | |
244 | /* Filename extension for the modules. */ |
245 | #ifndef MODULE_EXT |
246 | # define MODULE_EXT ".so" |
247 | #endif |
248 | static const char gconv_module_ext[] = MODULE_EXT; |
249 | |
250 | |
251 | #include <programs/xmalloc.h> |
252 | |
253 | |
254 | /* C string table handling. */ |
255 | struct Strtab; |
256 | struct Strent; |
257 | |
258 | /* Create new C string table object in memory. */ |
259 | extern struct Strtab *strtabinit (void); |
260 | |
261 | /* Free resources allocated for C string table ST. */ |
262 | extern void strtabfree (struct Strtab *st); |
263 | |
264 | /* Add string STR (length LEN is != 0) to C string table ST. */ |
265 | extern struct Strent *strtabadd (struct Strtab *st, const char *str, |
266 | size_t len); |
267 | |
268 | /* Finalize string table ST and store size in *SIZE and return a pointer. */ |
269 | extern void *strtabfinalize (struct Strtab *st, size_t *size); |
270 | |
271 | /* Get offset in string table for string associated with SE. */ |
272 | extern size_t strtaboffset (struct Strent *se); |
273 | |
274 | /* String table we construct. */ |
275 | static struct Strtab *strtab; |
276 | |
277 | |
278 | |
279 | int |
280 | main (int argc, char *argv[]) |
281 | { |
282 | int remaining; |
283 | int status = 0; |
284 | |
285 | /* Enable memory use testing. */ |
286 | /* mcheck_pedantic (NULL); */ |
287 | mtrace (); |
288 | |
289 | /* Set locale via LC_ALL. */ |
290 | setlocale (LC_ALL, "" ); |
291 | |
292 | /* Set the text message domain. */ |
293 | textdomain (_libc_intl_domainname); |
294 | |
295 | /* Parse and process arguments. */ |
296 | argp_parse (&argp, argc, argv, 0, &remaining, NULL); |
297 | |
298 | if (nostdlib && remaining == argc) |
299 | error (2, 0, _("Directory arguments required when using --nostdlib" )); |
300 | |
301 | /* Initialize the string table. */ |
302 | strtab = strtabinit (); |
303 | |
304 | /* Handle all directories mentioned. */ |
305 | while (remaining < argc) |
306 | status |= handle_dir (argv[remaining++]); |
307 | |
308 | if (! nostdlib) |
309 | { |
310 | /* In any case also handle the standard directory. */ |
311 | char *path = strdupa (GCONV_PATH), *tp = strsep (&path, ":" ); |
312 | while (tp != NULL) |
313 | { |
314 | status |= handle_dir (tp); |
315 | |
316 | tp = strsep (&path, ":" ); |
317 | } |
318 | } |
319 | |
320 | /* Add the builtin transformations and aliases without overwriting |
321 | anything. */ |
322 | add_builtins (); |
323 | |
324 | /* Store aliases in an array. */ |
325 | get_aliases (); |
326 | |
327 | /* Get list of all modules. */ |
328 | get_modules (); |
329 | |
330 | /* Generate list of all the names we know to handle in some way. */ |
331 | generate_name_list (); |
332 | |
333 | /* Now we know all the names we will handle, collect information |
334 | about them. */ |
335 | generate_name_info (); |
336 | |
337 | /* Write the output file, but only if we haven't seen any error. */ |
338 | if (status == 0) |
339 | status = write_output (); |
340 | else |
341 | error (1, 0, _("no output file produced because warnings were issued" )); |
342 | |
343 | return status; |
344 | } |
345 | |
346 | |
347 | /* Handle program arguments. */ |
348 | static error_t |
349 | parse_opt (int key, char *arg, struct argp_state *state) |
350 | { |
351 | switch (key) |
352 | { |
353 | case OPT_PREFIX: |
354 | prefix = arg; |
355 | prefix_len = strlen (prefix); |
356 | break; |
357 | case 'o': |
358 | output_file = arg; |
359 | output_file_len = strlen (output_file); |
360 | break; |
361 | case OPT_NOSTDLIB: |
362 | nostdlib = true; |
363 | break; |
364 | default: |
365 | return ARGP_ERR_UNKNOWN; |
366 | } |
367 | return 0; |
368 | } |
369 | |
370 | |
371 | static char * |
372 | more_help (int key, const char *text, void *input) |
373 | { |
374 | char *tp = NULL; |
375 | switch (key) |
376 | { |
377 | case ARGP_KEY_HELP_EXTRA: |
378 | /* We print some extra information. */ |
379 | if (asprintf (&tp, gettext ("\ |
380 | For bug reporting instructions, please see:\n\ |
381 | %s.\n" ), REPORT_BUGS_TO) < 0) |
382 | return NULL; |
383 | return tp; |
384 | default: |
385 | break; |
386 | } |
387 | return (char *) text; |
388 | } |
389 | |
390 | |
391 | /* Print the version information. */ |
392 | static void |
393 | print_version (FILE *stream, struct argp_state *state) |
394 | { |
395 | fprintf (stream, "iconvconfig %s%s\n" , PKGVERSION, VERSION); |
396 | fprintf (stream, gettext ("\ |
397 | Copyright (C) %s Free Software Foundation, Inc.\n\ |
398 | This is free software; see the source for copying conditions. There is NO\n\ |
399 | warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ |
400 | " ), "2017" ); |
401 | fprintf (stream, gettext ("Written by %s.\n" ), "Ulrich Drepper" ); |
402 | } |
403 | |
404 | |
405 | static int |
406 | alias_compare (const void *p1, const void *p2) |
407 | { |
408 | const struct alias *a1 = (const struct alias *) p1; |
409 | const struct alias *a2 = (const struct alias *) p2; |
410 | |
411 | return strcmp (a1->fromname, a2->fromname); |
412 | } |
413 | |
414 | |
415 | static void |
416 | new_alias (const char *fromname, size_t fromlen, const char *toname, |
417 | size_t tolen) |
418 | { |
419 | struct alias *newp; |
420 | void **inserted; |
421 | |
422 | newp = (struct alias *) xmalloc (sizeof (struct alias) + fromlen + tolen); |
423 | |
424 | newp->fromname = mempcpy (newp->toname, toname, tolen); |
425 | memcpy (newp->fromname, fromname, fromlen); |
426 | newp->module = NULL; |
427 | |
428 | inserted = (void **) tsearch (newp, &aliases, alias_compare); |
429 | if (inserted == NULL) |
430 | error (EXIT_FAILURE, errno, gettext ("while inserting in search tree" )); |
431 | if (*inserted != newp) |
432 | /* Something went wrong, free this entry. */ |
433 | free (newp); |
434 | else |
435 | { |
436 | newp->froment = strtabadd (strtab, newp->fromname, fromlen); |
437 | newp->toent = strtabadd (strtab, newp->toname, tolen); |
438 | } |
439 | } |
440 | |
441 | |
442 | /* Add new alias. */ |
443 | static void |
444 | add_alias (char *rp) |
445 | { |
446 | /* We now expect two more string. The strings are normalized |
447 | (converted to UPPER case) and strored in the alias database. */ |
448 | char *from; |
449 | char *to; |
450 | char *wp; |
451 | |
452 | while (isspace (*rp)) |
453 | ++rp; |
454 | from = wp = rp; |
455 | while (*rp != '\0' && !isspace (*rp)) |
456 | *wp++ = toupper (*rp++); |
457 | if (*rp == '\0') |
458 | /* There is no `to' string on the line. Ignore it. */ |
459 | return; |
460 | *wp++ = '\0'; |
461 | to = ++rp; |
462 | while (isspace (*rp)) |
463 | ++rp; |
464 | while (*rp != '\0' && !isspace (*rp)) |
465 | *wp++ = toupper (*rp++); |
466 | if (to == wp) |
467 | /* No `to' string, ignore the line. */ |
468 | return; |
469 | *wp++ = '\0'; |
470 | |
471 | assert (strlen (from) + 1 == (size_t) (to - from)); |
472 | assert (strlen (to) + 1 == (size_t) (wp - to)); |
473 | |
474 | new_alias (from, to - from, to, wp - to); |
475 | } |
476 | |
477 | |
478 | static void |
479 | append_alias (const void *nodep, VISIT value, int level) |
480 | { |
481 | if (value != leaf && value != postorder) |
482 | return; |
483 | |
484 | if (nalias_list_max == nalias_list) |
485 | { |
486 | nalias_list_max += 50; |
487 | alias_list = (struct alias **) xrealloc (alias_list, |
488 | (nalias_list_max |
489 | * sizeof (struct alias *))); |
490 | } |
491 | |
492 | alias_list[nalias_list++] = *(struct alias **) nodep; |
493 | } |
494 | |
495 | |
496 | static void |
497 | get_aliases (void) |
498 | { |
499 | twalk (aliases, append_alias); |
500 | } |
501 | |
502 | |
503 | static int |
504 | module_compare (const void *p1, const void *p2) |
505 | { |
506 | const struct module *m1 = (const struct module *) p1; |
507 | const struct module *m2 = (const struct module *) p2; |
508 | int result; |
509 | |
510 | result = strcmp (m1->fromname, m2->fromname); |
511 | if (result == 0) |
512 | result = strcmp (m1->toname, m2->toname); |
513 | |
514 | return result; |
515 | } |
516 | |
517 | |
518 | /* Create new module record. */ |
519 | static void |
520 | new_module (const char *fromname, size_t fromlen, const char *toname, |
521 | size_t tolen, const char *directory, |
522 | const char *filename, size_t filelen, int cost, size_t need_ext) |
523 | { |
524 | struct module *new_module; |
525 | size_t dirlen = strlen (directory) + 1; |
526 | char *tmp; |
527 | void **inserted; |
528 | |
529 | new_module = (struct module *) xmalloc (sizeof (struct module) |
530 | + fromlen + tolen + filelen |
531 | + need_ext); |
532 | |
533 | new_module->fromname = mempcpy (new_module->toname, toname, tolen); |
534 | |
535 | new_module->filename = mempcpy (new_module->fromname, fromname, fromlen); |
536 | |
537 | new_module->cost = cost; |
538 | new_module->next = NULL; |
539 | |
540 | tmp = mempcpy (new_module->filename, filename, filelen); |
541 | if (need_ext) |
542 | { |
543 | memcpy (tmp - 1, gconv_module_ext, need_ext + 1); |
544 | filelen += need_ext; |
545 | } |
546 | new_module->directory = directory; |
547 | |
548 | /* Now insert the new module data structure in our search tree. */ |
549 | inserted = (void **) tsearch (new_module, &modules, module_compare); |
550 | if (inserted == NULL) |
551 | error (EXIT_FAILURE, errno, "while inserting in search tree" ); |
552 | if (*inserted != new_module) |
553 | free (new_module); |
554 | else |
555 | { |
556 | new_module->fromname_strent = strtabadd (strtab, new_module->fromname, |
557 | fromlen); |
558 | new_module->toname_strent = strtabadd (strtab, new_module->toname, |
559 | tolen); |
560 | new_module->filename_strent = strtabadd (strtab, new_module->filename, |
561 | filelen); |
562 | new_module->directory_strent = strtabadd (strtab, directory, dirlen); |
563 | } |
564 | } |
565 | |
566 | |
567 | /* Add new module. */ |
568 | static void |
569 | internal_function |
570 | add_module (char *rp, const char *directory) |
571 | { |
572 | /* We expect now |
573 | 1. `from' name |
574 | 2. `to' name |
575 | 3. filename of the module |
576 | 4. an optional cost value |
577 | */ |
578 | char *from; |
579 | char *to; |
580 | char *module; |
581 | char *wp; |
582 | int need_ext; |
583 | int cost; |
584 | |
585 | while (isspace (*rp)) |
586 | ++rp; |
587 | from = rp; |
588 | while (*rp != '\0' && !isspace (*rp)) |
589 | { |
590 | *rp = toupper (*rp); |
591 | ++rp; |
592 | } |
593 | if (*rp == '\0') |
594 | return; |
595 | *rp++ = '\0'; |
596 | to = wp = rp; |
597 | while (isspace (*rp)) |
598 | ++rp; |
599 | while (*rp != '\0' && !isspace (*rp)) |
600 | *wp++ = toupper (*rp++); |
601 | if (*rp == '\0') |
602 | return; |
603 | *wp++ = '\0'; |
604 | do |
605 | ++rp; |
606 | while (isspace (*rp)); |
607 | module = wp; |
608 | while (*rp != '\0' && !isspace (*rp)) |
609 | *wp++ = *rp++; |
610 | if (*rp == '\0') |
611 | { |
612 | /* There is no cost, use one by default. */ |
613 | *wp++ = '\0'; |
614 | cost = 1; |
615 | } |
616 | else |
617 | { |
618 | /* There might be a cost value. */ |
619 | char *endp; |
620 | |
621 | *wp++ = '\0'; |
622 | cost = strtol (rp, &endp, 10); |
623 | if (rp == endp || cost < 1) |
624 | /* No useful information. */ |
625 | cost = 1; |
626 | } |
627 | |
628 | if (module[0] == '\0') |
629 | /* No module name given. */ |
630 | return; |
631 | |
632 | /* See whether we must add the ending. */ |
633 | need_ext = 0; |
634 | if ((size_t) (wp - module) < sizeof (gconv_module_ext) |
635 | || memcmp (wp - sizeof (gconv_module_ext), gconv_module_ext, |
636 | sizeof (gconv_module_ext)) != 0) |
637 | /* We must add the module extension. */ |
638 | need_ext = sizeof (gconv_module_ext) - 1; |
639 | |
640 | assert (strlen (from) + 1 == (size_t) (to - from)); |
641 | assert (strlen (to) + 1 == (size_t) (module - to)); |
642 | assert (strlen (module) + 1 == (size_t) (wp - module)); |
643 | |
644 | new_module (from, to - from, to, module - to, directory, module, wp - module, |
645 | cost, need_ext); |
646 | } |
647 | |
648 | |
649 | /* Read the config file and add the data for this directory to that. */ |
650 | static int |
651 | handle_dir (const char *dir) |
652 | { |
653 | char *cp; |
654 | FILE *fp; |
655 | char *line = NULL; |
656 | size_t linelen = 0; |
657 | size_t dirlen = strlen (dir); |
658 | |
659 | if (dir[dirlen - 1] != '/') |
660 | { |
661 | char *newp = (char *) xmalloc (dirlen + 2); |
662 | dir = memcpy (newp, dir, dirlen); |
663 | newp[dirlen++] = '/'; |
664 | newp[dirlen] = '\0'; |
665 | } |
666 | |
667 | char infile[prefix_len + dirlen + sizeof "gconv-modules" ]; |
668 | cp = infile; |
669 | if (dir[0] == '/') |
670 | cp = mempcpy (cp, prefix, prefix_len); |
671 | strcpy (mempcpy (cp, dir, dirlen), "gconv-modules" ); |
672 | |
673 | fp = fopen (infile, "r" ); |
674 | if (fp == NULL) |
675 | { |
676 | error (0, errno, "cannot open `%s'" , infile); |
677 | return 1; |
678 | } |
679 | |
680 | /* No threads present. */ |
681 | __fsetlocking (fp, FSETLOCKING_BYCALLER); |
682 | |
683 | while (!feof_unlocked (fp)) |
684 | { |
685 | char *rp, *endp, *word; |
686 | ssize_t n = __getdelim (&line, &linelen, '\n', fp); |
687 | |
688 | if (n < 0) |
689 | /* An error occurred. */ |
690 | break; |
691 | |
692 | rp = line; |
693 | /* Terminate the line (excluding comments or newline) with a NUL |
694 | byte to simplify the following code. */ |
695 | endp = strchr (rp, '#'); |
696 | if (endp != NULL) |
697 | *endp = '\0'; |
698 | else |
699 | if (rp[n - 1] == '\n') |
700 | rp[n - 1] = '\0'; |
701 | |
702 | while (isspace (*rp)) |
703 | ++rp; |
704 | |
705 | /* If this is an empty line go on with the next one. */ |
706 | if (rp == endp) |
707 | continue; |
708 | |
709 | word = rp; |
710 | while (*rp != '\0' && !isspace (*rp)) |
711 | ++rp; |
712 | |
713 | if (rp - word == sizeof ("alias" ) - 1 |
714 | && memcmp (word, "alias" , sizeof ("alias" ) - 1) == 0) |
715 | add_alias (rp); |
716 | else if (rp - word == sizeof ("module" ) - 1 |
717 | && memcmp (word, "module" , sizeof ("module" ) - 1) == 0) |
718 | add_module (rp, dir); |
719 | /* else */ |
720 | /* Otherwise ignore the line. */ |
721 | } |
722 | |
723 | free (line); |
724 | |
725 | fclose (fp); |
726 | |
727 | return 0; |
728 | } |
729 | |
730 | |
731 | static void |
732 | append_module (const void *nodep, VISIT value, int level) |
733 | { |
734 | struct module *mo; |
735 | |
736 | if (value != leaf && value != postorder) |
737 | return; |
738 | |
739 | mo = *(struct module **) nodep; |
740 | |
741 | if (nmodule_list > 0 |
742 | && strcmp (module_list[nmodule_list - 1]->fromname, mo->fromname) == 0) |
743 | { |
744 | /* Same name. */ |
745 | mo->next = module_list[nmodule_list - 1]; |
746 | module_list[nmodule_list - 1] = mo; |
747 | |
748 | return; |
749 | } |
750 | |
751 | if (nmodule_list_max == nmodule_list) |
752 | { |
753 | nmodule_list_max += 50; |
754 | module_list = (struct module **) xrealloc (module_list, |
755 | (nmodule_list_max |
756 | * sizeof (struct module *))); |
757 | } |
758 | |
759 | module_list[nmodule_list++] = mo; |
760 | } |
761 | |
762 | |
763 | static void |
764 | get_modules (void) |
765 | { |
766 | twalk (modules, append_module); |
767 | } |
768 | |
769 | |
770 | static void |
771 | add_builtins (void) |
772 | { |
773 | size_t cnt; |
774 | |
775 | /* Add all aliases. */ |
776 | for (cnt = 0; cnt < nbuiltin_alias; ++cnt) |
777 | new_alias (builtin_alias[cnt].from, |
778 | strlen (builtin_alias[cnt].from) + 1, |
779 | builtin_alias[cnt].to, |
780 | strlen (builtin_alias[cnt].to) + 1); |
781 | |
782 | /* add the builtin transformations. */ |
783 | for (cnt = 0; cnt < nbuiltin_trans; ++cnt) |
784 | new_module (builtin_trans[cnt].from, |
785 | strlen (builtin_trans[cnt].from) + 1, |
786 | builtin_trans[cnt].to, |
787 | strlen (builtin_trans[cnt].to) + 1, |
788 | "" , builtin_trans[cnt].module, |
789 | strlen (builtin_trans[cnt].module) + 1, |
790 | builtin_trans[cnt].cost, 0); |
791 | } |
792 | |
793 | |
794 | static int |
795 | name_compare (const void *p1, const void *p2) |
796 | { |
797 | const struct name *n1 = (const struct name *) p1; |
798 | const struct name *n2 = (const struct name *) p2; |
799 | |
800 | return strcmp (n1->name, n2->name); |
801 | } |
802 | |
803 | |
804 | static struct name * |
805 | new_name (const char *str, struct Strent *strent) |
806 | { |
807 | struct name *newp = (struct name *) xmalloc (sizeof (struct name)); |
808 | |
809 | newp->name = str; |
810 | newp->strent = strent; |
811 | newp->module_idx = -1; |
812 | newp->hashval = __hash_string (str); |
813 | |
814 | ++nnames; |
815 | |
816 | return newp; |
817 | } |
818 | |
819 | |
820 | static void |
821 | generate_name_list (void) |
822 | { |
823 | size_t i; |
824 | |
825 | /* A name we always need. */ |
826 | tsearch (new_name ("INTERNAL" , strtabadd (strtab, "INTERNAL" , |
827 | sizeof ("INTERNAL" ))), |
828 | &names, name_compare); |
829 | |
830 | for (i = 0; i < nmodule_list; ++i) |
831 | { |
832 | struct module *runp; |
833 | |
834 | if (strcmp (module_list[i]->fromname, "INTERNAL" ) != 0) |
835 | tsearch (new_name (module_list[i]->fromname, |
836 | module_list[i]->fromname_strent), |
837 | &names, name_compare); |
838 | |
839 | for (runp = module_list[i]; runp != NULL; runp = runp->next) |
840 | if (strcmp (runp->toname, "INTERNAL" ) != 0) |
841 | tsearch (new_name (runp->toname, runp->toname_strent), |
842 | &names, name_compare); |
843 | } |
844 | } |
845 | |
846 | |
847 | static int |
848 | name_to_module_idx (const char *name, int add) |
849 | { |
850 | struct name **res; |
851 | struct name fake_name = { .name = name }; |
852 | int idx; |
853 | |
854 | res = (struct name **) tfind (&fake_name, &names, name_compare); |
855 | if (res == NULL) |
856 | abort (); |
857 | |
858 | idx = (*res)->module_idx; |
859 | if (idx == -1 && add) |
860 | /* No module index assigned yet. */ |
861 | idx = (*res)->module_idx = nname_info++; |
862 | |
863 | return idx; |
864 | } |
865 | |
866 | |
867 | static void |
868 | generate_name_info (void) |
869 | { |
870 | size_t i; |
871 | int idx; |
872 | |
873 | name_info = (struct name_info *) xcalloc (nmodule_list + 1, |
874 | sizeof (struct name_info)); |
875 | |
876 | /* First add a special entry for the INTERNAL name. This must have |
877 | index zero. */ |
878 | idx = name_to_module_idx ("INTERNAL" , 1); |
879 | name_info[0].canonical_name = "INTERNAL" ; |
880 | name_info[0].canonical_strent = strtabadd (strtab, "INTERNAL" , |
881 | sizeof ("INTERNAL" )); |
882 | assert (nname_info == 1); |
883 | |
884 | for (i = 0; i < nmodule_list; ++i) |
885 | { |
886 | struct module *runp; |
887 | |
888 | for (runp = module_list[i]; runp != NULL; runp = runp->next) |
889 | if (strcmp (runp->fromname, "INTERNAL" ) == 0) |
890 | { |
891 | idx = name_to_module_idx (runp->toname, 1); |
892 | name_info[idx].from_internal = runp; |
893 | assert (name_info[idx].canonical_name == NULL |
894 | || strcmp (name_info[idx].canonical_name, |
895 | runp->toname) == 0); |
896 | name_info[idx].canonical_name = runp->toname; |
897 | name_info[idx].canonical_strent = runp->toname_strent; |
898 | } |
899 | else if (strcmp (runp->toname, "INTERNAL" ) == 0) |
900 | { |
901 | idx = name_to_module_idx (runp->fromname, 1); |
902 | name_info[idx].to_internal = runp; |
903 | assert (name_info[idx].canonical_name == NULL |
904 | || strcmp (name_info[idx].canonical_name, |
905 | runp->fromname) == 0); |
906 | name_info[idx].canonical_name = runp->fromname; |
907 | name_info[idx].canonical_strent = runp->fromname_strent; |
908 | } |
909 | else |
910 | { |
911 | /* This is a transformation not to or from the INTERNAL |
912 | encoding. */ |
913 | int from_idx = name_to_module_idx (runp->fromname, 1); |
914 | int to_idx = name_to_module_idx (runp->toname, 1); |
915 | struct other_conv_list *newp; |
916 | |
917 | newp = (struct other_conv_list *) |
918 | xmalloc (sizeof (struct other_conv_list)); |
919 | newp->other_conv.module_idx = to_idx; |
920 | newp->other_conv.module = runp; |
921 | newp->other_conv.next = NULL; /* XXX Allow multiple module sequence */ |
922 | newp->dest_idx = to_idx; |
923 | newp->next = name_info[from_idx].other_conv_list; |
924 | name_info[from_idx].other_conv_list = newp; |
925 | assert (name_info[from_idx].canonical_name == NULL |
926 | || strcmp (name_info[from_idx].canonical_name, |
927 | runp->fromname) == 0); |
928 | name_info[from_idx].canonical_name = runp->fromname; |
929 | name_info[from_idx].canonical_strent = runp->fromname_strent; |
930 | |
931 | ++nextra_modules; |
932 | } |
933 | } |
934 | |
935 | /* Now add the module index information for all the aliases. */ |
936 | for (i = 0; i < nalias_list; ++i) |
937 | { |
938 | struct name fake_name = { .name = alias_list[i]->toname }; |
939 | struct name **tonamep; |
940 | |
941 | tonamep = (struct name **) tfind (&fake_name, &names, name_compare); |
942 | if (tonamep != NULL) |
943 | { |
944 | struct name *newp = new_name (alias_list[i]->fromname, |
945 | alias_list[i]->froment); |
946 | newp->module_idx = (*tonamep)->module_idx; |
947 | tsearch (newp, &names, name_compare); |
948 | } |
949 | } |
950 | } |
951 | |
952 | |
953 | static int |
954 | is_prime (unsigned long int candidate) |
955 | { |
956 | /* No even number and none less than 10 will be passed here. */ |
957 | unsigned long int divn = 3; |
958 | unsigned long int sq = divn * divn; |
959 | |
960 | while (sq < candidate && candidate % divn != 0) |
961 | { |
962 | ++divn; |
963 | sq += 4 * divn; |
964 | ++divn; |
965 | } |
966 | |
967 | return candidate % divn != 0; |
968 | } |
969 | |
970 | |
971 | static uint32_t |
972 | next_prime (uint32_t seed) |
973 | { |
974 | /* Make it definitely odd. */ |
975 | seed |= 1; |
976 | |
977 | while (!is_prime (seed)) |
978 | seed += 2; |
979 | |
980 | return seed; |
981 | } |
982 | |
983 | |
984 | /* Format of the output file. |
985 | |
986 | Offset Length Description |
987 | 0000 4 Magic header bytes |
988 | 0004 2 Offset of string table (stoff) |
989 | 0006 2 Offset of name hashing table (hoff) |
990 | 0008 2 Hashing table size (hsize) |
991 | 000A 2 Offset of module table (moff) |
992 | 000C 2 Offset of other conversion module table (ooff) |
993 | |
994 | stoff ??? String table |
995 | |
996 | hoff 8*hsize Array of tuples |
997 | string table offset |
998 | module index |
999 | |
1000 | moff ??? Array of tuples |
1001 | canonical name offset |
1002 | from-internal module dir name offset |
1003 | from-internal module name off |
1004 | to-internal module dir name offset |
1005 | to-internal module name offset |
1006 | offset into other conversion table |
1007 | |
1008 | ooff ??? One or more of |
1009 | number of steps/modules |
1010 | one or more of tuple |
1011 | canonical name offset for output |
1012 | module dir name offset |
1013 | module name offset |
1014 | (following last entry with step count 0) |
1015 | */ |
1016 | |
1017 | static struct hash_entry *hash_table; |
1018 | static size_t hash_size; |
1019 | |
1020 | /* Function to insert the names. */ |
1021 | static void name_insert (const void *nodep, VISIT value, int level) |
1022 | { |
1023 | struct name *name; |
1024 | unsigned int idx; |
1025 | unsigned int hval2; |
1026 | |
1027 | if (value != leaf && value != postorder) |
1028 | return; |
1029 | |
1030 | name = *(struct name **) nodep; |
1031 | idx = name->hashval % hash_size; |
1032 | hval2 = 1 + name->hashval % (hash_size - 2); |
1033 | |
1034 | while (hash_table[idx].string_offset != 0) |
1035 | if ((idx += hval2) >= hash_size) |
1036 | idx -= hash_size; |
1037 | |
1038 | hash_table[idx].string_offset = strtaboffset (name->strent); |
1039 | |
1040 | assert (name->module_idx != -1); |
1041 | hash_table[idx].module_idx = name->module_idx; |
1042 | } |
1043 | |
1044 | static int |
1045 | write_output (void) |
1046 | { |
1047 | int fd; |
1048 | char *string_table; |
1049 | size_t string_table_size; |
1050 | struct gconvcache_header ; |
1051 | struct module_entry *module_table; |
1052 | char *; |
1053 | char *; |
1054 | size_t n; |
1055 | int idx; |
1056 | struct iovec iov[6]; |
1057 | static const gidx_t null_word; |
1058 | size_t total; |
1059 | char finalname[prefix_len + sizeof GCONV_MODULES_CACHE]; |
1060 | char tmpfname[(output_file == NULL ? sizeof finalname : output_file_len + 1) |
1061 | + strlen (".XXXXXX" )]; |
1062 | |
1063 | /* Open the output file. */ |
1064 | if (output_file == NULL) |
1065 | { |
1066 | assert (GCONV_MODULES_CACHE[0] == '/'); |
1067 | strcpy (stpcpy (mempcpy (tmpfname, prefix, prefix_len), |
1068 | GCONV_MODULES_CACHE), |
1069 | ".XXXXXX" ); |
1070 | strcpy (mempcpy (finalname, prefix, prefix_len), GCONV_MODULES_CACHE); |
1071 | } |
1072 | else |
1073 | strcpy (mempcpy (tmpfname, output_file, output_file_len), ".XXXXXX" ); |
1074 | fd = mkstemp (tmpfname); |
1075 | if (fd == -1) |
1076 | return 1; |
1077 | |
1078 | /* Create the string table. */ |
1079 | string_table = strtabfinalize (strtab, &string_table_size); |
1080 | |
1081 | /* Create the hashing table. We know how many strings we have. |
1082 | Creating a perfect hash table is not reasonable here. Therefore |
1083 | we use open hashing and a table size which is the next prime 40% |
1084 | larger than the number of strings. */ |
1085 | hash_size = next_prime (nnames * 1.4); |
1086 | hash_table = (struct hash_entry *) xcalloc (hash_size, |
1087 | sizeof (struct hash_entry)); |
1088 | /* Fill the hash table. */ |
1089 | twalk (names, name_insert); |
1090 | |
1091 | /* Create the section for the module list. */ |
1092 | module_table = (struct module_entry *) xcalloc (sizeof (struct module_entry), |
1093 | nname_info); |
1094 | |
1095 | /* Allocate memory for the non-INTERNAL conversions. The allocated |
1096 | memory can be more than is actually needed. */ |
1097 | extra_table = (char *) xcalloc (sizeof (struct extra_entry) |
1098 | + sizeof (gidx_t) |
1099 | + sizeof (struct extra_entry_module), |
1100 | nextra_modules); |
1101 | cur_extra_table = extra_table; |
1102 | |
1103 | /* Fill in the module information. */ |
1104 | for (n = 0; n < nname_info; ++n) |
1105 | { |
1106 | module_table[n].canonname_offset = |
1107 | strtaboffset (name_info[n].canonical_strent); |
1108 | |
1109 | if (name_info[n].from_internal == NULL) |
1110 | { |
1111 | module_table[n].fromdir_offset = 0; |
1112 | module_table[n].fromname_offset = 0; |
1113 | } |
1114 | else |
1115 | { |
1116 | module_table[n].fromdir_offset = |
1117 | strtaboffset (name_info[n].from_internal->directory_strent); |
1118 | module_table[n].fromname_offset = |
1119 | strtaboffset (name_info[n].from_internal->filename_strent); |
1120 | } |
1121 | |
1122 | if (name_info[n].to_internal == NULL) |
1123 | { |
1124 | module_table[n].todir_offset = 0; |
1125 | module_table[n].toname_offset = 0; |
1126 | } |
1127 | else |
1128 | { |
1129 | module_table[n].todir_offset = |
1130 | strtaboffset (name_info[n].to_internal->directory_strent); |
1131 | module_table[n].toname_offset = |
1132 | strtaboffset (name_info[n].to_internal->filename_strent); |
1133 | } |
1134 | |
1135 | if (name_info[n].other_conv_list != NULL) |
1136 | { |
1137 | struct other_conv_list *other = name_info[n].other_conv_list; |
1138 | |
1139 | /* Store the reference. We add 1 to distinguish the entry |
1140 | at offset zero from the case where no extra modules are |
1141 | available. The file reader has to account for the |
1142 | offset. */ |
1143 | module_table[n].extra_offset = 1 + cur_extra_table - extra_table; |
1144 | |
1145 | do |
1146 | { |
1147 | struct other_conv *runp; |
1148 | struct extra_entry *; |
1149 | |
1150 | /* Allocate new entry. */ |
1151 | extra = (struct extra_entry *) cur_extra_table; |
1152 | cur_extra_table += sizeof (struct extra_entry); |
1153 | extra->module_cnt = 0; |
1154 | |
1155 | runp = &other->other_conv; |
1156 | do |
1157 | { |
1158 | cur_extra_table += sizeof (struct extra_entry_module); |
1159 | extra->module[extra->module_cnt].outname_offset = |
1160 | runp->next == NULL |
1161 | ? other->dest_idx : runp->next->module_idx; |
1162 | extra->module[extra->module_cnt].dir_offset = |
1163 | strtaboffset (runp->module->directory_strent); |
1164 | extra->module[extra->module_cnt].name_offset = |
1165 | strtaboffset (runp->module->filename_strent); |
1166 | ++extra->module_cnt; |
1167 | |
1168 | runp = runp->next; |
1169 | } |
1170 | while (runp != NULL); |
1171 | |
1172 | other = other->next; |
1173 | } |
1174 | while (other != NULL); |
1175 | |
1176 | /* Final module_cnt is zero. */ |
1177 | *((gidx_t *) cur_extra_table) = 0; |
1178 | cur_extra_table += sizeof (gidx_t); |
1179 | } |
1180 | } |
1181 | |
1182 | /* Clear padding. */ |
1183 | memset (&header, 0, sizeof (struct gconvcache_header)); |
1184 | |
1185 | header.magic = GCONVCACHE_MAGIC; |
1186 | |
1187 | iov[0].iov_base = &header; |
1188 | iov[0].iov_len = sizeof (struct gconvcache_header); |
1189 | total = iov[0].iov_len; |
1190 | |
1191 | header.string_offset = total; |
1192 | iov[1].iov_base = string_table; |
1193 | iov[1].iov_len = string_table_size; |
1194 | total += iov[1].iov_len; |
1195 | |
1196 | idx = 2; |
1197 | if ((string_table_size & (sizeof (gidx_t) - 1)) != 0) |
1198 | { |
1199 | iov[2].iov_base = (void *) &null_word; |
1200 | iov[2].iov_len = (sizeof (gidx_t) |
1201 | - (string_table_size & (sizeof (gidx_t) - 1))); |
1202 | total += iov[2].iov_len; |
1203 | ++idx; |
1204 | } |
1205 | |
1206 | header.hash_offset = total; |
1207 | header.hash_size = hash_size; |
1208 | iov[idx].iov_base = hash_table; |
1209 | iov[idx].iov_len = hash_size * sizeof (struct hash_entry); |
1210 | total += iov[idx].iov_len; |
1211 | ++idx; |
1212 | |
1213 | header.module_offset = total; |
1214 | iov[idx].iov_base = module_table; |
1215 | iov[idx].iov_len = nname_info * sizeof (struct module_entry); |
1216 | total += iov[idx].iov_len; |
1217 | ++idx; |
1218 | |
1219 | assert ((size_t) (cur_extra_table - extra_table) |
1220 | <= ((sizeof (struct extra_entry) + sizeof (gidx_t) |
1221 | + sizeof (struct extra_entry_module)) |
1222 | * nextra_modules)); |
1223 | header.otherconv_offset = total; |
1224 | iov[idx].iov_base = extra_table; |
1225 | iov[idx].iov_len = cur_extra_table - extra_table; |
1226 | total += iov[idx].iov_len; |
1227 | ++idx; |
1228 | |
1229 | if ((size_t) TEMP_FAILURE_RETRY (writev (fd, iov, idx)) != total |
1230 | /* The file was created with mode 0600. Make it world-readable. */ |
1231 | || fchmod (fd, 0644) != 0 |
1232 | /* Rename the file, possibly replacing an old one. */ |
1233 | || rename (tmpfname, output_file ?: finalname) != 0) |
1234 | { |
1235 | int save_errno = errno; |
1236 | close (fd); |
1237 | unlink (tmpfname); |
1238 | error (EXIT_FAILURE, save_errno, |
1239 | gettext ("cannot generate output file" )); |
1240 | } |
1241 | |
1242 | close (fd); |
1243 | |
1244 | return 0; |
1245 | } |
1246 | |