commit 91927b7c76437db860cd86a7714476b56bb39d07

Author: Arjun Shankar <arjun@redhat.com>

Date:   Tue Jul 7 20:31:48 2020 +0200

    Rewrite iconv option parsing [BZ #19519]

    This commit replaces string manipulation during `iconv_open' and iconv_prog

    option parsing with a structured, flag based conversion specification.  In

    doing so, it alters the internal `__gconv_open' interface and accordingly

    adjusts its uses.

    This change fixes several hangs in the iconv program and therefore includes

    a new test to exercise iconv_prog options that originally led to these hangs.

    It also includes a new regression test for option handling in the iconv

    function.

    Reviewed-by: Florian Weimer <fweimer@redhat.com>

    Reviewed-by: Siddhesh Poyarekar <siddhesh@sourceware.org>

    Reviewed-by: Carlos O'Donell <carlos@redhat.com>

diff --git a/iconv/Makefile b/iconv/Makefile

index d71319b39e772fde..d09b8ac842731780 100644

--- a/iconv/Makefile

+++ b/iconv/Makefile

@@ -26,7 +26,7 @@ headers		= iconv.h gconv.h

 routines	= iconv_open iconv iconv_close \

 		  gconv_open gconv gconv_close gconv_db gconv_conf \

 		  gconv_builtin gconv_simple gconv_trans gconv_cache

-routines	+= gconv_dl

+routines	+= gconv_dl gconv_charset

 vpath %.c ../locale/programs ../intl

@@ -43,7 +43,8 @@ CFLAGS-charmap.c += -DCHARMAP_PATH='"$(i18ndir)/charmaps"' \

 CFLAGS-linereader.c += -DNO_TRANSLITERATION

 CFLAGS-simple-hash.c += -I../locale

-tests	= tst-iconv1 tst-iconv2 tst-iconv3 tst-iconv4 tst-iconv5 tst-iconv6

+tests	= tst-iconv1 tst-iconv2 tst-iconv3 tst-iconv4 tst-iconv5 tst-iconv6 \

+	  tst-iconv-opt

 others		= iconv_prog iconvconfig

 install-others-programs	= $(inst_bindir)/iconv

@@ -60,6 +61,7 @@ include $(patsubst %,$(..)libof-iterator.mk,$(cpp-srcs-left))

 ifeq ($(run-built-tests),yes)

 xtests-special += $(objpfx)test-iconvconfig.out

+tests-special += $(objpfx)tst-iconv_prog.out

 endif

 # Make a copy of the file because gconv module names are constructed

@@ -78,6 +80,13 @@ endif

 include ../Rules

+ifeq ($(run-built-tests),yes)

+LOCALES := en_US.UTF-8

+include ../gen-locales.mk

+

+$(objpfx)tst-iconv-opt.out: $(gen-locales)

+endif

+

 $(inst_bindir)/iconv: $(objpfx)iconv_prog $(+force)

 	$(do-install-program)

@@ -92,3 +101,8 @@ $(objpfx)test-iconvconfig.out: /dev/null $(objpfx)iconvconfig

 	 cmp $$tmp $(inst_gconvdir)/gconv-modules.cache; \

 	 rm -f $$tmp) > $@; \

 	$(evaluate-test)

+

+$(objpfx)tst-iconv_prog.out: tst-iconv_prog.sh $(objpfx)iconv_prog

+	$(BASH) $< $(common-objdir) '$(test-wrapper-env)' \

+		 '$(run-program-env)' > $@; \

+	$(evaluate-test)

diff --git a/iconv/Versions b/iconv/Versions

index 60ab10a277588515..8a5f4cf780b18925 100644

--- a/iconv/Versions

+++ b/iconv/Versions

@@ -6,6 +6,7 @@ libc {

   GLIBC_PRIVATE {

     # functions shared with iconv program

     __gconv_get_alias_db; __gconv_get_cache; __gconv_get_modules_db;

+    __gconv_open; __gconv_create_spec;

     # function used by the gconv modules

     __gconv_transliterate;

diff --git a/iconv/gconv_charset.c b/iconv/gconv_charset.c

new file mode 100644

index 0000000000000000..6ccd0773ccb6cd27

--- /dev/null

+++ b/iconv/gconv_charset.c

@@ -0,0 +1,218 @@

+/* Charset name normalization.

+   Copyright (C) 2020 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 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

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+

+#include <stdlib.h>

+#include <ctype.h>

+#include <locale.h>

+#include <stdbool.h>

+#include <string.h>

+#include <sys/stat.h>

+#include "gconv_int.h"

+#include "gconv_charset.h"

+

+

+/* This function returns a pointer to the last suffix in a conversion code

+   string.  Valid suffixes matched by this function are of the form: '/' or ','

+   followed by arbitrary text that doesn't contain '/' or ','.  It does not

+   edit the string in any way.  The caller is expected to parse the suffix and

+   remove it (by e.g. truncating the string) before the next call.  */

+static char *

+find_suffix (char *s)

+{

+  /* The conversion code is in the form of a triplet, separated by '/' chars.

+     The third component of the triplet contains suffixes. If we don't have two

+     slashes, we don't have a suffix.  */

+

+  int slash_count = 0;

+  char *suffix_term = NULL;

+

+  for (int i = 0; s[i] != '\0'; i++)

+    switch (s[i])

+      {

+        case '/':

+          slash_count++;

+          /* Fallthrough */

+        case ',':

+          suffix_term = &s[i];

+      }

+

+  if (slash_count >= 2)

+    return suffix_term;

+

+  return NULL;

+}

+

+

+struct gconv_parsed_code

+{

+  char *code;

+  bool translit;

+  bool ignore;

+};

+

+

+/* This function parses an iconv_open encoding PC.CODE, strips any suffixes

+   (such as TRANSLIT or IGNORE) from it and sets corresponding flags in it.  */

+static void

+gconv_parse_code (struct gconv_parsed_code *pc)

+{

+  pc->translit = false;

+  pc->ignore = false;

+

+  while (1)

+    {

+      /* First drop any trailing whitespaces and separators.  */

+      size_t len = strlen (pc->code);

+      while ((len > 0)

+             && (isspace (pc->code[len - 1])

+                 || pc->code[len - 1] == ','

+                 || pc->code[len - 1] == '/'))

+        len--;

+

+      pc->code[len] = '\0';

+

+      if (len == 0)

+        return;

+

+      char * suffix = find_suffix (pc->code);

+      if (suffix == NULL)

+        {

+          /* At this point, we have processed and removed all suffixes from the

+             code and what remains of the code is suffix free.  */

+          return;

+        }

+      else

+        {

+          /* A suffix is processed from the end of the code array going

+             backwards, one suffix at a time.  The suffix is an index into the

+             code character array and points to: one past the end of the code

+             and any unprocessed suffixes, and to the beginning of the suffix

+             currently being processed during this iteration.  We must process

+             this suffix and then drop it from the code by terminating the

+             preceding text with NULL.

+

+             We want to allow and recognize suffixes such as:

+

+             "/TRANSLIT"         i.e. single suffix

+             "//TRANSLIT"        i.e. single suffix and multiple separators

+             "//TRANSLIT/IGNORE" i.e. suffixes separated by "/"

+             "/TRANSLIT//IGNORE" i.e. suffixes separated by "//"

+             "//IGNORE,TRANSLIT" i.e. suffixes separated by ","

+             "//IGNORE,"         i.e. trailing ","

+             "//TRANSLIT/"       i.e. trailing "/"

+             "//TRANSLIT//"      i.e. trailing "//"

+             "/"                 i.e. empty suffix.

+

+             Unknown suffixes are silently discarded and ignored.  */

+

+          if ((__strcasecmp_l (suffix,

+                               GCONV_TRIPLE_SEPARATOR

+                               GCONV_TRANSLIT_SUFFIX,

+                               _nl_C_locobj_ptr) == 0)

+              || (__strcasecmp_l (suffix,

+                                  GCONV_SUFFIX_SEPARATOR

+                                  GCONV_TRANSLIT_SUFFIX,

+                                  _nl_C_locobj_ptr) == 0))

+            pc->translit = true;

+

+          if ((__strcasecmp_l (suffix,

+                               GCONV_TRIPLE_SEPARATOR

+                               GCONV_IGNORE_ERRORS_SUFFIX,

+                               _nl_C_locobj_ptr) == 0)

+              || (__strcasecmp_l (suffix,

+                                  GCONV_SUFFIX_SEPARATOR

+                                  GCONV_IGNORE_ERRORS_SUFFIX,

+                                  _nl_C_locobj_ptr) == 0))

+            pc->ignore = true;

+

+          /* We just processed this suffix.  We can now drop it from the

+             code string by truncating it at the suffix's position.  */

+          suffix[0] = '\0';

+        }

+    }

+}

+

+

+/* This function accepts the charset names of the source and destination of the

+   conversion and populates *conv_spec with an equivalent conversion

+   specification that may later be used by __gconv_open.  The charset names

+   might contain options in the form of suffixes that alter the conversion,

+   e.g. "ISO-10646/UTF-8/TRANSLIT".  It processes the charset names, ignoring

+   and truncating any suffix options in fromcode, and processing and truncating

+   any suffix options in tocode.  Supported suffix options ("TRANSLIT" or

+   "IGNORE") when found in tocode lead to the corresponding flag in *conv_spec

+   to be set to true.  Unrecognized suffix options are silently discarded.  If

+   the function succeeds, it returns conv_spec back to the caller.  It returns

+   NULL upon failure.  conv_spec must be allocated and freed by the caller.  */

+struct gconv_spec *

+__gconv_create_spec (struct gconv_spec *conv_spec, const char *fromcode,

+                   const char *tocode)

+{

+  struct gconv_parsed_code pfc, ptc;

+  struct gconv_spec *ret = NULL;

+

+  pfc.code = __strdup (fromcode);

+  ptc.code = __strdup (tocode);

+

+  if ((pfc.code == NULL)

+      || (ptc.code == NULL))

+    goto out;

+

+  gconv_parse_code (&pfc;;

+  gconv_parse_code (&ptc);

+

+  /* We ignore suffixes in the fromcode because that is how the current

+     implementation has always handled them.  Only suffixes in the tocode are

+     processed and handled.  The reality is that invalid input in the input

+     character set should only be ignored if the fromcode specifies IGNORE.

+     The current implementation ignores invalid intput in the input character

+     set if the tocode contains IGNORE.  We preserve this behavior for

+     backwards compatibility.  In the future we may split the handling of

+     IGNORE to allow a finer grained specification of ignorning invalid input

+     and/or ignoring invalid output.  */

+  conv_spec->translit = ptc.translit;

+  conv_spec->ignore = ptc.ignore;

+

+  /* 3 extra bytes because 1 extra for '\0', and 2 extra so strip might

+     be able to add one or two trailing '/' characters if necessary.  */

+  conv_spec->fromcode = malloc (strlen (fromcode) + 3);

+  if (conv_spec->fromcode == NULL)

+    goto out;

+

+  conv_spec->tocode = malloc (strlen (tocode) + 3);

+  if (conv_spec->tocode == NULL)

+    {

+      free (conv_spec->fromcode);

+      conv_spec->fromcode = NULL;

+      goto out;

+    }

+

+  /* Strip unrecognized characters and ensure that the code has two '/'

+     characters as per conversion code triplet specification.  */

+  strip (conv_spec->fromcode, pfc.code);

+  strip (conv_spec->tocode, ptc.code);

+  ret = conv_spec;

+

+out:

+  free (pfc.code);

+  free (ptc.code);

+

+  return ret;

+}

+libc_hidden_def (__gconv_create_spec)

diff --git a/iconv/gconv_charset.h b/iconv/gconv_charset.h

index 123e2a62cefdc017..b85d80313030b649 100644

--- a/iconv/gconv_charset.h

+++ b/iconv/gconv_charset.h

@@ -19,9 +19,68 @@

 #include <ctype.h>

 #include <locale.h>

+#include <stdbool.h>

+#include <string.h>

+#include <sys/stat.h>

+#include <stdlib.h>

+#include "gconv_int.h"

-static void

+/* An iconv encoding is in the form of a triplet, with parts separated by

+   a '/' character.  The first part is the standard name, the second part is

+   the character set, and the third part is the error handler.  If the first

+   part is sufficient to identify both the standard and the character set

+   then the second part can be empty e.g. UTF-8//.  If the first part is not

+   sufficient to identify both the standard and the character set then the

+   second part is required e.g. ISO-10646/UTF8/.  If neither the first or

+   second parts are provided e.g. //, then the current locale is used.

+   The actual values used in the first and second parts are not entirely

+   relevant to the implementation.  The values themselves are used in a hash

+   table to lookup modules and so the naming convention of the first two parts

+   is somewhat arbitrary and only helps locate the entries in the cache.

+   The third part is the error handler and is comprised of a ',' or '/'

+   separated list of suffixes.  Currently, we support "TRANSLIT" for

+   transliteration and "IGNORE" for ignoring conversion errors due to

+   unrecognized input characters.  */

+#define GCONV_TRIPLE_SEPARATOR "/"

+#define GCONV_SUFFIX_SEPARATOR ","

+#define GCONV_TRANSLIT_SUFFIX "TRANSLIT"

+#define GCONV_IGNORE_ERRORS_SUFFIX "IGNORE"

+

+

+/* This function accepts the charset names of the source and destination of the

+   conversion and populates *conv_spec with an equivalent conversion

+   specification that may later be used by __gconv_open.  The charset names

+   might contain options in the form of suffixes that alter the conversion,

+   e.g. "ISO-10646/UTF-8/TRANSLIT".  It processes the charset names, ignoring

+   and truncating any suffix options in fromcode, and processing and truncating

+   any suffix options in tocode.  Supported suffix options ("TRANSLIT" or

+   "IGNORE") when found in tocode lead to the corresponding flag in *conv_spec

+   to be set to true.  Unrecognized suffix options are silently discarded.  If

+   the function succeeds, it returns conv_spec back to the caller.  It returns

+   NULL upon failure.  */

+struct gconv_spec *

+__gconv_create_spec (struct gconv_spec *conv_spec, const char *fromcode,

+                     const char *tocode);

+libc_hidden_proto (__gconv_create_spec)

+

+

+/* This function frees all heap memory allocated by __gconv_create_spec.  */

+static void __attribute__ ((unused))

+gconv_destroy_spec (struct gconv_spec *conv_spec)

+{

+  free (conv_spec->fromcode);

+  free (conv_spec->tocode);

+  return;

+}

+

+

+/* This function copies in-order, characters from the source 's' that are

+   either alpha-numeric or one in one of these: "_-.,:/" - into the destination

+   'wp' while dropping all other characters.  In the process, it converts all

+   alphabetical characters to upper case.  It then appends up to two '/'

+   characters so that the total number of '/'es in the destination is 2.  */

+static inline void __attribute__ ((unused, always_inline))

 strip (char *wp, const char *s)

 {

   int slash_count = 0;

diff --git a/iconv/gconv_int.h b/iconv/gconv_int.h

index 3742557caed05c9a..4748e9b1fa3b5426 100644

--- a/iconv/gconv_int.h

+++ b/iconv/gconv_int.h

@@ -92,6 +92,15 @@ struct gconv_module

 };

+/* The specification of the conversion that needs to be performed.  */

+struct gconv_spec

+{

+  char *fromcode;

+  char *tocode;

+  bool translit;

+  bool ignore;

+};

+

 /* Flags for `gconv_open'.  */

 enum

 {

@@ -154,10 +163,12 @@ __libc_lock_define (extern, __gconv_lock attribute_hidden)

   })

-/* Return in *HANDLE decriptor for transformation from FROMSET to TOSET.  */

-extern int __gconv_open (const char *toset, const char *fromset,

-			 __gconv_t *handle, int flags)

-     attribute_hidden;

+/* Return in *HANDLE, a decriptor for the transformation.  The function expects

+   the specification of the transformation in the structure pointed to by

+   CONV_SPEC.  It only reads *CONV_SPEC and does not take ownership of it.  */

+extern int __gconv_open (struct gconv_spec *conv_spec,

+                         __gconv_t *handle, int flags);

+libc_hidden_proto (__gconv_open)

 /* Free resources associated with transformation descriptor CD.  */

 extern int __gconv_close (__gconv_t cd)

diff --git a/iconv/gconv_open.c b/iconv/gconv_open.c

index f739561f6edba8a8..002faa111a0b9016 100644

--- a/iconv/gconv_open.c

+++ b/iconv/gconv_open.c

@@ -27,7 +27,7 @@

 int

-__gconv_open (const char *toset, const char *fromset, __gconv_t *handle,

+__gconv_open (struct gconv_spec *conv_spec, __gconv_t *handle,

 	      int flags)

 {

   struct __gconv_step *steps;

@@ -36,77 +36,38 @@ __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,

   size_t cnt = 0;

   int res;

   int conv_flags = 0;

-  const char *errhand;

-  const char *ignore;

   bool translit = false;

+  char *tocode, *fromcode;

   /* Find out whether any error handling method is specified.  */

-  errhand = strchr (toset, '/');

-  if (errhand != NULL)

-    errhand = strchr (errhand + 1, '/');

-  if (__glibc_likely (errhand != NULL))

-    {

-      if (*++errhand == '\0')

-	errhand = NULL;

-      else

-	{

-	  /* Make copy without the error handling description.  */

-	  char *newtoset = (char *) alloca (errhand - toset + 1);

-	  char *tok;

-	  char *ptr = NULL /* Work around a bogus warning */;

-

-	  newtoset[errhand - toset] = '\0';

-	  toset = memcpy (newtoset, toset, errhand - toset);

+  translit = conv_spec->translit;

-	  /* Find the appropriate transliteration handlers.  */

-	  tok = strdupa (errhand);

+  if (conv_spec->ignore)

+    conv_flags |= __GCONV_IGNORE_ERRORS;

-	  tok = __strtok_r (tok, ",", &ptr);

-	  while (tok != NULL)

-	    {

-	      if (__strcasecmp_l (tok, "TRANSLIT", _nl_C_locobj_ptr) == 0)

-		translit = true;

-	      else if (__strcasecmp_l (tok, "IGNORE", _nl_C_locobj_ptr) == 0)

-		/* Set the flag to ignore all errors.  */

-		conv_flags |= __GCONV_IGNORE_ERRORS;

-

-	      tok = __strtok_r (NULL, ",", &ptr);

-	    }

-	}

-    }

-

-  /* For the source character set we ignore the error handler specification.

-     XXX Is this really always the best?  */

-  ignore = strchr (fromset, '/');

-  if (ignore != NULL && (ignore = strchr (ignore + 1, '/')) != NULL

-      && *++ignore != '\0')

-    {

-      char *newfromset = (char *) alloca (ignore - fromset + 1);

-

-      newfromset[ignore - fromset] = '\0';

-      fromset = memcpy (newfromset, fromset, ignore - fromset);

-    }

+  tocode = conv_spec->tocode;

+  fromcode = conv_spec->fromcode;

   /* If the string is empty define this to mean the charset of the

      currently selected locale.  */

-  if (strcmp (toset, "//") == 0)

+  if (strcmp (tocode, "//") == 0)

     {

       const char *codeset = _NL_CURRENT (LC_CTYPE, CODESET);

       size_t len = strlen (codeset);

       char *dest;

-      toset = dest = (char *) alloca (len + 3);

+      tocode = dest = (char *) alloca (len + 3);

       memcpy (__mempcpy (dest, codeset, len), "//", 3);

     }

-  if (strcmp (fromset, "//") == 0)

+  if (strcmp (fromcode, "//") == 0)

     {

       const char *codeset = _NL_CURRENT (LC_CTYPE, CODESET);

       size_t len = strlen (codeset);

       char *dest;

-      fromset = dest = (char *) alloca (len + 3);

+      fromcode = dest = (char *) alloca (len + 3);

       memcpy (__mempcpy (dest, codeset, len), "//", 3);

     }

-  res = __gconv_find_transform (toset, fromset, &steps, &nsteps, flags);

+  res = __gconv_find_transform (tocode, fromcode, &steps, &nsteps, flags);

   if (res == __GCONV_OK)

     {

       /* Allocate room for handle.  */

@@ -205,3 +166,4 @@ __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,

   *handle = result;

   return res;

 }

+libc_hidden_def (__gconv_open)

diff --git a/iconv/iconv_open.c b/iconv/iconv_open.c

index 9f5c32c02096254a..59d1ef4f07ed1022 100644

--- a/iconv/iconv_open.c

+++ b/iconv/iconv_open.c

@@ -31,49 +31,15 @@

 iconv_t

 iconv_open (const char *tocode, const char *fromcode)

 {

-  /* Normalize the name.  We remove all characters beside alpha-numeric,

-     '_', '-', '/', '.', and ':'.  */

-  size_t tocode_len = strlen (tocode) + 3;

-  char *tocode_conv;

-  bool tocode_usealloca = __libc_use_alloca (tocode_len);

-  if (tocode_usealloca)

-    tocode_conv = (char *) alloca (tocode_len);

-  else

-    {

-      tocode_conv = (char *) malloc (tocode_len);

-      if (tocode_conv == NULL)

-	return (iconv_t) -1;

-    }

-  strip (tocode_conv, tocode);

-  tocode = (tocode_conv[2] == '\0' && tocode[0] != '\0'

-	    ? upstr (tocode_conv, tocode) : tocode_conv);

+  __gconv_t cd;

+  struct gconv_spec conv_spec;

-  size_t fromcode_len = strlen (fromcode) + 3;

-  char *fromcode_conv;

-  bool fromcode_usealloca = __libc_use_alloca (fromcode_len);

-  if (fromcode_usealloca)

-    fromcode_conv = (char *) alloca (fromcode_len);

-  else

-    {

-      fromcode_conv = (char *) malloc (fromcode_len);

-      if (fromcode_conv == NULL)

-	{

-	  if (! tocode_usealloca)

-	    free (tocode_conv);

-	  return (iconv_t) -1;

-	}

-    }

-  strip (fromcode_conv, fromcode);

-  fromcode = (fromcode_conv[2] == '\0' && fromcode[0] != '\0'

-	      ? upstr (fromcode_conv, fromcode) : fromcode_conv);

+  if (__gconv_create_spec (&conv_spec, fromcode, tocode) == NULL)

+    return (iconv_t) -1;

-  __gconv_t cd;

-  int res = __gconv_open (tocode, fromcode, &cd, 0);

+  int res = __gconv_open (&conv_spec, &cd, 0);

-  if (! fromcode_usealloca)

-    free (fromcode_conv);

-  if (! tocode_usealloca)

-    free (tocode_conv);

+  gconv_destroy_spec (&conv_spec);

   if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)

     {

diff --git a/iconv/iconv_prog.c b/iconv/iconv_prog.c

index 52e9d3f3ddec3b2e..552efac81660e82a 100644

--- a/iconv/iconv_prog.c

+++ b/iconv/iconv_prog.c

@@ -39,6 +39,7 @@

 #include <gconv_int.h>

 #include "iconv_prog.h"

 #include "iconvconfig.h"

+#include "gconv_charset.h"

 /* Get libc version number.  */

 #include "../version.h"

@@ -118,8 +119,7 @@ main (int argc, char *argv[])

 {

   int status = EXIT_SUCCESS;

   int remaining;

-  iconv_t cd;

-  const char *orig_to_code;

+  __gconv_t cd;

   struct charmap_t *from_charmap = NULL;

   struct charmap_t *to_charmap = NULL;

@@ -139,39 +139,6 @@ main (int argc, char *argv[])

       exit (EXIT_SUCCESS);

     }

-  /* If we have to ignore errors make sure we use the appropriate name for

-     the to-character-set.  */

-  orig_to_code = to_code;

-  if (omit_invalid)

-    {

-      const char *errhand = strchrnul (to_code, '/');

-      int nslash = 2;

-      char *newp;

-      char *cp;

-

-      if (*errhand == '/')

-	{

-	  --nslash;

-	  errhand = strchrnul (errhand + 1, '/');

-

-	  if (*errhand == '/')

-	    {

-	      --nslash;

-	      errhand = strchr (errhand, '\0');

-	    }

-	}

-

-      newp = (char *) alloca (errhand - to_code + nslash + 7 + 1);

-      cp = mempcpy (newp, to_code, errhand - to_code);

-      while (nslash-- > 0)

-	*cp++ = '/';

-      if (cp[-1] != '/')

-	*cp++ = ',';

-      memcpy (cp, "IGNORE", sizeof ("IGNORE"));

-

-      to_code = newp;

-    }

-

   /* POSIX 1003.2b introduces a silly thing: the arguments to -t anf -f

      can be file names of charmaps.  In this case iconv will have to read

      those charmaps and use them to do the conversion.  But there are

@@ -184,10 +151,10 @@ main (int argc, char *argv[])

        file.  */

     from_charmap = charmap_read (from_code, /*0, 1*/1, 0, 0, 0);

-  if (strchr (orig_to_code, '/') != NULL)

+  if (strchr (to_code, '/') != NULL)

     /* The to-name might be a charmap file name.  Try reading the

        file.  */

-    to_charmap = charmap_read (orig_to_code, /*0, 1,*/1, 0, 0, 0);

+    to_charmap = charmap_read (to_code, /*0, 1,*/1, 0, 0, 0);

   /* At this point we have to handle two cases.  The first one is

@@ -201,9 +168,25 @@ main (int argc, char *argv[])

 				 argc, remaining, argv, output_file);

   else

     {

+      struct gconv_spec conv_spec;

+      int res;

+

+      if (__gconv_create_spec (&conv_spec, from_code, to_code) == NULL)

+        {

+          error (EXIT_FAILURE, errno,

+                 _("failed to start conversion processing"));

+          exit (1);

+        }

+

+      if (omit_invalid)

+        conv_spec.ignore = true;

+

       /* Let's see whether we have these coded character sets.  */

-      cd = iconv_open (to_code, from_code);

-      if (cd == (iconv_t) -1)

+      res = __gconv_open (&conv_spec, &cd, 0);

+

+      gconv_destroy_spec (&conv_spec);

+

+      if (res != __GCONV_OK)

 	{

 	  if (errno == EINVAL)

 	    {

@@ -221,7 +204,7 @@ main (int argc, char *argv[])

 	      const char *from_pretty =

 		(from_code[0] ? from_code : nl_langinfo (CODESET));

 	      const char *to_pretty =

-		(orig_to_code[0] ? orig_to_code : nl_langinfo (CODESET));

+		(to_code[0] ? to_code : nl_langinfo (CODESET));

 	      if (from_wrong)

 		{

diff --git a/iconv/tst-iconv-opt.c b/iconv/tst-iconv-opt.c

new file mode 100644

index 0000000000000000..669d812a6a9b8749

--- /dev/null

+++ b/iconv/tst-iconv-opt.c

@@ -0,0 +1,347 @@

+/* Test iconv's TRANSLIT and IGNORE option handling

+

+   Copyright (C) 2020 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 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