sys/libiconv/iconv.c

   1 /*
   2  * Copyright (c) 2000-2001, Boris Popov
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *    This product includes software developed by Boris Popov.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/libkern/iconv.c,v 1.1.2.1 2001/05/21 08:28:07 bp Exp $
  33  * $DragonFly: src/sys/libiconv/iconv.c,v 1.6 2007/03/08 16:42:34 dillon Exp $
  34  */
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/iconv.h>
  39 #include <sys/malloc.h>
  40
  41 #include "iconv_converter_if.h"
  42
  43 SYSCTL_DECL(_kern_iconv);
  44
  45 SYSCTL_NODE(_kern, OID_AUTO, iconv, CTLFLAG_RW, NULL, "kernel iconv interface");
  46
  47 MALLOC_DEFINE(M_ICONV, "ICONV", "ICONV structures");
  48 MALLOC_DEFINE(M_ICONVDATA, "ICONV data", "ICONV data");
  49
  50 MODULE_VERSION(libiconv, 1);
  51
  52 #ifdef notnow
  53 /*
  54  * iconv converter instance
  55  */
  56 struct iconv_converter {
  57         KOBJ_FIELDS;
  58         void *                  c_data;
  59 };
  60 #endif
  61
  62 struct sysctl_oid *iconv_oid_hook = &sysctl___kern_iconv;
  63
  64 /*
  65  * List of loaded converters
  66  */
  67 static TAILQ_HEAD(iconv_converter_list, iconv_converter_class)
  68     iconv_converters = TAILQ_HEAD_INITIALIZER(iconv_converters);
  69
  70 /*
  71  * List of supported/loaded charsets pairs
  72  */
  73 static TAILQ_HEAD(, iconv_cspair)
  74     iconv_cslist = TAILQ_HEAD_INITIALIZER(iconv_cslist);
  75 static int iconv_csid = 1;
  76
  77 static char iconv_unicode_string[] = "unicode"; /* save eight bytes when possible */
  78
  79 static void iconv_unregister_cspair(struct iconv_cspair *csp);
  80
  81 static int
  82 iconv_mod_unload(void)
  83 {
  84         struct iconv_cspair *csp;
  85
  86         while ((csp = TAILQ_FIRST(&iconv_cslist)) != NULL) {
  87                 if (csp->cp_refcount)
  88                         return EBUSY;
  89                 iconv_unregister_cspair(csp);
  90         }
  91         return 0;
  92 }
  93
  94 static int
  95 iconv_mod_handler(module_t mod, int type, void *data)
  96 {
  97         int error;
  98
  99         switch (type) {
 100             case MOD_LOAD:
 101                 error = 0;
 102                 break;
 103             case MOD_UNLOAD:
 104                 error = iconv_mod_unload();
 105                 break;
 106             default:
 107                 error = EINVAL;
 108         }
 109         return error;
 110 }
 111
 112 static moduledata_t iconv_mod = {
 113         "iconv", iconv_mod_handler, NULL
 114 };
 115
 116 DECLARE_MODULE(iconv, iconv_mod, SI_SUB_DRIVERS, SI_ORDER_SECOND);
 117
 118 static int
 119 iconv_register_converter(struct iconv_converter_class *dcp)
 120 {
 121         kobj_class_instantiate((kobj_class_t)dcp);
 122         TAILQ_INSERT_TAIL(&iconv_converters, dcp, cc_link);
 123         return 0;
 124 }
 125
 126 static int
 127 iconv_unregister_converter(struct iconv_converter_class *dcp)
 128 {
 129         if (dcp->refs != 1) {
 130                 ICDEBUG("converter have %d referenses left\n", dcp->refs);
 131                 return EBUSY;
 132         }
 133         TAILQ_REMOVE(&iconv_converters, dcp, cc_link);
 134         kobj_class_uninstantiate((kobj_class_t)dcp);
 135         return 0;
 136 }
 137
 138 static int
 139 iconv_lookupconv(const char *name, struct iconv_converter_class **dcpp)
 140 {
 141         struct iconv_converter_class *dcp;
 142
 143         TAILQ_FOREACH(dcp, &iconv_converters, cc_link) {
 144                 if (name == NULL)
 145                         continue;
 146                 if (strcmp(name, ICONV_CONVERTER_NAME(dcp)) == 0) {
 147                         if (dcpp)
 148                                 *dcpp = dcp;
 149                         return 0;
 150                 }
 151         }
 152         return ENOENT;
 153 }
 154
 155 static int
 156 iconv_lookupcs(const char *to, const char *from, struct iconv_cspair **cspp)
 157 {
 158         struct iconv_cspair *csp;
 159
 160         TAILQ_FOREACH(csp, &iconv_cslist, cp_link) {
 161                 if (strcmp(csp->cp_to, to) == 0 &&
 162                     strcmp(csp->cp_from, from) == 0) {
 163                         if (cspp)
 164                                 *cspp = csp;
 165                         return 0;
 166                 }
 167         }
 168         return ENOENT;
 169 }
 170
 171 static int
 172 iconv_register_cspair(const char *to, const char *from,
 173         struct iconv_converter_class *dcp, void *data,
 174         struct iconv_cspair **cspp)
 175 {
 176         struct iconv_cspair *csp;
 177         char *cp;
 178         int csize, ucsto, ucsfrom;
 179
 180         if (iconv_lookupcs(to, from, NULL) == 0)
 181                 return EEXIST;
 182         csize = sizeof(*csp);
 183         ucsto = strcmp(to, iconv_unicode_string) == 0;
 184         if (!ucsto)
 185                 csize += strlen(to) + 1;
 186         ucsfrom = strcmp(from, iconv_unicode_string) == 0;
 187         if (!ucsfrom)
 188                 csize += strlen(from) + 1;
 189         csp = kmalloc(csize, M_ICONV, M_WAITOK);
 190         bzero(csp, csize);
 191         csp->cp_id = iconv_csid++;
 192         csp->cp_dcp = dcp;
 193         cp = (char*)(csp + 1);
 194         if (!ucsto) {
 195                 strcpy(cp, to);
 196                 csp->cp_to = cp;
 197                 cp += strlen(cp) + 1;
 198         } else
 199                 csp->cp_to = iconv_unicode_string;
 200         if (!ucsfrom) {
 201                 strcpy(cp, from);
 202                 csp->cp_from = cp;
 203         } else
 204                 csp->cp_from = iconv_unicode_string;
 205         csp->cp_data = data;
 206
 207         TAILQ_INSERT_TAIL(&iconv_cslist, csp, cp_link);
 208         *cspp = csp;
 209         return 0;
 210 }
 211
 212 static void
 213 iconv_unregister_cspair(struct iconv_cspair *csp)
 214 {
 215         TAILQ_REMOVE(&iconv_cslist, csp, cp_link);
 216         if (csp->cp_data)
 217                 kfree(csp->cp_data, M_ICONVDATA);
 218         kfree(csp, M_ICONV);
 219 }
 220
 221 /*
 222  * Lookup and create an instance of converter.
 223  * Currently this layer didn't have associated 'instance' structure
 224  * to avoid unnesessary memory allocation.
 225  */
 226 int
 227 iconv_open(const char *to, const char *from, void **handle)
 228 {
 229         struct iconv_cspair *csp, *cspfrom, *cspto;
 230         struct iconv_converter_class *dcp;
 231         const char *cnvname;
 232         int error;
 233
 234         /*
 235          * First, lookup fully qualified cspairs
 236          */
 237         error = iconv_lookupcs(to, from, &csp);
 238         if (error == 0)
 239                 return ICONV_CONVERTER_OPEN(csp->cp_dcp, csp, NULL, handle);
 240
 241         /*
 242          * Well, nothing found. Now try to construct a composite conversion
 243          * ToDo: add a 'capability' field to converter
 244          */
 245         TAILQ_FOREACH(dcp, &iconv_converters, cc_link) {
 246                 cnvname = ICONV_CONVERTER_NAME(dcp);
 247                 if (cnvname == NULL)
 248                         continue;
 249                 error = iconv_lookupcs(cnvname, from, &cspfrom);
 250                 if (error)
 251                         continue;
 252                 error = iconv_lookupcs(to, cnvname, &cspto);
 253                 if (error)
 254                         continue;
 255                 /*
 256                  * Fine, we're found a pair which can be combined together
 257                  */
 258                 return ICONV_CONVERTER_OPEN(dcp, cspto, cspfrom, handle);
 259         }
 260         return ENOENT;
 261 }
 262
 263 int
 264 iconv_close(void *handle)
 265 {
 266         return ICONV_CONVERTER_CLOSE(handle);
 267 }
 268
 269 int
 270 iconv_conv(void *handle, const char **inbuf,
 271         size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
 272 {
 273         return ICONV_CONVERTER_CONV(handle, inbuf, inbytesleft, outbuf, outbytesleft);
 274 }
 275
 276 /*
 277  * Give a list of loaded converters. Each name terminated with 0.
 278  * An empty string terminates the list.
 279  */
 280 static int
 281 iconv_sysctl_drvlist(SYSCTL_HANDLER_ARGS)
 282 {
 283         struct iconv_converter_class *dcp;
 284         const char *name;
 285         char spc;
 286         int error;
 287
 288         error = 0;
 289
 290         TAILQ_FOREACH(dcp, &iconv_converters, cc_link) {
 291                 name = ICONV_CONVERTER_NAME(dcp);
 292                 if (name == NULL)
 293                         continue;
 294                 error = SYSCTL_OUT(req, name, strlen(name) + 1);
 295                 if (error)
 296                         break;
 297         }
 298         if (error)
 299                 return error;
 300         spc = 0;
 301         error = SYSCTL_OUT(req, &spc, sizeof(spc));
 302         return error;
 303 }
 304
 305 SYSCTL_PROC(_kern_iconv, OID_AUTO, drvlist, CTLFLAG_RD | CTLTYPE_OPAQUE,
 306             NULL, 0, iconv_sysctl_drvlist, "S,xlat", "registered converters");
 307
 308 /*
 309  * List all available charset pairs.
 310  */
 311 static int
 312 iconv_sysctl_cslist(SYSCTL_HANDLER_ARGS)
 313 {
 314         struct iconv_cspair *csp;
 315         struct iconv_cspair_info csi;
 316         int error;
 317
 318         error = 0;
 319         bzero(&csi, sizeof(csi));
 320         csi.cs_version = ICONV_CSPAIR_INFO_VER;
 321
 322         TAILQ_FOREACH(csp, &iconv_cslist, cp_link) {
 323                 csi.cs_id = csp->cp_id;
 324                 csi.cs_refcount = csp->cp_refcount;
 325                 csi.cs_base = csp->cp_base ? csp->cp_base->cp_id : 0;
 326                 strcpy(csi.cs_to, csp->cp_to);
 327                 strcpy(csi.cs_from, csp->cp_from);
 328                 error = SYSCTL_OUT(req, &csi, sizeof(csi));
 329                 if (error)
 330                         break;
 331         }
 332         return error;
 333 }
 334
 335 SYSCTL_PROC(_kern_iconv, OID_AUTO, cslist, CTLFLAG_RD | CTLTYPE_OPAQUE,
 336             NULL, 0, iconv_sysctl_cslist, "S,xlat", "registered charset pairs");
 337
 338 /*
 339  * Add new charset pair
 340  */
 341 static int
 342 iconv_sysctl_add(SYSCTL_HANDLER_ARGS)
 343 {
 344         struct iconv_converter_class *dcp;
 345         struct iconv_cspair *csp;
 346         struct iconv_add_in din;
 347         struct iconv_add_out dout;
 348         int error;
 349
 350         error = SYSCTL_IN(req, &din, sizeof(din));
 351         if (error)
 352                 return error;
 353         if (din.ia_version != ICONV_ADD_VER)
 354                 return EINVAL;
 355         if (din.ia_datalen > ICONV_CSMAXDATALEN)
 356                 return EINVAL;
 357
 358         /*
 359          * Make sure all user-supplied strings are terminated before
 360          * proceeding.
 361          */
 362         din.ia_converter[ICONV_CNVNMAXLEN-1] = 0;
 363         din.ia_to[ICONV_CSNMAXLEN-1] = 0;
 364         din.ia_from[ICONV_CSNMAXLEN-1] = 0;
 365
 366         if (iconv_lookupconv(din.ia_converter, &dcp) != 0)
 367                 return EINVAL;
 368         error = iconv_register_cspair(din.ia_to, din.ia_from, dcp, NULL, &csp);
 369         if (error)
 370                 return error;
 371         if (din.ia_datalen) {
 372                 csp->cp_data = kmalloc(din.ia_datalen, M_ICONVDATA, M_WAITOK);
 373                 error = copyin(din.ia_data, csp->cp_data, din.ia_datalen);
 374                 if (error)
 375                         goto bad;
 376         }
 377         dout.ia_csid = csp->cp_id;
 378         error = SYSCTL_OUT(req, &dout, sizeof(dout));
 379         if (error)
 380                 goto bad;
 381         return 0;
 382 bad:
 383         iconv_unregister_cspair(csp);
 384         return error;
 385 }
 386
 387 SYSCTL_PROC(_kern_iconv, OID_AUTO, add, CTLFLAG_RW | CTLTYPE_OPAQUE,
 388             NULL, 0, iconv_sysctl_add, "S,xlat", "register charset pair");
 389
 390 /*
 391  * Default stubs for converters
 392  */
 393 int
 394 iconv_converter_initstub(struct iconv_converter_class *dp)
 395 {
 396         return 0;
 397 }
 398
 399 int
 400 iconv_converter_donestub(struct iconv_converter_class *dp)
 401 {
 402         return 0;
 403 }
 404
 405 int
 406 iconv_converter_handler(module_t mod, int type, void *data)
 407 {
 408         struct iconv_converter_class *dcp = data;
 409         int error;
 410
 411         switch (type) {
 412             case MOD_LOAD:
 413                 error = iconv_register_converter(dcp);
 414                 if (error)
 415                         break;
 416                 error = ICONV_CONVERTER_INIT(dcp);
 417                 if (error)
 418                         iconv_unregister_converter(dcp);
 419                 break;
 420             case MOD_UNLOAD:
 421                 ICONV_CONVERTER_DONE(dcp);
 422                 error = iconv_unregister_converter(dcp);
 423                 break;
 424             default:
 425                 error = EINVAL;
 426         }
 427         return error;
 428 }
 429
 430 /*
 431  * Common used functions
 432  */
 433 char *
 434 iconv_convstr(void *handle, char *dst, const char *src)
 435 {
 436         char *p = dst;
 437         int inlen, outlen, error;
 438
 439         if (handle == NULL) {
 440                 strcpy(dst, src);
 441                 return dst;
 442         }
 443         inlen = outlen = strlen(src);
 444         error = iconv_conv(handle, NULL, NULL, &p, &outlen);
 445         if (error)
 446                 return NULL;
 447         error = iconv_conv(handle, &src, &inlen, &p, &outlen);
 448         if (error)
 449                 return NULL;
 450         *p = 0;
 451         return dst;
 452 }
 453
 454 void *
 455 iconv_convmem(void *handle, void *dst, const void *src, int size)
 456 {
 457         const char *s = src;
 458         char *d = dst;
 459         int inlen, outlen, error;
 460
 461         if (size == 0)
 462                 return dst;
 463         if (handle == NULL) {
 464                 memcpy(dst, src, size);
 465                 return dst;
 466         }
 467         inlen = outlen = size;
 468         error = iconv_conv(handle, NULL, NULL, &d, &outlen);
 469         if (error)
 470                 return NULL;
 471         error = iconv_conv(handle, &s, &inlen, &d, &outlen);
 472         if (error)
 473                 return NULL;
 474         return dst;
 475 }
 476
 477 int
 478 iconv_lookupcp(char **cpp, const char *s)
 479 {
 480         if (cpp == NULL) {
 481                 ICDEBUG("warning a NULL list passed\n");
 482                 return ENOENT;
 483         }
 484         for (; *cpp; cpp++)
 485                 if (strcmp(*cpp, s) == 0)
 486                         return 0;
 487         return ENOENT;
 488 }