libconv/common/config.c

	config.c revision 5aefb6555731130ca4fd295960123d71f2d21fe8
/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I% %E% SMI"

#include    <stdlib.h>
#include    <sys/types.h>
#include    <string.h>
#include    "rtc.h"
#include    "_conv.h"
#include    "config_msg.h"

#define FEATSZ  MSG_GBL_OSQBRKT_SIZE + \
        MSG_CONF_EDLIBPATH_SIZE + \
        MSG_CONF_ESLIBPATH_SIZE + \
        MSG_CONF_ADLIBPATH_SIZE + \
        MSG_CONF_ASLIBPATH_SIZE + \
        MSG_CONF_DIRCFG_SIZE + \
        MSG_CONF_OBJALT_SIZE + \
        MSG_CONF_MEMRESV_SIZE + \
        MSG_CONF_ENVS_SIZE + \
        MSG_CONF_FLTR_SIZE + \
        CONV_INV_STRSIZE + MSG_GBL_CSQBRKT_SIZE

/*
 * String conversion routine for configuration file information.
 */
const char *
conv_config_feat(int features)
{
    static  char    string[FEATSZ];
    static Val_desc vda[] = {
        { CONF_EDLIBPATH,   MSG_ORIG(MSG_CONF_EDLIBPATH) },
        { CONF_ESLIBPATH,   MSG_ORIG(MSG_CONF_ESLIBPATH) },
        { CONF_ADLIBPATH,   MSG_ORIG(MSG_CONF_ADLIBPATH) },
        { CONF_ASLIBPATH,   MSG_ORIG(MSG_CONF_ASLIBPATH) },
        { CONF_DIRCFG,      MSG_ORIG(MSG_CONF_DIRCFG) },
        { CONF_OBJALT,      MSG_ORIG(MSG_CONF_OBJALT) },
        { CONF_MEMRESV,     MSG_ORIG(MSG_CONF_MEMRESV) },
        { CONF_ENVS,        MSG_ORIG(MSG_CONF_ENVS) },
        { CONF_FLTR,        MSG_ORIG(MSG_CONF_FLTR) },
        { 0,            0 }
    };

    (void) strlcpy(string, MSG_ORIG(MSG_GBL_OSQBRKT), FEATSZ);
    if (conv_expn_field(string, FEATSZ, vda, features,
        features, 0, 0))
        (void) strlcat(string, MSG_ORIG(MSG_GBL_CSQBRKT), FEATSZ);

    return ((const char *)string);
}

#define FLAGSZ  MSG_GBL_OSQBRKT_SIZE + \
        MSG_CONF_DIRENT_SIZE + \
        MSG_CONF_ALLENTS_SIZE + \
        MSG_CONF_NOEXIST_SIZE + \
        MSG_CONF_EXEC_SIZE + \
        MSG_CONF_ALTER_SIZE + \
        MSG_CONF_OPTIONAL_SIZE + \
        MSG_CONF_DUMP_SIZE + \
        MSG_CONF_REALPATH_SIZE + \
        MSG_CONF_NOALTER_SIZE + \
        MSG_CONF_GROUP_SIZE + \
        MSG_CONF_APP_SIZE + \
        MSG_CONF_CMDLINE_SIZE + \
        MSG_CONF_FILTER_SIZE + \
        MSG_CONF_FILTEE_SIZE + \
        CONV_INV_STRSIZE + MSG_GBL_CSQBRKT_SIZE

/*
 * String conversion routine for object flags.
 */
const char *
conv_config_obj(ushort_t flags)
{
    static char string[FLAGSZ];
    static Val_desc vda[] = {
        { RTC_OBJ_DIRENT,   MSG_ORIG(MSG_CONF_DIRENT) },
        { RTC_OBJ_ALLENTS,  MSG_ORIG(MSG_CONF_ALLENTS) },
        { RTC_OBJ_NOEXIST,  MSG_ORIG(MSG_CONF_NOEXIST) },
        { RTC_OBJ_EXEC,     MSG_ORIG(MSG_CONF_EXEC) },
        { RTC_OBJ_ALTER,    MSG_ORIG(MSG_CONF_ALTER) },
        { RTC_OBJ_DUMP,     MSG_ORIG(MSG_CONF_DUMP) },
        { RTC_OBJ_NOALTER,  MSG_ORIG(MSG_CONF_NOALTER) },
        { RTC_OBJ_REALPTH,  MSG_ORIG(MSG_CONF_REALPATH) },
        { RTC_OBJ_GROUP,    MSG_ORIG(MSG_CONF_GROUP) },
        { RTC_OBJ_APP,      MSG_ORIG(MSG_CONF_APP) },
        { RTC_OBJ_CMDLINE,  MSG_ORIG(MSG_CONF_CMDLINE) },
        { RTC_OBJ_FILTER,   MSG_ORIG(MSG_CONF_FILTER) },
        { RTC_OBJ_FILTEE,   MSG_ORIG(MSG_CONF_FILTEE) },
        { 0,            0 }
    };
    ushort_t    _flags = flags;

    if ((flags == 0) || (flags == RTC_OBJ_OPTINAL))
        return (MSG_ORIG(MSG_GBL_NULL));

    (void) strlcpy(string, MSG_ORIG(MSG_GBL_OSQBRKT), FLAGSZ);

    /*
     * Print an alternative-optional object simply as optional.
     */
    if ((flags & (RTC_OBJ_ALTER | RTC_OBJ_OPTINAL)) ==
        (RTC_OBJ_ALTER | RTC_OBJ_OPTINAL)) {
        if (strlcat(string, MSG_ORIG(MSG_CONF_OPTIONAL),
            FLAGSZ) >= FLAGSZ)
            return (conv_invalid_val(string, FLAGSZ, flags, 0));
        flags = _flags &= ~(RTC_OBJ_ALTER | RTC_OBJ_OPTINAL);
    }
    flags = _flags &= ~RTC_OBJ_OPTINAL;

    if (conv_expn_field(string, FLAGSZ, vda, flags, _flags, 0, 0))
        (void) strlcat(string, MSG_ORIG(MSG_GBL_CSQBRKT), FLAGSZ);

    return ((const char *)string);
}

/*
 * Determine whether and old pathname exists within a search path string,
 * without a new pathname, i.e., does the search path string contain "/usr/lib"
 * but not "/lib".  If so, add the new pathname before the old pathname.  For
 * example, convert:
 *
 *  /local/lib:/opt/sfw/lib:/usr/lib
 * to:
 *  /local/lib:/opt/sfw/lib:/lib:/usr/lib
 */
const char *
conv_config_upm(const char *str, const char *old, const char *new,
    size_t newlen)
{
    const char  *curstr, *ptr;
    const char  *curold = 0, *curnew = 0;
    const char  *ptrold = old, * ptrnew = new;
    int     chkold = 1, chknew = 1;

    for (curstr = ptr = str; *ptr; ptr++) {
        if (*ptr == ':') {
            /*
             * We've come to the end of a token within the string.
             */
            if ((uintptr_t)ptr - (uintptr_t)curstr) {
                /*
                 * If the old or new string checking is still
                 * enabled, we've found a match.
                 */
                if (chkold)
                    curold = curstr;
                if (chknew)
                    curnew = curstr;
            }
            curstr = (char *)(ptr + 1);

            /*
             * If an old or new string hasn't yet been matched,
             * re-enable the checking for either.
             */
            if (curold == 0) {
                ptrold = old;
                chkold = 1;
            }
            if (curnew == 0) {
                ptrnew = new;
                chknew = 1;
            }
            continue;
        }

        /*
         * Determine if the current token matches the old or new string.
         * If not, disable the checking for each string.
         */
        if (chkold && (*ptr != *ptrold++))
            chkold = 0;
        if (chknew && (*ptr != *ptrnew++))
            chknew = 0;
    }

    /*
     * We've come to the end of the string, if the old or new string
     * checking is still enabled, we've found a match.
     */
    if ((uintptr_t)ptr - (uintptr_t)curstr) {
        if (chkold)
            curold = curstr;
        if (chknew)
            curnew = curstr;
    }

    /*
     * If an old string hasn't been found, or it has and a new string has
     * been found, return the original string.
     */
    if ((curold == 0) || curnew)
        return (str);
    else {
        char    *newstr;
        size_t  len;

        /*
         * Allocate a new string, enlarged to accommodate the new string
         * that will be inserted, and an associated separator.
         */
        if ((curstr = malloc(newlen + 2 +
            (uintptr_t)ptr - (uintptr_t)str)) == 0)
            return (str);

        newstr = (char *)curstr;
        for (len = (uintptr_t)curold - (uintptr_t)str; len; len--)
            *(newstr++) = *(str++);     /* copy up to */
                            /*    insertion point */
        for (len = newlen; len; len--)
            *(newstr++) = *(new++);     /* add new string and */
        *(newstr++) = ':';          /*    separator */
        for (len = (uintptr_t)ptr - (uintptr_t)str; len; len--)
            *(newstr++) = *(str++);     /* add remaining */
        *(newstr++) = '\0';         /*  string */

        return (curstr);
    }
}