lib/libc/citrus/citrus_esdb.c

   1 /* $FreeBSD: head/lib/libc/iconv/citrus_esdb.c 219019 2011-02-25 00:04:39Z gabor $ */
   2 /* $NetBSD: citrus_esdb.c,v 1.5 2008/02/09 14:56:20 junyoung Exp $ */
   3
   4 /*-
   5  * Copyright (c)2003 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/types.h>
  32
  33 #include <assert.h>
  34 #include <errno.h>
  35 #include <limits.h>
  36 #include <paths.h>
  37 #include <stdbool.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_memstream.h"
  47 #include "citrus_mmap.h"
  48 #include "citrus_lookup.h"
  49 #include "citrus_db.h"
  50 #include "citrus_db_hash.h"
  51 #include "citrus_esdb.h"
  52 #include "citrus_esdb_file.h"
  53
  54 #define ESDB_DIR        "esdb.dir"
  55 #define ESDB_ALIAS      "esdb.alias"
  56
  57 /*
  58  * _citrus_esdb_alias:
  59  *      resolve encoding scheme name aliases.
  60  */
  61 const char *
  62 _citrus_esdb_alias(const char *esname, char *buf, size_t bufsize)
  63 {
  64
  65         return (_lookup_alias(_PATH_ESDB "/" ESDB_ALIAS, esname, buf, bufsize,
  66             _LOOKUP_CASE_IGNORE));
  67 }
  68
  69
  70 /*
  71  * conv_esdb:
  72  *      external representation -> local structure.
  73  */
  74 static int
  75 conv_esdb(struct _citrus_esdb *esdb, struct _region *fr)
  76 {
  77         struct _citrus_db *db;
  78         const char *str;
  79         char buf[100];
  80         uint32_t csid, i, num_charsets, tmp, version;
  81         int ret;
  82
  83         /* open db */
  84         ret = _db_open(&db, fr, _CITRUS_ESDB_MAGIC, &_db_hash_std, NULL);
  85         if (ret)
  86                 goto err0;
  87
  88         /* check version */
  89         ret = _db_lookup32_by_s(db, _CITRUS_ESDB_SYM_VERSION, &version, NULL);
  90         if (ret)
  91                 goto err1;
  92         switch (version) {
  93         case 0x00000001:
  94                 /* current version */
  95                 /* initial version */
  96                 break;
  97         default:
  98                 ret = EFTYPE;
  99                 goto err1;
 100         }
 101
 102         /* get encoding/variable */
 103         ret = _db_lookupstr_by_s(db, _CITRUS_ESDB_SYM_ENCODING, &str, NULL);
 104         if (ret)
 105                 goto err1;
 106         esdb->db_encname = strdup(str);
 107         if (esdb->db_encname == NULL) {
 108                 ret = errno;
 109                 goto err1;
 110         }
 111
 112         esdb->db_len_variable = 0;
 113         esdb->db_variable = NULL;
 114         ret = _db_lookupstr_by_s(db, _CITRUS_ESDB_SYM_VARIABLE, &str, NULL);
 115         if (ret == 0) {
 116                 esdb->db_len_variable = strlen(str) + 1;
 117                 esdb->db_variable = strdup(str);
 118                 if (esdb->db_variable == NULL) {
 119                         ret = errno;
 120                         goto err2;
 121                 }
 122         } else if (ret != ENOENT)
 123                 goto err2;
 124
 125         /* get number of charsets */
 126         ret = _db_lookup32_by_s(db, _CITRUS_ESDB_SYM_NUM_CHARSETS,
 127             &num_charsets, NULL);
 128         if (ret)
 129                 goto err3;
 130         esdb->db_num_charsets = num_charsets;
 131
 132         /* get invalid character */
 133         ret = _db_lookup32_by_s(db, _CITRUS_ESDB_SYM_INVALID, &tmp, NULL);
 134         if (ret == 0) {
 135                 esdb->db_use_invalid = 1;
 136                 esdb->db_invalid = tmp;
 137         } else if (ret == ENOENT)
 138                 esdb->db_use_invalid = 0;
 139         else
 140                 goto err3;
 141
 142         /* get charsets */
 143         esdb->db_charsets = malloc(num_charsets * sizeof(*esdb->db_charsets));
 144         if (esdb->db_charsets == NULL) {
 145                 ret = errno;
 146                 goto err3;
 147         }
 148         for (i = 0; i < num_charsets; i++) {
 149                 snprintf(buf, sizeof(buf),
 150                     _CITRUS_ESDB_SYM_CSID_PREFIX "%d", i);
 151                 ret = _db_lookup32_by_s(db, buf, &csid, NULL);
 152                 if (ret)
 153                         goto err4;
 154                 esdb->db_charsets[i].ec_csid = csid;
 155
 156                 snprintf(buf, sizeof(buf),
 157                     _CITRUS_ESDB_SYM_CSNAME_PREFIX "%d", i);
 158                 ret = _db_lookupstr_by_s(db, buf, &str, NULL);
 159                 if (ret)
 160                         goto err4;
 161                 esdb->db_charsets[i].ec_csname = strdup(str);
 162                 if (esdb->db_charsets[i].ec_csname == NULL) {
 163                         ret = errno;
 164                         goto err4;
 165                 }
 166         }
 167
 168         _db_close(db);
 169         return (0);
 170
 171 err4:
 172         for (; i > 0; i--)
 173                 free(esdb->db_charsets[i - 1].ec_csname);
 174         free(esdb->db_charsets);
 175 err3:
 176         free(esdb->db_variable);
 177 err2:
 178         free(esdb->db_encname);
 179 err1:
 180         _db_close(db);
 181         if (ret == ENOENT)
 182                 ret = EFTYPE;
 183 err0:
 184         return (ret);
 185 }
 186
 187 /*
 188  * _citrus_esdb_open:
 189  *      open an ESDB file.
 190  */
 191 int
 192 _citrus_esdb_open(struct _citrus_esdb *db, const char *esname)
 193 {
 194         struct _region fr;
 195         const char *realname, *encfile;
 196         char buf1[PATH_MAX], buf2[PATH_MAX], path[PATH_MAX];
 197         int ret;
 198
 199         snprintf(path, sizeof(path), "%s/%s", _PATH_ESDB, ESDB_ALIAS);
 200         realname = _lookup_alias(path, esname, buf1, sizeof(buf1),
 201             _LOOKUP_CASE_IGNORE);
 202
 203         snprintf(path, sizeof(path), "%s/%s", _PATH_ESDB, ESDB_DIR);
 204         encfile = _lookup_simple(path, realname, buf2, sizeof(buf2),
 205             _LOOKUP_CASE_IGNORE);
 206         if (encfile == NULL)
 207                 return (ENOENT);
 208
 209         /* open file */
 210         snprintf(path, sizeof(path), "%s/%s", _PATH_ESDB, encfile);
 211         ret = _map_file(&fr, path);
 212         if (ret)
 213                 return (ret);
 214
 215         ret = conv_esdb(db, &fr);
 216
 217         _unmap_file(&fr);
 218
 219         return (ret);
 220 }
 221
 222 /*
 223  * _citrus_esdb_close:
 224  *      free an ESDB.
 225  */
 226 void
 227 _citrus_esdb_close(struct _citrus_esdb *db)
 228 {
 229
 230         for (int i = 0; i < db->db_num_charsets; i++)
 231                 free(db->db_charsets[i].ec_csname);
 232         db->db_num_charsets = 0;
 233         free(db->db_charsets); db->db_charsets = NULL;
 234         free(db->db_encname); db->db_encname = NULL;
 235         db->db_len_variable = 0;
 236         free(db->db_variable); db->db_variable = NULL;
 237 }
 238
 239 /*
 240  * _citrus_esdb_free_list:
 241  *      free the list.
 242  */
 243 void
 244 _citrus_esdb_free_list(char **list, size_t num)
 245 {
 246
 247         for (size_t i = 0; i < num; i++)
 248                 free(list[i]);
 249         free(list);
 250 }
 251
 252 /*
 253  * _citrus_esdb_get_list:
 254  *      get esdb entries.
 255  */
 256 int
 257 _citrus_esdb_get_list(char ***rlist, size_t *rnum, bool sorted)
 258 {
 259         struct _citrus_lookup *cla, *cld;
 260         struct _region key, data;
 261         char **list, **q;
 262         char buf[PATH_MAX];
 263         size_t num;
 264         int ret;
 265
 266         num = 0;
 267
 268         ret = _lookup_seq_open(&cla, _PATH_ESDB "/" ESDB_ALIAS,
 269             _LOOKUP_CASE_IGNORE);
 270         if (ret)
 271                 goto quit0;
 272
 273         ret = _lookup_seq_open(&cld, _PATH_ESDB "/" ESDB_DIR,
 274             _LOOKUP_CASE_IGNORE);
 275         if (ret)
 276                 goto quit1;
 277
 278         /* count number of entries */
 279         num = _lookup_get_num_entries(cla) + _lookup_get_num_entries(cld);
 280
 281         _lookup_seq_rewind(cla);
 282         _lookup_seq_rewind(cld);
 283
 284         /* allocate list pointer space */
 285         list = malloc(num * sizeof(char *));
 286         num = 0;
 287         if (list == NULL) {
 288                 ret = errno;
 289                 goto quit3;
 290         }
 291
 292         /* get alias entries */
 293         while ((ret = _lookup_seq_next(cla, &key, &data)) == 0) {
 294                 if (sorted)
 295                         snprintf(buf, sizeof(buf), "%.*s/%.*s",
 296                             (int)_region_size(&data),
 297                             (const char *)_region_head(&data),
 298                             (int)_region_size(&key),
 299                             (const char *)_region_head(&key));
 300                 else
 301                         snprintf(buf, sizeof(buf), "%.*s/%.*s",
 302                             (int)_region_size(&data),
 303                             (const char *)_region_head(&data),
 304                             (int)_region_size(&key),
 305                             (const char *)_region_head(&key));
 306                 _bcs_convert_to_upper(buf);
 307                 list[num] = strdup(buf);
 308                 if (list[num] == NULL) {
 309                         ret = errno;
 310                         goto quit3;
 311                 }
 312                 num++;
 313         }
 314         if (ret != ENOENT)
 315                 goto quit3;
 316         /* get dir entries */
 317         while ((ret = _lookup_seq_next(cld, &key, &data)) == 0) {
 318                 if (!sorted)
 319                         snprintf(buf, sizeof(buf), "%.*s",
 320                             (int)_region_size(&key),
 321                             (const char *)_region_head(&key));
 322                 else {
 323                         /* check duplicated entry */
 324                         char *p;
 325                         char buf1[PATH_MAX];
 326
 327                         snprintf(buf1, sizeof(buf1), "%.*s",
 328                             (int)_region_size(&data),
 329                             (const char *)_region_head(&data));
 330                         if ((p = strchr(buf1, '/')) != NULL)
 331                                 memcpy(buf1, p + 1, strlen(p) - 1);
 332                         if ((p = strstr(buf1, ".esdb")) != NULL)
 333                                 *p = '\0';
 334                         snprintf(buf, sizeof(buf), "%s/%.*s", buf1,
 335                             (int)_region_size(&key),
 336                             (const char *)_region_head(&key));
 337                 }
 338                 _bcs_convert_to_upper(buf);
 339                 ret = _lookup_seq_lookup(cla, buf, NULL);
 340                 if (ret) {
 341                         if (ret != ENOENT)
 342                                 goto quit3;
 343                         /* not duplicated */
 344                         list[num] = strdup(buf);
 345                         if (list[num] == NULL) {
 346                                 ret = errno;
 347                                 goto quit3;
 348                         }
 349                         num++;
 350                 }
 351         }
 352         if (ret != ENOENT)
 353                 goto quit3;
 354
 355         ret = 0;
 356         /* XXX: why reallocing the list space posteriorly?
 357             shouldn't be done earlier? */
 358         q = realloc(list, num * sizeof(char *));
 359         if (!q) {
 360                 ret = ENOMEM;
 361                 goto quit3;
 362         }
 363         list = q;
 364         *rlist = list;
 365         *rnum = num;
 366 quit3:
 367         if (ret)
 368                 _citrus_esdb_free_list(list, num);
 369         _lookup_seq_close(cld);
 370 quit1:
 371         _lookup_seq_close(cla);
 372 quit0:
 373         return (ret);
 374 }