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

#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <dlfcn.h>
#include <link.h>
#include <sys/utsname.h>
#include <ctype.h>
#include <strings.h>
#include <string.h>
#include <idn/api.h>
#include <idn/version.h>
#include "ace.h"


void *
_icv_open()
{
        ace_state_t *cd;

        cd = (ace_state_t *)calloc(1, sizeof(ace_state_t));
        if (cd == (ace_state_t *)NULL) {
                errno = ENOMEM;
                return ((void *)-1);
        }

        cd->libidnkit = dlopen(ICV_LIBIDNKITPATH, RTLD_LAZY);
        if (cd->libidnkit == (void *)NULL) {
                free((void *)cd);
                errno = EINVAL;
                return ((void *)-1);
        }

        cd->idn_function = (idn_result_t(*)(int, const char *, char *,
#if defined(ICV_ACE_TO_UTF8)
                size_t))dlsym(cd->libidnkit, "idn_decodename");
#else
                size_t))dlsym(cd->libidnkit, "idn_encodename");
#endif  /* defined(ICV_ACE_TO_UTF8) */
        if (cd->idn_function ==
            (idn_result_t(*)(int, const char *, char *, size_t))NULL) {
                (void) dlclose(cd->libidnkit);
                free((void *)cd);
                errno = EINVAL;
                return ((void *)-1);
        }

        cd->ib = (uchar_t *)malloc(_SYS_NMLN);
        if (cd->ib == (uchar_t *)NULL) {
                (void) dlclose(cd->libidnkit);
                free((void *)cd);
                errno = ENOMEM;
                return ((void *)-1);
        }

        cd->ob = (uchar_t *)malloc(_SYS_NMLN);
        if (cd->ob == (uchar_t *)NULL) {
                (void) dlclose(cd->libidnkit);
                free((void *)cd->ib);
                free((void *)cd);
                errno = ENOMEM;
                return ((void *)-1);
        }

        cd->ibl = cd->obl = _SYS_NMLN;
        cd->iblconsumed = cd->oblremaining = 0;

        return ((void *)cd);
}


void
_icv_close(ace_state_t *cd)
{
        if (! cd)
                errno = EBADF;
        else {
                (void) dlclose(cd->libidnkit);
                free((void *)cd->ib);
                free((void *)cd->ob);
                free((void *)cd);
        }
}


size_t
_icv_iconv(ace_state_t *cd, char **inbuf, size_t *inbufleft, char **outbuf,
                size_t *outbufleft)
{
        size_t ret_val = 0;
        uchar_t *ib;
        uchar_t *ob;
        uchar_t *ibtail;
        uchar_t *obtail;
        uchar_t *tmps;
        idn_result_t idnres;
        idn_action_t actions;
        int i;


        if (! cd) {
                errno = EBADF;
                return((size_t)-1);
        }

        /*
         * We need an output buffer in pretty much anycase and so we check it
         * here and issue E2BIG if there the output buffer isn't supplied
         * properly.
         */
        if (!outbuf || !(*outbuf)) {
                errno = E2BIG;
                return ((size_t)-1);
        }

        ob = (uchar_t *)*outbuf;
        obtail = ob + *outbufleft;

        /*
         * Always flush first any previously remaining output buffer at
         * the conversion descriptor.
         */
        for (i = 0; i < cd->oblremaining; i++) {
                if (ob >= obtail) {
                        errno = E2BIG;
                        cd->oblremaining -= i;
                        (void) memmove((void *)cd->ob,
                                (const void *)(cd->ob + i), cd->oblremaining);
                        ret_val = (size_t)-1;
                        goto ICV_ICONV_RETURN_TWO;
                }
                *ob++ = cd->ob[i];
        }
        cd->oblremaining = 0;

#ifdef IDNKIT_VERSION_LIBIDN

        /* IDNkit v2 */

        actions =
                 IDN_RTCONV
                |IDN_PROHCHECK
                |IDN_NFCCHECK
                |IDN_PREFCHECK
                |IDN_COMBCHECK
                |IDN_CTXOLITECHECK
                |IDN_BIDICHECK
                |IDN_LOCALCHECK
                |IDN_IDNCONV
                |IDN_LENCHECK;

# if defined(ICV_ACE_TO_UTF8)
        actions |= IDN_RTCHECK;
# else
        actions |= IDN_MAP;
# endif

#else

        /* IDNkit v1 */
        actions =
                 IDN_DELIMMAP
                |IDN_NAMEPREP
                |IDN_IDNCONV
                |IDN_ASCCHECK;

# if defined(ICV_ACE_TO_UTF8)
        actions |= IDN_RTCHECK;
# else
        actions |= IDN_LOCALMAP;
# endif

#endif

#if !defined(ICV_IDN_ALLOW_UNASSIGNED)
        actions |= IDN_UNASCHECK;
#endif

        /* Process reset request. */
        if (!inbuf || !(*inbuf)) {
                if (cd->iblconsumed > 0) {
                        if (cd->iblconsumed >= cd->ibl) {
                                cd->ibl += _SYS_NMLN;
                                tmps = (uchar_t *)realloc((void *)cd->ib,
                                                        cd->ibl);
                                if (tmps == (uchar_t *)NULL) {
                                        /*
                                         * We couldn't allocate any more;
                                         * return with realloc()'s errno.
                                         */
                                        cd->ibl -= _SYS_NMLN;
                                        ret_val = (size_t)-1;
                                        goto ICV_ICONV_RETURN_TWO;
                                }
                                cd->ib = tmps;
                        }

                        *(cd->ib + cd->iblconsumed++) = '\0';

                        i = 0;
ICV_ICONV_LOOP_ONE:
                        idnres = (*(cd->idn_function))(actions,
                            (const char *)cd->ib, (char *)cd->ob,
                                cd->obl);
                        switch (idnres) {
                        case idn_success:
                                break;
                        case idn_buffer_overflow:
                                if (++i >= 2) {
                                        errno = EILSEQ;
                                        ret_val = (size_t)-1;
                                        goto ICV_ICONV_RETURN_TWO;
                                }
                                cd->obl += _SYS_NMLN;
                                tmps = (uchar_t *)realloc((void *)cd->ob,
                                                        cd->obl);
                                if (tmps == (uchar_t *)NULL) {
                                        /*
                                         * We couldn't allocate any more;
                                         * return with realloc()'s errno.
                                         */
                                        cd->obl -= _SYS_NMLN;
                                        ret_val = (size_t)-1;
                                        goto ICV_ICONV_RETURN_TWO;
                                }
                                cd->ob = tmps;
                                goto ICV_ICONV_LOOP_ONE;
                        default:
                                /*
                                 * Anything else we just treat
                                 * as illegal sequence error.
                                 */
                                errno = EILSEQ;
                                ret_val = (size_t)-1;
                                goto ICV_ICONV_RETURN_TWO;
                        }

                        cd->iblconsumed = 0;

                        cd->oblremaining = strlen((const char *)cd->ob);
                        for (i = 0; i < cd->oblremaining; i++) {
                                if (ob >= obtail) {
                                        errno = E2BIG;
                                        cd->oblremaining -= i;
                                        (void) memmove((void *)cd->ob,
                                            (const void *)(cd->ob + i),
                                                cd->oblremaining);
                                        ret_val = (size_t)-1;
                                        goto ICV_ICONV_RETURN_TWO;
                                }
                                *ob++ = cd->ob[i];
                        }
                        cd->oblremaining = 0;
                }

                ret_val = (size_t)0;
                goto ICV_ICONV_RETURN_TWO;
        }

        ib = (uchar_t *)*inbuf;
        ibtail = ib + *inbufleft;

        while (ib < ibtail) {
                /*
                 * We only use bare minimum single byte space class characters
                 * as delimiters between names.
                 */
                if (isspace(*ib)) {
                        if (cd->iblconsumed > 0) {
                                if (cd->iblconsumed >= cd->ibl) {
                                        cd->ibl += _SYS_NMLN;
                                        tmps = (uchar_t *)realloc(
                                                (void *)cd->ib, cd->ibl);
                                        if (tmps == (uchar_t *)NULL) {
                                                /*
                                                 * We couldn't allocate any
                                                 * more; return with
                                                 * realloc()'s errno.
                                                 */
                                                cd->ibl -= _SYS_NMLN;
                                                ret_val = (size_t)-1;
                                                break;
                                        }
                                        cd->ib = tmps;
                                }
                                *(cd->ib + cd->iblconsumed) = '\0';
                                i = 0;
ICV_ICONV_LOOP:
                                idnres = (*(cd->idn_function))(actions,
                                    (const char *)cd->ib, (char *)cd->ob,
                                        cd->obl);
                                switch (idnres) {
                                case idn_success:
                                        break;
                                case idn_buffer_overflow:
                                        if (++i >= 2) {
                                                errno = EILSEQ;
                                                ret_val = (size_t)-1;
                                                goto ICV_ICONV_RETURN;
                                        }
                                        cd->obl += _SYS_NMLN;
                                        tmps = (uchar_t *)realloc(
                                                (void *)cd->ob, cd->obl);
                                        if (tmps == (uchar_t *)NULL) {
                                                /*
                                                 * We couldn't allocate any
                                                 * more; return with
                                                 * realloc()'s errno.
                                                 */
                                                cd->obl -= _SYS_NMLN;
                                                ret_val = (size_t)-1;
                                                goto ICV_ICONV_RETURN;
                                        }
                                        cd->ob = tmps;
                                        goto ICV_ICONV_LOOP;
                                default:
                                        /*
                                         * Anything else we just treat
                                         * as illegal sequence error.
                                         */
                                        errno = EILSEQ;
                                        ret_val = (size_t)-1;
                                        goto ICV_ICONV_RETURN;
                                }

                                cd->iblconsumed = 0;

                                cd->oblremaining = strlen((const char *)cd->ob);
                                for (i = 0; i < cd->oblremaining; i++) {
                                        if (ob >= obtail) {
                                                errno = E2BIG;
                                                ret_val = (size_t)-1;
                                                cd->oblremaining -= i;
                                                (void) memmove((void *)cd->ob,
                                                    (const void *)(cd->ob + i),
                                                        cd->oblremaining);
                                                goto ICV_ICONV_RETURN;
                                        }
                                        *ob++ = cd->ob[i];
                                }
                                cd->oblremaining = 0;
                        }
                        if (ob >= obtail) {
                                errno = E2BIG;
                                ret_val = (size_t)-1;
                                break;
                        }
                        *ob++ = *ib++;
                } else {
                        if (cd->iblconsumed >= cd->ibl) {
                                cd->ibl += _SYS_NMLN;
                                tmps = (uchar_t *)realloc((void *)cd->ib,
                                                cd->ibl);
                                if (tmps == (uchar_t *)NULL) {
                                        /*
                                         * We couldn't allocate any more;
                                         * return with realloc()'s errno.
                                         */
                                        cd->ibl -= _SYS_NMLN;
                                        ret_val = (size_t)-1;
                                        break;
                                }
                                cd->ib = tmps;
                        }
                        *(cd->ib + cd->iblconsumed++) = *ib++;
                }
        } /* while (ib < ibtail) */

ICV_ICONV_RETURN:
        *inbuf = (char *)ib;
        *inbufleft = ibtail - ib;
ICV_ICONV_RETURN_TWO:
        *outbuf = (char *)ob;
        *outbufleft = obtail - ob;

        return(ret_val);
}