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

/*
 * Utility functions
 */
#include <libintl.h>
#include <stdio.h>
#include <dlfcn.h>
#include <string.h>
#include <errno.h>
#include <alloca.h>
#include "sgs.h"
#include "rtc.h"
#include "_crle.h"
#include "msg.h"

/*
 * Add an environment string.  A list of environment variable descriptors is
 * maintained so that duplicate definitions can be caught, the first one wins.
 */
int
addenv(Crle_desc *crle, const char *arg, unsigned int flags)
{
        Env_desc        *env;
        char            *str;
        size_t          varsz, totsz = strlen(arg) + 1;

        /*
         * Determine "=" location so as to separated the variable name from
         * its value.
         */
        if ((str = strchr(arg, '=')) != NULL) {
                Aliste  idx;

                varsz = (size_t)(str - arg);

                /*
                 * Traverse any existing environment variables to see if we've
                 * caught a duplicate.
                 */
                for (APLIST_TRAVERSE(crle->c_env, idx, env)) {
                        if ((env->e_varsz == varsz) &&
                            (strncmp(env->e_str, arg, varsz) == 0)) {
                                /*
                                 * If the user has already specified this string
                                 * given them a warning, and ignore the new one.
                                 */
                                if ((env->e_flags & RTC_ENV_CONFIG) == 0) {
                                        (void) fprintf(stderr,
                                            MSG_INTL(MSG_WARN_ENV),
                                            crle->c_name, (int)varsz,
                                            env->e_str);
                                        return (2);
                                }

                                /*
                                 * Otherwise the original string must have been
                                 * retrieved from a config file.  In this case
                                 * allow the user to override it.
                                 */
                                free((void *)env->e_str);
                                crle->c_strsize -= env->e_totsz;
                                crle->c_strsize += totsz;

                                if ((env->e_str = strdup(arg)) == 0) {
                                        int err = errno;
                                        (void) fprintf(stderr,
                                            MSG_INTL(MSG_SYS_MALLOC),
                                            crle->c_name, strerror(err));
                                        return (0);
                                }
                                env->e_varsz = varsz;
                                env->e_totsz = totsz;
                                env->e_flags &= ~RTC_ENV_CONFIG;
                                env->e_flags |= flags;

                                return (1);
                        }
                }
        } else {
                Aliste  idx;

                /*
                 * Although this is just a plain environment definition (no "=")
                 * and probably has no effect on ld.so.1 anyway, we might as
                 * well make sure we're not duplicating the same string.
                 */
                for (APLIST_TRAVERSE(crle->c_env, idx, env)) {
                        if (env->e_varsz)
                                continue;
                        if (strcmp(env->e_str, arg) == 0) {
                                if ((env->e_flags & RTC_ENV_CONFIG) == 0) {
                                        (void) fprintf(stderr,
                                            MSG_INTL(MSG_WARN_ENV),
                                            crle->c_name, (int)totsz,
                                            env->e_str);
                                        return (2);
                                }
                                env->e_flags &= ~RTC_ENV_CONFIG;
                                env->e_flags |= flags;

                                return (1);
                        }
                }
                varsz = 0;
        }

        /*
         * Allocate a new environment descriptor.
         */
        if (((env = malloc(sizeof (Env_desc))) == NULL) ||
            ((env->e_str = strdup(arg)) == NULL)) {
                int err = errno;
                (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC),
                    crle->c_name, strerror(err));
                free(env);
                return (0);
        }
        env->e_varsz = varsz;
        env->e_totsz = totsz;
        env->e_flags = flags;

        if (aplist_append(&(crle->c_env), env, AL_CNT_CRLE) == NULL)
                return (0);

        /*
         * Update the number of environment variables found, and the string
         * table requirement.
         */
        crle->c_envnum++;
        crle->c_strsize += totsz;

        return (1);
}

/*
 * Add a library path.  Multiple library paths are concatenated together into a
 * colon separated string suitable for runtime processing.  These colon
 * separated strings can also be passed in as arguments to addlib(), e.g.,
 * -l /usr/lib:/usr/local/lib.  This is enabled to make update easier.
 */
int
addlib(Crle_desc *crle, char **lib, const char *args)
{
        char            *str, *arg;
        char            *lasts;
        size_t          tlen = strlen(args) + 1;
        const char      *colon = MSG_ORIG(MSG_STR_COLON);

        /*
         * Parse the argument for any ":" separated elements.
         */
        str = alloca(tlen);
        (void) strcpy(str, args);
        arg = str;

        if ((arg = strtok_r(arg, colon, &lasts)) != NULL) {
                do {
                        size_t  llen, alen = strlen(arg);

                        if (*lib) {
                                /*
                                 * Determine whether this argument exists in the
                                 * existing string buffer.
                                 */
                                if (((str = strstr(*lib, arg)) != NULL) &&
                                    (((str == *lib) ||
                                    (*(str - 1) == *colon)) &&
                                    (str += alen) &&
                                    ((*str == '\0') || (*str == *colon))))
                                        continue;

                                llen = strlen(*lib);
                                tlen = llen + 1;
                        } else {
                                /*
                                 * This is the first argument to be added.
                                 */
                                llen = 0;
                                tlen = 0;
                        }

                        /*
                         * This is a new string, so add it to the buffer.  If
                         * this is the first occurrence of a string the size is
                         * simply the size of the string + a trailing null.
                         * Otherwise the size is the old string + ":" + the
                         * size of the new string + a trailing null.
                         */
                        alen += 1;
                        tlen += alen;
                        if ((str = realloc((void *)*lib, tlen)) == 0) {
                                int err = errno;
                                (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC),
                                    crle->c_name, strerror(err));
                                return (1);
                        }
                        if (llen == 0)
                                (void) strcpy(str, arg);
                        else {
                                /* LINTED */
                                (void) sprintf(&str[llen],
                                    MSG_ORIG(MSG_FMT_COLON), arg);
                        }
                        *lib = str;
                        crle->c_strsize += alen;

                } while ((arg = strtok_r(NULL, colon, &lasts)) != NULL);
        }

        return (0);
}


/*
 * -f option expansion.  Interpret its argument as a numeric or symbolic
 * representation of the dldump(3C) flags.
 */
int
dlflags(Crle_desc *crle, const char *arg)
{
        int             _flags;
        char            *tok, *_arg;
        char            *lasts;
        const char      *separate = MSG_ORIG(MSG_MOD_SEPARATE);

        /*
         * Scan the argument looking for allowable tokens.  First determine if
         * the string is numeric, otherwise try and parse any known flags.
         */
        if ((_flags = (int)strtol(arg, (char **)NULL, 0)) != 0)
                return (_flags);

        if ((_arg = malloc(strlen(arg) + 1)) == 0)
                return (0);
        (void) strcpy(_arg, arg);

        if ((tok = strtok_r(_arg, separate, &lasts)) != NULL) {
                /* BEGIN CSTYLED */
                do {
                    if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_RELATIVE)) == 0)
                        _flags |= RTLD_REL_RELATIVE;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_EXEC)) == 0)
                        _flags |= RTLD_REL_EXEC;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_DEPENDS)) == 0)
                        _flags |= RTLD_REL_DEPENDS;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_PRELOAD)) == 0)
                        _flags |= RTLD_REL_PRELOAD;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_SELF)) == 0)
                        _flags |= RTLD_REL_SELF;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_WEAK)) == 0)
                        _flags |= RTLD_REL_WEAK;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_ALL)) == 0)
                        _flags |= RTLD_REL_ALL;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_MEMORY)) == 0)
                        _flags |= RTLD_MEMORY;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_STRIP)) == 0)
                        _flags |= RTLD_STRIP;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_NOHEAP)) == 0)
                        _flags |= RTLD_NOHEAP;
                    else if (strcmp(tok, MSG_ORIG(MSG_MOD_REL_CONFGEN)) == 0)
                        _flags |= RTLD_CONFGEN;
                    else {
                        (void) fprintf(stderr, MSG_INTL(MSG_ARG_FLAGS),
                            crle->c_name, tok);
                        free(_arg);
                        return (0);
                    }
                } while ((tok = strtok_r(NULL, separate, &lasts)) != NULL);
                /* END CSTYLED */
        }
        if (_flags == 0)
                (void) fprintf(stderr, MSG_INTL(MSG_ARG_FLAGS),
                    crle->c_name, arg);

        free(_arg);
        return (_flags);
}

/*
 * Internationalization interface for sgsmsg(1l) use.
 */
const char *
_crle_msg(Msg mid)
{
        return (gettext(MSG_ORIG(mid)));
}