/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#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/sunddi.h>
#include <sys/byteorder.h>
#include <sys/errno.h>
#include <sys/modctl.h>
#include <sys/kiconv.h>
#include <sys/u8_textprep.h>
#include <sys/kiconv_cck_common.h>
#include <sys/kiconv_sc.h>
#include <sys/kiconv_gb18030_utf8.h>
#include <sys/kiconv_gb2312_utf8.h>
#include <sys/kiconv_utf8_gb18030.h>
#include <sys/kiconv_utf8_gb2312.h>

static int8_t gb2312_to_utf8(uchar_t byte1, uchar_t byte2, uchar_t *ob,
        uchar_t *obtail, size_t *ret_val);
static int8_t gbk_to_utf8(uint32_t gbk_val, uchar_t *ob, uchar_t *obtail,
        size_t *ret_val, boolean_t isgbk4);
static int8_t utf8_to_gb2312(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
        uchar_t *ob, uchar_t *obtail, size_t *ret);
static int8_t utf8_to_gbk(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
        uchar_t *ob, uchar_t *obtail, size_t *ret);
static int8_t utf8_to_gb18030(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
        uchar_t *ob, uchar_t *obtail, size_t *ret);

#define KICONV_SC_GB18030               (0x01)
#define KICONV_SC_GBK                   (0x02)
#define KICONV_SC_EUCCN                 (0x03)
#define KICONV_SC_MAX_MAGIC_ID          (0x03)

static void *
open_fr_gb18030()
{
        return ((void *)KICONV_SC_GB18030);
}

static void *
open_fr_gbk()
{
        return ((void *)KICONV_SC_GBK);
}

static void *
open_fr_euccn()
{
        return ((void *)KICONV_SC_EUCCN);
}

static int
close_fr_sc(void *s)
{
        if ((uintptr_t)s > KICONV_SC_MAX_MAGIC_ID)
                return (EBADF);

        return (0);
}

/*
 * Encoding convertor from UTF-8 to GB18030.
 */
size_t
kiconv_to_gb18030(void *kcd, char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft, int *errno)
{

        return kiconv_utf8_to_cck(kcd, inbuf, inbytesleft, outbuf,
            outbytesleft, errno, utf8_to_gb18030);
}

/*
 * String based encoding convertor from UTF-8 to GB18030.
 */
size_t
kiconvstr_to_gb18030(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
        return kiconvstr_utf8_to_cck((uchar_t *)inarray, inlen,
            (uchar_t *)outarray, outlen, flag, errno, utf8_to_gb18030);
}

/*
 * Encoding convertor from GB18030 to UTF-8.
 */
size_t
kiconv_fr_gb18030(void *kcd, char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft, int *errno)
{
        uchar_t         *ib;
        uchar_t         *ob;
        uchar_t         *ibtail;
        uchar_t         *obtail;
        size_t          ret_val;
        int8_t          sz;
        uint32_t        gb_val;
        boolean_t       isgbk4;

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

        /* If this is a state reset request, process and return. */
        if (inbuf == NULL || *inbuf == NULL) {
                return (0);
        }

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

        while (ib < ibtail) {
                if (KICONV_IS_ASCII(*ib)) {
                        if (ob >= obtail) {
                                KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                        }

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

                /*
                 * Issue EILSEQ error if the first byte is not a
                 * valid GB18030 leading byte.
                 */
                if (! KICONV_SC_IS_GBK_1st_BYTE(*ib)) {
                        KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                }

                isgbk4 = (ibtail - ib < 2) ? B_FALSE :
                    KICONV_SC_IS_GB18030_2nd_BYTE(*(ib + 1));

                if (isgbk4) {
                        if (ibtail - ib < 4) {
                                KICONV_SET_ERRNO_AND_BREAK(EINVAL);
                        }

                        if (! (KICONV_SC_IS_GB18030_2nd_BYTE(*(ib + 1)) &&
                            KICONV_SC_IS_GB18030_3rd_BYTE(*(ib + 2)) &&
                            KICONV_SC_IS_GB18030_4th_BYTE(*(ib + 3)))) {
                                KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                        }

                        gb_val = (uint32_t)(*ib) << 24 |
                            (uint32_t)(*(ib + 1)) << 16 |
                            (uint32_t)(*(ib + 2)) << 8 | *(ib + 3);
                } else {
                        if (ibtail - ib < 2) {
                                KICONV_SET_ERRNO_AND_BREAK(EINVAL);
                        }

                        if (! KICONV_SC_IS_GBK_2nd_BYTE(*(ib + 1))) {
                                KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                        }

                        gb_val = (uint32_t)(*ib) << 8 | *(ib + 1);
                }

                sz = gbk_to_utf8(gb_val, ob, obtail, &ret_val, isgbk4);
                if (sz < 0) {
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                ib += isgbk4 ? 4 : 2;
                ob += sz;
        }

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

        return (ret_val);
}

/*
 * String based encoding convertor from GB18030 to UTF-8.
 */
size_t
kiconvstr_fr_gb18030(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
        uchar_t         *ib;
        uchar_t         *ob;
        uchar_t         *ibtail;
        uchar_t         *obtail;
        uchar_t         *oldib;
        size_t          ret_val;
        int8_t          sz;
        uint32_t        gb_val;
        boolean_t       isgbk4;
        boolean_t       do_not_ignore_null;

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

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

                if (KICONV_IS_ASCII(*ib)) {
                        if (ob >= obtail) {
                                KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                        }

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

                oldib = ib;

                if (! KICONV_SC_IS_GBK_1st_BYTE(*ib)) {
                        KICONV_SET_ERRNO_WITH_FLAG(1, EILSEQ);
                }

                isgbk4 = (ibtail - ib < 2) ? B_FALSE :
                    KICONV_SC_IS_GB18030_2nd_BYTE(*(ib + 1));

                if (isgbk4) {
                        if (ibtail - ib < 4) {
                                if (flag & KICONV_REPLACE_INVALID) {
                                        ib = ibtail;
                                        goto REPLACE_INVALID;
                                }

                                KICONV_SET_ERRNO_AND_BREAK(EINVAL);
                        }

                        if (! (KICONV_SC_IS_GB18030_2nd_BYTE(*(ib + 1)) &&
                            KICONV_SC_IS_GB18030_3rd_BYTE(*(ib + 2)) &&
                            KICONV_SC_IS_GB18030_4th_BYTE(*(ib + 3)))) {
                                KICONV_SET_ERRNO_WITH_FLAG(4, EILSEQ);
                        }

                        gb_val = (uint32_t)(*ib) << 24 |
                            (uint32_t)(*(ib + 1)) << 16 |
                            (uint32_t)(*(ib + 2)) << 8 | *(ib + 3);
                } else {
                        if (ibtail - ib < 2) {
                                if (flag & KICONV_REPLACE_INVALID) {
                                        ib = ibtail;
                                        goto REPLACE_INVALID;
                                }

                                KICONV_SET_ERRNO_AND_BREAK(EINVAL);
                        }

                        if (! KICONV_SC_IS_GBK_2nd_BYTE(*(ib + 1))) {
                                KICONV_SET_ERRNO_WITH_FLAG(2, EILSEQ);
                        }

                        gb_val = (uint32_t)(*ib) << 8 | *(ib + 1);
                }

                sz = gbk_to_utf8(gb_val, ob, obtail, &ret_val, isgbk4);
                if (sz < 0) {
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                ib += isgbk4 ? 4 : 2;
                ob += sz;
                continue;

REPLACE_INVALID:
                if (obtail - ob < KICONV_UTF8_REPLACEMENT_CHAR_LEN) {
                        ib = oldib;
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR1;
                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR2;
                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR3;
                ret_val++;
        }

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

        return (ret_val);
}

/*
 * Encoding convertor from UTF-8 to GBK.
 */
size_t
kiconv_to_gbk(void *kcd, char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft, int *errno)
{

        return kiconv_utf8_to_cck(kcd, inbuf, inbytesleft, outbuf,
            outbytesleft, errno, utf8_to_gbk);
}

/*
 * String based encoding convertor from UTF-8 to GBK.
 */
size_t
kiconvstr_to_gbk(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
        return kiconvstr_utf8_to_cck((uchar_t *)inarray, inlen,
            (uchar_t *)outarray, outlen, flag, errno, utf8_to_gbk);
}

/*
 * Encoding convertor from GBK to UTF-8.
 */
size_t
kiconv_fr_gbk(void *kcd, char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft, int *errno)
{
        uchar_t         *ib;
        uchar_t         *ob;
        uchar_t         *ibtail;
        uchar_t         *obtail;
        size_t          ret_val;
        int8_t          sz;
        uint32_t        gb_val;

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

        /* If this is a state reset request, process and return. */
        if (inbuf == NULL || *inbuf == NULL) {
                return (0);
        }

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

        while (ib < ibtail) {
                if (KICONV_IS_ASCII(*ib)) {
                        if (ob >= obtail) {
                                KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                        }

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

                /*
                 * Issue EILSEQ error if the first byte is not a
                 * valid GBK leading byte.
                 */
                if (! KICONV_SC_IS_GBK_1st_BYTE(*ib)) {
                        KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                }

                /*
                 * Issue EINVAL error if input buffer has an incomplete
                 * character at the end of the buffer.
                 */
                if (ibtail - ib < 2) {
                        KICONV_SET_ERRNO_AND_BREAK(EINVAL);
                }

                /*
                 * Issue EILSEQ error if the remaining byte is not
                 * a valid GBK byte.
                 */
                if (! KICONV_SC_IS_GBK_2nd_BYTE(*(ib + 1))) {
                        KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                }

                /* Now we have a valid GBK character. */
                gb_val = (uint32_t)(*ib) << 8 | *(ib + 1);
                sz = gbk_to_utf8(gb_val, ob, obtail, &ret_val, B_FALSE);

                if (sz < 0) {
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                ib += 2;
                ob += sz;
        }

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

        return (ret_val);
}

/*
 * String based encoding convertor from GBK to UTF-8.
 */
size_t
kiconvstr_fr_gbk(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
        uchar_t         *ib;
        uchar_t         *ob;
        uchar_t         *ibtail;
        uchar_t         *obtail;
        uchar_t         *oldib;
        size_t          ret_val;
        int8_t          sz;
        uint32_t        gb_val;
        boolean_t       do_not_ignore_null;

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

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

                if (KICONV_IS_ASCII(*ib)) {
                        if (ob >= obtail) {
                                KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                        }

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

                oldib = ib;

                if (! KICONV_SC_IS_GBK_1st_BYTE(*ib)) {
                        KICONV_SET_ERRNO_WITH_FLAG(1, EILSEQ);
                }

                if (ibtail - ib < 2) {
                        KICONV_SET_ERRNO_WITH_FLAG(1, EINVAL);
                }

                if (! KICONV_SC_IS_GBK_2nd_BYTE(*(ib + 1))) {
                        KICONV_SET_ERRNO_WITH_FLAG(2, EILSEQ);
                }

                gb_val = (uint32_t)(*ib << 8) | *(ib + 1);
                sz = gbk_to_utf8(gb_val, ob, obtail, &ret_val, B_FALSE);

                if (sz < 0) {
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                ib += 2;
                ob += sz;
                continue;

REPLACE_INVALID:
                if (obtail - ob < KICONV_UTF8_REPLACEMENT_CHAR_LEN) {
                        ib = oldib;
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR1;
                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR2;
                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR3;
                ret_val++;
        }

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

        return (ret_val);
}

/*
 * Encoding convertor from UTF-8 to EUC-CN.
 */
size_t
kiconv_to_euccn(void *kcd, char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft, int *errno)
{
        return kiconv_utf8_to_cck(kcd, inbuf, inbytesleft, outbuf,
            outbytesleft, errno, utf8_to_gb2312);
}

/*
 * String based encoding convertor from UTF-8 to EUC-CN.
 */
size_t
kiconvstr_to_euccn(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
        return kiconvstr_utf8_to_cck((uchar_t *)inarray, inlen,
            (uchar_t *)outarray, outlen, flag, errno, utf8_to_gb2312);
}

/*
 * Encoding converto from EUC-CN to UTF-8 code.
 */
size_t
kiconv_fr_euccn(void *kcd, char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft, int *errno)
{
        uchar_t         *ib;
        uchar_t         *ob;
        uchar_t         *ibtail;
        uchar_t         *obtail;
        size_t          ret_val;
        int8_t          sz;

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

        /* If this is a state reset request, process and return. */
        if (inbuf == NULL || *inbuf == NULL) {
                return (0);
        }

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

        while (ib < ibtail) {
                if (KICONV_IS_ASCII(*ib)) {
                        if (ob >= obtail) {
                                KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                        }

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

                /*
                 * Issue EILSEQ error if the first byte is not a
                 * valid GB2312 leading byte.
                 */
                if (! KICONV_SC_IS_GB2312_BYTE(*ib)) {
                        KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                }

                /*
                 * Issue EINVAL error if input buffer has an incomplete
                 * character at the end of the buffer.
                 */
                if (ibtail - ib < 2) {
                        KICONV_SET_ERRNO_AND_BREAK(EINVAL);
                }

                /*
                 * Issue EILSEQ error if the remaining byte is not
                 * a valid GB2312 byte.
                 */
                if (! KICONV_SC_IS_GB2312_BYTE(*(ib + 1))) {
                        KICONV_SET_ERRNO_AND_BREAK(EILSEQ);
                }

                /* Now we have a valid GB2312 character */
                sz = gb2312_to_utf8(*ib, *(ib + 1), ob, obtail, &ret_val);
                if (sz < 0) {
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                ib += 2;
                ob += sz;
        }

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

        return (ret_val);
}

/*
 * String based encoding convertor from EUC-CN to UTF-8.
 */
size_t
kiconvstr_fr_euccn(char *inarray, size_t *inlen, char *outarray,
    size_t *outlen, int flag, int *errno)
{
        uchar_t         *ib;
        uchar_t         *ob;
        uchar_t         *ibtail;
        uchar_t         *obtail;
        uchar_t         *oldib;
        size_t          ret_val;
        int8_t          sz;
        boolean_t       do_not_ignore_null;

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

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

                if (KICONV_IS_ASCII(*ib)) {
                        if (ob >= obtail) {
                                KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                        }

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

                oldib = ib;

                if (! KICONV_SC_IS_GB2312_BYTE(*ib)) {
                        KICONV_SET_ERRNO_WITH_FLAG(1, EILSEQ);
                }

                if (ibtail - ib < 2) {
                        KICONV_SET_ERRNO_WITH_FLAG(1, EINVAL);
                }

                if (! KICONV_SC_IS_GB2312_BYTE(*(ib + 1))) {
                        KICONV_SET_ERRNO_WITH_FLAG(2, EILSEQ);
                }

                sz = gb2312_to_utf8(*ib, *(ib + 1), ob, obtail, &ret_val);
                if (sz < 0) {
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                ib += 2;
                ob += sz;
                continue;

REPLACE_INVALID:
                if (obtail - ob < KICONV_UTF8_REPLACEMENT_CHAR_LEN) {
                        ib = oldib;
                        KICONV_SET_ERRNO_AND_BREAK(E2BIG);
                }

                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR1;
                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR2;
                *ob++ = KICONV_UTF8_REPLACEMENT_CHAR3;
                ret_val++;
        }

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

        return (ret_val);
}

/*
 * Convert single GB2312 character to UTF-8.
 * Return: > 0  - Converted successfully
 *         = -1 - E2BIG
 */
static int8_t
gb2312_to_utf8(uchar_t b1, uchar_t b2, uchar_t *ob, uchar_t *obtail,
    size_t *ret_val)
{
        size_t  index;
        int8_t  sz;
        uchar_t *u8;

        /* index = (b1 - KICONV_EUC_START) * 94 + b2 - KICONV_EUC_START; */
        index = b1 * 94 + b2 - 0x3BBF;

        if (index >= KICONV_GB2312_UTF8_MAX)
                index = KICONV_GB2312_UTF8_MAX - 1;     /* Map to 0xEFBFBD */

        u8 = kiconv_gb2312_utf8[index];
        sz = u8_number_of_bytes[u8[0]];

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

        for (index = 0; index < sz; index++)
                *ob++ = u8[index];

        /*
         * As kiconv_gb2312_utf8 contain muliple KICONV_UTF8_REPLACEMENT_CHAR
         * elements, so need to ckeck more.
         */
        if (sz == KICONV_UTF8_REPLACEMENT_CHAR_LEN &&
            u8[0] == KICONV_UTF8_REPLACEMENT_CHAR1 &&
            u8[1] == KICONV_UTF8_REPLACEMENT_CHAR2 &&
            u8[2] == KICONV_UTF8_REPLACEMENT_CHAR3)
                (*ret_val)++;

        return (sz);
}

/*
 * Convert single GB18030 or GBK character to UTF-8.
 * Return: > 0  - Converted successfully
 *         = -1 - E2BIG
 */
static int8_t
gbk_to_utf8(uint32_t gbk_val, uchar_t *ob, uchar_t *obtail, size_t *ret_val,
    boolean_t isgbk4)
{
        size_t  index;
        int8_t  sz;
        uchar_t u8array[4];
        uchar_t *u8;

        if (isgbk4) {
                if (gbk_val >= KICONV_SC_PLANE1_GB18030_START) {
                        uint32_t        u32;

                        /*
                         * u32 = ((gbk_val >> 24) - 0x90) * 12600 +
                         *   (((gbk_val & 0xFF0000) >> 16) - 0x30) * 1260 +
                         *   (((gbk_val & 0xFF00) >> 8) - 0x81) * 10 +
                         *   (gbk_val & 0xFF - 0x30)+
                         *   KICONV_SC_PLANE1_UCS4_START;
                         */
                        u32 = (gbk_val >> 24) * 12600 +
                            ((gbk_val & 0xFF0000) >> 16) * 1260 +
                            ((gbk_val & 0xFF00) >> 8) * 10 +
                            (gbk_val & 0xFF) - 0x1BA0FA;
                        u8array[0] = (uchar_t)(0xF0 | ((u32 & 0x1C0000) >> 18));
                        u8array[1] = (uchar_t)(0x80 | ((u32 & 0x03F000) >> 12));
                        u8array[2] = (uchar_t)(0x80 | ((u32 & 0x000FC0) >> 6));
                        u8array[3] = (uchar_t)(0x80 | (u32 & 0x00003F));
                        u8 = u8array;
                        index = 1;
                } else {
                        index = kiconv_binsearch(gbk_val,
                            kiconv_gbk4_utf8, KICONV_GBK4_UTF8_MAX);
                        u8 = kiconv_gbk4_utf8[index].u8;
                }
        } else {
                index = kiconv_binsearch(gbk_val,
                    kiconv_gbk_utf8, KICONV_GBK_UTF8_MAX);
                u8 = kiconv_gbk_utf8[index].u8;
        }

        sz = u8_number_of_bytes[u8[0]];
        if (obtail - ob < sz) {
                *ret_val = (size_t)-1;
                return (-1);
        }

        if (index == 0)
                (*ret_val)++;   /* Non-identical conversion */

        for (index = 0; index < sz; index++)
                *ob++ = u8[index];

        return (sz);
}

/*
 * Convert single UTF-8 character to GB18030.
 * Return: > 0  - Converted successfully
 *         = -1 - E2BIG
 */
/* ARGSUSED */
static int8_t
utf8_to_gb18030(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
    uchar_t *ob, uchar_t *obtail, size_t *ret)
{
        size_t          index;
        int8_t          gbklen;
        uint32_t        gbkcode;

        if (utf8 >= KICONV_SC_PLANE1_UTF8_START) {
                /* Four bytes GB18030 [0x90308130, 0xe339fe39] handling. */
                uint32_t        u32;

                u32 = (((utf8 & 0x07000000) >> 6) | ((utf8 & 0x3F0000) >> 4) |
                    ((utf8 & 0x3F00) >> 2) | (utf8 & 0x3F)) -
                    KICONV_SC_PLANE1_UCS4_START;
                gbkcode = ((u32 / 12600 + 0x90) << 24) |
                    (((u32 % 12600) / 1260 + 0x30) << 16) |
                    (((u32 % 1260) / 10 + 0x81) << 8) | (u32 % 10 + 0x30);
                gbklen = 4;
                index = 1;
        } else {
                index = kiconv_binsearch(utf8, kiconv_utf8_gb18030,
                    KICONV_UTF8_GB18030_MAX);
                gbkcode = kiconv_utf8_gb18030[index].value;
                KICONV_SC_GET_GB_LEN(gbkcode, gbklen);
        }

        if (obtail - ob < gbklen) {
                *ret = (size_t)-1;
                return (-1);
        }

        if (index == 0)
                (*ret)++;               /* Non-identical conversion */

        if (gbklen == 2) {
                *ob++ = (uchar_t)(gbkcode >> 8);
        } else if (gbklen == 4) {
                *ob++ = (uchar_t)(gbkcode >> 24);
                *ob++ = (uchar_t)(gbkcode >> 16);
                *ob++ = (uchar_t)(gbkcode >> 8);
        }
        *ob = (uchar_t)(gbkcode & 0xFF);

        return (gbklen);
}

/*
 * Convert single UTF-8 character to GBK.
 * Return: > 0  - Converted successfully
 *         = -1 - E2BIG
 */
/* ARGSUSED */
static int8_t
utf8_to_gbk(uint32_t utf8, uchar_t **inbuf, uchar_t *ibtail,
    uchar_t *ob, uchar_t *obtail, size_t *ret)
{
        size_t          index;
        int8_t          gbklen;
        uint32_t        gbkcode;

        index = kiconv_binsearch(utf8, kiconv_utf8_gb18030,
            KICONV_UTF8_GB18030_MAX);
        gbkcode = kiconv_utf8_gb18030[index].value;
        KICONV_SC_GET_GB_LEN(gbkcode, gbklen);

        /* GBK and GB18030 share the same table, so check the length. */
        if (gbklen == 4) {
                index = 0;
                gbkcode = kiconv_utf8_gb18030[index].value;
                gbklen = 1;
        }

        if (obtail - ob < gbklen) {
                *ret = (size_t)-1;
                return (-1);
        }

        if (index == 0)
                (*ret)++;               /* Non-identical conversion */

        if (gbklen > 1)
                *ob++ = (uchar_t)(gbkcode >> 8);
        *ob = (uchar_t)(gbkcode & 0xFF);

        return (gbklen);
}

/*
 * Convert single UTF-8 character to GB2312.
 * Return: > 0  - Converted successfully
 *         = -1 - E2BIG
 */
/* ARGSUSED */
static int8_t
utf8_to_gb2312(uint32_t utf8, uchar_t **inbuf, uchar_t *intail,
    uchar_t *ob, uchar_t *obtail, size_t *ret)
{
        size_t          index;
        int8_t          gblen;
        uint32_t        gbcode;

        index = kiconv_binsearch(utf8, kiconv_utf8_gb2312,
            KICONV_UTF8_GB2312_MAX);
        gbcode = kiconv_utf8_gb2312[index].value;
        gblen = (gbcode <= 0xFF) ? 1 : 2;

        if (obtail - ob < gblen) {
                *ret = (size_t)-1;
                return (-1);
        }

        if (index == 0)
                (*ret)++;

        if (gblen > 1)
                *ob++ = (uchar_t)(gbcode >> 8);
        *ob = (uchar_t)(gbcode & 0xFF);

        return (gblen);
}

static kiconv_ops_t kiconv_sc_ops_tbl[] = {
        {
                "gb18030", "utf-8", kiconv_open_to_cck, kiconv_to_gb18030,
                kiconv_close_to_cck, kiconvstr_to_gb18030
        },
        {
                "utf-8", "gb18030", open_fr_gb18030, kiconv_fr_gb18030,
                close_fr_sc, kiconvstr_fr_gb18030
        },
        {
                "gbk", "utf-8", kiconv_open_to_cck, kiconv_to_gbk,
                kiconv_close_to_cck, kiconvstr_to_gbk
        },
        {
                "utf-8", "gbk", open_fr_gbk, kiconv_fr_gbk,
                close_fr_sc, kiconvstr_fr_gbk
        },
        {
                "euccn", "utf-8", kiconv_open_to_cck, kiconv_to_euccn,
                kiconv_close_to_cck, kiconvstr_to_euccn
        },
        {
                "utf-8", "euccn", open_fr_euccn, kiconv_fr_euccn,
                close_fr_sc, kiconvstr_fr_euccn
        },
};

static kiconv_module_info_t kiconv_sc_info = {
        "kiconv_sc",            /* module name */
        sizeof (kiconv_sc_ops_tbl) / sizeof (kiconv_sc_ops_tbl[0]),
        kiconv_sc_ops_tbl,
        0,
        NULL,
        NULL,
        0
};

static struct modlkiconv modlkiconv_sc = {
        &mod_kiconvops,
        "kiconv Simplified Chinese module 1.0",
        &kiconv_sc_info
};

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

int
_init(void)
{
        int err;

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

        return (err);
}

int
_fini(void)
{
        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_SC))
                return (EBUSY);

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

        return (err);
}

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