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

#include "lint.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/param.h>
#include <alloca.h>
#include "iconv.h"
#include "iconvP.h"
#include "../i18n/_loc_path.h"

static iconv_p  iconv_open_all(const char *, const char *, char *);
static iconv_p  iconv_open_passthru(void);
static iconv_p  iconv_open_private(const char *, const char *);
static iconv_p  iconv_search_alias(const char *, const char *, char *);
static size_t   passthru_icv_iconv(iconv_t, const char **, size_t *, char **,
    size_t *);
static void     passthru_icv_close(iconv_t);

#define PASSTHRU_MAGIC_NUMBER   (0x53756e)


/*
 * These functions are mainly implemented by using a shared object and
 * the dlopen() functions. The actual conversion algorithm for a particular
 * conversion is implemented via a shared object as a loadable conversion
 * module which is linked dynamically at run time.
 *
 * The loadable conversion module resides as either:
 *
 *      /usr/lib/iconv/geniconvtbl.so
 *
 * if the conversion is supported through a geniconvtbl code conversion
 * binary table or as a module that directly specifies the conversion at:
 *
 *      /usr/lib/iconv/fromcode%tocode.so
 *
 * where fromcode is the source encoding and tocode is the target encoding.
 * The modules have 3 entries: _icv_open(), _icv_iconv(), and _icv_close().
 *
 * If there is no code conversion supported and if the fromcode and the tocode
 * are specifying the same codeset, then, the byte-by-byte, pass-through code
 * conversion that is embedded in the libc is used instead.
 *
 * The following are the related PSARC cases:
 *
 *      PSARC/1993/153 iconv/iconv_open/iconv_close
 *      PSARC/1999/292 Addition of geniconvtbl(1)
 *      PSARC/2001/072 GNU gettext support
 *      PSARC/2009/561 Pass-through iconv code conversion
 *
 * The PSARC/2001/072 includes the /usr/lib/iconv/alias interface.
 */

iconv_t
iconv_open(const char *tocode, const char *fromcode)
{
        iconv_t cd;
        char    *ipath;

        if ((cd = malloc(sizeof (struct _iconv_info))) == NULL)
                return ((iconv_t)-1);

        /*
         * Memory for ipath is allocated/released in this function.
         */
        ipath = malloc(MAXPATHLEN);
        if (ipath == NULL) {
                free(cd);
                return ((iconv_t)-1);
        }

        cd->_conv = iconv_open_all(tocode, fromcode, ipath);
        if (cd->_conv != (iconv_p)-1) {
                /* found a valid module for this conversion */
                free(ipath);
                return (cd);
        }

        /*
         * Now, try using the encoding name aliasing table
         */
        cd->_conv = iconv_search_alias(tocode, fromcode, ipath);
        free(ipath);
        if (cd->_conv == (iconv_p)-1) {
                free(cd);
                return ((iconv_t)-1);
        }

        /* found a valid module for this conversion */
        return (cd);
}

static size_t
search_alias(char **paddr, size_t size, const char *variant)
{
        char    *addr = *paddr;
        char    *p, *sp, *q;
        size_t  var_len, can_len;

        var_len = strlen(variant);
        p = addr;
        q = addr + size;
        while (q > p) {
                if (*p == '#') {
                        /*
                         * Line beginning with '#' is a comment
                         */
                        p++;
                        while ((q > p) && (*p++ != '\n'))
                                ;
                        continue;
                }
                /* skip leading spaces */
                while ((q > p) &&
                    ((*p == ' ') || (*p == '\t')))
                        p++;
                if (q <= p)
                        break;
                sp = p;
                while ((q > p) && (*p != ' ') &&
                    (*p != '\t') && (*p != '\n'))
                        p++;
                if (q <= p) {
                        /* invalid entry */
                        break;
                }
                if (*p == '\n') {
                        /* invalid entry */
                        p++;
                        continue;
                }

                if (((p - sp) != var_len) ||
                    ((strncmp(sp, variant, var_len) != 0) &&
                    (strncasecmp(sp, variant, var_len) != 0))) {
                        /*
                         * didn't match
                         */

                        /* skip remaining chars in this line */
                        p++;
                        while ((q > p) && (*p++ != '\n'))
                                ;
                        continue;
                }

                /* matching entry found */

                /* skip spaces */
                while ((q > p) &&
                    ((*p == ' ') || (*p == '\t')))
                        p++;
                if (q <= p)
                        break;
                sp = p;
                while ((q > p) && (*p != ' ') &&
                    (*p != '\t') && (*p != '\n'))
                        p++;
                can_len = p - sp;
                if (can_len == 0) {
                        while ((q > p) && (*p++ != '\n'))
                                ;
                        continue;
                }
                *paddr = sp;
                return (can_len);
                /* NOTREACHED */
        }
        return (0);
}

static iconv_p
iconv_open_all(const char *to, const char *from, char *ipath)
{
        iconv_p cv;
        int     len;

        /*
         * First, try using the geniconvtbl conversion, which is performed by
         * /usr/lib/iconv/geniconvtbl.so with the conversion table file:
         * /usr/lib/iconv/geniconvtbl/binarytables/fromcode%tocode.bt
         *
         * If the geniconvtbl conversion cannot be done, try the conversion
         * by the individual shared object.
         */

        len = snprintf(ipath, MAXPATHLEN, _GENICONVTBL_PATH, from, to);
        if ((len <= MAXPATHLEN) && (access(ipath, R_OK) == 0)) {
                /*
                 * from%to.bt exists in the table dir
                 */
                cv = iconv_open_private(_GENICONVTBL_INT_PATH, ipath);
                if (cv != (iconv_p)-1) {
                        /* found a valid module for this conversion */
                        return (cv);
                }
        }

        /* Next, try /usr/lib/iconv/from%to.so */
        len = snprintf(ipath, MAXPATHLEN, _ICONV_PATH, from, to);
        if ((len <= MAXPATHLEN) && (access(ipath, R_OK) == 0)) {
                /*
                 * /usr/lib/iconv/from%to.so exists
                 * errno will be set by iconv_open_private on error
                 */
                return (iconv_open_private(ipath, NULL));
        }

        /*
         * Finally, as a last resort check if the 'to' and the 'from' are
         * referring to the same codeset name or not. If so, assign the
         * embedded pass-through code conversion.
         */
        if (strcasecmp(to, from) == 0)
                return (iconv_open_passthru());

        /* no valid module for this conversion found */
        errno = EINVAL;
        return ((iconv_p)-1);
}

static iconv_p
iconv_search_alias(const char *tocode, const char *fromcode, char *ipath)
{
        char    *p;
        char    *to_canonical, *from_canonical;
        size_t  tolen, fromlen;
        iconv_p cv;
        int     fd;
        struct stat64   statbuf;
        caddr_t addr;
        size_t  buflen;

        fd = open(_ENCODING_ALIAS_PATH, O_RDONLY);
        if (fd == -1) {
                /*
                 * if no alias file found,
                 * errno will be set to EINVAL.
                 */
                errno = EINVAL;
                return ((iconv_p)-1);
        }
        if (fstat64(fd, &statbuf) == -1) {
                (void) close(fd);
                /* use errno set by fstat64 */
                return ((iconv_p)-1);
        }
        buflen = (size_t)statbuf.st_size;
        addr = mmap(NULL, buflen, PROT_READ, MAP_SHARED, fd, 0);
        (void) close(fd);
        if (addr == MAP_FAILED) {
                /* use errno set by mmap */
                return ((iconv_p)-1);
        }
        p = (char *)addr;
        tolen = search_alias(&p, buflen, tocode);
        if (tolen) {
                to_canonical = alloca(tolen + 1);
                (void) memcpy(to_canonical, p, tolen);
                to_canonical[tolen] = '\0';
        } else {
                to_canonical = (char *)tocode;
        }
        p = (char *)addr;
        fromlen = search_alias(&p, buflen, fromcode);
        if (fromlen) {
                from_canonical = alloca(fromlen + 1);
                (void) memcpy(from_canonical, p, fromlen);
                from_canonical[fromlen] = '\0';
        } else {
                from_canonical = (char *)fromcode;
        }
        (void) munmap(addr, buflen);
        if (tolen == 0 && fromlen == 0) {
                errno = EINVAL;
                return ((iconv_p)-1);
        }

        cv = iconv_open_all(to_canonical, from_canonical, ipath);

        /* errno set by iconv_open_all on error */
        return (cv);
}

static iconv_p
iconv_open_passthru(void)
{
        iconv_p cdpath;

        /*
         * For a pass-through byte-by-byte code conversion, allocate
         * an internal conversion descriptor and initialize the data
         * fields appropriately and we are done.
         */
        cdpath = malloc(sizeof (struct _iconv_fields));
        if (cdpath == NULL)
                return ((iconv_p)-1);

        cdpath->_icv_handle = NULL;
        cdpath->_icv_iconv = passthru_icv_iconv;
        cdpath->_icv_close = passthru_icv_close;
        cdpath->_icv_state = (void *)PASSTHRU_MAGIC_NUMBER;

        return (cdpath);
}

static iconv_p
iconv_open_private(const char *lib, const char *tbl)
{
        iconv_t (*fptr)(const char *);
        iconv_p cdpath;

        if ((cdpath = malloc(sizeof (struct _iconv_fields))) == NULL)
                return ((iconv_p)-1);

        if ((cdpath->_icv_handle = dlopen(lib, RTLD_LAZY)) == 0) {
                free(cdpath);
                /* dlopen does not define error no */
                errno = EINVAL;
                return ((iconv_p)-1);
        }

        /* gets address of _icv_open */
        if ((fptr = (iconv_t(*)(const char *))dlsym(cdpath->_icv_handle,
            "_icv_open")) == NULL) {
                (void) dlclose(cdpath->_icv_handle);
                free(cdpath);
                /* dlsym does not define errno */
                errno = EINVAL;
                return ((iconv_p)-1);
        }

        /*
         * gets address of _icv_iconv in the loadable conversion module
         * and stores it in cdpath->_icv_iconv
         */

        if ((cdpath->_icv_iconv = (size_t(*)(iconv_t, const char **,
            size_t *, char **, size_t *))dlsym(cdpath->_icv_handle,
            "_icv_iconv")) == NULL) {
                (void) dlclose(cdpath->_icv_handle);
                free(cdpath);
                /* dlsym does not define errno */
                errno = EINVAL;
                return ((iconv_p)-1);
        }

        /*
         * gets address of _icv_close in the loadable conversion module
         * and stores it in cd->_icv_close
         */
        if ((cdpath->_icv_close = (void(*)(iconv_t))dlsym(cdpath->_icv_handle,
            "_icv_close")) == NULL) {
                (void) dlclose(cdpath->_icv_handle);
                free(cdpath);
                /* dlsym does not define errno */
                errno = EINVAL;
                return ((iconv_p)-1);
        }

        /*
         * initialize the state of the actual _icv_iconv conversion routine
         * For the normal iconv module, NULL will be passed as an argument
         * although the iconv_open() of the module won't use that.
         */
        cdpath->_icv_state = (void *)(*fptr)(tbl);

        if (cdpath->_icv_state == (struct _icv_state *)-1) {
                (void) dlclose(cdpath->_icv_handle);
                free(cdpath);
                /* this module does not satisfy this conversion */
                errno = EINVAL;
                return ((iconv_p)-1);
        }

        return (cdpath);
}

int
iconv_close(iconv_t cd)
{
        if (cd == NULL) {
                errno = EBADF;
                return (-1);
        }
        (*(cd->_conv)->_icv_close)(cd->_conv->_icv_state);
        if (cd->_conv->_icv_handle != NULL)
                (void) dlclose(cd->_conv->_icv_handle);
        free(cd->_conv);
        free(cd);
        return (0);
}

/*
 * To have minimal performance impact to the existing run-time behavior,
 * we supply a dummy passthru_icv_close() that will just return.
 */
static void
passthru_icv_close(iconv_t cd __unused)
{
}

size_t
iconv(iconv_t cd, const char **inbuf, size_t *inbytesleft,
    char **outbuf, size_t *outbytesleft)
{
        /* check if cd is valid */
        if (cd == NULL || cd == (iconv_t)-1) {
                errno = EBADF;
                return ((size_t)-1);
        }

        /* direct conversion */
        return ((*(cd->_conv)->_icv_iconv)(cd->_conv->_icv_state,
            inbuf, inbytesleft, outbuf, outbytesleft));
}

static size_t
passthru_icv_iconv(iconv_t cd, const char **inbuf, size_t *inbufleft,
    char **outbuf, size_t *outbufleft)
{
        size_t ibl;
        size_t obl;
        size_t len;
        size_t ret_val;

        /* Check if the conversion descriptor is a valid one. */
        if (cd != (iconv_t)PASSTHRU_MAGIC_NUMBER) {
                errno = EBADF;
                return ((size_t)-1);
        }

        /* For any state reset request, return success. */
        if (inbuf == NULL || *inbuf == NULL)
                return (0);

        /*
         * Initialize internally used variables for a better performance
         * and prepare for a couple of the return values before the actual
         * copying of the bytes.
         */
        ibl = *inbufleft;
        obl = *outbufleft;

        if (ibl > obl) {
                len = obl;
                errno = E2BIG;
                ret_val = (size_t)-1;
        } else {
                len = ibl;
                ret_val = 0;
        }

        /*
         * Do the copy using memmove(). There are no EILSEQ or EINVAL
         * checkings since this is a simple copying.
         */
        (void) memmove((void *)*outbuf, (const void *)*inbuf, len);

        /* Update the return values related to the buffers then do return. */
        *inbuf = *inbuf + len;
        *outbuf = *outbuf + len;
        *inbufleft = ibl - len;
        *outbufleft = obl - len;

        return (ret_val);
}