1: /* Find matching transformation algorithms and initialize steps.
    2:    Copyright (C) 1997,1998,1999,2000,2001,2004,2005,2007
    3:         Free Software Foundation, Inc.
    4:    This file is part of the GNU C Library.
    5:    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
    6: 
    7:    The GNU C Library is free software; you can redistribute it and/or
    8:    modify it under the terms of the GNU Lesser General Public
    9:    License as published by the Free Software Foundation; either
   10:    version 2.1 of the License, or (at your option) any later version.
   11: 
   12:    The GNU C Library is distributed in the hope that it will be useful,
   13:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   14:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   15:    Lesser General Public License for more details.
   16: 
   17:    You should have received a copy of the GNU Lesser General Public
   18:    License along with the GNU C Library; if not, write to the Free
   19:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   20:    02111-1307 USA.  */
   21: 
   22: #include <errno.h>
   23: #include <locale.h>
   24: #include "../locale/localeinfo.h"
   25: #include <stdlib.h>
   26: #include <string.h>
   27: 
   28: #include <gconv_int.h>
   29: 
   30: 
   31: int
   32: internal_function
   33: __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,
   34:               int flags)
   35: {
   36:   struct __gconv_step *steps;
   37:   size_t nsteps;
   38:   __gconv_t result = NULL;
   39:   size_t cnt = 0;
   40:   int res;
   41:   int conv_flags = 0;
   42:   const char *errhand;
   43:   const char *ignore;
   44:   struct trans_struct *trans = NULL;
   45: 
   46:   /* Find out whether any error handling method is specified.  */
   47:   errhand = strchr (toset, '/');
   48:   if (errhand != NULL)
   49:     errhand = strchr (errhand + 1, '/');
   50:   if (__builtin_expect (errhand != NULL, 1))
   51:     {
   52:       if (*++errhand == '\0')
   53:         errhand = NULL;
   54:       else
   55:         {
   56:           /* Make copy without the error handling description.  */
   57:           char *newtoset = (char *) alloca (errhand - toset + 1);
   58:           char *tok;
   59:           char *ptr = NULL /* Work around a bogus warning */;
   60: 
   61:           newtoset[errhand - toset] = '\0';
   62:           toset = memcpy (newtoset, toset, errhand - toset);
   63: 
   64:           /* Find the appropriate transliteration handlers.  */
   65:           tok = strdupa (errhand);
   66: 
   67:           tok = __strtok_r (tok, ",", &ptr);
   68:           while (tok != NULL)
   69:             {
   70:               if (__strcasecmp_l (tok, "TRANSLIT", _nl_C_locobj_ptr) == 0)
   71:                 {
   72:                   /* It's the builtin transliteration handling.  We only
   73:                      support it for working on the internal encoding.  */
   74:                   static const char *const internal_trans_names[1]
   75:                     = { "INTERNAL" };
   76:                   struct trans_struct *lastp = NULL;
   77:                   struct trans_struct *runp;
   78: 
   79:                   for (runp = trans; runp != NULL; runp = runp->next)
   80:                     if (runp->trans_fct == __gconv_transliterate)
   81:                       break;
   82:                     else
   83:                       lastp = runp;
   84: 
   85:                   if (runp == NULL)
   86:                     {
   87:                       struct trans_struct *newp;
   88: 
   89:                       newp = (struct trans_struct *) alloca (sizeof (*newp));
   90:                       memset (newp, '\0', sizeof (*newp));
   91: 
   92:                       /* We leave the `name' field zero to signal that
   93:                          this is an internal transliteration step.  */
   94:                       newp->csnames = (const char **) internal_trans_names;
   95:                       newp->ncsnames = 1;
   96:                       newp->trans_fct = __gconv_transliterate;
   97: 
   98:                       if (lastp == NULL)
   99:                         trans = newp;
  100:                       else
  101:                         lastp->next = newp;
  102:                     }
  103:                 }
  104:               else if (__strcasecmp_l (tok, "IGNORE", _nl_C_locobj_ptr) == 0)
  105:                 /* Set the flag to ignore all errors.  */
  106:                 conv_flags |= __GCONV_IGNORE_ERRORS;
  107:               else
  108:                 {
  109:                   /* `tok' is possibly a module name.  We'll see later
  110:                      whether we can find it.  But first see that we do
  111:                      not already a module of this name.  */
  112:                   struct trans_struct *lastp = NULL;
  113:                   struct trans_struct *runp;
  114: 
  115:                   for (runp = trans; runp != NULL; runp = runp->next)
  116:                     if (runp->name != NULL
  117:                         && __strcasecmp_l (tok, runp->name,
  118:                                            _nl_C_locobj_ptr) == 0)
  119:                       break;
  120:                     else
  121:                       lastp = runp;
  122: 
  123:                   if (runp == NULL)
  124:                     {
  125:                       struct trans_struct *newp;
  126: 
  127:                       newp = (struct trans_struct *) alloca (sizeof (*newp));
  128:                       memset (newp, '\0', sizeof (*newp));
  129:                       newp->name = tok;
  130: 
  131:                       if (lastp == NULL)
  132:                         trans = newp;
  133:                       else
  134:                         lastp->next = newp;
  135:                     }
  136:                 }
  137: 
  138:               tok = __strtok_r (NULL, ",", &ptr);
  139:             }
  140:         }
  141:     }
  142: 
  143:   /* For the source character set we ignore the error handler specification.
  144:      XXX Is this really always the best?  */
  145:   ignore = strchr (fromset, '/');
  146:   if (ignore != NULL && (ignore = strchr (ignore + 1, '/')) != NULL
  147:       && *++ignore != '\0')
  148:     {
  149:       char *newfromset = (char *) alloca (ignore - fromset + 1);
  150: 
  151:       newfromset[ignore - fromset] = '\0';
  152:       fromset = memcpy (newfromset, fromset, ignore - fromset);
  153:     }
  154: 
  155:   /* If the string is empty define this to mean the charset of the
  156:      currently selected locale.  */
  157:   if (strcmp (toset, "//") == 0)
  158:     {
  159:       const char *codeset = _NL_CURRENT (LC_CTYPE, CODESET);
  160:       size_t len = strlen (codeset);
  161:       char *dest;
  162:       toset = dest = (char *) alloca (len + 3);
  163:       memcpy (__mempcpy (dest, codeset, len), "//", 3);
  164:     }
  165:   if (strcmp (fromset, "//") == 0)
  166:     {
  167:       const char *codeset = _NL_CURRENT (LC_CTYPE, CODESET);
  168:       size_t len = strlen (codeset);
  169:       char *dest;
  170:       fromset = dest = (char *) alloca (len + 3);
  171:       memcpy (__mempcpy (dest, codeset, len), "//", 3);
  172:     }
  173: 
  174:   res = __gconv_find_transform (toset, fromset, &steps, &nsteps, flags);
  175:   if (res == __GCONV_OK)
  176:     {
  177:       /* Find the modules.  */
  178:       struct trans_struct *lastp = NULL;
  179:       struct trans_struct *runp;
  180: 
  181:       for (runp = trans; runp != NULL; runp = runp->next)
  182:         {
  183:           if (runp->name == NULL
  184:               || __builtin_expect (__gconv_translit_find (runp), 0) == 0)
  185:             lastp = runp;
  186:           else
  187:             {
  188:               /* This means we haven't found the module.  Remove it.  */
  189:               if (lastp == NULL)
  190:                 trans  = runp->next;
  191:               else
  192:                 lastp->next  = runp->next;
  193:             }
  194:         }
  195: 
  196:       /* Allocate room for handle.  */
  197:       result = (__gconv_t) malloc (sizeof (struct __gconv_info)
  198:                                    + (nsteps
  199:                                       * sizeof (struct __gconv_step_data)));
  200:       if (result == NULL)
  201:         res = __GCONV_NOMEM;
  202:       else
  203:         {
  204:           size_t n;
  205: 
  206:           /* Remember the list of steps.  */
  207:           result->__steps = steps;
  208:           result->__nsteps = nsteps;
  209: 
  210:           /* Clear the array for the step data.  */
  211:           memset (result->__data, '\0',
  212:                   nsteps * sizeof (struct __gconv_step_data));
  213: 
  214:           /* Call all initialization functions for the transformation
  215:              step implementations.  */
  216:           for (cnt = 0; cnt < nsteps; ++cnt)
  217:             {
  218:               size_t size;
  219: 
  220:               /* Would have to be done if we would not clear the whole
  221:                  array above.  */
  222: #if 0
  223:               /* Reset the counter.  */
  224:               result->__data[cnt].__invocation_counter = 0;
  225: 
  226:               /* It's a regular use.  */
  227:               result->__data[cnt].__internal_use = 0;
  228: #endif
  229: 
  230:               /* We use the `mbstate_t' member in DATA.  */
  231:               result->__data[cnt].__statep = &result->__data[cnt].__state;
  232: 
  233:               /* Now see whether we can use any of the transliteration
  234:                  modules for this step.  */
  235:               for (runp = trans; runp != NULL; runp = runp->next)
  236:                 for (n = 0; n < runp->ncsnames; ++n)
  237:                   if (__strcasecmp_l (steps[cnt].__from_name,
  238:                                       runp->csnames[n], _nl_C_locobj_ptr) == 0)
  239:                     {
  240:                       void *data = NULL;
  241: 
  242:                       /* Match!  Now try the initializer.  */
  243:                       if (runp->trans_init_fct == NULL
  244:                           || (runp->trans_init_fct (&data,
  245:                                                     steps[cnt].__to_name)
  246:                               == __GCONV_OK))
  247:                         {
  248:                           /* Append at the end of the list.  */
  249:                           struct __gconv_trans_data *newp;
  250:                           struct __gconv_trans_data **lastp;
  251: 
  252:                           newp = (struct __gconv_trans_data *)
  253:                             malloc (sizeof (struct __gconv_trans_data));
  254:                           if (newp == NULL)
  255:                             {
  256:                               res = __GCONV_NOMEM;
  257:                               goto bail;
  258:                             }
  259: 
  260:                           newp->__trans_fct = runp->trans_fct;
  261:                           newp->__trans_context_fct = runp->trans_context_fct;
  262:                           newp->__trans_end_fct = runp->trans_end_fct;
  263:                           newp->__data = data;
  264:                           newp->__next = NULL;
  265: 
  266:                           lastp = &result->__data[cnt].__trans;
  267:                           while (*lastp != NULL)
  268:                             lastp = &(*lastp)->__next;
  269: 
  270:                           *lastp = newp;
  271:                         }
  272:                       break;
  273:                     }
  274: 
  275:               /* If this is the last step we must not allocate an
  276:                  output buffer.  */
  277:               if (cnt < nsteps - 1)
  278:                 {
  279:                   result->__data[cnt].__flags = conv_flags;
  280: 
  281:                   /* Allocate the buffer.  */
  282:                   size = (GCONV_NCHAR_GOAL * steps[cnt].__max_needed_to);
  283: 
  284:                   result->__data[cnt].__outbuf = malloc (size);
  285:                   if (result->__data[cnt].__outbuf == NULL)
  286:                     {
  287:                       res = __GCONV_NOMEM;
  288:                       goto bail;
  289:                     }
  290: 
  291:                   result->__data[cnt].__outbufend =
  292:                     result->__data[cnt].__outbuf + size;
  293:                 }
  294:               else
  295:                 {
  296:                   /* Handle the last entry.  */
  297:                   result->__data[cnt].__flags = conv_flags | __GCONV_IS_LAST;
  298: 
  299:                   break;
  300:                 }
  301:             }
  302:         }
  303: 
  304:       if (res != __GCONV_OK)
  305:         {
  306:           /* Something went wrong.  Free all the resources.  */
  307:           int serrno;
  308:         bail:
  309:           serrno = errno;
  310: 
  311:           if (result != NULL)
  312:             {
  313:               while (cnt-- > 0)
  314:                 {
  315:                   struct __gconv_trans_data *transp;
  316: 
  317:                   transp = result->__data[cnt].__trans;
  318:                   while (transp != NULL)
  319:                     {
  320:                       struct __gconv_trans_data *curp = transp;
  321:                       transp = transp->__next;
  322: 
  323:                       if (__builtin_expect (curp->__trans_end_fct != NULL, 0))
  324:                         curp->__trans_end_fct (curp->__data);
  325: 
  326:                       free (curp);
  327:                     }
  328: 
  329:                   free (result->__data[cnt].__outbuf);
  330:                 }
  331: 
  332:               free (result);
  333:               result = NULL;
  334:             }
  335: 
  336:           __gconv_close_transform (steps, nsteps);
  337: 
  338:           __set_errno (serrno);
  339:         }
  340:     }
  341: 
  342:   *handle = result;
  343:   return res;
  344: }