Home | History | Annotate | Line # | Download | only in citrus 
      1 /*	$NetBSD: citrus_mapper.c,v 1.10 2012/06/08 07:49:42 martin Exp $	*/
      2 
      3 /*-
      4  * Copyright (c)2003 Citrus Project,
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 #if defined(LIBC_SCCS) && !defined(lint)
     31 __RCSID("$NetBSD: citrus_mapper.c,v 1.10 2012/06/08 07:49:42 martin Exp $");
     32 #endif /* LIBC_SCCS and not lint */
     33 
     34 #include "namespace.h"
     35 #include "reentrant.h"
     36 #include <assert.h>
     37 #include <stdio.h>
     38 #include <stdlib.h>
     39 #include <string.h>
     40 #include <errno.h>
     41 #include <limits.h>
     42 #include <sys/types.h>
     43 #include <sys/stat.h>
     44 #include <sys/queue.h>
     45 
     46 #include "citrus_namespace.h"
     47 #include "citrus_types.h"
     48 #include "citrus_region.h"
     49 #include "citrus_memstream.h"
     50 #include "citrus_bcs.h"
     51 #include "citrus_mmap.h"
     52 #include "citrus_module.h"
     53 #include "citrus_hash.h"
     54 #include "citrus_mapper.h"
     55 
     56 #define _CITRUS_MAPPER_DIR	"mapper.dir"
     57 
     58 #define CM_HASH_SIZE 101
     59 #define REFCOUNT_PERSISTENT	-1
     60 
     61 #ifdef _REENTRANT
     62 static rwlock_t lock = RWLOCK_INITIALIZER;
     63 #endif
     64 
     65 struct _citrus_mapper_area {
     66 	_CITRUS_HASH_HEAD(, _citrus_mapper, CM_HASH_SIZE)	ma_cache;
     67 	char							*ma_dir;
     68 };
     69 
     70 /*
     71  * _citrus_mapper_create_area:
     72  *	create mapper area
     73  */
     74 
     75 int
     76 _citrus_mapper_create_area(
     77 	struct _citrus_mapper_area *__restrict *__restrict rma,
     78 	const char *__restrict area)
     79 {
     80 	struct stat st;
     81 	int ret;
     82 	char path[PATH_MAX];
     83 	struct _citrus_mapper_area *ma;
     84 
     85 	rwlock_wrlock(&lock);
     86 
     87 	if (*rma != NULL) {
     88 		ret = 0;
     89 		goto quit;
     90 	}
     91 
     92 	snprintf(path, (size_t)PATH_MAX, "%s/%s", area, _CITRUS_MAPPER_DIR);
     93 
     94 	ret = stat(path, &st);
     95 	if (ret)
     96 		goto quit;
     97 
     98 	ma = malloc(sizeof(*ma));
     99 	if (ma == NULL) {
    100 		ret = errno;
    101 		goto quit;
    102 	}
    103 	ma->ma_dir = strdup(area);
    104 	if (ma->ma_dir == NULL) {
    105 		free(ma);
    106 		ret = errno;
    107 		goto quit;
    108 	}
    109 	_CITRUS_HASH_INIT(&ma->ma_cache, CM_HASH_SIZE);
    110 
    111 	*rma = ma;
    112 	ret = 0;
    113 quit:
    114 	rwlock_unlock(&lock);
    115 
    116 	return ret;
    117 }
    118 
    119 
    120 /*
    121  * lookup_mapper_entry:
    122  *	lookup mapper.dir entry in the specified directory.
    123  *
    124  * line format of iconv.dir file:
    125  *	mapper	module	arg
    126  * mapper : mapper name.
    127  * module : mapper module name.
    128  * arg    : argument for the module (generally, description file name)
    129  */
    130 
    131 static int
    132 lookup_mapper_entry(const char *dir, const char *mapname,
    133 		    void *linebuf, size_t linebufsize,
    134 		    const char **module, const char **variable)
    135 {
    136 	struct _region r;
    137 	struct _memstream ms;
    138 	int ret;
    139 	const char *cp, *cq;
    140 	char *p;
    141 	size_t len;
    142 	char path[PATH_MAX];
    143 
    144 	/* create mapper.dir path */
    145 	snprintf(path, (size_t)PATH_MAX, "%s/%s", dir, _CITRUS_MAPPER_DIR);
    146 
    147 	/* open read stream */
    148 	ret = _map_file(&r, path);
    149 	if (ret)
    150 		return ret;
    151 
    152 	_memstream_bind(&ms, &r);
    153 
    154 	/* search the line matching to the map name */
    155 	cp = _memstream_matchline(&ms, mapname, &len, 0);
    156 	if (!cp) {
    157 		ret = ENOENT;
    158 		goto quit;
    159 	}
    160 	if (!len || len>linebufsize-1) {
    161 		ret = EINVAL;
    162 		goto quit;
    163 	}
    164 
    165 	p = linebuf;
    166 	/* get module name */
    167 	*module = p;
    168 	cq = _bcs_skip_nonws_len(cp, &len);
    169 	strlcpy(p, cp, (size_t)(cq-cp+1));
    170 	p += cq-cp+1;
    171 
    172 	/* get variable */
    173 	*variable = p;
    174 	cp = _bcs_skip_ws_len(cq, &len);
    175 	strlcpy(p, cp, len+1);
    176 
    177 	ret = 0;
    178 
    179 quit:
    180 	_unmap_file(&r);
    181 	return ret;
    182 }
    183 
    184 /*
    185  * mapper_close:
    186  *	simply close a mapper. (without handling hash)
    187  */
    188 static void
    189 mapper_close(struct _citrus_mapper *cm)
    190 {
    191 	if (cm->cm_module) {
    192 		if (cm->cm_ops) {
    193 			if (cm->cm_closure)
    194 				(*cm->cm_ops->mo_uninit)(cm);
    195 			free(cm->cm_ops);
    196 		}
    197 		_citrus_unload_module(cm->cm_module);
    198 	}
    199 	free(cm->cm_traits);
    200 	free(cm);
    201 }
    202 
    203 /*
    204  * mapper_open:
    205  *	simply open a mapper. (without handling hash)
    206  */
    207 static int
    208 mapper_open(struct _citrus_mapper_area *__restrict ma,
    209 	    struct _citrus_mapper * __restrict * __restrict rcm,
    210 	    const char * __restrict module,
    211 	    const char * __restrict variable)
    212 {
    213 	int ret;
    214 	struct _citrus_mapper *cm;
    215 	_citrus_mapper_getops_t getops;
    216 
    217 	/* initialize mapper handle */
    218 	cm = malloc(sizeof(*cm));
    219 	if (!cm)
    220 		return errno;
    221 
    222 	cm->cm_module = NULL;
    223 	cm->cm_ops = NULL;
    224 	cm->cm_closure = NULL;
    225 	cm->cm_traits = NULL;
    226 	cm->cm_refcount = 0;
    227 	cm->cm_key = NULL;
    228 
    229 	/* load module */
    230 	ret = _citrus_load_module(&cm->cm_module, module);
    231 	if (ret)
    232 		goto err;
    233 
    234 	/* get operators */
    235 	getops = (_citrus_mapper_getops_t)
    236 	    _citrus_find_getops(cm->cm_module, module, "mapper");
    237 	if (!getops) {
    238 		ret = EOPNOTSUPP;
    239 		goto err;
    240 	}
    241 	cm->cm_ops = malloc(sizeof(*cm->cm_ops));
    242 	if (!cm->cm_ops) {
    243 		ret = errno;
    244 		goto err;
    245 	}
    246 	ret = (*getops)(cm->cm_ops, sizeof(*cm->cm_ops),
    247 			_CITRUS_MAPPER_ABI_VERSION);
    248 	if (ret)
    249 		goto err;
    250 
    251 	if (!cm->cm_ops->mo_init ||
    252 	    !cm->cm_ops->mo_uninit ||
    253 	    !cm->cm_ops->mo_convert ||
    254 	    !cm->cm_ops->mo_init_state) {
    255 		ret = EINVAL;
    256 		goto err;
    257 	}
    258 
    259 	/* allocate traits structure */
    260 	cm->cm_traits = malloc(sizeof(*cm->cm_traits));
    261 	if (cm->cm_traits == NULL) {
    262 		ret = errno;
    263 		goto err;
    264 	}
    265 	/* initialize the mapper */
    266 	ret = (*cm->cm_ops->mo_init)(ma, cm, ma->ma_dir,
    267 				     (const void *)variable,
    268 				     strlen(variable)+1,
    269 				     cm->cm_traits, sizeof(*cm->cm_traits));
    270 	if (ret)
    271 		goto err;
    272 
    273 	*rcm = cm;
    274 
    275 	return 0;
    276 
    277 err:
    278 	mapper_close(cm);
    279 	return ret;
    280 }
    281 
    282 /*
    283  * _citrus_mapper_open_direct:
    284  *	open a mapper.
    285  */
    286 int
    287 _citrus_mapper_open_direct(struct _citrus_mapper_area *__restrict ma,
    288 			   struct _citrus_mapper * __restrict * __restrict rcm,
    289 			   const char * __restrict module,
    290 			   const char * __restrict variable)
    291 {
    292 	return mapper_open(ma, rcm, module, variable);
    293 }
    294 
    295 /*
    296  * hash_func
    297  */
    298 static __inline int
    299 hash_func(const char *key)
    300 {
    301 	return _string_hash_func(key, CM_HASH_SIZE);
    302 }
    303 
    304 /*
    305  * match_func
    306  */
    307 static __inline int
    308 match_func(struct _citrus_mapper *cm, const char *key)
    309 {
    310 	return strcmp(cm->cm_key, key);
    311 }
    312 
    313 /*
    314  * _citrus_mapper_open:
    315  *	open a mapper with looking up "mapper.dir".
    316  */
    317 int
    318 _citrus_mapper_open(struct _citrus_mapper_area *__restrict ma,
    319 		    struct _citrus_mapper * __restrict * __restrict rcm,
    320 		    const char * __restrict mapname)
    321 {
    322 	int ret;
    323 	char linebuf[PATH_MAX];
    324 	const char *module, *variable = NULL;
    325 	struct _citrus_mapper *cm;
    326 	int hashval;
    327 
    328 	rwlock_wrlock(&lock);
    329 
    330 	/* search in the cache */
    331 	hashval = hash_func(mapname);
    332 	_CITRUS_HASH_SEARCH(&ma->ma_cache, cm, cm_entry, match_func, mapname,
    333 			    hashval);
    334 	if (cm) {
    335 		/* found */
    336 		cm->cm_refcount++;
    337 		*rcm = cm;
    338 		ret = 0;
    339 		goto quit;
    340 	}
    341 
    342 	/* search mapper entry */
    343 	ret = lookup_mapper_entry(ma->ma_dir, mapname, linebuf,
    344 	    (size_t)PATH_MAX, &module, &variable);
    345 	if (ret)
    346 		goto quit;
    347 
    348 	/* open mapper */
    349 	ret = mapper_open(ma, &cm, module, variable);
    350 	if (ret)
    351 		goto quit;
    352 	cm->cm_key = strdup(mapname);
    353 	if (cm->cm_key == NULL) {
    354 		ret = errno;
    355 		rwlock_unlock(&lock);
    356 		_mapper_close(cm);
    357 		return ret;
    358 	}
    359 
    360 	/* insert to the cache */
    361 	cm->cm_refcount = 1;
    362 	_CITRUS_HASH_INSERT(&ma->ma_cache, cm, cm_entry, hashval);
    363 
    364 	*rcm = cm;
    365 	ret = 0;
    366 quit:
    367 	rwlock_unlock(&lock);
    368 	return ret;
    369 }
    370 
    371 /*
    372  * _citrus_mapper_close:
    373  *	close the specified mapper.
    374  */
    375 void
    376 _citrus_mapper_close(struct _citrus_mapper *cm)
    377 {
    378 	if (cm) {
    379 		rwlock_wrlock(&lock);
    380 		if (cm->cm_refcount == REFCOUNT_PERSISTENT)
    381 			goto quit;
    382 		if (cm->cm_refcount > 0) {
    383 			if (--cm->cm_refcount > 0)
    384 				goto quit;
    385 			_CITRUS_HASH_REMOVE(cm, cm_entry);
    386 			free(cm->cm_key);
    387 		}
    388 		rwlock_unlock(&lock);
    389 		mapper_close(cm);
    390 		return;
    391 quit:
    392 		rwlock_unlock(&lock);
    393 	}
    394 }
    395 
    396 /*
    397  * _citrus_mapper_set_persistent:
    398  *	set persistent count.
    399  */
    400 void
    401 _citrus_mapper_set_persistent(struct _citrus_mapper * __restrict cm)
    402 {
    403 	rwlock_wrlock(&lock);
    404 	cm->cm_refcount = REFCOUNT_PERSISTENT;
    405 	rwlock_unlock(&lock);
    406 }
    407