[thirdparty/glibc.git] / iconv / iconv_prog.c

/* Convert text in given files from the specified from-set to the to-set.
   Copyright (C) 1998 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include <argp.h>
#include <errno.h>
#include <error.h>
#include <fcntl.h>
#include <iconv.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>

/* Get libc version number.  */
#include "../version.h"

#define PACKAGE _libc_intl_domainname


/* Name and version of program.  */
static void print_version (FILE *stream, struct argp_state *state);
void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;

#define OPT_VERBOSE	1000

/* Definitions of arguments for argp functions.  */
static const struct argp_option options[] =
{
  { NULL, 0, NULL, 0, N_("Input/Output format specification:") },
  { "from-code", 'f', "NAME", 0, N_("encoding of original text") },
  { "to-code", 't', "NAME", 0, N_("encoding for output") },
  { NULL, 0, NULL, 0, N_("Output control:") },
  { "output", 'o', "FILE", 0, N_("output file") },
  { "verbose", OPT_VERBOSE, NULL, 0, N_("print progress information") },
  { NULL, 0, NULL, 0, NULL }
};

/* Short description of program.  */
static const char doc[] = N_("\
Convert encoding of given files from one encoding to another.");

/* Strings for arguments in help texts.  */
static const char args_doc[] = N_("[FILE...]");

/* Prototype for option handler.  */
static error_t parse_opt __P ((int key, char *arg, struct argp_state *state));

/* Function to print some extra text in the help message.  */
static char *more_help __P ((int key, const char *text, void *input));

/* Data structure to communicate with argp functions.  */
static struct argp argp =
{
  options, parse_opt, args_doc, doc, NULL, more_help
};

/* Code sets to convert from and to respectively.  */
static const char *from_code;
static const char *to_code;

/* File to write output to.  If NULL write to stdout.  */
static const char *output_file;

/* Nonzero if verbose ouput is wanted.  */
static int verbose;

/* Prototypes for the functions doing the actual work.  */
static int process_block (iconv_t cd, const char *addr, size_t len,
			  FILE *output);
static int process_fd (iconv_t cd, int fd, FILE *output);
static int process_file (iconv_t cd, FILE *input, FILE *output);


int
main (int argc, char *argv[])
{
  int status = EXIT_SUCCESS;
  int remaining;
  FILE *output;
  iconv_t cd;

  /* Set locale via LC_ALL.  */
  setlocale (LC_ALL, "");

  /* Set the text message domain.  */
  textdomain (_libc_intl_domainname);

  /* Parse and process arguments.  */
  argp_parse (&argp, argc, argv, 0, &remaining, NULL);

  /* If either the from- or to-code is not specified this is an error
     since we do not know what to do.  */
  if (from_code == NULL && to_code == NULL)
    error (EXIT_FAILURE, 0,
	   _("neither original not target encoding specified"));
  if (from_code == NULL)
    error (EXIT_FAILURE, 0, _("original encoding not specified using `-f'"));
  if (to_code == NULL)
    error (EXIT_FAILURE, 0, _("target encoding not specified using `-t'"));

  /* Let's see whether we have these coded character sets.  */
  cd = iconv_open (to_code, from_code);
  if (cd == (iconv_t) -1)
    if (errno == EINVAL)
      error (EXIT_FAILURE, 0, _("conversion from `%s' to `%s' not supported"),
	     from_code, to_code);
    else
      error (EXIT_FAILURE, errno, _("failed to start conversion processing"));

  /* Determine output file.  */
  if (output_file != NULL)
    {
      output = fopen (output_file, "w");
      if (output == NULL)
	error (EXIT_FAILURE, errno, _("cannot open output file"));
    }
  else
    output = stdout;

  /* Now process the remaining files.  Write them to stdout or the file
     specified with the `-o' parameter.  If we have no file given as
     the parameter process all from stdin.  */
  if (remaining == argc)
    process_file (cd, stdin, output);
  else
    do
      {
	struct stat st;
	const char *addr;
	int fd = open (argv[remaining], O_RDONLY);

	if (verbose)
	  printf ("%s:\n", argv[remaining]);

	if (fd == -1)
	  {
	    error (0, errno, _("cannot open input file `%s'"),
		   argv[remaining]);
	    status = EXIT_FAILURE;
	    continue;
	  }

	/* We have possibilities for reading the input file.  First try
	   to mmap() it since this will provide the fastest solution.  */
	if (fstat (fd, &st) == 0
	    && ((addr = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0))
		!= MAP_FAILED))
	  {
	    /* Yes, we can use mmap().  The descriptor is not needed
               anymore.  */
	    if (close (fd) != 0)
	      error (EXIT_FAILURE, errno, _("error while closing input `%s'"),
		     argv[remaining]);

	    if (process_block (cd, addr, st.st_size, stdout) < 0)
	      {
		/* Something went wrong.  */
		status = EXIT_FAILURE;

		/* We don't need the input data anymore.  */
		munmap ((void *) addr, st.st_size);

		/* We cannot go on with producing output since it might
		   lead to problem because the last output might leave
		   the output stream in an undefined state.  */
		break;
	      }

	    /* We don't need the input data anymore.  */
	    munmap ((void *) addr, st.st_size);
	  }
	else
	  {
	    /* Read the file in pieces.  */
	    if (process_fd (cd, fd, output) != 0)
	      {
		/* Something went wrong.  */
		status = EXIT_FAILURE;

		/* We don't need the input file anymore.  */
		close (fd);

		/* We cannot go on with producing output since it might
		   lead to problem because the last output might leave
		   the output stream in an undefined state.  */
		break;
	      }

	    /* Now close the file.  */
	    close (fd);
	  }
      }
    while (++remaining < argc);

  /* Close the output file now.  */
  if (fclose (output))
    error (EXIT_FAILURE, errno, _("error while closing output file"));

  return status;
}


/* Handle program arguments.  */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
  switch (key)
    {
    case 'f':
      from_code = arg;
      break;
    case 't':
      to_code = arg;
      break;
    case 'o':
      output_file = arg;
      break;
    case OPT_VERBOSE:
      verbose = 1;
      break;
    default:
      return ARGP_ERR_UNKNOWN;
    }
  return 0;
}


static char *
more_help (int key, const char *text, void *input)
{
  switch (key)
    {
    case ARGP_KEY_HELP_EXTRA:
      /* We print some extra information.  */
      return strdup (gettext ("\
Report bugs using the `glibcbug' script to <bugs@gnu.org>.\n"));
    default:
      break;
    }
  return (char *) text;
}


/* Print the version information.  */
static void
print_version (FILE *stream, struct argp_state *state)
{
  fprintf (stream, "iconv (GNU %s) %s\n", PACKAGE, VERSION);
  fprintf (stream, gettext ("\
Copyright (C) %s Free Software Foundation, Inc.\n\
This is free software; see the source for copying conditions.  There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
"), "1998");
  fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
}


static int
process_block (iconv_t cd, const char *addr, size_t len, FILE *output)
{
#define OUTBUF_SIZE	32768
  char outbuf[OUTBUF_SIZE];
  char *outptr = outbuf;
  size_t outlen = OUTBUF_SIZE;

  while (len > 0)
    {
      size_t n = iconv (cd, &addr, &len, &outptr, &outlen);

      if (outptr != outbuf)
	{
	  /* We have something to write out.  */
	  if (fwrite (outbuf, 1, outptr - outbuf, output) != 0
	      || ferror (output))
	    {
	      /* Error occurred while printing the result.  */
	      error (0, 0, _("\
conversion stopped due to problem in writing the output"));
	      return -1;
	    }
	}

      if (n != (size_t) -1)
	/* Everything is processed.  */
	break;

      if (errno != E2BIG)
	{
	  /* iconv() ran into a problem.  */
	  switch (errno)
	    {
	    case EILSEQ:
	      error (0, 0, _("illegal input sequence"));
	      break;
	    case EINVAL:
	      error (0, 0, _("\
incomplete character or shift sequence at end of buffer"));
	      break;
	    case EBADF:
	      error (0, 0, _("internal error (illegal descriptor)"));
	      break;
	    default:
	      error (0, 0, _("unknown iconv() error %d"), errno);
	      break;
	    }

	  return -1;
	}
    }

  return 0;
}


static int
process_fd (iconv_t cd, int fd, FILE *output)
{
  /* we have a problem with reading from a desriptor since we must not
     provide the iconv() function an incomplete character or shift
     sequence at the end of the buffer.  Since we have to deal with
     arbitrary encodings we must read the whole text in a buffer and
     process it in one step.  */
  static char *inbuf = NULL;
  static size_t maxlen = 0;
  char *inptr = NULL;
  size_t actlen = 0;

  while (actlen < maxlen)
    {
      size_t n = read (fd, inptr, maxlen - actlen);

      if (n == 0)
	/* No more text to read.  */
	break;

      if (n == -1)
	{
	  /* Error while reading.  */
	  error (0, errno, _("error while reading the input"));
	  return -1;
	}

      inptr += n;
      actlen += n;
    }

  if (actlen == maxlen)
    while (1)
      {
	size_t n;

	/* Increase the buffer.  */
	maxlen += 32768;
	inbuf = realloc (inbuf, maxlen);
	if (inbuf == NULL)
	  error (0, errno, _("unable to allocate buffer for input"));
	inptr = inbuf + actlen;

	do
	  {
	    n = read (fd, inptr, maxlen - actlen);

	    if (n == 0)
	      /* No more text to read.  */
	      break;

	    if (n == -1)
	      {
		/* Error while reading.  */
		error (0, errno, _("error while reading the input"));
		return -1;
	      }

	    inptr += n;
	    actlen += n;
	  }
	while (actlen < maxlen);

	if (n == 0)
	  /* Break again so we leave both loops.  */
	  break;
      }

  /* Now we have all the input in the buffer.  Process it in one run.  */
  return process_block (cd, inbuf, actlen, output);
}


static int
process_file (iconv_t cd, FILE *input, FILE *output)
{
  /* This should be safe since we use this function only for `stdin' and
     we haven't read anything so far.  */
  return process_fd (cd, fileno (input), output);
}
Commit	Line	Data
fb5663ca UD	1	/* Convert text in given files from the specified from-set to the to-set.
	2	Copyright (C) 1998 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	The GNU C Library is free software; you can redistribute it and/or
	7	modify it under the terms of the GNU Library General Public License as
	8	published by the Free Software Foundation; either version 2 of the
	9	License, or (at your option) any later version.
	10
	11	The GNU C Library is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	Library General Public License for more details.
	15
	16	You should have received a copy of the GNU Library General Public
	17	License along with the GNU C Library; see the file COPYING.LIB. If not,
	18	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	#include <argp.h>
	22	#include <errno.h>
	23	#include <error.h>
	24	#include <fcntl.h>
	25	#include <iconv.h>
	26	#include <locale.h>
	27	#include <stdio.h>
	28	#include <stdlib.h>
	29	#include <string.h>
	30	#include <unistd.h>
	31	#include <sys/mman.h>
	32
	33	/* Get libc version number. */
	34	#include "../version.h"
	35
	36	#define PACKAGE _libc_intl_domainname
	37
	38
	39	/* Name and version of program. */
	40	static void print_version (FILE stream, struct argp_state state);
	41	void (argp_program_version_hook) (FILE , struct argp_state *) = print_version;
	42
	43	#define OPT_VERBOSE 1000
	44
	45	/* Definitions of arguments for argp functions. */
	46	static const struct argp_option options[] =
	47	{
	48	{ NULL, 0, NULL, 0, N_("Input/Output format specification:") },
	49	{ "from-code", 'f', "NAME", 0, N_("encoding of original text") },
	50	{ "to-code", 't', "NAME", 0, N_("encoding for output") },
	51	{ NULL, 0, NULL, 0, N_("Output control:") },
	52	{ "output", 'o', "FILE", 0, N_("output file") },
	53	{ "verbose", OPT_VERBOSE, NULL, 0, N_("print progress information") },
	54	{ NULL, 0, NULL, 0, NULL }
	55	};
	56
	57	/* Short description of program. */
	58	static const char doc[] = N_("\
	59	Convert encoding of given files from one encoding to another.");
	60
	61	/* Strings for arguments in help texts. */
	62	static const char args_doc[] = N_("[FILE...]");
	63
	64	/* Prototype for option handler. */
65	static error_t parse_opt __P ((int key, char arg, struct argp_state state));
66
67	/* Function to print some extra text in the help message. */
68	static char more_help __P ((int key, const char text, void *input));
69
70	/* Data structure to communicate with argp functions. */
71	static struct argp argp =
72	{
73	options, parse_opt, args_doc, doc, NULL, more_help
74	};
75
76	/* Code sets to convert from and to respectively. */
77	static const char *from_code;
78	static const char *to_code;
79
80	/* File to write output to. If NULL write to stdout. */
81	static const char *output_file;
82
83	/* Nonzero if verbose ouput is wanted. */
84	static int verbose;
85
86	/* Prototypes for the functions doing the actual work. */
87	static int process_block (iconv_t cd, const char *addr, size_t len,
88	FILE *output);
89	static int process_fd (iconv_t cd, int fd, FILE *output);
90	static int process_file (iconv_t cd, FILE input, FILE output);
91
92
93	int
94	main (int argc, char *argv[])
95	{
96	int status = EXIT_SUCCESS;
97	int remaining;
98	FILE *output;
99	iconv_t cd;
100
101	/* Set locale via LC_ALL. */
102	setlocale (LC_ALL, "");
103
104	/* Set the text message domain. */
105	textdomain (_libc_intl_domainname);
106
107	/* Parse and process arguments. */
108	argp_parse (&argp, argc, argv, 0, &remaining, NULL);
109
110	/* If either the from- or to-code is not specified this is an error
111	since we do not know what to do. */
112	if (from_code == NULL && to_code == NULL)
113	error (EXIT_FAILURE, 0,
114	_("neither original not target encoding specified"));
115	if (from_code == NULL)
116	error (EXIT_FAILURE, 0, _("original encoding not specified using `-f'"));
117	if (to_code == NULL)
118	error (EXIT_FAILURE, 0, _("target encoding not specified using `-t'"));
119
120	/* Let's see whether we have these coded character sets. */
121	cd = iconv_open (to_code, from_code);
122	if (cd == (iconv_t) -1)
123	if (errno == EINVAL)
124	error (EXIT_FAILURE, 0, _("conversion from `%s' to `%s' not supported"),
125	from_code, to_code);
126	else
127	error (EXIT_FAILURE, errno, _("failed to start conversion processing"));
128
129	/* Determine output file. */
130	if (output_file != NULL)
131	{
132	output = fopen (output_file, "w");
133	if (output == NULL)
134	error (EXIT_FAILURE, errno, _("cannot open output file"));
135	}
136	else
137	output = stdout;
138
139	/* Now process the remaining files. Write them to stdout or the file
140	specified with the `-o' parameter. If we have no file given as
141	the parameter process all from stdin. */
142	if (remaining == argc)
143	process_file (cd, stdin, output);
144	else
145	do
146	{
147	struct stat st;
148	const char *addr;
149	int fd = open (argv[remaining], O_RDONLY);
150
151	if (verbose)
152	printf ("%s:\n", argv[remaining]);
153
154	if (fd == -1)
155	{
156	error (0, errno, _("cannot open input file `%s'"),
157	argv[remaining]);
158	status = EXIT_FAILURE;
159	continue;
160	}
161
162	/* We have possibilities for reading the input file. First try
163	to mmap() it since this will provide the fastest solution. */
164	if (fstat (fd, &st) == 0
165	&& ((addr = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0))
166	!= MAP_FAILED))
167	{
168	/* Yes, we can use mmap(). The descriptor is not needed
169	anymore. */
170	if (close (fd) != 0)
171	error (EXIT_FAILURE, errno, _("error while closing input `%s'"),
172	argv[remaining]);
173
174	if (process_block (cd, addr, st.st_size, stdout) < 0)
175	{
176	/* Something went wrong. */
177	status = EXIT_FAILURE;
178
179	/* We don't need the input data anymore. */
180	munmap ((void *) addr, st.st_size);
181
182	/* We cannot go on with producing output since it might
183	lead to problem because the last output might leave
184	the output stream in an undefined state. */
185	break;
186	}
187
188	/* We don't need the input data anymore. */
189	munmap ((void *) addr, st.st_size);
190	}
191	else
192	{
193	/* Read the file in pieces. */
194	if (process_fd (cd, fd, output) != 0)
195	{
196	/* Something went wrong. */
197	status = EXIT_FAILURE;
198
199	/* We don't need the input file anymore. */
200	close (fd);
201
202	/* We cannot go on with producing output since it might
203	lead to problem because the last output might leave
204	the output stream in an undefined state. */
205	break;
206	}
207
208	/* Now close the file. */
209	close (fd);
210	}
211	}
212	while (++remaining < argc);
213
214	/* Close the output file now. */
215	if (fclose (output))
216	error (EXIT_FAILURE, errno, _("error while closing output file"));
217
218	return status;
219	}
220
221
222	/* Handle program arguments. */
223	static error_t
224	parse_opt (int key, char arg, struct argp_state state)
225	{
226	switch (key)
227	{
228	case 'f':
229	from_code = arg;
230	break;
231	case 't':
232	to_code = arg;
233	break;
234	case 'o':
235	output_file = arg;
236	break;
237	case OPT_VERBOSE:
238	verbose = 1;
239	break;
240	default:
241	return ARGP_ERR_UNKNOWN;
242	}
243	return 0;
244	}
245
246
247	static char *
248	more_help (int key, const char text, void input)
249	{
250	switch (key)
251	{
252	case ARGP_KEY_HELP_EXTRA:
253	/* We print some extra information. */
254	return strdup (gettext ("\
255	Report bugs using the `glibcbug' script to <bugs@gnu.org>.\n"));
256	default:
257	break;
258	}
259	return (char *) text;
260	}
261
262
263	/* Print the version information. */
264	static void
265	print_version (FILE stream, struct argp_state state)
266	{
267	fprintf (stream, "iconv (GNU %s) %s\n", PACKAGE, VERSION);
268	fprintf (stream, gettext ("\
269	Copyright (C) %s Free Software Foundation, Inc.\n\
270	This is free software; see the source for copying conditions. There is NO\n\
271	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
272	"), "1998");
273	fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
274	}
275
276
277	static int
278	process_block (iconv_t cd, const char addr, size_t len, FILE output)
279	{
280	#define OUTBUF_SIZE 32768
281	char outbuf[OUTBUF_SIZE];
282	char *outptr = outbuf;
283	size_t outlen = OUTBUF_SIZE;
284
285	while (len > 0)
286	{
287	size_t n = iconv (cd, &addr, &len, &outptr, &outlen);
288
289	if (outptr != outbuf)
290	{
291	/* We have something to write out. */
292	if (fwrite (outbuf, 1, outptr - outbuf, output) != 0
293	\|\| ferror (output))
294	{
295	/* Error occurred while printing the result. */
296	error (0, 0, _("\
297	conversion stopped due to problem in writing the output"));
298	return -1;
299	}
300	}
301
302	if (n != (size_t) -1)
303	/* Everything is processed. */
304	break;
305
306	if (errno != E2BIG)
307	{
308	/* iconv() ran into a problem. */
309	switch (errno)
310	{
311	case EILSEQ:
312	error (0, 0, _("illegal input sequence"));
313	break;
314	case EINVAL:
315	error (0, 0, _("\
316	incomplete character or shift sequence at end of buffer"));
317	break;
318	case EBADF:
319	error (0, 0, _("internal error (illegal descriptor)"));
320	break;
321	default:
322	error (0, 0, _("unknown iconv() error %d"), errno);
323	break;
324	}
325
326	return -1;
327	}
328	}
329
330	return 0;
331	}
332
333
334	static int
335	process_fd (iconv_t cd, int fd, FILE *output)
336	{
337	/* we have a problem with reading from a desriptor since we must not
338	provide the iconv() function an incomplete character or shift
339	sequence at the end of the buffer. Since we have to deal with
340	arbitrary encodings we must read the whole text in a buffer and
341	process it in one step. */
342	static char *inbuf = NULL;
343	static size_t maxlen = 0;
344	char *inptr = NULL;
345	size_t actlen = 0;
346
347	while (actlen < maxlen)
348	{
349	size_t n = read (fd, inptr, maxlen - actlen);
350
351	if (n == 0)
352	/* No more text to read. */
353	break;
354
355	if (n == -1)
356	{
357	/* Error while reading. */
358	error (0, errno, _("error while reading the input"));
359	return -1;
360	}
361
362	inptr += n;
363	actlen += n;
364	}
365
366	if (actlen == maxlen)
367	while (1)
368	{
369	size_t n;
370
371	/* Increase the buffer. */
372	maxlen += 32768;
373	inbuf = realloc (inbuf, maxlen);
374	if (inbuf == NULL)
375	error (0, errno, _("unable to allocate buffer for input"));
376	inptr = inbuf + actlen;
377
378	do
379	{
380	n = read (fd, inptr, maxlen - actlen);
381
382	if (n == 0)
383	/* No more text to read. */
384	break;
385
386	if (n == -1)
387	{
388	/* Error while reading. */
389	error (0, errno, _("error while reading the input"));
390	return -1;
391	}
392
393	inptr += n;
394	actlen += n;
395	}
396	while (actlen < maxlen);
397
398	if (n == 0)
399	/* Break again so we leave both loops. */
400	break;
401	}
402
403	/* Now we have all the input in the buffer. Process it in one run. */
404	return process_block (cd, inbuf, actlen, output);
405	}
406
407
408	static int
409	process_file (iconv_t cd, FILE input, FILE output)
410	{
411	/* This should be safe since we use this function only for `stdin' and
412	we haven't read anything so far. */
413	return process_fd (cd, fileno (input), output);
414	}