(__libc_memalign): Likewise. Handle malloc (0).
[kopensolaris-gnu/glibc.git] / iconv / iconv_prog.c
1 /* Convert text in given files from the specified from-set to the to-set.
2    Copyright (C) 1998-2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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 version 2 as
8    published by the Free Software Foundation.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software Foundation,
17    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
18
19 #include <argp.h>
20 #include <assert.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <error.h>
24 #include <fcntl.h>
25 #include <iconv.h>
26 #include <langinfo.h>
27 #include <locale.h>
28 #include <search.h>
29 #include <stdbool.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <libintl.h>
35 #ifdef _POSIX_MAPPED_FILES
36 # include <sys/mman.h>
37 #endif
38 #include <charmap.h>
39 #include <gconv_int.h>
40 #include "iconv_prog.h"
41 #include "iconvconfig.h"
42
43 /* Get libc version number.  */
44 #include "../version.h"
45
46 #define PACKAGE _libc_intl_domainname
47
48
49 /* Name and version of program.  */
50 static void print_version (FILE *stream, struct argp_state *state);
51 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
52
53 #define OPT_VERBOSE     1000
54 #define OPT_LIST        'l'
55
56 /* Definitions of arguments for argp functions.  */
57 static const struct argp_option options[] =
58 {
59   { NULL, 0, NULL, 0, N_("Input/Output format specification:") },
60   { "from-code", 'f', "NAME", 0, N_("encoding of original text") },
61   { "to-code", 't', "NAME", 0, N_("encoding for output") },
62   { NULL, 0, NULL, 0, N_("Information:") },
63   { "list", 'l', NULL, 0, N_("list all known coded character sets") },
64   { NULL, 0, NULL, 0, N_("Output control:") },
65   { NULL, 'c', NULL, 0, N_("omit invalid characters from output") },
66   { "output", 'o', "FILE", 0, N_("output file") },
67   { "silent", 's', NULL, 0, N_("suppress warnings") },
68   { "verbose", OPT_VERBOSE, NULL, 0, N_("print progress information") },
69   { NULL, 0, NULL, 0, NULL }
70 };
71
72 /* Short description of program.  */
73 static const char doc[] = N_("\
74 Convert encoding of given files from one encoding to another.");
75
76 /* Strings for arguments in help texts.  */
77 static const char args_doc[] = N_("[FILE...]");
78
79 /* Prototype for option handler.  */
80 static error_t parse_opt (int key, char *arg, struct argp_state *state);
81
82 /* Function to print some extra text in the help message.  */
83 static char *more_help (int key, const char *text, void *input);
84
85 /* Data structure to communicate with argp functions.  */
86 static struct argp argp =
87 {
88   options, parse_opt, args_doc, doc, NULL, more_help
89 };
90
91 /* Code sets to convert from and to respectively.  An empty string as the
92    default causes the 'iconv_open' function to look up the charset of the
93    currently selected locale and use it.  */
94 static const char *from_code = "";
95 static const char *to_code = "";
96
97 /* File to write output to.  If NULL write to stdout.  */
98 static const char *output_file;
99
100 /* Nonzero if verbose ouput is wanted.  */
101 int verbose;
102
103 /* Nonzero if list of all coded character sets is wanted.  */
104 static int list;
105
106 /* If nonzero omit invalid character from output.  */
107 int omit_invalid;
108
109 /* Prototypes for the functions doing the actual work.  */
110 static int process_block (iconv_t cd, char *addr, size_t len, FILE *output);
111 static int process_fd (iconv_t cd, int fd, FILE *output);
112 static int process_file (iconv_t cd, FILE *input, FILE *output);
113 static void print_known_names (void) internal_function;
114
115
116 int
117 main (int argc, char *argv[])
118 {
119   int status = EXIT_SUCCESS;
120   int remaining;
121   FILE *output;
122   iconv_t cd;
123   const char *orig_to_code;
124   struct charmap_t *from_charmap = NULL;
125   struct charmap_t *to_charmap = NULL;
126
127   /* Set locale via LC_ALL.  */
128   setlocale (LC_ALL, "");
129
130   /* Set the text message domain.  */
131   textdomain (_libc_intl_domainname);
132
133   /* Parse and process arguments.  */
134   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
135
136   /* List all coded character sets if wanted.  */
137   if (list)
138     {
139       print_known_names ();
140       exit (EXIT_SUCCESS);
141     }
142
143   /* If we have to ignore errors make sure we use the appropriate name for
144      the to-character-set.  */
145   orig_to_code = to_code;
146   if (omit_invalid)
147     {
148       const char *errhand = strchrnul (to_code, '/');
149       int nslash = 2;
150       char *newp;
151       char *cp;
152
153       if (*errhand == '/')
154         {
155           --nslash;
156           errhand = strchrnul (errhand, '/');
157
158           if (*errhand == '/')
159             {
160               --nslash;
161               errhand = strchr (errhand, '\0');
162             }
163         }
164
165       newp = (char *) alloca (errhand - to_code + nslash + 7 + 1);
166       cp = mempcpy (newp, to_code, errhand - to_code);
167       while (nslash-- > 0)
168         *cp++ = '/';
169       if (cp[-1] != '/')
170         *cp++ = ',';
171       memcpy (cp, "IGNORE", sizeof ("IGNORE"));
172
173       to_code = newp;
174     }
175
176   /* POSIX 1003.2b introduces a silly thing: the arguments to -t anf -f
177      can be file names of charmaps.  In this case iconv will have to read
178      those charmaps and use them to do the conversion.  But there are
179      holes in the specification.  There is nothing said that if -f is a
180      charmap filename that -t must be, too.  And vice versa.  There is
181      also no word about the symbolic names used.  What if they don't
182      match?  */
183   if (strchr (from_code, '/') != NULL)
184     /* The from-name might be a charmap file name.  Try reading the
185        file.  */
186     from_charmap = charmap_read (from_code, /*0, 1*/1, 0, 0, 0);
187
188   if (strchr (orig_to_code, '/') != NULL)
189     /* The to-name might be a charmap file name.  Try reading the
190        file.  */
191     to_charmap = charmap_read (orig_to_code, /*0, 1,*/1, 0, 0, 0);
192
193
194   /* Determine output file.  */
195   if (output_file != NULL && strcmp (output_file, "-") != 0)
196     {
197       output = fopen (output_file, "w");
198       if (output == NULL)
199         error (EXIT_FAILURE, errno, _("cannot open output file"));
200     }
201   else
202     output = stdout;
203
204   /* At this point we have to handle two cases.  The first one is
205      where a charmap is used for the from- or to-charset, or both.  We
206      handle this special since it is very different from the sane way of
207      doing things.  The other case allows converting using the iconv()
208      function.  */
209   if (from_charmap != NULL || to_charmap != NULL)
210     /* Construct the conversion table and do the conversion.  */
211     status = charmap_conversion (from_code, from_charmap, to_code, to_charmap,
212                                  argc, remaining, argv, output);
213   else
214     {
215       /* Let's see whether we have these coded character sets.  */
216       cd = iconv_open (to_code, from_code);
217       if (cd == (iconv_t) -1)
218         {
219           if (errno == EINVAL)
220             {
221               /* Try to be nice with the user and tell her which of the
222                  two encoding names is wrong.  This is possible because
223                  all supported encodings can be converted from/to Unicode,
224                  in other words, because the graph of encodings is
225                  connected.  */
226               bool from_wrong =
227                 (iconv_open ("UTF-8", from_code) == (iconv_t) -1
228                  && errno == EINVAL);
229               bool to_wrong =
230                 (iconv_open (to_code, "UTF-8") == (iconv_t) -1
231                  && errno == EINVAL);
232               const char *from_pretty =
233                 (from_code[0] ? from_code : nl_langinfo (CODESET));
234               const char *to_pretty =
235                 (orig_to_code[0] ? orig_to_code : nl_langinfo (CODESET));
236
237               if (from_wrong)
238                 {
239                   if (to_wrong)
240                     error (0, 0,
241                            _("\
242 conversions from `%s' and to `%s' are not supported"),
243                            from_pretty, to_pretty);
244                   else
245                     error (0, 0,
246                            _("conversion from `%s' is not supported"),
247                            from_pretty);
248                 }
249               else
250                 {
251                   if (to_wrong)
252                     error (0, 0,
253                            _("conversion to `%s' is not supported"),
254                            to_pretty);
255                   else
256                     error (0, 0,
257                            _("conversion from `%s' to `%s' is not supported"),
258                            from_pretty, to_pretty);
259                 }
260
261               argp_help (&argp, stderr, ARGP_HELP_SEE,
262                          program_invocation_short_name);
263               exit (1);
264             }
265           else
266             error (EXIT_FAILURE, errno,
267                    _("failed to start conversion processing"));
268         }
269
270       /* Now process the remaining files.  Write them to stdout or the file
271          specified with the `-o' parameter.  If we have no file given as
272          the parameter process all from stdin.  */
273       if (remaining == argc)
274         {
275           if (process_file (cd, stdin, output) != 0)
276             status = EXIT_FAILURE;
277         }
278       else
279         do
280           {
281 #ifdef _POSIX_MAPPED_FILES
282             struct stat st;
283             char *addr;
284 #endif
285             int fd, ret;
286
287             if (verbose)
288               fprintf (stderr, "%s:\n", argv[remaining]);
289             if (strcmp (argv[remaining], "-") == 0)
290               fd = 0;
291             else
292               {
293                 fd = open (argv[remaining], O_RDONLY);
294
295                 if (fd == -1)
296                   {
297                     error (0, errno, _("cannot open input file `%s'"),
298                            argv[remaining]);
299                     status = EXIT_FAILURE;
300                     continue;
301                   }
302               }
303
304 #ifdef _POSIX_MAPPED_FILES
305             /* We have possibilities for reading the input file.  First try
306                to mmap() it since this will provide the fastest solution.  */
307             if (fstat (fd, &st) == 0
308                 && ((addr = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE,
309                                   fd, 0)) != MAP_FAILED))
310               {
311                 /* Yes, we can use mmap().  The descriptor is not needed
312                    anymore.  */
313                 if (close (fd) != 0)
314                   error (EXIT_FAILURE, errno,
315                          _("error while closing input `%s'"),
316                          argv[remaining]);
317
318                 ret = process_block (cd, addr, st.st_size, output);
319
320                 /* We don't need the input data anymore.  */
321                 munmap ((void *) addr, st.st_size);
322
323                 if (ret != 0)
324                   {
325                     status = EXIT_FAILURE;
326
327                     if (ret < 0)
328                       /* We cannot go on with producing output since it might
329                          lead to problem because the last output might leave
330                          the output stream in an undefined state.  */
331                       break;
332                   }
333               }
334             else
335 #endif  /* _POSIX_MAPPED_FILES */
336               {
337                 /* Read the file in pieces.  */
338                 ret = process_fd (cd, fd, output);
339
340                 /* Now close the file.  */
341                 close (fd);
342
343                 if (ret != 0)
344                   {
345                     /* Something went wrong.  */
346                     status = EXIT_FAILURE;
347
348                     if (ret < 0)
349                       /* We cannot go on with producing output since it might
350                          lead to problem because the last output might leave
351                          the output stream in an undefined state.  */
352                       break;
353                   }
354               }
355           }
356         while (++remaining < argc);
357     }
358
359   /* Close the output file now.  */
360   if (fclose (output))
361     error (EXIT_FAILURE, errno, _("error while closing output file"));
362
363   return status;
364 }
365
366
367 /* Handle program arguments.  */
368 static error_t
369 parse_opt (int key, char *arg, struct argp_state *state)
370 {
371   switch (key)
372     {
373     case 'f':
374       from_code = arg;
375       break;
376     case 't':
377       to_code = arg;
378       break;
379     case 'o':
380       output_file = arg;
381       break;
382     case 's':
383       /* Nothing, for now at least.  We are not giving out any information
384          about missing character or so.  */
385       break;
386     case 'c':
387       /* Omit invalid characters from output.  */
388       omit_invalid = 1;
389       break;
390     case OPT_VERBOSE:
391       verbose = 1;
392       break;
393     case OPT_LIST:
394       list = 1;
395       break;
396     default:
397       return ARGP_ERR_UNKNOWN;
398     }
399   return 0;
400 }
401
402
403 static char *
404 more_help (int key, const char *text, void *input)
405 {
406   switch (key)
407     {
408     case ARGP_KEY_HELP_EXTRA:
409       /* We print some extra information.  */
410       return strdup (gettext ("\
411 For bug reporting instructions, please see:\n\
412 <http://www.gnu.org/software/libc/bugs.html>.\n"));
413     default:
414       break;
415     }
416   return (char *) text;
417 }
418
419
420 /* Print the version information.  */
421 static void
422 print_version (FILE *stream, struct argp_state *state)
423 {
424   fprintf (stream, "iconv (GNU %s) %s\n", PACKAGE, VERSION);
425   fprintf (stream, gettext ("\
426 Copyright (C) %s Free Software Foundation, Inc.\n\
427 This is free software; see the source for copying conditions.  There is NO\n\
428 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
429 "), "2007");
430   fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
431 }
432
433
434 static int
435 process_block (iconv_t cd, char *addr, size_t len, FILE *output)
436 {
437 #define OUTBUF_SIZE     32768
438   const char *start = addr;
439   char outbuf[OUTBUF_SIZE];
440   char *outptr;
441   size_t outlen;
442   size_t n;
443   int ret = 0;
444
445   while (len > 0)
446     {
447       outptr = outbuf;
448       outlen = OUTBUF_SIZE;
449       n = iconv (cd, &addr, &len, &outptr, &outlen);
450
451       if (n == (size_t) -1 && omit_invalid && errno == EILSEQ)
452         {
453           ret = 1;
454           if (len == 0)
455             n = 0;
456           else
457             errno = E2BIG;
458         }
459
460       if (outptr != outbuf)
461         {
462           /* We have something to write out.  */
463           int errno_save = errno;
464
465           if (fwrite (outbuf, 1, outptr - outbuf, output)
466               < (size_t) (outptr - outbuf)
467               || ferror (output))
468             {
469               /* Error occurred while printing the result.  */
470               error (0, 0, _("\
471 conversion stopped due to problem in writing the output"));
472               return -1;
473             }
474
475           errno = errno_save;
476         }
477
478       if (n != (size_t) -1)
479         {
480           /* All the input test is processed.  For state-dependent
481              character sets we have to flush the state now.  */
482           outptr = outbuf;
483           outlen = OUTBUF_SIZE;
484           n = iconv (cd, NULL, NULL, &outptr, &outlen);
485
486           if (outptr != outbuf)
487             {
488               /* We have something to write out.  */
489               int errno_save = errno;
490
491               if (fwrite (outbuf, 1, outptr - outbuf, output)
492                   < (size_t) (outptr - outbuf)
493                   || ferror (output))
494                 {
495                   /* Error occurred while printing the result.  */
496                   error (0, 0, _("\
497 conversion stopped due to problem in writing the output"));
498                   return -1;
499                 }
500
501               errno = errno_save;
502             }
503
504           if (n != (size_t) -1)
505             break;
506
507           if (omit_invalid && errno == EILSEQ)
508             {
509               ret = 1;
510               break;
511             }
512         }
513
514       if (errno != E2BIG)
515         {
516           /* iconv() ran into a problem.  */
517           switch (errno)
518             {
519             case EILSEQ:
520               if (! omit_invalid)
521                 error (0, 0, _("illegal input sequence at position %ld"),
522                        (long int) (addr - start));
523               break;
524             case EINVAL:
525               error (0, 0, _("\
526 incomplete character or shift sequence at end of buffer"));
527               break;
528             case EBADF:
529               error (0, 0, _("internal error (illegal descriptor)"));
530               break;
531             default:
532               error (0, 0, _("unknown iconv() error %d"), errno);
533               break;
534             }
535
536           return -1;
537         }
538     }
539
540   return ret;
541 }
542
543
544 static int
545 process_fd (iconv_t cd, int fd, FILE *output)
546 {
547   /* we have a problem with reading from a desriptor since we must not
548      provide the iconv() function an incomplete character or shift
549      sequence at the end of the buffer.  Since we have to deal with
550      arbitrary encodings we must read the whole text in a buffer and
551      process it in one step.  */
552   static char *inbuf = NULL;
553   static size_t maxlen = 0;
554   char *inptr = NULL;
555   size_t actlen = 0;
556
557   while (actlen < maxlen)
558     {
559       ssize_t n = read (fd, inptr, maxlen - actlen);
560
561       if (n == 0)
562         /* No more text to read.  */
563         break;
564
565       if (n == -1)
566         {
567           /* Error while reading.  */
568           error (0, errno, _("error while reading the input"));
569           return -1;
570         }
571
572       inptr += n;
573       actlen += n;
574     }
575
576   if (actlen == maxlen)
577     while (1)
578       {
579         ssize_t n;
580         char *new_inbuf;
581
582         /* Increase the buffer.  */
583         new_inbuf = (char *) realloc (inbuf, maxlen + 32768);
584         if (new_inbuf == NULL)
585           {
586             error (0, errno, _("unable to allocate buffer for input"));
587             return -1;
588           }
589         inbuf = new_inbuf;
590         maxlen += 32768;
591         inptr = inbuf + actlen;
592
593         do
594           {
595             n = read (fd, inptr, maxlen - actlen);
596
597             if (n == 0)
598               /* No more text to read.  */
599               break;
600
601             if (n == -1)
602               {
603                 /* Error while reading.  */
604                 error (0, errno, _("error while reading the input"));
605                 return -1;
606               }
607
608             inptr += n;
609             actlen += n;
610           }
611         while (actlen < maxlen);
612
613         if (n == 0)
614           /* Break again so we leave both loops.  */
615           break;
616       }
617
618   /* Now we have all the input in the buffer.  Process it in one run.  */
619   return process_block (cd, inbuf, actlen, output);
620 }
621
622
623 static int
624 process_file (iconv_t cd, FILE *input, FILE *output)
625 {
626   /* This should be safe since we use this function only for `stdin' and
627      we haven't read anything so far.  */
628   return process_fd (cd, fileno (input), output);
629 }
630
631
632 /* Print all known character sets/encodings.  */
633 static void *printlist;
634 static size_t column;
635 static int not_first;
636
637 static void
638 insert_print_list (const void *nodep, VISIT value, int level)
639 {
640   if (value == leaf || value == postorder)
641     {
642       const struct gconv_alias *s = *(const struct gconv_alias **) nodep;
643       tsearch (s->fromname, &printlist, (__compar_fn_t) strverscmp);
644     }
645 }
646
647 static void
648 do_print_human  (const void *nodep, VISIT value, int level)
649 {
650   if (value == leaf || value == postorder)
651     {
652       const char *s = *(const char **) nodep;
653       size_t len = strlen (s);
654       size_t cnt;
655
656       while (len > 0 && s[len - 1] == '/')
657         --len;
658
659       for (cnt = 0; cnt < len; ++cnt)
660         if (isalnum (s[cnt]))
661           break;
662       if (cnt == len)
663         return;
664
665       if (not_first)
666         {
667           putchar (',');
668           ++column;
669
670           if (column > 2 && column + len > 77)
671             {
672               fputs ("\n  ", stdout);
673               column = 2;
674             }
675           else
676             {
677               putchar (' ');
678               ++column;
679             }
680         }
681       else
682         not_first = 1;
683
684       fwrite (s, len, 1, stdout);
685       column += len;
686     }
687 }
688
689 static void
690 do_print  (const void *nodep, VISIT value, int level)
691 {
692   if (value == leaf || value == postorder)
693     {
694       const char *s = *(const char **) nodep;
695
696       puts (s);
697     }
698 }
699
700 static void
701 internal_function
702 add_known_names (struct gconv_module *node)
703 {
704   if (node->left != NULL)
705     add_known_names (node->left);
706   if (node->right != NULL)
707     add_known_names (node->right);
708   do
709     {
710       if (strcmp (node->from_string, "INTERNAL"))
711         tsearch (node->from_string, &printlist,
712                  (__compar_fn_t) strverscmp);
713       if (strcmp (node->to_string, "INTERNAL") != 0)
714         tsearch (node->to_string, &printlist, (__compar_fn_t) strverscmp);
715
716       node = node->same;
717     }
718   while (node != NULL);
719 }
720
721
722 static void
723 insert_cache (void)
724 {
725   const struct gconvcache_header *header;
726   const char *strtab;
727   const struct hash_entry *hashtab;
728   size_t cnt;
729
730   header = (const struct gconvcache_header *) __gconv_get_cache ();
731   strtab = (char *) header + header->string_offset;
732   hashtab = (struct hash_entry *) ((char *) header + header->hash_offset);
733
734   for (cnt = 0; cnt < header->hash_size; ++cnt)
735     if (hashtab[cnt].string_offset != 0)
736       {
737         const char *str = strtab + hashtab[cnt].string_offset;
738
739         if (strcmp (str, "INTERNAL") != 0)
740           tsearch (str, &printlist, (__compar_fn_t) strverscmp);
741       }
742 }
743
744
745 static void
746 internal_function
747 print_known_names (void)
748 {
749   iconv_t h;
750   void *cache;
751
752   /* We must initialize the internal databases first.  */
753   h = iconv_open ("L1", "L1");
754   iconv_close (h);
755
756   /* See whether we have a cache.  */
757   cache = __gconv_get_cache ();
758   if (cache != NULL)
759     /* Yep, use only this information.  */
760     insert_cache ();
761   else
762     {
763       struct gconv_module *modules;
764
765       /* No, then use the information read from the gconv-modules file.
766          First add the aliases.  */
767       twalk (__gconv_get_alias_db (), insert_print_list);
768
769       /* Add the from- and to-names from the known modules.  */
770       modules = __gconv_get_modules_db ();
771       if (modules != NULL)
772         add_known_names (modules);
773     }
774
775   bool human_readable = isatty (fileno (stdout));
776
777   if (human_readable)
778     fputs (_("\
779 The following list contain all the coded character sets known.  This does\n\
780 not necessarily mean that all combinations of these names can be used for\n\
781 the FROM and TO command line parameters.  One coded character set can be\n\
782 listed with several different names (aliases).\n\n  "), stdout);
783
784   /* Now print the collected names.  */
785   column = 2;
786   twalk (printlist, human_readable ? do_print_human : do_print);
787
788   if (human_readable && column != 0)
789     puts ("");
790 }