/*
* 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.
*/
#include <stdio.h>
#include <strings.h>
#include <_machelf.h>
#include "_conv.h"
#include "globals_msg.h"
/*
* Map an integer into a descriptive string.
*
* entry:
* inv_buf - A buffer into which this routine can format
* a result string, if necessary.
* val - The value for which a string is desired.
* flags - CONV_FMT_* values to be passed to conv_invalid_val() if
* necessary. The caller is reponsible for having examined
* the CONV_FMT_ALT_* part of flags and passing the proper
* msg array.
* num_msg - # of Msg entries in msg.
* msg - Array of num_msg Msg items corresponding to the possible
* strings corresponding to val.
* local_sgs_msg - Message string table from module from which
* this function is called.
*
* exit:
* If val lies in the range [0-(num_msg-1)], then the string
* corresponding to it is returned. If val is outside the range,
* conv_invalid_val() is called to format an ASCII representation
* of it into inv_buf, and that is returned.
*/
/*ARGSUSED5*/
static const char *
map_msg2str(Conv_inv_buf_t *inv_buf, Conv_elfvalue_t val,
Conv_fmt_flags_t flags, size_t num_msg, const Msg *msg,
const char *local_sgs_msg)
{
if ((val < num_msg) && (msg[val] != 0))
return (MSG_ORIG_STRTAB(msg[val], local_sgs_msg));
/* If we get here, it's an unknown value */
return (conv_invalid_val(inv_buf, val, flags));
}
/*
* Map an integer into a descriptive string from a NULL terminated
* array of Val_desc or Val_desc2 descriptors.
*
* entry:
* inv_buf - A buffer into which this routine can format
* a result string, if necessary.
* osabi,mach (_conv_vd22str only) - The osab/mach under which
* val is to be interpreted. Items with a non-0 osabi or machine
* that do not match are quietly ignored.
* val - The value for which a string is desired.
* flags - CONV_FMT_* values to be passed to conv_invalid_val() if
* necessary. The caller is reponsible for having examined
* the CONV_FMT_ALT_* part of flags and passing the proper
* descriptor array.
* vdp - Pointer to NULL terminated array of Val_desc descriptors.
* local_sgs_msg - Message string table from module from which
* this function is called.
*
* exit:
* If val is found in the vdp array, and in the osabi version of
* this function if the osabi matches, then the string corresponding
* val is returned. If a string for val is not found, conv_invalid_val()
* is called to format an ASCII representation of it into inv_buf, and
* that is returned.
*/
/*ARGSUSED4*/
static const char *
map_vd2str(Conv_inv_buf_t *inv_buf, Conv_elfvalue_t val,
Conv_fmt_flags_t flags, const Val_desc *vdp, const char *local_sgs_msg)
{
for (; vdp->v_msg; vdp++) {
if (val == vdp->v_val)
return (MSG_ORIG_STRTAB(vdp->v_msg, local_sgs_msg));
}
/* If we get here, it's an unknown value */
return (conv_invalid_val(inv_buf, val, flags));
}
/*ARGSUSED6*/
static const char *
map_vd22str(Conv_inv_buf_t *inv_buf, uchar_t osabi, Half mach,
Conv_elfvalue_t val, Conv_fmt_flags_t flags, const Val_desc2 *vdp,
const char *local_sgs_msg)
{
for (; vdp->v_msg; vdp++) {
if (CONV_VD2_SKIP(osabi, mach, vdp))
continue;
if (val == vdp->v_val)
return (MSG_ORIG_STRTAB(vdp->v_msg, local_sgs_msg));
}
/* If we get here, it's an unknown value */
return (conv_invalid_val(inv_buf, val, flags));
}
/*
* Process an array of conv_ds_XXX_t structures and call the appropriate
* map functions for the format of the strings given.
*/
const char *
_conv_map_ds(uchar_t osabi, Half mach, Conv_elfvalue_t value,
const conv_ds_t **dsp, Conv_fmt_flags_t fmt_flags, Conv_inv_buf_t *inv_buf,
const char *local_sgs_msg)
{
const conv_ds_t *ds;
for (ds = *dsp; ds != NULL; ds = *(++dsp)) {
if ((value < ds->ds_baseval) || (value > ds->ds_topval))
continue;
switch (ds->ds_type) {
case CONV_DS_MSGARR:
return (map_msg2str(inv_buf, value - ds->ds_baseval,
fmt_flags, ds->ds_topval - ds->ds_baseval + 1,
/*LINTED*/
((conv_ds_msg_t *)ds)->ds_msg,
local_sgs_msg));
case CONV_DS_VD:
return (map_vd2str(inv_buf, value, fmt_flags,
/*LINTED*/
((conv_ds_vd_t *)ds)->ds_vd,
local_sgs_msg));
case CONV_DS_VD2:
return (map_vd22str(inv_buf, osabi, mach, value,
fmt_flags,
/*LINTED*/
((conv_ds_vd2_t *)ds)->ds_vd2,
local_sgs_msg));
}
}
return (conv_invalid_val(inv_buf, value, fmt_flags));
}
/*
* Iterate over every message string in a given array of Msg codes,
* calling a user supplied callback for each one.
*
* entry:
* basevalue - Value corresponding to the first Msg in the array.
* local_sgs_msg - Pointer to the __sgs_msg array for the
* libconv module making the call.
* num_msg - # of items in array referenced by msg
* msg - Array of Msg indexes for the strings to iterate over.
* The value corresponding to each element of msg must be:
* value[i] = basevalue + i
* func, uvalue - User supplied function to be called for each
* string in msg. uvalue is an arbitrary user supplied pointer
* to be passed to func.
* local_sgs_msg - Pointer to the __sgs_msg array for the
* libconv module making the call.
*
* exit:
* The callback function is called for every non-zero item in
* msg[]. If any callback returns CONV_ITER_DONE, execution stops
* with that item and the function returns immediately. Otherwise,
* it continues to the end of the array.
*
* The value from the last callback is returned.
*/
/*ARGSUSED5*/
static conv_iter_ret_t
_conv_iter_msgarr(uint32_t basevalue, const Msg *msg, size_t num_msg,
conv_iter_cb_t func, void *uvalue, const char *local_sgs_msg)
{
for (; num_msg-- > 0; basevalue++, msg++) {
if (*msg != 0)
if ((* func)(MSG_ORIG_STRTAB(*msg, local_sgs_msg),
basevalue, uvalue) == CONV_ITER_DONE)
return (CONV_ITER_DONE);
}
return (CONV_ITER_CONT);
}
/*
* Iterate over every message string in a given array of Val_desc or
* Val_desc2 descriptors, calling a user supplied callback for each one.
*
* entry:
* osabi,mach (_conv_iter_vd2 only) - The osabi/mach for which
* strings are desired. Strings with a non-0 osabi or machine
* that do not match are quietly ignored.
* vdp - Pointer to NULL terminated array of Val_desc descriptors.
* func, uvalue - User supplied function to be called for each
* string in msg. uvalue is an arbitrary user supplied pointer
* to be passed to func.
* local_sgs_msg - Pointer to the __sgs_msg array for the
* libconv module making the call.
*
* exit:
* The callback function is called for every descriptor referenced by
* vdp. In the case of the OSABI-version of this function, strings from
* the wrong osabi are not used. If any callback returns CONV_ITER_DONE,
* execution stops with that item and the function returns immediately.
* Otherwise, it continues to the end of the array.
*
* The value from the last callback is returned.
*/
/*ARGSUSED3*/
conv_iter_ret_t
_conv_iter_vd(const Val_desc *vdp, conv_iter_cb_t func, void *uvalue,
const char *local_sgs_msg)
{
for (; vdp->v_msg; vdp++) {
if ((* func)(MSG_ORIG_STRTAB(vdp->v_msg, local_sgs_msg),
vdp->v_val, uvalue) == CONV_ITER_DONE)
return (CONV_ITER_DONE);
}
return (CONV_ITER_CONT);
}
/*ARGSUSED5*/
conv_iter_ret_t
_conv_iter_vd2(conv_iter_osabi_t osabi, Half mach, const Val_desc2 *vdp,
conv_iter_cb_t func, void *uvalue, const char *local_sgs_msg)
{
for (; vdp->v_msg; vdp++) {
if (CONV_ITER_VD2_SKIP(osabi, mach, vdp))
continue;
if ((* func)(MSG_ORIG_STRTAB(vdp->v_msg, local_sgs_msg),
vdp->v_val, uvalue) == CONV_ITER_DONE)
return (CONV_ITER_DONE);
}
return (CONV_ITER_CONT);
}
/*
* Process an array of conv_ds_XXX_t structures and call the appropriate
* iteration functions for the format of the strings given.
*/
conv_iter_ret_t
_conv_iter_ds(conv_iter_osabi_t osabi, Half mach, const conv_ds_t **dsp,
conv_iter_cb_t func, void *uvalue, const char *local_sgs_msg)
{
const conv_ds_t *ds;
for (ds = *dsp; ds != NULL; ds = *(++dsp)) {
switch (ds->ds_type) {
case CONV_DS_MSGARR:
if (_conv_iter_msgarr(ds->ds_baseval,
/*LINTED*/
((conv_ds_msg_t *)ds)->ds_msg,
ds->ds_topval - ds->ds_baseval + 1, func, uvalue,
local_sgs_msg) == CONV_ITER_DONE)
return (CONV_ITER_DONE);
break;
case CONV_DS_VD:
/*LINTED*/
if (_conv_iter_vd(((conv_ds_vd_t *)ds)->ds_vd,
func, uvalue, local_sgs_msg) == CONV_ITER_DONE)
return (CONV_ITER_DONE);
break;
case CONV_DS_VD2:
if (_conv_iter_vd2(osabi, mach,
/*LINTED*/
((conv_ds_vd2_t *)ds)->ds_vd2,
func, uvalue, local_sgs_msg) == CONV_ITER_DONE)
return (CONV_ITER_DONE);
break;
}
}
return (CONV_ITER_CONT);
}
/*
* Initialize the uvalue block prior to use of an interation function
* employing conv_iter_strtol().
*
* entry:
* str - String to be matched to a value
* uvalue - Pointer to uninitialized uvalue block
*
* exit:
* Initializes the uvalue block for use. Returns True (1) if a non-empty
* string was supplied, and False (0).
*/
int
conv_iter_strtol_init(const char *str, conv_strtol_uvalue_t *uvalue)
{
const char *tail;
while (conv_strproc_isspace(*str))
str++;
uvalue->csl_str = str;
uvalue->csl_found = 0;
tail = str + strlen(str);
while ((tail > str) && conv_strproc_isspace(*(tail - 1)))
tail--;
uvalue->csl_strlen = tail - str;
return (uvalue->csl_strlen > 0);
}
/*
* conv_iter_strtol() is used with iteration functions to map a string
* to the value of its corresponding ELF constant.
*
* entry:
* str - String supplied by this iteration
* value - Value of ELF constant corresponding to str
* uvalue - Pointer to conv_strtol_uvalue_t block previously
* initialized by a call to conv_iter_strtol_init().
*/
conv_iter_ret_t
conv_iter_strtol(const char *str, uint32_t value, void *uvalue)
{
conv_strtol_uvalue_t *state = (conv_strtol_uvalue_t *)uvalue;
if ((strlen(str) == state->csl_strlen) &&
(strncasecmp(str, state->csl_str, state->csl_strlen) == 0)) {
state->csl_found = 1;
state->csl_value = value;
return (CONV_ITER_DONE); /* Found it. Stop now. */
}
return (CONV_ITER_CONT); /* Keep looking */
}