kiconv/kiconv_emea/kiconv_emea.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Kernel iconv code conversion module (kiconv_emea) for Europe, Middle East,
 * and South East Asia (PSARC/2007/173).
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/debug.h>
#include <sys/kmem.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ksynch.h>
#include <sys/modctl.h>
#include <sys/byteorder.h>
#include <sys/errno.h>
#include <sys/kiconv.h>
#include <sys/kiconv_emea1.h>
#include <sys/kiconv_emea2.h>


/*
 * The following macros indicate ids to the correct code conversion mapping
 * data tables to use. The actual tables are coming from <sys/kiconv_emea1.h>
 * and <sys/kiconv_emea2.h>. If you update the header files, then, you might
 * also need to update the table ids at below.
 *
 * The table for KICONV_TBLID_720 is a special case and should come from
 * a separate header file than others at <sys/kiconv_emea1.h> hence it has
 * an id that is rather unusual distinguishing itself from others. (And,
 * the ids much be of uint8_t.)
 */
#define KICONV_TBLID_720        (0xFFU)
#define KICONV_TBLID_RANGE1_START   KICONV_TBLID_720
#define KICONV_TBLID_RANGE1_END     KICONV_TBLID_720

#define KICONV_TBLID_737        (0)
#define KICONV_TBLID_852        (1)
#define KICONV_TBLID_857        (2)
#define KICONV_TBLID_862        (3)
#define KICONV_TBLID_866        (4)
#define KICONV_TBLID_1250       (5)
#define KICONV_TBLID_1251       (6)
#define KICONV_TBLID_1253       (7)
#define KICONV_TBLID_1254       (8)
#define KICONV_TBLID_1255       (9)
#define KICONV_TBLID_1256       (10)
#define KICONV_TBLID_1257       (11)
#define KICONV_TBLID_8859_2     (12)
#define KICONV_TBLID_8859_3     (13)
#define KICONV_TBLID_8859_4     (14)
#define KICONV_TBLID_8859_5     (15)
#define KICONV_TBLID_8859_6     (16)
#define KICONV_TBLID_8859_7     (17)
#define KICONV_TBLID_8859_8     (18)
#define KICONV_TBLID_8859_9     (19)
#define KICONV_TBLID_8859_10        (20)
#define KICONV_TBLID_8859_11        (21)
#define KICONV_TBLID_8859_13        (22)
#define KICONV_TBLID_KOI8_R     (23)

#define KICONV_MAX_MAPPING_TBLID    KICONV_TBLID_KOI8_R

/*
 * The following tables are coming from u8_textprep.c. We use them to
 * check on validity of UTF-8 characters and their bytes.
 */
extern const int8_t u8_number_of_bytes[];
extern const uint8_t u8_valid_min_2nd_byte[];
extern const uint8_t u8_valid_max_2nd_byte[];


/*
 * The following 25 open_to_xxxx() functions are kiconv_open functions for
 * the conversions from UTF-8 to xxxx single byte codesets.
 */
static void *
open_to_720()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_720;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_737()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_737;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_852()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_852;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_857()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_857;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_862()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_862;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_866()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_866;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1250()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1250;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1251()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1251;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1253()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1253;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1254()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1254;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1255()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1255;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1256()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1256;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_1257()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_1257;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88592()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_2;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88593()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_3;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88594()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_4;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88595()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_5;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88596()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_6;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88597()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_7;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88598()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_8;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_88599()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_9;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_885910()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_10;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_885911()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_11;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_885913()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_8859_13;
    s->bom_processed = 0;

    return ((void *)s);
}

static void *
open_to_koi8r()
{
    kiconv_state_t s;

    s = (kiconv_state_t)kmem_alloc(sizeof (kiconv_state_data_t), KM_SLEEP);
    s->id = KICONV_TBLID_KOI8_R;
    s->bom_processed = 0;

    return ((void *)s);
}

/*
 * The following 25 open_fr_xxxx() functions are kiconv_open functions for
 * the conversions from xxxx single byte codeset to UTF-8.
 */
static void *
open_fr_720()
{
    return ((void *)KICONV_TBLID_720);
}

static void *
open_fr_737()
{
    return ((void *)KICONV_TBLID_737);
}

static void *
open_fr_852()
{
    return ((void *)KICONV_TBLID_852);
}

static void *
open_fr_857()
{
    return ((void *)KICONV_TBLID_857);
}

static void *
open_fr_862()
{
    return ((void *)KICONV_TBLID_862);
}

static void *
open_fr_866()
{
    return ((void *)KICONV_TBLID_866);
}

static void *
open_fr_1250()
{
    return ((void *)KICONV_TBLID_1250);
}

static void *
open_fr_1251()
{
    return ((void *)KICONV_TBLID_1251);
}

static void *
open_fr_1253()
{
    return ((void *)KICONV_TBLID_1253);
}

static void *
open_fr_1254()
{
    return ((void *)KICONV_TBLID_1254);
}

static void *
open_fr_1255()
{
    return ((void *)KICONV_TBLID_1255);
}

static void *
open_fr_1256()
{
    return ((void *)KICONV_TBLID_1256);
}

static void *
open_fr_1257()
{
    return ((void *)KICONV_TBLID_1257);
}

static void *
open_fr_88592()
{
    return ((void *)KICONV_TBLID_8859_2);
}

static void *
open_fr_88593()
{
    return ((void *)KICONV_TBLID_8859_3);
}

static void *
open_fr_88594()
{
    return ((void *)KICONV_TBLID_8859_4);
}

static void *
open_fr_88595()
{
    return ((void *)KICONV_TBLID_8859_5);
}

static void *
open_fr_88596()
{
    return ((void *)KICONV_TBLID_8859_6);
}

static void *
open_fr_88597()
{
    return ((void *)KICONV_TBLID_8859_7);
}

static void *
open_fr_88598()
{
    return ((void *)KICONV_TBLID_8859_8);
}

static void *
open_fr_88599()
{
    return ((void *)KICONV_TBLID_8859_9);
}

static void *
open_fr_885910()
{
    return ((void *)KICONV_TBLID_8859_10);
}

static void *
open_fr_885911()
{
    return ((void *)KICONV_TBLID_8859_11);
}

static void *
open_fr_885913()
{
    return ((void *)KICONV_TBLID_8859_13);
}

static void *
open_fr_koi8r()
{
    return ((void *)KICONV_TBLID_KOI8_R);
}

/*
 * The following is the common kiconv_close function for the conversions from
 * UTF-8 to single byte codesets.
 */
static int
close_to_sb(void *s)
{
    if (! s || s == (void *)-1)
        return (EBADF);

    kmem_free(s, sizeof (kiconv_state_data_t));

    return (0);
}

/*
 * The following is the common kiconv_close function for the conversions from
 * single byte codesets to UTF-8.
 */
static int
close_fr_sb(void *s)
{
    if ((ulong_t)s > KICONV_MAX_MAPPING_TBLID &&
        ((ulong_t)s < KICONV_TBLID_RANGE1_START ||
        (ulong_t)s > KICONV_TBLID_RANGE1_END))
        return (EBADF);

    return (0);
}

/*
 * The following is the common kiconv function for the conversions from
 * UTF-8 to single byte codesets. (This may look a lot similar to
 * kiconvstr_to_sb() but they do have different features to cover and
 * it's not really worth to try to merge them into a single function since
 * you'll have to add performance penalty for both per each character
 * conversion as you will have to figure out if this is kiconv_to_sb() or
 * kiconvstr_to_sb().)
 */
static size_t
kiconv_to_sb(void *kcd, char **inbuf, size_t *inbytesleft, char **outbuf,
    size_t *outbytesleft, int *errno)
{
    kiconv_to_sb_tbl_comp_t *tbl;
    size_t id;
    size_t ret_val;
    uchar_t *ib;
    uchar_t *oldib;
    uchar_t *ob;
    uchar_t *ibtail;
    uchar_t *obtail;
    uint32_t u8;
    size_t i;
    size_t l;
    size_t h;
    size_t init_h;
    int8_t sz;
    boolean_t second;

    /* Check on the kiconv code conversion descriptor. */
    if (! kcd || kcd == (void *)-1) {
        *errno = EBADF;
        return ((size_t)-1);
    }

    /* Get the table id and check on it. */
    id = ((kiconv_state_t)kcd)->id;
    if (id > KICONV_MAX_MAPPING_TBLID &&
        (id < KICONV_TBLID_RANGE1_START || id > KICONV_TBLID_RANGE1_END)) {
        *errno = EBADF;
        return ((size_t)-1);
    }

    /* If this is a state reset request, process and return. */
    if (! inbuf || ! (*inbuf)) {
        ((kiconv_state_t)kcd)->bom_processed = 0;
        return ((size_t)0);
    }

    ret_val = 0;
    ib = (uchar_t *)*inbuf;
    ob = (uchar_t *)*outbuf;
    ibtail = ib + *inbytesleft;
    obtail = ob + *outbytesleft;

    /*
     * Get the table we want to use and also calculate the "init_h"
     * which is the initial high index for the binary search that we will
     * use. While the table sizes are all the same at the moment, to be
     * ready for future cases where tables could be in different sizes,
     * we separately calculate the init_h at here.
     */
    if (id == KICONV_TBLID_720) {
        tbl = (kiconv_to_sb_tbl_comp_t *)u8_to_cp720_tbl;
        init_h = sizeof (u8_to_cp720_tbl);
    } else {
        tbl = (kiconv_to_sb_tbl_comp_t *)to_sb_tbl[id];
        init_h = sizeof (to_sb_tbl[id]);
    }
    init_h = init_h / sizeof (kiconv_to_sb_tbl_comp_t) - 1;

    /*
     * If we haven't checked on the UTF-8 signature BOM character in
     * the beginning of the conversion data stream, we check it and if
     * find one, we skip it since we have no use for it.
     */
    if (((kiconv_state_t)kcd)->bom_processed == 0 && (ibtail - ib) >= 3 &&
        *ib == 0xef && *(ib + 1) == 0xbb && *(ib + 2) == 0xbf)
            ib += 3;
    ((kiconv_state_t)kcd)->bom_processed = 1;

    while (ib < ibtail) {
        sz = u8_number_of_bytes[*ib];
        if (sz <= 0) {
            *errno = EILSEQ;
            ret_val = (size_t)-1;
            break;
        }

        /*
         * If there is no room to write at the output buffer,
         * we issue E2BIG and let the caller knows about it.
         */
        if (ob >= obtail) {
            *errno = E2BIG;
            ret_val = (size_t)-1;
            break;
        }

        /*
         * If it is a 7-bit ASCII character, we don't need to
         * process further and we just copy the character over.
         *
         * If not, we collect the character bytes up to four bytes,
         * validate the bytes, and binary search for the corresponding
         * single byte codeset character byte. If we find it from
         * the mapping table, we put that into the output buffer;
         * otherwise, we put a replacement character instead as
         * a non-identical conversion.
         */
        if (sz == 1) {
            *ob++ = *ib++;
            continue;
        }

        /*
         * Issue EINVAL if the last character at the input buffer
         * is an incomplete character missing a byte or more.
         */
        if ((ibtail - ib) < sz) {
            *errno = EINVAL;
            ret_val = (size_t)-1;
            break;
        }

        /*
         * We collect UTF-8 character bytes and at the same time,
         * check on if the bytes are valid bytes or not. This follows
         * the latest UTF-8 byte representation.
         */
        oldib = ib;
        u8 = *ib++;
        second = B_TRUE;
        for (i = 1; i < sz; i++) {
            if (second) {
                if (*ib < u8_valid_min_2nd_byte[u8] ||
                    *ib > u8_valid_max_2nd_byte[u8]) {
                    *errno = EILSEQ;
                    ret_val = (size_t)-1;
                    ib = oldib;
                    goto TO_SB_ILLEGAL_CHAR_ERR;
                }
                second = B_FALSE;
            } else if (*ib < 0x80 || *ib > 0xbf) {
                *errno = EILSEQ;
                ret_val = (size_t)-1;
                ib = oldib;
                goto TO_SB_ILLEGAL_CHAR_ERR;
            }
            u8 = (u8 << 8) | ((uint32_t)*ib);
            ib++;
        }

        i = l = 0;
        h = init_h;
        while (l <= h) {
            i = (l + h) / 2;
            if (tbl[i].u8 == u8)
                break;
            else if (tbl[i].u8 < u8)
                l = i + 1;
            else
                h = i - 1;
        }

        if (tbl[i].u8 == u8) {
            *ob++ = tbl[i].sb;
        } else {
            /*
             * What this means is that we encountered
             * a non-identical conversion. In other words,
             * input buffer contains a valid character in
             * the fromcode but the tocode doesn't have
             * any character that can be mapped to.
             *
             * In this case, we insert an ASCII replacement
             * character instead at the output buffer and
             * count such non-identical conversions by
             * increasing the ret_val.
             *
             * If the return value of the function is bigger
             * than zero, that means we had such non-identical
             * conversion(s).
             */
            *ob++ = KICONV_ASCII_REPLACEMENT_CHAR;
            ret_val++;
        }
    }

TO_SB_ILLEGAL_CHAR_ERR:
    *inbuf = (char *)ib;
    *inbytesleft = ibtail - ib;
    *outbuf = (char *)ob;
    *outbytesleft = obtail - ob;

    return (ret_val);
}

/*
 * The following is the common kiconv function for the conversions from
 * single byte codesets to UTf-8.
 */
static size_t
kiconv_fr_sb(void *kcd, char **inbuf, size_t *inbytesleft, char **outbuf,
    size_t *outbytesleft, int *errno)
{
    kiconv_to_utf8_tbl_comp_t *tbl;
    size_t ret_val;
    uchar_t *ib;
    uchar_t *ob;
    uchar_t *ibtail;
    uchar_t *obtail;
    size_t i;
    size_t k;
    int8_t sz;

    /* Validate the kiconv code conversion descriptor. */
    if ((ulong_t)kcd > KICONV_MAX_MAPPING_TBLID &&
        ((ulong_t)kcd < KICONV_TBLID_RANGE1_START ||
        (ulong_t)kcd > KICONV_TBLID_RANGE1_END)) {
        *errno = EBADF;
        return ((size_t)-1);
    }

    /*
     * If this is a state reset request, there is nothing to do and so
     * we just return.
     */
    if (! inbuf || ! (*inbuf))
        return ((size_t)0);

    ret_val = 0;
    ib = (uchar_t *)*inbuf;
    ob = (uchar_t *)*outbuf;
    ibtail = ib + *inbytesleft;
    obtail = ob + *outbytesleft;

    tbl = ((ulong_t)kcd == KICONV_TBLID_720) ?
        (kiconv_to_utf8_tbl_comp_t *)cp720_to_u8_tbl :
        (kiconv_to_utf8_tbl_comp_t *)to_u8_tbl[(ulong_t)kcd];

    while (ib < ibtail) {
        /*
         * If this is a 7-bit ASCII character, we just copy over and
         * that's all we need to do for this character.
         */
        if (*ib < 0x80) {
            if (ob >= obtail) {
                *errno = E2BIG;
                ret_val = (size_t)-1;
                break;
            }

            *ob++ = *ib++;
            continue;
        }

        /*
         * Otherwise, we get the corresponding UTF-8 character bytes
         * from the mapping table and copy them over.
         *
         * We don't need to worry about if the UTF-8 character bytes
         * at the mapping tables are valid or not since they are good.
         */
        k = *ib - 0x80;
        sz = u8_number_of_bytes[tbl[k].u8[0]];

        /*
         * If (sz <= 0), that means the character in the input buffer
         * is an illegal character possibly unassigned or non-character
         * at the fromcode single byte codeset.
         */
        if (sz <= 0) {
            *errno = EILSEQ;
            ret_val = (size_t)-1;
            break;
        }

        if ((obtail - ob) < sz) {
            *errno = E2BIG;
            ret_val = (size_t)-1;
            break;
        }

        for (i = 0; i < sz; i++)
            *ob++ = tbl[k].u8[i];

        ib++;
    }

    *inbuf = (char *)ib;
    *inbytesleft = ibtail - ib;
    *outbuf = (char *)ob;
    *outbytesleft = obtail - ob;

    return (ret_val);
}

/*
 * The following is the common kiconvstr function for the conversions from
 * UTF-8 to single byte codeset.
 */
static size_t
kiconvstr_to_sb(size_t id, uchar_t *ib, size_t *inlen, uchar_t *ob,
    size_t *outlen, int flag, int *errno)
{
    kiconv_to_sb_tbl_comp_t *tbl;
    size_t ret_val;
    uchar_t *oldib;
    uchar_t *ibtail;
    uchar_t *obtail;
    uint32_t u8;
    size_t i;
    size_t l;
    size_t h;
    size_t init_h;
    int8_t sz;
    boolean_t second;
    boolean_t do_not_ignore_null;

    /* Let's double check on the table id. */
    if (id > KICONV_MAX_MAPPING_TBLID &&
        (id < KICONV_TBLID_RANGE1_START || id > KICONV_TBLID_RANGE1_END)) {
        *errno = EBADF;
        return ((size_t)-1);
    }

    ret_val = 0;
    ibtail = ib + *inlen;
    obtail = ob + *outlen;
    do_not_ignore_null = ((flag & KICONV_IGNORE_NULL) == 0);

    if (id == KICONV_TBLID_720) {
        tbl = (kiconv_to_sb_tbl_comp_t *)u8_to_cp720_tbl;
        init_h = sizeof (u8_to_cp720_tbl);
    } else {
        tbl = (kiconv_to_sb_tbl_comp_t *)to_sb_tbl[id];
        init_h = sizeof (to_sb_tbl[id]);
    }
    init_h = init_h / sizeof (kiconv_to_sb_tbl_comp_t) - 1;

    /* Skip any UTF-8 signature BOM character in the beginning. */
    if ((ibtail - ib) >= 3 && *ib == 0xef && *(ib + 1) == 0xbb &&
        *(ib + 2) == 0xbf)
            ib += 3;

    /*
     * Basically this is pretty much the same as kiconv_to_sb() except
     * that we are now accepting two flag values and doing the processing
     * accordingly.
     */
    while (ib < ibtail) {
        sz = u8_number_of_bytes[*ib];
        if (sz <= 0) {
            if (flag & KICONV_REPLACE_INVALID) {
                if (ob >= obtail) {
                    *errno = E2BIG;
                    ret_val = (size_t)-1;
                    break;
                }

                ib++;
                goto STR_TO_SB_REPLACE_INVALID;
            }

            *errno = EILSEQ;
            ret_val = (size_t)-1;
            break;
        }

        if (*ib == '\0' && do_not_ignore_null)
            break;

        if (ob >= obtail) {
            *errno = E2BIG;
            ret_val = (size_t)-1;
            break;
        }

        if (sz == 1) {
            *ob++ = *ib++;
            continue;
        }

        if ((ibtail - ib) < sz) {
            if (flag & KICONV_REPLACE_INVALID) {
                ib = ibtail;
                goto STR_TO_SB_REPLACE_INVALID;
            }

            *errno = EINVAL;
            ret_val = (size_t)-1;
            break;
        }

        oldib = ib;
        u8 = *ib++;
        second = B_TRUE;
        for (i = 1; i < sz; i++) {
            if (second) {
                if (*ib < u8_valid_min_2nd_byte[u8] ||
                    *ib > u8_valid_max_2nd_byte[u8]) {
                    if (flag & KICONV_REPLACE_INVALID) {
                        ib = oldib + sz;
                        goto STR_TO_SB_REPLACE_INVALID;
                    }

                    *errno = EILSEQ;
                    ret_val = (size_t)-1;
                    ib = oldib;
                    goto STR_TO_SB_ILLEGAL_CHAR_ERR;
                }
                second = B_FALSE;
            } else if (*ib < 0x80 || *ib > 0xbf) {
                if (flag & KICONV_REPLACE_INVALID) {
                    ib = oldib + sz;
                    goto STR_TO_SB_REPLACE_INVALID;
                }

                *errno = EILSEQ;
                ret_val = (size_t)-1;
                ib = oldib;
                goto STR_TO_SB_ILLEGAL_CHAR_ERR;
            }
            u8 = (u8 << 8) | ((uint32_t)*ib);
            ib++;
        }

        i = l = 0;
        h = init_h;
        while (l <= h) {
            i = (l + h) / 2;
            if (tbl[i].u8 == u8)
                break;
            else if (tbl[i].u8 < u8)
                l = i + 1;
            else
                h = i - 1;
        }

        if (tbl[i].u8 == u8) {
            *ob++ = tbl[i].sb;
        } else {
STR_TO_SB_REPLACE_INVALID:
            *ob++ = KICONV_ASCII_REPLACEMENT_CHAR;
            ret_val++;
        }
    }

STR_TO_SB_ILLEGAL_CHAR_ERR:
    *inlen = ibtail - ib;
    *outlen = obtail - ob;

    return (ret_val);
}

/*
 * The following 25 functions are the real entry points that will be
 * given to the kiconv framework at the genunix.
 */
static size_t
kiconvstr_to_720(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_720, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_737(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_737, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_852(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_852, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_857(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_857, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_862(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_862, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_866(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_866, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1250(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1250, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1251(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1251, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1253(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1253, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1254(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1254, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1255(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1255, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1256(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1256, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_1257(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_1257, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88592(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_2, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88593(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_3, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88594(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_4, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88595(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_5, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88596(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_6, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88597(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_7, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88598(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_8, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_88599(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_9, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_885910(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_10, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_885911(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_11, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_885913(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_8859_13, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_to_koi8r(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_to_sb(KICONV_TBLID_KOI8_R, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

/*
 * The following is the common kiconvstr function for the conversions from
 * single byte codeset to UTF-8.
 */
static size_t
kiconvstr_fr_sb(size_t id, uchar_t *ib, size_t *inlen, uchar_t *ob,
    size_t *outlen, int flag, int *errno)
{
    kiconv_to_utf8_tbl_comp_t *tbl;
    size_t ret_val;
    uchar_t *ibtail;
    uchar_t *obtail;
    size_t i;
    size_t k;
    int8_t sz;
    boolean_t do_not_ignore_null;

    if (id > KICONV_MAX_MAPPING_TBLID &&
        (id < KICONV_TBLID_RANGE1_START || id > KICONV_TBLID_RANGE1_END)) {
        *errno = EBADF;
        return ((size_t)-1);
    }

    ret_val = 0;
    ibtail = ib + *inlen;
    obtail = ob + *outlen;
    do_not_ignore_null = ((flag & KICONV_IGNORE_NULL) == 0);

    tbl = (id == KICONV_TBLID_720) ?
        (kiconv_to_utf8_tbl_comp_t *)cp720_to_u8_tbl :
        (kiconv_to_utf8_tbl_comp_t *)to_u8_tbl[id];

    while (ib < ibtail) {
        if (*ib == '\0' && do_not_ignore_null)
            break;

        if (*ib < 0x80) {
            if (ob >= obtail) {
                *errno = E2BIG;
                ret_val = (size_t)-1;
                break;
            }
            *ob++ = *ib++;
            continue;
        }

        k = *ib - 0x80;
        sz = u8_number_of_bytes[tbl[k].u8[0]];

        if (sz <= 0) {
            if (flag & KICONV_REPLACE_INVALID) {
                if ((obtail - ob) < 3) {
                    *errno = E2BIG;
                    ret_val = (size_t)-1;
                    break;
                }

                /* Save KICONV_UTF8_REPLACEMENT_CHAR. */
                *ob++ = 0xef;
                *ob++ = 0xbf;
                *ob++ = 0xbd;
                ret_val++;
                ib++;

                continue;
            }

            *errno = EILSEQ;
            ret_val = (size_t)-1;
            break;
        }

        if ((obtail - ob) < sz) {
            *errno = E2BIG;
            ret_val = (size_t)-1;
            break;
        }

        for (i = 0; i < sz; i++)
            *ob++ = tbl[k].u8[i];

        ib++;
    }

    *inlen = ibtail - ib;
    *outlen = obtail - ob;

    return (ret_val);
}

/*
 * The following 25 functions are the real entry points that will be
 * given to kiconv framework at the genunix.
 */
static size_t
kiconvstr_fr_720(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_720, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_737(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_737, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_852(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_852, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_857(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_857, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_862(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_862, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_866(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_866, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1250(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1250, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1251(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1251, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1253(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1253, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1254(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1254, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1255(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1255, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1256(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1256, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_1257(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_1257, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88592(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_2, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88593(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_3, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88594(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_4, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88595(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_5, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88596(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_6, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88597(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_7, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88598(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_8, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_88599(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_9, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_885910(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_10, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_885911(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_11, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_885913(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_8859_13, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}

static size_t
kiconvstr_fr_koi8r(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
    return (kiconvstr_fr_sb(KICONV_TBLID_KOI8_R, (uchar_t *)inarray,
        inlen, (uchar_t *)outarray, outlen, flag, errno));
}


/*
 * The following are the supported code conversions that will be passed to
 * and registered from this module. The tocode and fromcode names are
 * normalized.
 */
#define KICONV_MAX_EMEA_OPS     50

static kiconv_ops_t kiconv_emea_ops[KICONV_MAX_EMEA_OPS] = {
    {
        "utf8", "cp1250",
        open_fr_1250, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1250
    },
    {
        "cp1250", "utf8",
        open_to_1250, kiconv_to_sb, close_to_sb, kiconvstr_to_1250
    },
    {
        "utf8", "iso88592",
        open_fr_88592, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88592
    },
    {
        "iso88592", "utf8",
        open_to_88592, kiconv_to_sb, close_to_sb, kiconvstr_to_88592
    },
    {
        "utf8", "cp852",
        open_fr_852, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_852
    },
    {
        "cp852", "utf8",
        open_to_852, kiconv_to_sb, close_to_sb, kiconvstr_to_852
    },
    {
        "utf8", "cp1251",
        open_fr_1251, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1251
    },
    {
        "cp1251", "utf8",
        open_to_1251, kiconv_to_sb, close_to_sb, kiconvstr_to_1251
    },
    {
        "utf8", "iso88595",
        open_fr_88595, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88595
    },
    {
        "iso88595", "utf8",
        open_to_88595, kiconv_to_sb, close_to_sb, kiconvstr_to_88595
    },
    {
        "utf8", "koi8r",
        open_fr_koi8r, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_koi8r
    },
    {
        "koi8r", "utf8",
        open_to_koi8r, kiconv_to_sb, close_to_sb, kiconvstr_to_koi8r
    },
    {
        "utf8", "cp866",
        open_fr_866, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_866
    },
    {
        "cp866", "utf8",
        open_to_866, kiconv_to_sb, close_to_sb, kiconvstr_to_866
    },
    {
        "utf8", "cp1253",
        open_fr_1253, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1253
    },
    {
        "cp1253", "utf8",
        open_to_1253, kiconv_to_sb, close_to_sb, kiconvstr_to_1253
    },
    {
        "utf8", "iso88597",
        open_fr_88597, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88597
    },
    {
        "iso88597", "utf8",
        open_to_88597, kiconv_to_sb, close_to_sb, kiconvstr_to_88597
    },
    {
        "utf8", "cp737",
        open_fr_737, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_737
    },
    {
        "cp737", "utf8",
        open_to_737, kiconv_to_sb, close_to_sb, kiconvstr_to_737
    },
    {
        "utf8", "cp1254",
        open_fr_1254, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1254
    },
    {
        "cp1254", "utf8",
        open_to_1254, kiconv_to_sb, close_to_sb, kiconvstr_to_1254
    },
    {
        "utf8", "iso88599",
        open_fr_88599, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88599
    },
    {
        "iso88599", "utf8",
        open_to_88599, kiconv_to_sb, close_to_sb, kiconvstr_to_88599
    },
    {
        "utf8", "cp857",
        open_fr_857, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_857
    },
    {
        "cp857", "utf8",
        open_to_857, kiconv_to_sb, close_to_sb, kiconvstr_to_857
    },
    {
        "utf8", "cp1256",
        open_fr_1256, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1256
    },
    {
        "cp1256", "utf8",
        open_to_1256, kiconv_to_sb, close_to_sb, kiconvstr_to_1256
    },
    {
        "utf8", "iso88596",
        open_fr_88596, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88596
    },
    {
        "iso88596", "utf8",
        open_to_88596, kiconv_to_sb, close_to_sb, kiconvstr_to_88596
    },
    {
        "utf8", "cp720",
        open_fr_720, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_720
    },
    {
        "cp720", "utf8",
        open_to_720, kiconv_to_sb, close_to_sb, kiconvstr_to_720
    },
    {
        "utf8", "cp1255",
        open_fr_1255, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1255
    },
    {
        "cp1255", "utf8",
        open_to_1255, kiconv_to_sb, close_to_sb, kiconvstr_to_1255
    },
    {
        "utf8", "iso88598",
        open_fr_88598, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88598
    },
    {
        "iso88598", "utf8",
        open_to_88598, kiconv_to_sb, close_to_sb, kiconvstr_to_88598
    },
    {
        "utf8", "cp862",
        open_fr_862, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_862
    },
    {
        "cp862", "utf8",
        open_to_862, kiconv_to_sb, close_to_sb, kiconvstr_to_862
    },
    {
        "utf8", "cp1257",
        open_fr_1257, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_1257
    },
    {
        "cp1257", "utf8",
        open_to_1257, kiconv_to_sb, close_to_sb, kiconvstr_to_1257
    },
    {
        "utf8", "iso885913",
        open_fr_885913, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_885913
    },
    {
        "iso885913", "utf8",
        open_to_885913, kiconv_to_sb, close_to_sb, kiconvstr_to_885913
    },
    {
        "utf8", "iso885910",
        open_fr_885910, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_885910
    },
    {
        "iso885910", "utf8",
        open_to_885910, kiconv_to_sb, close_to_sb, kiconvstr_to_885910
    },
    {
        "utf8", "iso885911",
        open_fr_885911, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_885911
    },
    {
        "iso885911", "utf8",
        open_to_885911, kiconv_to_sb, close_to_sb, kiconvstr_to_885911
    },
    {
        "utf8", "iso88593",
        open_fr_88593, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88593
    },
    {
        "iso88593", "utf8",
        open_to_88593, kiconv_to_sb, close_to_sb, kiconvstr_to_88593
    },
    {
        "utf8", "iso88594",
        open_fr_88594, kiconv_fr_sb, close_fr_sb, kiconvstr_fr_88594
    },
    {
        "iso88594", "utf8",
        open_to_88594, kiconv_to_sb, close_to_sb, kiconvstr_to_88594
    },
};

static kiconv_module_info_t kiconv_emea_modinfo = {
    "kiconv_emea",      /* Must be the same as in kiconv framework. */
    KICONV_MAX_EMEA_OPS,    /* size_t kiconv_num_convs */
    kiconv_emea_ops,    /* kiconv_ops_t *kiconv_ops_tbl */
    0,          /* size_t kiconv_num_aliases */
    NULL,           /* char **aliases */
    NULL,           /* char **canonicals */
    0           /* int nowait */
};

static struct modlkiconv kiconv_emea = {
    &mod_kiconvops,
    "kiconv module for EMEA",
    &kiconv_emea_modinfo
};

static struct modlinkage linkage = {
    MODREV_1,
    (void *)&kiconv_emea,
    NULL
};

int
_init()
{
    int err;

    err = mod_install(&linkage);
    if (err)
        cmn_err(CE_WARN, "kiconv_emea: failed to load kernel module");

    return (err);
}

int
_info(struct modinfo *modinfop)
{
    return (mod_info(&linkage, modinfop));
}

int
_fini()
{
    int err;

    /*
     * If this module is being used, then, we cannot remove the module.
     * The following checking will catch pretty much all usual cases.
     *
     * Any remaining will be catached by the kiconv_unregister_module()
     * during mod_remove() at below.
     */
    if (kiconv_module_ref_count(KICONV_MODULE_ID_EMEA))
        return (EBUSY);

    err = mod_remove(&linkage);
    if (err)
        cmn_err(CE_WARN, "kiconv_emea: failed to remove kernel module");

    return (err);
}