/*
* 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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <libintl.h>
#include <sys/varargs.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <alist.h>
#include <debug.h>
#include <_debug.h>
#include <msg.h>
/*
* Define a debug descriptor. Note, although this provides the default
* definition to which most users bind, ld.so.1 must provide its own definition,
* and thus interposition is expected. This item should be defined NODIRECT.
*/
static Dbg_desc _dbg_desc = { 0, 0, NULL, { 0, 0 }, { 0, 0 } };
Dbg_desc *dbg_desc = &_dbg_desc;
int _Dbg_cnt = 0;
/*
* Debugging initialization and processing. The dbg_options[] array defines
* a set of option strings that can be specified using the -D flag or from an
* environment variable. For each option, a class is enabled in the d_class
* bit mask, or an extra flag is enabled in the d_extra bit mask.
*/
static DBG_options _Dbg_options[] = { /* Options accepted by both linkers */
{MSG_ORIG(MSG_TOK_DETAIL), 0, DBG_E_DETAIL},
{MSG_ORIG(MSG_TOK_LONG), 0, DBG_E_LONG},
{MSG_ORIG(MSG_TOK_HELP), 0, DBG_E_HELP},
{MSG_ORIG(MSG_TOK_TTIME), 0, DBG_E_TTIME},
{MSG_ORIG(MSG_TOK_DTIME), 0, DBG_E_DTIME},
{MSG_ORIG(MSG_TOK_ALL), DBG_C_ALL & ~DBG_C_DEMANGLE, 0},
{MSG_ORIG(MSG_TOK_BASIC), DBG_C_BASIC, 0},
{MSG_ORIG(MSG_TOK_CAP), DBG_C_CAP, 0},
{MSG_ORIG(MSG_TOK_DEMANGLE), DBG_C_DEMANGLE, 0},
{MSG_ORIG(MSG_TOK_FILES), DBG_C_FILES, 0},
{MSG_ORIG(MSG_TOK_LIBS), DBG_C_LIBS, 0},
{MSG_ORIG(MSG_TOK_MOVE), DBG_C_MOVE, 0},
{MSG_ORIG(MSG_TOK_RELOC), DBG_C_RELOC, 0},
{MSG_ORIG(MSG_TOK_SYMBOLS), DBG_C_SYMBOLS, 0},
{MSG_ORIG(MSG_TOK_TLS), DBG_C_TLS, 0},
{MSG_ORIG(MSG_TOK_UNUSED), DBG_C_UNUSED, 0},
{MSG_ORIG(MSG_TOK_VERSIONS), DBG_C_VERSIONS, 0},
{NULL, 0, 0},
};
static DBG_options _Dbg_options_ld[] = { /* ld only options */
{MSG_ORIG(MSG_TOK_CLASS), 0, DBG_E_SNAME | DBG_E_CLASS},
{MSG_ORIG(MSG_TOK_FULLNAME), 0, DBG_E_SNAME | DBG_E_FNAME},
{MSG_ORIG(MSG_TOK_NAME), 0, DBG_E_SNAME},
{MSG_ORIG(MSG_TOK_ARGS), DBG_C_ARGS, 0},
{MSG_ORIG(MSG_TOK_ENTRY), DBG_C_ENTRY, 0},
{MSG_ORIG(MSG_TOK_GOT), DBG_C_GOT, 0},
{MSG_ORIG(MSG_TOK_MAP), DBG_C_MAP, 0},
{MSG_ORIG(MSG_TOK_SECTIONS), DBG_C_SECTIONS, 0},
{MSG_ORIG(MSG_TOK_SEGMENTS), DBG_C_SEGMENTS, 0},
{MSG_ORIG(MSG_TOK_STATS), DBG_C_STATS, 0},
{MSG_ORIG(MSG_TOK_STRTAB), DBG_C_STRTAB, 0},
{MSG_ORIG(MSG_TOK_SUPPORT), DBG_C_SUPPORT, 0},
{NULL, 0, 0},
};
static DBG_options _Dbg_options_rtld[] = { /* ld.so.1 only options */
{MSG_ORIG(MSG_TOK_AUDIT), DBG_C_AUDITING, 0},
{MSG_ORIG(MSG_TOK_BINDINGS), DBG_C_BINDINGS, 0},
{MSG_ORIG(MSG_TOK_DL), DBG_C_DL, 0},
{MSG_ORIG(MSG_TOK_INIT), DBG_C_INIT, 0},
{NULL, 0, 0},
};
/*
* Compare name to the options found in optarr. If one matches,
* update *dbp and return TRUE. Otherwise, FALSE.
*/
static Boolean
process_options(const char *name, Boolean set, Dbg_desc *dbp,
DBG_options *optarr)
{
DBG_options *opt;
for (opt = optarr; opt->o_name != NULL; opt++) {
if (strcmp(name, opt->o_name) != 0)
continue;
if (set == TRUE) {
if (opt->o_class)
dbp->d_class |= opt->o_class;
if (opt->o_extra)
dbp->d_extra |= opt->o_extra;
} else {
if (opt->o_class)
dbp->d_class &= ~(opt->o_class);
if (opt->o_extra)
dbp->d_extra &= ~(opt->o_extra);
}
return (TRUE);
}
return (FALSE);
}
/*
* Provide a debugging usage message
*/
void
Dbg_help(void)
{
Dbg_util_nl(0, DBG_NL_STD);
dbg_print(0, MSG_INTL(MSG_USE_R1_A));
dbg_print(0, MSG_INTL(MSG_USE_R1_B));
dbg_print(0, MSG_INTL(MSG_USE_R1_C));
dbg_print(0, MSG_INTL(MSG_USE_R1_D));
dbg_print(0, MSG_INTL(MSG_USE_R1_E));
dbg_print(0, MSG_INTL(MSG_USE_R1_F));
dbg_print(0, MSG_INTL(MSG_USE_R1_G));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_R2_A));
dbg_print(0, MSG_INTL(MSG_USE_R2_B));
dbg_print(0, MSG_INTL(MSG_USE_R2_C));
dbg_print(0, MSG_INTL(MSG_USE_R2_D));
dbg_print(0, MSG_INTL(MSG_USE_R2_E));
dbg_print(0, MSG_INTL(MSG_USE_R2_F));
dbg_print(0, MSG_INTL(MSG_USE_R2_G));
dbg_print(0, MSG_INTL(MSG_USE_R2_H));
dbg_print(0, MSG_INTL(MSG_USE_R2_I));
dbg_print(0, MSG_INTL(MSG_USE_R2_J));
dbg_print(0, MSG_INTL(MSG_USE_R2_K));
dbg_print(0, MSG_INTL(MSG_USE_R2_L));
dbg_print(0, MSG_INTL(MSG_USE_R2_M));
dbg_print(0, MSG_INTL(MSG_USE_R2_N));
dbg_print(0, MSG_INTL(MSG_USE_R2_O));
dbg_print(0, MSG_INTL(MSG_USE_R2_P));
dbg_print(0, MSG_INTL(MSG_USE_R2_Q));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_R2_R));
dbg_print(0, MSG_INTL(MSG_USE_R2_S));
dbg_print(0, MSG_INTL(MSG_USE_R2_T));
dbg_print(0, MSG_INTL(MSG_USE_R2_U));
dbg_print(0, MSG_INTL(MSG_USE_R2_V));
dbg_print(0, MSG_INTL(MSG_USE_R2_W));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_R3_A));
dbg_print(0, MSG_INTL(MSG_USE_R3_B));
dbg_print(0, MSG_INTL(MSG_USE_R3_C));
dbg_print(0, MSG_INTL(MSG_USE_R3_D));
dbg_print(0, MSG_INTL(MSG_USE_R3_E));
dbg_print(0, MSG_INTL(MSG_USE_R3_F));
dbg_print(0, MSG_INTL(MSG_USE_R3_G));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_R3_H));
dbg_print(0, MSG_INTL(MSG_USE_R3_F));
dbg_print(0, MSG_INTL(MSG_USE_R3_I));
dbg_print(0, MSG_INTL(MSG_USE_R3_J));
dbg_print(0, MSG_INTL(MSG_USE_R3_K));
dbg_print(0, MSG_INTL(MSG_USE_R3_L));
dbg_print(0, MSG_INTL(MSG_USE_R3_M));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_R3_N));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_HDR_DCT));
dbg_print(0, MSG_INTL(MSG_USE_HDR_BOTH));
dbg_print(0, MSG_INTL(MSG_USE_R4_A));
dbg_print(0, MSG_INTL(MSG_USE_R4_B));
dbg_print(0, MSG_INTL(MSG_USE_R4_B2));
dbg_print(0, MSG_INTL(MSG_USE_R4_C));
dbg_print(0, MSG_INTL(MSG_USE_R4_C2));
dbg_print(0, MSG_INTL(MSG_USE_R4_C3));
dbg_print(0, MSG_INTL(MSG_USE_R4_D));
dbg_print(0, MSG_INTL(MSG_USE_R4_E));
dbg_print(0, MSG_INTL(MSG_USE_R4_E2));
dbg_print(0, MSG_INTL(MSG_USE_R4_E3));
dbg_print(0, MSG_INTL(MSG_USE_R4_F));
dbg_print(0, MSG_INTL(MSG_USE_R4_F2));
dbg_print(0, MSG_INTL(MSG_USE_R4_F3));
dbg_print(0, MSG_INTL(MSG_USE_R4_F4));
dbg_print(0, MSG_INTL(MSG_USE_R4_F5));
dbg_print(0, MSG_INTL(MSG_USE_R4_F6));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_HDR_RTLD));
dbg_print(0, MSG_INTL(MSG_USE_R5_A));
dbg_print(0, MSG_INTL(MSG_USE_R5_A2));
dbg_print(0, MSG_INTL(MSG_USE_R5_A3));
dbg_print(0, MSG_INTL(MSG_USE_R5_A4));
dbg_print(0, MSG_INTL(MSG_USE_R5_A5));
dbg_print(0, MSG_INTL(MSG_USE_R5_A6));
dbg_print(0, MSG_INTL(MSG_USE_R5_A7));
dbg_print(0, MSG_INTL(MSG_USE_R5_A8));
dbg_print(0, MSG_INTL(MSG_USE_R5_A9));
dbg_print(0, MSG_INTL(MSG_USE_R5_A0));
dbg_print(0, MSG_INTL(MSG_USE_R5_B));
dbg_print(0, MSG_INTL(MSG_USE_R5_C));
dbg_print(0, MSG_INTL(MSG_USE_R5_D));
dbg_print(0, MSG_INTL(MSG_USE_R5_E));
dbg_print(0, MSG_INTL(MSG_USE_R5_F));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_HDR_LD));
dbg_print(0, MSG_INTL(MSG_USE_R6_A));
dbg_print(0, MSG_INTL(MSG_USE_R6_B));
dbg_print(0, MSG_INTL(MSG_USE_R6_C));
dbg_print(0, MSG_INTL(MSG_USE_R6_C2));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_HDR_CST));
dbg_print(0, MSG_INTL(MSG_USE_HDR_BOTH));
dbg_print(0, MSG_INTL(MSG_USE_R7_A));
dbg_print(0, MSG_INTL(MSG_USE_R7_B));
dbg_print(0, MSG_INTL(MSG_USE_R7_C));
dbg_print(0, MSG_INTL(MSG_USE_R7_D));
dbg_print(0, MSG_INTL(MSG_USE_R7_E));
dbg_print(0, MSG_INTL(MSG_USE_R7_F));
dbg_print(0, MSG_INTL(MSG_USE_R7_F2));
dbg_print(0, MSG_INTL(MSG_USE_R7_G));
dbg_print(0, MSG_INTL(MSG_USE_R7_H));
dbg_print(0, MSG_INTL(MSG_USE_R7_I));
dbg_print(0, MSG_INTL(MSG_USE_R7_I2));
dbg_print(0, MSG_INTL(MSG_USE_R7_J));
dbg_print(0, MSG_INTL(MSG_USE_R7_K));
dbg_print(0, MSG_INTL(MSG_USE_R7_K2));
dbg_print(0, MSG_INTL(MSG_USE_R7_L));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_HDR_RTLD));
dbg_print(0, MSG_INTL(MSG_USE_R8_A));
dbg_print(0, MSG_INTL(MSG_USE_R8_B));
dbg_print(0, MSG_INTL(MSG_USE_R8_B2));
dbg_print(0, MSG_INTL(MSG_USE_R8_C));
dbg_print(0, MSG_INTL(MSG_USE_R8_D));
Dbg_util_nl(0, DBG_NL_FRC);
dbg_print(0, MSG_INTL(MSG_USE_HDR_LD));
dbg_print(0, MSG_INTL(MSG_USE_R9_A));
dbg_print(0, MSG_INTL(MSG_USE_R9_B));
dbg_print(0, MSG_INTL(MSG_USE_R9_C));
dbg_print(0, MSG_INTL(MSG_USE_R9_D));
dbg_print(0, MSG_INTL(MSG_USE_R9_E));
dbg_print(0, MSG_INTL(MSG_USE_R9_F));
dbg_print(0, MSG_INTL(MSG_USE_R9_F2));
dbg_print(0, MSG_INTL(MSG_USE_R9_G));
dbg_print(0, MSG_INTL(MSG_USE_R9_H));
dbg_print(0, MSG_INTL(MSG_USE_R9_H2));
dbg_print(0, MSG_INTL(MSG_USE_R9_I));
Dbg_util_nl(0, DBG_NL_FRC);
}
/*
* Provide a debugging message showing the version of the linker package
*/
void
Dbg_version(void)
{
Dbg_util_nl(0, DBG_NL_STD);
dbg_print(0, MSG_ORIG(MSG_STR_LDVER), link_ver_string);
Dbg_util_nl(0, DBG_NL_STD);
}
/*
* Messaging support - funnel everything through dgettext() as this provides
* the real binding to libc.
*/
const char *
_liblddbg_msg(Msg mid)
{
return (dgettext(MSG_ORIG(MSG_SUNW_OST_SGS), MSG_ORIG(mid)));
}
/*
* Given a name starting with "lmid", finish processing it. Return TRUE
* if a valid lmid token was seen, and FALSE for any error.
*
* exit:
* On failure, returns FALSE, indicating a syntax error
*
* On success:
* - Appropriate flags in dbg->d_extra have been set
* - Any link-map list names specified have been added to
* d_list, for the rtld dbg_print() to compare against
* link-map list names.
* - TRUE is returned.
*/
static Boolean
process_lmid(char *name, Dbg_desc *dbp)
{
/*
* "lmid" can have an optional argument. Allowed values are "all",
* "alt[0-9]+", "base", or "ldso". Alt has a variable ending, but
* we can use process_options() to handle the other three.
*/
static DBG_options options_lmid[] = {
{MSG_ORIG(MSG_TOK_LMID_ALL), 0, DBG_E_LMID_ALL},
{MSG_ORIG(MSG_TOK_LMID_BASE), 0, DBG_E_LMID_BASE},
{MSG_ORIG(MSG_TOK_LMID_LDSO), 0, DBG_E_LMID_LDSO},
{NULL, NULL},
};
Dbg_desc tmp_db;
const char *lmid_opt;
/* If it's a plain "lmid", we can set the flag and return now */
if (name[MSG_TOK_LMID_SIZE] == '\0') {
dbp->d_extra |= DBG_E_LMID;
return (TRUE);
}
/* If there's no value, its an error */
if (conv_strproc_extract_value(name, MSG_TOK_LMID_SIZE,
CONV_SPEXV_F_UCASE, &lmid_opt) == 0)
return (FALSE);
/*
* ALL, BASE, or LDSO?
*/
tmp_db.d_extra = 0;
if (process_options(lmid_opt, TRUE, &tmp_db, options_lmid)) {
/*
* If BASE, and we haven't already seen it, add it to the
* rtld name matching list. For the others, setting the
* e_extra bit suffices.
*/
if (((tmp_db.d_extra & DBG_E_LMID_BASE) != 0) &&
((dbp->d_extra & DBG_E_LMID_BASE) == 0) &&
(aplist_append(&dbp->d_list, MSG_ORIG(MSG_TOK_LMID_BASE),
AL_CNT_DEBUG) == NULL))
return (FALSE);
/* Add the resulting flags into the callers descriptor */
dbp->d_extra |= DBG_E_LMID | tmp_db.d_extra;
return (TRUE);
}
/*
* ALT?
*/
if (strncmp(lmid_opt, MSG_ORIG(MSG_TOK_LMID_ALT),
MSG_TOK_LMID_ALT_SIZE) == 0) {
const char *tail = lmid_opt + MSG_TOK_LMID_ALT_SIZE;
/* 'ALT' without a # means "all alternative link-map lists" */
if (*tail == '\0') {
dbp->d_extra |= DBG_E_LMID | DBG_E_LMID_ALT;
return (TRUE);
}
/*
* It is ALT[0-9]+. Make sure the characters following 'ALT'
* are numbers, and then add it to the rtld name matching list.
*/
for (; *tail; tail++)
if ((*tail < '0') || (*tail > '9'))
return (FALSE);
if (aplist_append(&dbp->d_list, lmid_opt, AL_CNT_DEBUG) == NULL)
return (FALSE);
dbp->d_extra |= DBG_E_LMID;
return (TRUE);
}
/* It's nothing we recognize */
return (FALSE);
}
/*
* Validate and enable the appropriate debugging classes.
*
* entry:
* string - String to be analyzed for debugging options
* dbp - Pointer to debug descriptor to be initialized
* outfile_ret - NULL, or pointer to receive result of 'output='
* token. A NULL value means that the 'output=' token
* is not accepted. A non-NULL value means that it is.
*
* exit:
* On failure, False (0) is returned.
*
* On success, string has been parsed, and the descriptor referenced
* by dbp has been initialized. If outfile is non-NULL, *outfile will
* be set to NULL if the 'output=' token is not present, and to the
* user supplied string otherwise. True (1) is returned.
*/
int
Dbg_setup(dbg_setup_caller_t caller, const char *string, Dbg_desc *dbp,
const char **outfile)
{
char *name, *_name; /* buffer in which to perform */
/* strtok_r() operations. */
char *lasts;
const char *delimit = MSG_ORIG(MSG_STR_DELIMIT);
/*
* Clear the help flags --- these items only apply for a single
* call to Dbg_setup().
*/
dbp->d_extra &= ~(DBG_E_HELP | DBG_E_HELP_EXIT);
if ((_name = (char *)malloc(strlen(string) + 1)) == NULL)
return (0);
(void) strcpy(_name, string);
if (outfile)
*outfile = NULL; /* No output file yet */
/*
* The token should be of the form "-Dtok,tok,tok,...". Separate the
* pieces and build up the appropriate mask, unrecognized options are
* flagged.
*/
if ((name = strtok_r(_name, delimit, &lasts)) != NULL) {
do {
Boolean set;
/* Remove leading and trailing whitespace */
name = conv_strproc_trim(name);
if (name[0] == '!') {
set = FALSE;
name++;
} else
set = TRUE;
if (*name == '\0')
continue; /* Skip null token */
/*
* First, determine if the token represents a class or
* extra.
*/
if (process_options(name, set, dbp, _Dbg_options))
continue;
switch (caller) {
case DBG_CALLER_LD: /* ld only tokens */
if (process_options(name, set, dbp,
_Dbg_options_ld))
continue;
break;
case DBG_CALLER_RTLD: /* rtld only tokens */
if (process_options(name, set, dbp,
_Dbg_options_rtld))
continue;
break;
}
/* The remaining options do not accept negation */
if (!set) {
dbg_print(0, MSG_INTL(MSG_USE_CNTNEGOPT), name);
continue;
}
/*
* Is it an 'output=' token? This item is a special
* case because it depends on the presence of
* a non-NULL outfile argument, and because the
* part following the '=' is variable.
*/
if ((outfile != NULL) &&
strncmp(name, MSG_ORIG(MSG_TOK_OUTFILE),
MSG_TOK_OUTFILE_SIZE) == 0) {
if (conv_strproc_extract_value(name,
MSG_TOK_OUTFILE_SIZE, 0, outfile))
continue;
}
/*
* Only the rtld "lmid" token is left.
*/
if ((caller == DBG_CALLER_RTLD) && (strncmp(name,
MSG_ORIG(MSG_TOK_LMID), MSG_TOK_LMID_SIZE) == 0) &&
process_lmid(name, dbp))
continue;
/* If we make it here, the token is not understood */
dbg_print(0, MSG_INTL(MSG_USE_UNRECOG), name);
} while ((name = strtok_r(NULL, delimit, &lasts)) != NULL);
}
/*
* If the debug help option was specified and this is the only debug
* class, return an indication that the user should exit.
*/
if ((_Dbg_cnt++ == 0) && (dbp->d_extra & DBG_E_HELP) &&
(dbp->d_class == 0))
dbp->d_extra |= DBG_E_HELP_EXIT;
return (1);
}
/*
* Define our own printing routine. This provides a basic fallback, as ld(1)
* and ld.so.1(1) provide their own routines that augment their diagnostic
* output, and direct the output to stderr. This item should be defined
* NODIRECT.
*/
/* PRINTFLIKE2 */
void
dbg_print(Lm_list *lml, const char *format, ...)
{
va_list ap;
#if defined(lint)
/*
* The lml argument is only meaningful for diagnostics sent to ld.so.1.
* Supress the lint error by making a dummy assignment.
*/
lml = 0;
#endif
va_start(ap, format);
(void) vprintf(format, ap);
(void) printf(MSG_ORIG(MSG_STR_NL));
va_end(ap);
}
/*
* Return an internationalized state transition string. These are used by
* various debugging output.
*/
const char *
Dbg_state_str(dbg_state_t type)
{
static const Msg state[DBG_STATE_NUM] = {
MSG_STR_ADD, /* MSG_INTL(MSG_STR_ADD) */
MSG_STR_CURRENT, /* MSG_INTL(MSG_STR_CURRENT) */
MSG_STR_EXCLUDE, /* MSG_INTL(MSG_STR_EXCLUDE) */
MSG_STR_IGNORE, /* MSG_INTL(MSG_STR_IGNORE) */
MSG_STR_MOD_BEFORE, /* MSG_INTL(MSG_STR_MOD_BEFORE) */
MSG_STR_MOD_AFTER, /* MSG_INTL(MSG_STR_MOD_AFTER) */
MSG_STR_NEW, /* MSG_INTL(MSG_STR_NEW) */
MSG_STR_NEW_IMPLICIT, /* MSG_INTL(MSG_STR_NEW_IMPLICIT) */
MSG_STR_RESET, /* MSG_INTL(MSG_STR_RESET) */
MSG_STR_ORIGINAL, /* MSG_INTL(MSG_STR_ORIGINAL) */
MSG_STR_RESOLVED, /* MSG_INTL(MSG_STR_RESOLVED) */
};
#if DBG_STATE_NUM != (DBG_STATE_RESOLVED + 1)
#error DBG_SEG_NUM has changed. Update segtype[]
#endif
assert(type < DBG_STATE_NUM);
return (MSG_INTL(state[type]));
}