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.4 2004/04/01 08:41:24 joerg 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 = malloc(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                 free(csp->cp_data, M_ICONVDATA);
 218         free(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         if (iconv_lookupconv(din.ia_converter, &dcp) != 0)
 358                 return EINVAL;
 359         error = iconv_register_cspair(din.ia_to, din.ia_from, dcp, NULL, &csp);
 360         if (error)
 361                 return error;
 362         if (din.ia_datalen) {
 363                 csp->cp_data = malloc(din.ia_datalen, M_ICONVDATA, M_WAITOK);
 364                 error = copyin(din.ia_data, csp->cp_data, din.ia_datalen);
 365                 if (error)
 366                         goto bad;
 367         }
 368         dout.ia_csid = csp->cp_id;
 369         error = SYSCTL_OUT(req, &dout, sizeof(dout));
 370         if (error)
 371                 goto bad;
 372         return 0;
 373 bad:
 374         iconv_unregister_cspair(csp);
 375         return error;
 376 }
 377
 378 SYSCTL_PROC(_kern_iconv, OID_AUTO, add, CTLFLAG_RW | CTLTYPE_OPAQUE,
 379             NULL, 0, iconv_sysctl_add, "S,xlat", "register charset pair");
 380
 381 /*
 382  * Default stubs for converters
 383  */
 384 int
 385 iconv_converter_initstub(struct iconv_converter_class *dp)
 386 {
 387         return 0;
 388 }
 389
 390 int
 391 iconv_converter_donestub(struct iconv_converter_class *dp)
 392 {
 393         return 0;
 394 }
 395
 396 int
 397 iconv_converter_handler(module_t mod, int type, void *data)
 398 {
 399         struct iconv_converter_class *dcp = data;
 400         int error;
 401
 402         switch (type) {
 403             case MOD_LOAD:
 404                 error = iconv_register_converter(dcp);
 405                 if (error)
 406                         break;
 407                 error = ICONV_CONVERTER_INIT(dcp);
 408                 if (error)
 409                         iconv_unregister_converter(dcp);
 410                 break;
 411             case MOD_UNLOAD:
 412                 ICONV_CONVERTER_DONE(dcp);
 413                 error = iconv_unregister_converter(dcp);
 414                 break;
 415             default:
 416                 error = EINVAL;
 417         }
 418         return error;
 419 }
 420
 421 /*
 422  * Common used functions
 423  */
 424 char *
 425 iconv_convstr(void *handle, char *dst, const char *src)
 426 {
 427         char *p = dst;
 428         int inlen, outlen, error;
 429
 430         if (handle == NULL) {
 431                 strcpy(dst, src);
 432                 return dst;
 433         }
 434         inlen = outlen = strlen(src);
 435         error = iconv_conv(handle, NULL, NULL, &p, &outlen);
 436         if (error)
 437                 return NULL;
 438         error = iconv_conv(handle, &src, &inlen, &p, &outlen);
 439         if (error)
 440                 return NULL;
 441         *p = 0;
 442         return dst;
 443 }
 444
 445 void *
 446 iconv_convmem(void *handle, void *dst, const void *src, int size)
 447 {
 448         const char *s = src;
 449         char *d = dst;
 450         int inlen, outlen, error;
 451
 452         if (size == 0)
 453                 return dst;
 454         if (handle == NULL) {
 455                 memcpy(dst, src, size);
 456                 return dst;
 457         }
 458         inlen = outlen = size;
 459         error = iconv_conv(handle, NULL, NULL, &d, &outlen);
 460         if (error)
 461                 return NULL;
 462         error = iconv_conv(handle, &s, &inlen, &d, &outlen);
 463         if (error)
 464                 return NULL;
 465         return dst;
 466 }
 467
 468 int
 469 iconv_lookupcp(char **cpp, const char *s)
 470 {
 471         if (cpp == NULL) {
 472                 ICDEBUG("warning a NULL list passed\n");
 473                 return ENOENT;
 474         }
 475         for (; *cpp; cpp++)
 476                 if (strcmp(*cpp, s) == 0)
 477                         return 0;
 478         return ENOENT;
 479 }