lib/i18n_module/mapper_std/citrus_mapper_std.c

   1 /* $FreeBSD: head/lib/libiconv_modules/mapper_std/citrus_mapper_std.c 219019 2011-02-25 00:04:39Z gabor $ */
   2 /*      $NetBSD: citrus_mapper_std.c,v 1.8 2006/09/11 13:06:33 tnozaki Exp $    */
   3
   4 /*-
   5  * Copyright (c)2003, 2006 Citrus Project,
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 #include <sys/endian.h>
  32 #include <sys/queue.h>
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <stdint.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 #include "citrus_namespace.h"
  43 #include "citrus_types.h"
  44 #include "citrus_bcs.h"
  45 #include "citrus_region.h"
  46 #include "citrus_mmap.h"
  47 #include "citrus_module.h"
  48 #include "citrus_hash.h"
  49 #include "citrus_mapper.h"
  50 #include "citrus_db.h"
  51 #include "citrus_db_hash.h"
  52
  53 #include "citrus_mapper_std.h"
  54 #include "citrus_mapper_std_file.h"
  55
  56 /* ---------------------------------------------------------------------- */
  57
  58 _CITRUS_MAPPER_DECLS(mapper_std);
  59 _CITRUS_MAPPER_DEF_OPS(mapper_std);
  60
  61
  62 /* ---------------------------------------------------------------------- */
  63
  64 int
  65 _citrus_mapper_std_mapper_getops(struct _citrus_mapper_ops *ops)
  66 {
  67
  68         memcpy(ops, &_citrus_mapper_std_mapper_ops,
  69             sizeof(_citrus_mapper_std_mapper_ops));
  70
  71         return (0);
  72 }
  73
  74 /* ---------------------------------------------------------------------- */
  75
  76 static int
  77 /*ARGSUSED*/
  78 rowcol_convert(struct _citrus_mapper_std * __restrict ms,
  79     _index_t * __restrict dst, _index_t src, void * __restrict ps __unused)
  80 {
  81         struct _citrus_mapper_std_linear_zone *lz;
  82         struct _citrus_mapper_std_rowcol *rc;
  83         _index_t idx = 0, n;
  84         size_t i;
  85         uint32_t conv;
  86
  87         /* ps may be unused */
  88         rc = &ms->ms_rowcol;
  89
  90         for (i = rc->rc_src_rowcol_len * rc->rc_src_rowcol_bits,
  91             lz = &rc->rc_src_rowcol[0]; i > 0; ++lz) {
  92                 i -= rc->rc_src_rowcol_bits;
  93                 n = (src >> i) & rc->rc_src_rowcol_mask;
  94                 if (n < lz->begin || n > lz->end) {
  95                         switch (rc->rc_oob_mode) {
  96                         case _CITRUS_MAPPER_STD_OOB_NONIDENTICAL:
  97                                 *dst = rc->rc_dst_invalid;
  98                                 return (_MAPPER_CONVERT_NONIDENTICAL);
  99                         case _CITRUS_MAPPER_STD_OOB_ILSEQ:
 100                                 return (_MAPPER_CONVERT_ILSEQ);
 101                         default:
 102                                 return (_MAPPER_CONVERT_FATAL);
 103                         }
 104                 }
 105                 idx = idx * lz->width + n - lz->begin;
 106         }
 107         switch (rc->rc_dst_unit_bits) {
 108         case 8:
 109                 conv = _region_peek8(&rc->rc_table, idx);
 110                 break;
 111         case 16:
 112                 conv = be16toh(_region_peek16(&rc->rc_table, idx*2));
 113                 break;
 114         case 32:
 115                 conv = be32toh(_region_peek32(&rc->rc_table, idx*4));
 116                 break;
 117         default:
 118                 return (_MAPPER_CONVERT_FATAL);
 119         }
 120
 121         if (conv == rc->rc_dst_invalid) {
 122                 *dst = rc->rc_dst_invalid;
 123                 return (_MAPPER_CONVERT_NONIDENTICAL);
 124         }
 125         if (conv == rc->rc_dst_ilseq)
 126                 return (_MAPPER_CONVERT_ILSEQ);
 127
 128         *dst = conv;
 129
 130         return (_MAPPER_CONVERT_SUCCESS);
 131 }
 132
 133 static __inline int
 134 set_linear_zone(struct _citrus_mapper_std_linear_zone *lz,
 135     uint32_t begin, uint32_t end)
 136 {
 137
 138         if (begin > end)
 139                 return (EFTYPE);
 140
 141         lz->begin = begin;
 142         lz->end = end;
 143         lz->width= end - begin + 1;
 144
 145         return (0);
 146 }
 147
 148 static __inline int
 149 rowcol_parse_variable_compat(struct _citrus_mapper_std_rowcol *rc,
 150     struct _region *r)
 151 {
 152         const struct _citrus_mapper_std_rowcol_info_compat_x *rcx;
 153         struct _citrus_mapper_std_linear_zone *lz;
 154         uint32_t m, n;
 155         int ret;
 156
 157         rcx = _region_head(r);
 158
 159         rc->rc_dst_invalid = be32toh(rcx->rcx_dst_invalid);
 160         rc->rc_dst_unit_bits = be32toh(rcx->rcx_dst_unit_bits);
 161         m = be32toh(rcx->rcx_src_col_bits);
 162         n = 1 << (m - 1);
 163         n |= n - 1;
 164         rc->rc_src_rowcol_bits = m;
 165         rc->rc_src_rowcol_mask = n;
 166
 167         rc->rc_src_rowcol = malloc(2 *
 168             sizeof(*rc->rc_src_rowcol));
 169         if (rc->rc_src_rowcol == NULL)
 170                 return (ENOMEM);
 171         lz = rc->rc_src_rowcol;
 172         rc->rc_src_rowcol_len = 1;
 173         m = be32toh(rcx->rcx_src_row_begin);
 174         n = be32toh(rcx->rcx_src_row_end);
 175         if (m + n > 0) {
 176                 ret = set_linear_zone(lz, m, n);
 177                 if (ret != 0)
 178                         return (ret);
 179                 ++rc->rc_src_rowcol_len, ++lz;
 180         }
 181         m = be32toh(rcx->rcx_src_col_begin);
 182         n = be32toh(rcx->rcx_src_col_end);
 183
 184         return (set_linear_zone(lz, m, n));
 185 }
 186
 187 static __inline int
 188 rowcol_parse_variable(struct _citrus_mapper_std_rowcol *rc,
 189     struct _region *r)
 190 {
 191         const struct _citrus_mapper_std_rowcol_info_x *rcx;
 192         struct _citrus_mapper_std_linear_zone *lz;
 193         size_t i;
 194         uint32_t m, n;
 195         int ret;
 196
 197         rcx = _region_head(r);
 198
 199         rc->rc_dst_invalid = be32toh(rcx->rcx_dst_invalid);
 200         rc->rc_dst_unit_bits = be32toh(rcx->rcx_dst_unit_bits);
 201
 202         m = be32toh(rcx->rcx_src_rowcol_bits);
 203         n = 1 << (m - 1);
 204         n |= n - 1;
 205         rc->rc_src_rowcol_bits = m;
 206         rc->rc_src_rowcol_mask = n;
 207
 208         rc->rc_src_rowcol_len = be32toh(rcx->rcx_src_rowcol_len);
 209         if (rc->rc_src_rowcol_len > _CITRUS_MAPPER_STD_ROWCOL_MAX)
 210                 return (EFTYPE);
 211         rc->rc_src_rowcol = malloc(rc->rc_src_rowcol_len *
 212             sizeof(*rc->rc_src_rowcol));
 213         if (rc->rc_src_rowcol == NULL)
 214                 return (ENOMEM);
 215         for (i = 0, lz = rc->rc_src_rowcol;
 216             i < rc->rc_src_rowcol_len; ++i, ++lz) {
 217                 m = be32toh(rcx->rcx_src_rowcol[i].begin),
 218                 n = be32toh(rcx->rcx_src_rowcol[i].end);
 219                 ret = set_linear_zone(lz, m, n);
 220                 if (ret != 0) {
 221                         free(rc->rc_src_rowcol);
 222                         rc->rc_src_rowcol = NULL;
 223                         return (ret);
 224                 }
 225         }
 226         return (0);
 227 }
 228
 229 static void
 230 rowcol_uninit(struct _citrus_mapper_std *ms)
 231 {
 232         struct _citrus_mapper_std_rowcol *rc;
 233
 234         rc = &ms->ms_rowcol;
 235         free(rc->rc_src_rowcol);
 236 }
 237
 238 static int
 239 rowcol_init(struct _citrus_mapper_std *ms)
 240 {
 241         struct _citrus_mapper_std_linear_zone *lz;
 242         struct _citrus_mapper_std_rowcol *rc;
 243         const struct _citrus_mapper_std_rowcol_ext_ilseq_info_x *eix;
 244         struct _region r;
 245         uint64_t table_size;
 246         size_t i;
 247         int ret;
 248
 249         ms->ms_convert = &rowcol_convert;
 250         ms->ms_uninit = &rowcol_uninit;
 251         rc = &ms->ms_rowcol;
 252
 253         /* get table region */
 254         ret = _db_lookup_by_s(ms->ms_db, _CITRUS_MAPPER_STD_SYM_TABLE,
 255             &rc->rc_table, NULL);
 256         if (ret) {
 257                 if (ret == ENOENT)
 258                         ret = EFTYPE;
 259                 return (ret);
 260         }
 261
 262         /* get table information */
 263         ret = _db_lookup_by_s(ms->ms_db, _CITRUS_MAPPER_STD_SYM_INFO, &r, NULL);
 264         if (ret) {
 265                 if (ret == ENOENT)
 266                         ret = EFTYPE;
 267                 return (ret);
 268         }
 269         switch (_region_size(&r)) {
 270         case _CITRUS_MAPPER_STD_ROWCOL_INFO_COMPAT_SIZE:
 271                 ret = rowcol_parse_variable_compat(rc, &r);
 272                 break;
 273         case _CITRUS_MAPPER_STD_ROWCOL_INFO_SIZE:
 274                 ret = rowcol_parse_variable(rc, &r);
 275                 break;
 276         default:
 277                 return (EFTYPE);
 278         }
 279         if (ret != 0)
 280                 return (ret);
 281         /* sanity check */
 282         switch (rc->rc_src_rowcol_bits) {
 283         case 8: case 16: case 32:
 284                 if (rc->rc_src_rowcol_len <= 32 / rc->rc_src_rowcol_bits)
 285                         break;
 286         /*FALLTHROUGH*/
 287         default:
 288                 return (EFTYPE);
 289         }
 290
 291         /* ilseq extension */
 292         rc->rc_oob_mode = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL;
 293         rc->rc_dst_ilseq = rc->rc_dst_invalid;
 294         ret = _db_lookup_by_s(ms->ms_db,
 295             _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &r, NULL);
 296         if (ret && ret != ENOENT)
 297                 return (ret);
 298         if (_region_size(&r) < sizeof(*eix))
 299                 return (EFTYPE);
 300         if (ret == 0) {
 301                 eix = _region_head(&r);
 302                 rc->rc_oob_mode = be32toh(eix->eix_oob_mode);
 303                 rc->rc_dst_ilseq = be32toh(eix->eix_dst_ilseq);
 304         }
 305
 306         /* calcurate expected table size */
 307         i = rc->rc_src_rowcol_len;
 308         lz = &rc->rc_src_rowcol[--i];
 309         table_size = lz->width;
 310         while (i > 0) {
 311                 lz = &rc->rc_src_rowcol[--i];
 312                 table_size *= lz->width;
 313         }
 314         table_size *= rc->rc_dst_unit_bits/8;
 315
 316         if (table_size > UINT32_MAX ||
 317             _region_size(&rc->rc_table) < table_size)
 318                 return (EFTYPE);
 319
 320         return (0);
 321 }
 322
 323 typedef int (*initfunc_t)(struct _citrus_mapper_std *);
 324 static const struct {
 325         initfunc_t                       t_init;
 326         const char                      *t_name;
 327 } types[] = {
 328         { &rowcol_init, _CITRUS_MAPPER_STD_TYPE_ROWCOL },
 329 };
 330 #define NUM_OF_TYPES ((int)(sizeof(types)/sizeof(types[0])))
 331
 332 static int
 333 /*ARGSUSED*/
 334 _citrus_mapper_std_mapper_init(struct _citrus_mapper_area *__restrict ma __unused,
 335     struct _citrus_mapper * __restrict cm, const char * __restrict curdir,
 336     const void * __restrict var, size_t lenvar,
 337     struct _citrus_mapper_traits * __restrict mt, size_t lenmt)
 338 {
 339         struct _citrus_mapper_std *ms;
 340         char path[PATH_MAX];
 341         const char *type;
 342         int id, ret;
 343
 344         /* set traits */
 345         if (lenmt < sizeof(*mt)) {
 346                 ret = EINVAL;
 347                 goto err0;
 348         }
 349         mt->mt_src_max = mt->mt_dst_max = 1;    /* 1:1 converter */
 350         mt->mt_state_size = 0;                  /* stateless */
 351
 352         /* alloc mapper std structure */
 353         ms = malloc(sizeof(*ms));
 354         if (ms == NULL) {
 355                 ret = errno;
 356                 goto err0;
 357         }
 358
 359         /* open mapper file */
 360         snprintf(path, sizeof(path), "%s/%.*s", curdir, (int)lenvar,
 361             (const char *)var);
 362         ret = _map_file(&ms->ms_file, path);
 363         if (ret)
 364                 goto err1;
 365
 366         ret = _db_open(&ms->ms_db, &ms->ms_file, _CITRUS_MAPPER_STD_MAGIC,
 367             &_db_hash_std, NULL);
 368         if (ret)
 369                 goto err2;
 370
 371         /* get mapper type */
 372         ret = _db_lookupstr_by_s(ms->ms_db, _CITRUS_MAPPER_STD_SYM_TYPE,
 373             &type, NULL);
 374         if (ret) {
 375                 if (ret == ENOENT)
 376                         ret = EFTYPE;
 377                 goto err3;
 378         }
 379         for (id = 0; id < NUM_OF_TYPES; id++)
 380                 if (_bcs_strcasecmp(type, types[id].t_name) == 0)
 381                         break;
 382
 383         if (id == NUM_OF_TYPES)
 384                 goto err3;
 385
 386         /* init the per-type structure */
 387         ret = (*types[id].t_init)(ms);
 388         if (ret)
 389                 goto err3;
 390
 391         cm->cm_closure = ms;
 392
 393         return (0);
 394
 395 err3:
 396         _db_close(ms->ms_db);
 397 err2:
 398         _unmap_file(&ms->ms_file);
 399 err1:
 400         free(ms);
 401 err0:
 402         return (ret);
 403 }
 404
 405 static void
 406 /*ARGSUSED*/
 407 _citrus_mapper_std_mapper_uninit(struct _citrus_mapper *cm)
 408 {
 409         struct _citrus_mapper_std *ms;
 410
 411         ms = cm->cm_closure;
 412         if (ms->ms_uninit)
 413                 (*ms->ms_uninit)(ms);
 414         _db_close(ms->ms_db);
 415         _unmap_file(&ms->ms_file);
 416         free(ms);
 417 }
 418
 419 static void
 420 /*ARGSUSED*/
 421 _citrus_mapper_std_mapper_init_state(void)
 422 {
 423
 424 }
 425
 426 static int
 427 /*ARGSUSED*/
 428 _citrus_mapper_std_mapper_convert(struct _citrus_mapper * __restrict cm,
 429     _index_t * __restrict dst, _index_t src, void * __restrict ps)
 430 {
 431         struct _citrus_mapper_std *ms;
 432
 433         ms = cm->cm_closure;
 434         return ((*ms->ms_convert)(ms, dst, src, ps));
 435 }