minix/lib/libc/citrus/modules/citrus_iconv_std.c
Ben Gras 2fe8fb192f Full switch to clang/ELF. Drop ack. Simplify.
There is important information about booting non-ack images in
docs/UPDATING. ack/aout-format images can't be built any more, and
booting clang/ELF-format ones is a little different. Updating to the
new boot monitor is recommended.

Changes in this commit:

	. drop boot monitor -> allowing dropping ack support
	. facility to copy ELF boot files to /boot so that old boot monitor
	  can still boot fairly easily, see UPDATING
	. no more ack-format libraries -> single-case libraries
	. some cleanup of OBJECT_FMT, COMPILER_TYPE, etc cases
	. drop several ack toolchain commands, but not all support
	  commands (e.g. aal is gone but acksize is not yet).
	. a few libc files moved to netbsd libc dir
	. new /bin/date as minix date used code in libc/
	. test compile fix
	. harmonize includes
	. /usr/lib is no longer special: without ack, /usr/lib plays no
	  kind of special bootstrapping role any more and bootstrapping
	  is done exclusively through packages, so releases depend even
	  less on the state of the machine making them now.
	. rename nbsd_lib* to lib*
	. reduce mtree
2012-02-14 14:52:02 +01:00

586 lines
14 KiB
C

/* $NetBSD: citrus_iconv_std.c,v 1.15 2006/11/13 19:08:19 tnozaki Exp $ */
/*-
* Copyright (c)2003 Citrus Project,
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
__RCSID("$NetBSD: citrus_iconv_std.c,v 1.15 2006/11/13 19:08:19 tnozaki Exp $");
#endif /* LIBC_SCCS and not lint */
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <machine/endian.h>
#include <sys/queue.h>
#include "citrus_namespace.h"
#include "citrus_types.h"
#include "citrus_module.h"
#include "citrus_region.h"
#include "citrus_mmap.h"
#include "citrus_hash.h"
#include "citrus_iconv.h"
#include "citrus_stdenc.h"
#include "citrus_mapper.h"
#include "citrus_csmapper.h"
#include "citrus_memstream.h"
#include "citrus_iconv_std.h"
#include "citrus_esdb.h"
/* ---------------------------------------------------------------------- */
_CITRUS_ICONV_DECLS(iconv_std);
_CITRUS_ICONV_DEF_OPS(iconv_std);
/* ---------------------------------------------------------------------- */
int
_citrus_iconv_std_iconv_getops(struct _citrus_iconv_ops *ops, size_t lenops,
u_int32_t expected_version)
{
if (expected_version<_CITRUS_ICONV_ABI_VERSION || lenops<sizeof(*ops))
return (EINVAL);
memcpy(ops, &_citrus_iconv_std_iconv_ops,
sizeof(_citrus_iconv_std_iconv_ops));
return (0);
}
/* ---------------------------------------------------------------------- */
/*
* convenience routines for stdenc.
*/
static __inline void
save_encoding_state(struct _citrus_iconv_std_encoding *se)
{
if (se->se_ps)
memcpy(se->se_pssaved, se->se_ps,
_stdenc_get_state_size(se->se_handle));
}
static __inline void
restore_encoding_state(struct _citrus_iconv_std_encoding *se)
{
if (se->se_ps)
memcpy(se->se_ps, se->se_pssaved,
_stdenc_get_state_size(se->se_handle));
}
static __inline void
init_encoding_state(struct _citrus_iconv_std_encoding *se)
{
if (se->se_ps)
_stdenc_init_state(se->se_handle, se->se_ps);
}
static __inline int
mbtocsx(struct _citrus_iconv_std_encoding *se,
_csid_t *csid, _index_t *idx, const char **s, size_t n,
size_t *nresult)
{
return _stdenc_mbtocs(se->se_handle, csid, idx, s, n, se->se_ps,
nresult);
}
static __inline int
cstombx(struct _citrus_iconv_std_encoding *se,
char *s, size_t n, _csid_t csid, _index_t idx, size_t *nresult)
{
return _stdenc_cstomb(se->se_handle, s, n, csid, idx, se->se_ps,
nresult);
}
static __inline int
wctombx(struct _citrus_iconv_std_encoding *se,
char *s, size_t n, _wc_t wc, size_t *nresult)
{
return _stdenc_wctomb(se->se_handle, s, n, wc, se->se_ps, nresult);
}
static __inline int
put_state_resetx(struct _citrus_iconv_std_encoding *se,
char *s, size_t n, size_t *nresult)
{
return _stdenc_put_state_reset(se->se_handle, s, n, se->se_ps, nresult);
}
static __inline int
get_state_desc_gen(struct _citrus_iconv_std_encoding *se, int *rstate)
{
int ret;
struct _stdenc_state_desc ssd;
ret = _stdenc_get_state_desc(se->se_handle, se->se_ps,
_STDENC_SDID_GENERIC, &ssd);
if (!ret)
*rstate = ssd.u.generic.state;
return ret;
}
/*
* init encoding context
*/
static int
init_encoding(struct _citrus_iconv_std_encoding *se, struct _stdenc *cs,
void *ps1, void *ps2)
{
int ret = -1;
se->se_handle = cs;
se->se_ps = ps1;
se->se_pssaved = ps2;
if (se->se_ps)
ret = _stdenc_init_state(cs, se->se_ps);
if (!ret && se->se_pssaved)
ret = _stdenc_init_state(cs, se->se_pssaved);
return ret;
}
static int
open_csmapper(struct _csmapper **rcm, const char *src, const char *dst,
unsigned long *rnorm)
{
int ret;
struct _csmapper *cm;
ret = _csmapper_open(&cm, src, dst, 0, rnorm);
if (ret)
return ret;
if (_csmapper_get_src_max(cm) != 1 || _csmapper_get_dst_max(cm) != 1 ||
_csmapper_get_state_size(cm) != 0) {
_csmapper_close(cm);
return EINVAL;
}
*rcm = cm;
return 0;
}
static void
close_dsts(struct _citrus_iconv_std_dst_list *dl)
{
struct _citrus_iconv_std_dst *sd;
while ((sd=TAILQ_FIRST(dl)) != NULL) {
TAILQ_REMOVE(dl, sd, sd_entry);
_csmapper_close(sd->sd_mapper);
free(sd);
}
}
static int
open_dsts(struct _citrus_iconv_std_dst_list *dl,
const struct _esdb_charset *ec, const struct _esdb *dbdst)
{
int i, ret;
struct _citrus_iconv_std_dst *sd, *sdtmp;
unsigned long norm;
sd = malloc(sizeof(*sd));
if (sd == NULL)
return errno;
for (i=0; i<dbdst->db_num_charsets; i++) {
ret = open_csmapper(&sd->sd_mapper, ec->ec_csname,
dbdst->db_charsets[i].ec_csname, &norm);
if (ret == 0) {
sd->sd_csid = dbdst->db_charsets[i].ec_csid;
sd->sd_norm = norm;
/* insert this mapper by sorted order. */
TAILQ_FOREACH(sdtmp, dl, sd_entry) {
if (sdtmp->sd_norm > norm) {
TAILQ_INSERT_BEFORE(sdtmp, sd,
sd_entry);
sd = NULL;
break;
}
}
if (sd)
TAILQ_INSERT_TAIL(dl, sd, sd_entry);
sd = malloc(sizeof(*sd));
if (sd == NULL) {
ret = errno;
close_dsts(dl);
return ret;
}
} else if (ret != ENOENT) {
close_dsts(dl);
free(sd);
return ret;
}
}
free(sd);
return 0;
}
static void
close_srcs(struct _citrus_iconv_std_src_list *sl)
{
struct _citrus_iconv_std_src *ss;
while ((ss=TAILQ_FIRST(sl)) != NULL) {
TAILQ_REMOVE(sl, ss, ss_entry);
close_dsts(&ss->ss_dsts);
free(ss);
}
}
static int
open_srcs(struct _citrus_iconv_std_src_list *sl,
const struct _esdb *dbsrc, const struct _esdb *dbdst)
{
int i, ret, count = 0;
struct _citrus_iconv_std_src *ss;
ss = malloc(sizeof(*ss));
if (ss == NULL)
return errno;
TAILQ_INIT(&ss->ss_dsts);
for (i=0; i<dbsrc->db_num_charsets; i++) {
ret = open_dsts(&ss->ss_dsts, &dbsrc->db_charsets[i], dbdst);
if (ret)
goto err;
if (!TAILQ_EMPTY(&ss->ss_dsts)) {
ss->ss_csid = dbsrc->db_charsets[i].ec_csid;
TAILQ_INSERT_TAIL(sl, ss, ss_entry);
ss = malloc(sizeof(*ss));
if (ss == NULL) {
ret = errno;
goto err;
}
count++;
TAILQ_INIT(&ss->ss_dsts);
}
}
free(ss);
return count ? 0 : ENOENT;
err:
free(ss);
close_srcs(sl);
return ret;
}
/* do convert a character */
#define E_NO_CORRESPONDING_CHAR ENOENT /* XXX */
static int
/*ARGSUSED*/
do_conv(const struct _citrus_iconv_std_shared *is,
struct _citrus_iconv_std_context *sc, _csid_t *csid, _index_t *idx)
{
_index_t tmpidx;
int ret;
struct _citrus_iconv_std_src *ss;
struct _citrus_iconv_std_dst *sd;
TAILQ_FOREACH(ss, &is->is_srcs, ss_entry) {
if (ss->ss_csid == *csid) {
TAILQ_FOREACH(sd, &ss->ss_dsts, sd_entry) {
ret = _csmapper_convert(sd->sd_mapper,
&tmpidx, *idx, NULL);
switch (ret) {
case _MAPPER_CONVERT_SUCCESS:
*csid = sd->sd_csid;
*idx = tmpidx;
return 0;
case _MAPPER_CONVERT_NONIDENTICAL:
break;
case _MAPPER_CONVERT_SRC_MORE:
/*FALLTHROUGH*/
case _MAPPER_CONVERT_DST_MORE:
/*FALLTHROUGH*/
case _MAPPER_CONVERT_FATAL:
return EINVAL;
case _MAPPER_CONVERT_ILSEQ:
return EILSEQ;
}
}
break;
}
}
return E_NO_CORRESPONDING_CHAR;
}
/* ---------------------------------------------------------------------- */
static int
/*ARGSUSED*/
_citrus_iconv_std_iconv_init_shared(struct _citrus_iconv_shared *ci,
const char * __restrict curdir,
const char * __restrict src,
const char * __restrict dst,
const void * __restrict var, size_t lenvar)
{
int ret;
struct _citrus_iconv_std_shared *is;
struct _citrus_esdb esdbsrc, esdbdst;
is = malloc(sizeof(*is));
if (is==NULL) {
ret = errno;
goto err0;
}
ret = _citrus_esdb_open(&esdbsrc, src);
if (ret)
goto err1;
ret = _citrus_esdb_open(&esdbdst, dst);
if (ret)
goto err2;
ret = _stdenc_open(&is->is_src_encoding, esdbsrc.db_encname,
esdbsrc.db_variable, esdbsrc.db_len_variable);
if (ret)
goto err3;
ret = _stdenc_open(&is->is_dst_encoding, esdbdst.db_encname,
esdbdst.db_variable, esdbdst.db_len_variable);
if (ret)
goto err4;
is->is_use_invalid = esdbdst.db_use_invalid;
is->is_invalid = esdbdst.db_invalid;
TAILQ_INIT(&is->is_srcs);
ret = open_srcs(&is->is_srcs, &esdbsrc, &esdbdst);
if (ret)
goto err5;
_esdb_close(&esdbsrc);
_esdb_close(&esdbdst);
ci->ci_closure = is;
return 0;
err5:
_stdenc_close(is->is_dst_encoding);
err4:
_stdenc_close(is->is_src_encoding);
err3:
_esdb_close(&esdbdst);
err2:
_esdb_close(&esdbsrc);
err1:
free(is);
err0:
return ret;
}
static void
_citrus_iconv_std_iconv_uninit_shared(struct _citrus_iconv_shared *ci)
{
struct _citrus_iconv_std_shared *is = ci->ci_closure;
if (is == NULL)
return;
_stdenc_close(is->is_src_encoding);
_stdenc_close(is->is_dst_encoding);
close_srcs(&is->is_srcs);
free(is);
}
static int
_citrus_iconv_std_iconv_init_context(struct _citrus_iconv *cv)
{
const struct _citrus_iconv_std_shared *is = cv->cv_shared->ci_closure;
struct _citrus_iconv_std_context *sc;
int ret;
size_t szpssrc, szpsdst, sz;
char *ptr;
szpssrc = _stdenc_get_state_size(is->is_src_encoding);
szpsdst = _stdenc_get_state_size(is->is_dst_encoding);
sz = (szpssrc + szpsdst)*2 + sizeof(struct _citrus_iconv_std_context);
sc = malloc(sz);
if (sc == NULL)
return errno;
ptr = (char *)&sc[1];
if (szpssrc)
init_encoding(&sc->sc_src_encoding, is->is_src_encoding,
ptr, ptr+szpssrc);
else
init_encoding(&sc->sc_src_encoding, is->is_src_encoding,
NULL, NULL);
ptr += szpssrc*2;
if (szpsdst)
init_encoding(&sc->sc_dst_encoding, is->is_dst_encoding,
ptr, ptr+szpsdst);
else
init_encoding(&sc->sc_dst_encoding, is->is_dst_encoding,
NULL, NULL);
cv->cv_closure = (void *)sc;
return 0;
}
static void
_citrus_iconv_std_iconv_uninit_context(struct _citrus_iconv *cv)
{
free(cv->cv_closure);
}
static int
_citrus_iconv_std_iconv_convert(struct _citrus_iconv * __restrict cv,
const char * __restrict * __restrict in,
size_t * __restrict inbytes,
char * __restrict * __restrict out,
size_t * __restrict outbytes, u_int32_t flags,
size_t * __restrict invalids)
{
const struct _citrus_iconv_std_shared *is = cv->cv_shared->ci_closure;
struct _citrus_iconv_std_context *sc = cv->cv_closure;
_index_t idx;
_csid_t csid;
int ret, state;
size_t szrin, szrout;
size_t inval;
const char *tmpin;
inval = 0;
if (in==NULL || *in==NULL) {
/* special cases */
if (out!=NULL && *out!=NULL) {
/* init output state and store the shift sequence */
save_encoding_state(&sc->sc_src_encoding);
save_encoding_state(&sc->sc_dst_encoding);
szrout = 0;
ret = put_state_resetx(&sc->sc_dst_encoding,
*out, *outbytes,
&szrout);
if (ret)
goto err;
if (szrout == (size_t)-2) {
/* too small to store the character */
ret = EINVAL;
goto err;
}
*out += szrout;
*outbytes -= szrout;
} else
/* otherwise, discard the shift sequence */
init_encoding_state(&sc->sc_dst_encoding);
init_encoding_state(&sc->sc_src_encoding);
*invalids = 0;
return 0;
}
/* normal case */
for (;;) {
if (*inbytes==0) {
ret = get_state_desc_gen(&sc->sc_src_encoding, &state);
if (state == _STDENC_SDGEN_INITIAL ||
state == _STDENC_SDGEN_STABLE)
break;
}
/* save the encoding states for the error recovery */
save_encoding_state(&sc->sc_src_encoding);
save_encoding_state(&sc->sc_dst_encoding);
/* mb -> csid/index */
tmpin = *in;
szrin = szrout = 0;
ret = mbtocsx(&sc->sc_src_encoding, &csid, &idx,
&tmpin, *inbytes, &szrin);
if (ret)
goto err;
if (szrin == (size_t)-2) {
/* incompleted character */
ret = get_state_desc_gen(&sc->sc_src_encoding, &state);
if (ret) {
ret = EINVAL;
goto err;
}
switch (state) {
case _STDENC_SDGEN_INITIAL:
case _STDENC_SDGEN_STABLE:
/* fetch shift sequences only. */
goto next;
}
ret = EINVAL;
goto err;
}
/* convert the character */
ret = do_conv(is, sc, &csid, &idx);
if (ret) {
if (ret == E_NO_CORRESPONDING_CHAR) {
inval++;
szrout = 0;
if ((flags&_CITRUS_ICONV_F_HIDE_INVALID)==0 &&
is->is_use_invalid) {
ret = wctombx(&sc->sc_dst_encoding,
*out, *outbytes,
is->is_invalid,
&szrout);
if (ret)
goto err;
}
goto next;
} else {
goto err;
}
}
/* csid/index -> mb */
ret = cstombx(&sc->sc_dst_encoding,
*out, *outbytes, csid, idx, &szrout);
if (ret)
goto err;
next:
_DIAGASSERT(*inbytes>=szrin && *outbytes>=szrout);
*inbytes -= tmpin-*in; /* szrin is insufficient on \0. */
*in = tmpin;
*outbytes -= szrout;
*out += szrout;
}
*invalids = inval;
return 0;
err:
restore_encoding_state(&sc->sc_src_encoding);
restore_encoding_state(&sc->sc_dst_encoding);
err_norestore:
*invalids = inval;
return ret;
}