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
586 lines
14 KiB
C
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;
|
|
}
|