8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / fm / libfmd_msg / common / fmd_msg.c

/*
 * 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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * FMD Message Library
 *
 * This library supports a simple set of routines for use in converting FMA
 * events and message codes to localized human-readable message strings.
 *
 * 1. Library API
 *
 * The APIs are as follows:
 *
 * fmd_msg_init - set up the library and return a handle
 * fmd_msg_fini - destroy the handle from fmd_msg_init
 *
 * fmd_msg_locale_set - set the default locale (initially based on environ(5))
 * fmd_msg_locale_get - get the default locale
 *
 * fmd_msg_url_set - set the default URL for knowledge articles
 * fmd_msg_url_get - get the default URL for knowledge articles
 *
 * fmd_msg_gettext_nv - format the entire message for the given event
 * fmd_msg_gettext_id - format the entire message for the given event code
 * fmd_msg_gettext_key - format the entire message for the given dict for the
 *                       given explicit message key
 *
 * fmd_msg_getitem_nv - format a single message item for the given event
 * fmd_msg_getitem_id - format a single message item for the given event code
 *
 * Upon success, fmd_msg_gettext_* and fmd_msg_getitem_* return newly-allocated
 * localized strings in multi-byte format.  The caller must call free() on the
 * resulting buffer to deallocate the string after making use of it.  Upon
 * failure, these functions return NULL and set errno as follows:
 *
 * ENOMEM - Memory allocation failure while formatting message
 * ENOENT - No message was found for the specified message identifier
 * EINVAL - Invalid argument (e.g. bad event code, illegal fmd_msg_item_t)
 * EILSEQ - Illegal multi-byte sequence detected in message
 *
 * 2. Variable Expansion
 *
 * The human-readable messages are stored in msgfmt(1) message object files in
 * the corresponding locale directories.  The values for the message items are
 * permitted to contain variable expansions, currently defined as follows:
 *
 * %%     - literal % character
 * %s     - knowledge article URL (e.g. http://illumos.org/msg/<MSG-ID>)
 * %< x > - value x from the current event, using the expression syntax below:
 *
 * foo.bar  => print nvlist_t member "bar" contained within nvlist_t "foo"
 * foo[123] => print array element 123 of nvlist_t member "foo"
 * foo[123].bar => print member "bar" of nvlist_t element 123 in array "foo"
 *
 * For example, the msgstr value for FMD-8000-2K might be defined as:
 *
 * msgid "FMD-8000-2K.action"
 * msgstr "Use fmdump -v -u %<uuid> to locate the module.  Use fmadm \
 *     reset %<fault-list[0].asru.mod-name> to reset the module."
 *
 * 3. Locking
 *
 * In order to format a human-readable message, libfmd_msg must get and set
 * the process locale and potentially alter text domain bindings.  At present,
 * these facilities in libc are not fully MT-safe.  As such, a library-wide
 * lock is provided: fmd_msg_lock() and fmd_msg_unlock().  These locking calls
 * are made internally as part of the top-level library entry points, but they
 * can also be used by applications that themselves call setlocale() and wish
 * to appropriately synchronize with other threads that are calling libfmd_msg.
 */


#include <sys/fm/protocol.h>

#include <libintl.h>
#include <locale.h>
#include <wchar.h>

#include <alloca.h>
#include <assert.h>
#include <netdb.h>
#include <pthread.h>
#include <synch.h>
#include <strings.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <sys/sysmacros.h>

#include <fmd_msg.h>

#define FMD_MSGBUF_SZ   256

struct fmd_msg_hdl {
        int fmh_version;        /* libfmd_msg client abi version number */
        char *fmh_urlbase;      /* base url for all knowledge articles */
        char *fmh_binding;      /* base directory for bindtextdomain() */
        char *fmh_locale;       /* default program locale from environment */
        const char *fmh_template; /* FMD_MSG_TEMPLATE value for fmh_locale */
};

typedef struct fmd_msg_buf {
        wchar_t *fmb_data;      /* wide-character data buffer */
        size_t fmb_size;        /* size of fmb_data in wchar_t units */
        size_t fmb_used;        /* used portion of fmb_data in wchar_t units */
        int fmb_error;          /* error if any has occurred */
} fmd_msg_buf_t;

static const char *const fmd_msg_items[] = {
        "type",                 /* key for FMD_MSG_ITEM_TYPE */
        "severity",             /* key for FMD_MSG_ITEM_SEVERITY */
        "description",          /* key for FMD_MSG_ITEM_DESC */
        "response",             /* key for FMD_MSG_ITEM_RESPONSE */
        "impact",               /* key for FMD_MSG_ITEM_IMPACT */
        "action",               /* key for FMD_MSG_ITEM_ACTION */
        "url",                  /* key for FMD_MSG_ITEM_URL */
};

static pthread_rwlock_t fmd_msg_rwlock = PTHREAD_RWLOCK_INITIALIZER;

static const char FMD_MSG_DOMAIN[] = "FMD";
static const char FMD_MSG_TEMPLATE[] = "syslog-msgs-message-template";
static const char FMD_MSG_URLKEY[] = "syslog-url";
static const char FMD_MSG_URLBASE[] = "http://illumos.org/msg/";
static const char FMD_MSG_NLSPATH[] = "NLSPATH=/usr/lib/fm/fmd/fmd.cat";
static const char FMD_MSG_MISSING[] = "-";

/*
 * An enumeration of token types.  The following are valid tokens that can be
 * embedded into the message content:
 *
 * T_INT - integer tokens (for array indices)
 * T_IDENT - nvpair identifiers
 * T_DOT - "."
 * T_LBRAC - "["
 * T_RBRAC - "]"
 *
 * A NULL character (T_EOF) is used to terminate messages.
 * Invalid tokens are assigned the type T_ERR.
 */
typedef enum {
        T_EOF,
        T_ERR,
        T_IDENT,
        T_INT,
        T_DOT,
        T_LBRAC,
        T_RBRAC
} fmd_msg_nv_tkind_t;

typedef struct fmd_msg_nv_token {
        fmd_msg_nv_tkind_t t_kind;
        union {
                char tu_str[256];
                uint_t tu_int;
        } t_data;
} fmd_msg_nv_token_t;

static const struct fmd_msg_nv_type {
        data_type_t nvt_type;
        data_type_t nvt_base;
        size_t nvt_size;
        int (*nvt_value)();
        int (*nvt_array)();
} fmd_msg_nv_types[] = {
        { DATA_TYPE_INT8, DATA_TYPE_INT8,
            sizeof (int8_t), nvpair_value_int8, NULL },
        { DATA_TYPE_INT16, DATA_TYPE_INT16,
            sizeof (int16_t), nvpair_value_int16, NULL },
        { DATA_TYPE_INT32, DATA_TYPE_INT32,
            sizeof (int32_t), nvpair_value_int32, NULL },
        { DATA_TYPE_INT64, DATA_TYPE_INT64,
            sizeof (int64_t), nvpair_value_int64, NULL },
        { DATA_TYPE_UINT8, DATA_TYPE_UINT8,
            sizeof (uint8_t), nvpair_value_uint8, NULL },
        { DATA_TYPE_UINT16, DATA_TYPE_UINT16,
            sizeof (uint16_t), nvpair_value_uint16, NULL },
        { DATA_TYPE_UINT32, DATA_TYPE_UINT32,
            sizeof (uint32_t), nvpair_value_uint32, NULL },
        { DATA_TYPE_UINT64, DATA_TYPE_UINT64,
            sizeof (uint64_t), nvpair_value_uint64, NULL },
        { DATA_TYPE_BYTE, DATA_TYPE_BYTE,
            sizeof (uchar_t), nvpair_value_byte, NULL },
        { DATA_TYPE_BOOLEAN, DATA_TYPE_BOOLEAN,
            0, NULL, NULL },
        { DATA_TYPE_BOOLEAN_VALUE, DATA_TYPE_BOOLEAN_VALUE,
            sizeof (boolean_t), nvpair_value_boolean_value, NULL },
        { DATA_TYPE_HRTIME, DATA_TYPE_HRTIME,
            sizeof (hrtime_t), nvpair_value_hrtime, NULL },
        { DATA_TYPE_STRING, DATA_TYPE_STRING,
            sizeof (char *), nvpair_value_string, NULL },
        { DATA_TYPE_NVLIST, DATA_TYPE_NVLIST,
            sizeof (nvlist_t *), nvpair_value_nvlist, NULL },
        { DATA_TYPE_INT8_ARRAY, DATA_TYPE_INT8,
            sizeof (int8_t), NULL, nvpair_value_int8_array },
        { DATA_TYPE_INT16_ARRAY, DATA_TYPE_INT16,
            sizeof (int16_t), NULL, nvpair_value_int16_array },
        { DATA_TYPE_INT32_ARRAY, DATA_TYPE_INT32,
            sizeof (int32_t), NULL, nvpair_value_int32_array },
        { DATA_TYPE_INT64_ARRAY, DATA_TYPE_INT64,
            sizeof (int64_t), NULL, nvpair_value_int64_array },
        { DATA_TYPE_UINT8_ARRAY, DATA_TYPE_UINT8,
            sizeof (uint8_t), NULL, nvpair_value_uint8_array },
        { DATA_TYPE_UINT16_ARRAY, DATA_TYPE_UINT16,
            sizeof (uint16_t), NULL, nvpair_value_uint16_array },
        { DATA_TYPE_UINT32_ARRAY, DATA_TYPE_UINT32,
            sizeof (uint32_t), NULL, nvpair_value_uint32_array },
        { DATA_TYPE_UINT64_ARRAY, DATA_TYPE_UINT64,
            sizeof (uint64_t), NULL, nvpair_value_uint64_array },
        { DATA_TYPE_BYTE_ARRAY, DATA_TYPE_BYTE,
            sizeof (uchar_t), NULL, nvpair_value_byte_array },
        { DATA_TYPE_BOOLEAN_ARRAY, DATA_TYPE_BOOLEAN_VALUE,
            sizeof (boolean_t), NULL, nvpair_value_boolean_array },
        { DATA_TYPE_STRING_ARRAY, DATA_TYPE_STRING,
            sizeof (char *), NULL, nvpair_value_string_array },
        { DATA_TYPE_NVLIST_ARRAY, DATA_TYPE_NVLIST,
            sizeof (nvlist_t *), NULL, nvpair_value_nvlist_array },
        { DATA_TYPE_UNKNOWN, DATA_TYPE_UNKNOWN, 0, NULL, NULL }
};

static int fmd_msg_nv_parse_nvpair(fmd_msg_buf_t *, nvpair_t *, char *);
static int fmd_msg_nv_parse_nvname(fmd_msg_buf_t *, nvlist_t *, char *);
static int fmd_msg_nv_parse_nvlist(fmd_msg_buf_t *, nvlist_t *, char *);

/*ARGSUSED*/
static int
fmd_msg_lock_held(fmd_msg_hdl_t *h)
{
        return (RW_WRITE_HELD(&fmd_msg_rwlock));
}

void
fmd_msg_lock(void)
{
        if (pthread_rwlock_wrlock(&fmd_msg_rwlock) != 0)
                abort();
}

void
fmd_msg_unlock(void)
{
        if (pthread_rwlock_unlock(&fmd_msg_rwlock) != 0)
                abort();
}

static fmd_msg_hdl_t *
fmd_msg_init_err(fmd_msg_hdl_t *h, int err)
{
        fmd_msg_fini(h);
        errno = err;
        return (NULL);
}

fmd_msg_hdl_t *
fmd_msg_init(const char *root, int version)
{
        fmd_msg_hdl_t *h = NULL;
        const char *s;
        size_t len;

        if (version != FMD_MSG_VERSION)
                return (fmd_msg_init_err(h, EINVAL));

        if ((h = malloc(sizeof (fmd_msg_hdl_t))) == NULL)
                return (fmd_msg_init_err(h, ENOMEM));

        bzero(h, sizeof (fmd_msg_hdl_t));
        h->fmh_version = version;

        if ((h->fmh_urlbase = strdup(FMD_MSG_URLBASE)) == NULL)
                return (fmd_msg_init_err(h, ENOMEM));

        /*
         * Initialize the program's locale from the environment if it hasn't
         * already been initialized, and then retrieve the default setting.
         */
        (void) setlocale(LC_ALL, "");
        s = setlocale(LC_ALL, NULL);
        h->fmh_locale = strdup(s ? s : "C");

        if (h->fmh_locale == NULL)
                return (fmd_msg_init_err(h, ENOMEM));

        /*
         * If a non-default root directory is specified, then look up the base
         * directory for our default catalog, and set fmh_binding as the same
         * directory prefixed with the new root directory.  This simply turns
         * usr/lib/locale into <rootdir>/usr/lib/locale, but handles all of the
         * environ(5) settings that can change the default messages binding.
         */
        if (root != NULL && root[0] != '\0' && strcmp(root, "/") != 0) {
                if (root[0] != '/')
                        return (fmd_msg_init_err(h, EINVAL));

                if ((s = bindtextdomain(FMD_MSG_DOMAIN, NULL)) == NULL)
                        s = "/usr/lib/locale"; /* substitute default */

                len = strlen(root) + strlen(s) + 1;

                if ((h->fmh_binding = malloc(len)) == NULL)
                        return (fmd_msg_init_err(h, ENOMEM));

                (void) snprintf(h->fmh_binding, len, "%s%s", root, s);
        }

        /*
         * All FMA event dictionaries use msgfmt(1) message objects to produce
         * messages, even for the C locale.  We therefore want to use dgettext
         * for all message lookups, but its defined behavior in the C locale is
         * to return the input string.  Since our input strings are event codes
         * and not format strings, this doesn't help us.  We resolve this nit
         * by setting NLSPATH to a non-existent file: the presence of NLSPATH
         * is defined to force dgettext(3C) to do a full lookup even for C.
         */
        if (getenv("NLSPATH") == NULL &&
            ((s = strdup(FMD_MSG_NLSPATH)) == NULL || putenv((char *)s) != 0))
                return (fmd_msg_init_err(h, errno));

        /*
         * Cache the message template for the current locale.  This is the
         * snprintf(3C) format string for the final human-readable message.
         * If the lookup fails for the current locale, fall back to the C locale
         * and try again.  Then restore the original locale.
         */
        if ((h->fmh_template = dgettext(FMD_MSG_DOMAIN, FMD_MSG_TEMPLATE))
            == FMD_MSG_TEMPLATE && strcmp(h->fmh_locale, "C") != 0) {
                (void) setlocale(LC_ALL, "C");
                h->fmh_template = dgettext(FMD_MSG_DOMAIN, FMD_MSG_TEMPLATE);
                (void) setlocale(LC_ALL, h->fmh_locale);
        }

        return (h);
}

void
fmd_msg_fini(fmd_msg_hdl_t *h)
{
        if (h == NULL)
                return; /* simplify caller code */

        free(h->fmh_binding);
        free(h->fmh_urlbase);
        free(h->fmh_locale);
        free(h);
}

int
fmd_msg_locale_set(fmd_msg_hdl_t *h, const char *locale)
{
        char *l;

        if (locale == NULL) {
                errno = EINVAL;
                return (-1);
        }

        if ((l = strdup(locale)) == NULL) {
                errno = ENOMEM;
                return (-1);
        }

        fmd_msg_lock();

        if (setlocale(LC_ALL, l) == NULL) {
                free(l);
                errno = EINVAL;
                fmd_msg_unlock();
                return (-1);
        }

        h->fmh_template = dgettext(FMD_MSG_DOMAIN, FMD_MSG_TEMPLATE);
        free(h->fmh_locale);
        h->fmh_locale = l;

        fmd_msg_unlock();
        return (0);
}

const char *
fmd_msg_locale_get(fmd_msg_hdl_t *h)
{
        return (h->fmh_locale);
}

int
fmd_msg_url_set(fmd_msg_hdl_t *h, const char *url)
{
        char *u;

        if (url == NULL) {
                errno = EINVAL;
                return (-1);
        }

        if ((u = strdup(url)) == NULL) {
                errno = ENOMEM;
                return (-1);
        }

        fmd_msg_lock();

        free(h->fmh_urlbase);
        h->fmh_urlbase = u;

        fmd_msg_unlock();
        return (0);
}

const char *
fmd_msg_url_get(fmd_msg_hdl_t *h)
{
        return (h->fmh_urlbase);
}

static wchar_t *
fmd_msg_mbstowcs(const char *s)
{
        size_t n = strlen(s) + 1;
        wchar_t *w = malloc(n * sizeof (wchar_t));

        if (w == NULL) {
                errno = ENOMEM;
                return (NULL);
        }

        if (mbstowcs(w, s, n) == (size_t)-1) {
                free(w);
                return (NULL);
        }

        return (w);
}

static void
fmd_msg_buf_init(fmd_msg_buf_t *b)
{
        bzero(b, sizeof (fmd_msg_buf_t));
        b->fmb_data = malloc(sizeof (wchar_t) * FMD_MSGBUF_SZ);

        if (b->fmb_data == NULL)
                b->fmb_error = ENOMEM;
        else
                b->fmb_size = FMD_MSGBUF_SZ;
}

static void
fmd_msg_buf_fini(fmd_msg_buf_t *b)
{
        free(b->fmb_data);
        bzero(b, sizeof (fmd_msg_buf_t));
}

static char *
fmd_msg_buf_read(fmd_msg_buf_t *b)
{
        char *s;

        if (b->fmb_error != 0) {
                errno = b->fmb_error;
                return (NULL);
        }

        if ((s = malloc(b->fmb_used * MB_CUR_MAX)) == NULL) {
                errno = ENOMEM;
                return (NULL);
        }

        if (wcstombs(s, b->fmb_data, b->fmb_used) == (size_t)-1) {
                free(s);
                return (NULL);
        }

        return (s);
}

/*
 * Buffer utility function to write a wide-character string into the buffer,
 * appending it at the end, and growing the buffer as needed as we go.  Any
 * allocation errors are stored in fmb_error and deferred until later.
 */
static void
fmd_msg_buf_write(fmd_msg_buf_t *b, const wchar_t *w, size_t n)
{
        if (b->fmb_used + n > b->fmb_size) {
                size_t size = MAX(b->fmb_size * 2, b->fmb_used + n);
                wchar_t *data = malloc(sizeof (wchar_t) * size);

                if (data == NULL) {
                        if (b->fmb_error == 0)
                                b->fmb_error = ENOMEM;
                        return;
                }

                bcopy(b->fmb_data, data, b->fmb_used * sizeof (wchar_t));
                free(b->fmb_data);

                b->fmb_data = data;
                b->fmb_size = size;
        }

        bcopy(w, &b->fmb_data[b->fmb_used], sizeof (wchar_t) * n);
        b->fmb_used += n;
}

/*
 * Buffer utility function to printf a multi-byte string, convert to wide-
 * character form, and then write the result into an fmd_msg_buf_t.
 */
/*PRINTFLIKE2*/
static void
fmd_msg_buf_printf(fmd_msg_buf_t *b, const char *format, ...)
{
        ssize_t len;
        va_list ap;
        char *buf;
        wchar_t *w;

        va_start(ap, format);
        len = vsnprintf(NULL, 0, format, ap);
        buf = alloca(len + 1);
        (void) vsnprintf(buf, len + 1, format, ap);
        va_end(ap);

        if ((w = fmd_msg_mbstowcs(buf)) == NULL) {
                if (b->fmb_error != 0)
                        b->fmb_error = errno;
        } else {
                fmd_msg_buf_write(b, w, wcslen(w));
                free(w);
        }
}

/*PRINTFLIKE1*/
static int
fmd_msg_nv_error(const char *format, ...)
{
        int err = errno;
        va_list ap;

        if (getenv("FMD_MSG_DEBUG") == NULL)
                return (1);

        (void) fprintf(stderr, "libfmd_msg DEBUG: ");
        va_start(ap, format);
        (void) vfprintf(stderr, format, ap);
        va_end(ap);

        if (strchr(format, '\n') == NULL)
                (void) fprintf(stderr, ": %s\n", strerror(err));

        return (1);
}

static const struct fmd_msg_nv_type *
fmd_msg_nv_type_lookup(data_type_t type)
{
        const struct fmd_msg_nv_type *t;

        for (t = fmd_msg_nv_types; t->nvt_type != DATA_TYPE_UNKNOWN; t++) {
                if (t->nvt_type == type)
                        break;
        }

        return (t);
}

/*
 * Print the specified string, escaping any unprintable character sequences
 * using the ISO C character escape sequences.
 */
static void
fmd_msg_nv_print_string(fmd_msg_buf_t *b, const char *s)
{
        char c;

        while ((c = *s++) != '\0') {
                if (c >= ' ' && c <= '~' && c != '\'') {
                        fmd_msg_buf_printf(b, "%c", c);
                        continue;
                }

                switch (c) {
                case '\0':
                        fmd_msg_buf_printf(b, "\\0");
                        break;
                case '\a':
                        fmd_msg_buf_printf(b, "\\a");
                        break;
                case '\b':
                        fmd_msg_buf_printf(b, "\\b");
                        break;
                case '\f':
                        fmd_msg_buf_printf(b, "\\f");
                        break;
                case '\n':
                        fmd_msg_buf_printf(b, "\\n");
                        break;
                case '\r':
                        fmd_msg_buf_printf(b, "\\r");
                        break;
                case '\t':
                        fmd_msg_buf_printf(b, "\\t");
                        break;
                case '\v':
                        fmd_msg_buf_printf(b, "\\v");
                        break;
                case '\'':
                        fmd_msg_buf_printf(b, "\\'");
                        break;
                case '"':
                        fmd_msg_buf_printf(b, "\\\"");
                        break;
                case '\\':
                        fmd_msg_buf_printf(b, "\\\\");
                        break;
                default:
                        fmd_msg_buf_printf(b, "\\x%02x", (uchar_t)c);
                }
        }
}

/*
 * Print the value of the specified nvpair into the supplied buffer.
 *
 * For nvpairs that are arrays types, passing -1 as the idx param indicates
 * that we want to print all of the elements in the array.
 *
 * Returns 0 on success, 1 otherwise.
 */
static int
fmd_msg_nv_print_items(fmd_msg_buf_t *b, nvpair_t *nvp,
    data_type_t type, void *p, uint_t n, uint_t idx)
{
        const struct fmd_msg_nv_type *nvt = fmd_msg_nv_type_lookup(type);
        uint_t i;

        if (idx != -1u) {
                if (idx >= n) {
                        return (fmd_msg_nv_error("index %u out-of-range for "
                            "array %s: valid range is [0 .. %u]\n",
                            idx, nvpair_name(nvp), n ? n - 1 : 0));
                }
                p = (uchar_t *)p + nvt->nvt_size * idx;
                n = 1;
        }

        for (i = 0; i < n; i++, p = (uchar_t *)p + nvt->nvt_size) {
                if (i > 0)
                        fmd_msg_buf_printf(b, " "); /* array item delimiter */

                switch (type) {
                case DATA_TYPE_INT8:
                        fmd_msg_buf_printf(b, "%d", *(int8_t *)p);
                        break;

                case DATA_TYPE_INT16:
                        fmd_msg_buf_printf(b, "%d", *(int16_t *)p);
                        break;

                case DATA_TYPE_INT32:
                        fmd_msg_buf_printf(b, "%d", *(int32_t *)p);
                        break;

                case DATA_TYPE_INT64:
                        fmd_msg_buf_printf(b, "%lld", *(longlong_t *)p);
                        break;

                case DATA_TYPE_UINT8:
                        fmd_msg_buf_printf(b, "%u", *(uint8_t *)p);
                        break;

                case DATA_TYPE_UINT16:
                        fmd_msg_buf_printf(b, "%u", *(uint16_t *)p);
                        break;

                case DATA_TYPE_UINT32:
                        fmd_msg_buf_printf(b, "%u", *(uint32_t *)p);
                        break;

                case DATA_TYPE_UINT64:
                        fmd_msg_buf_printf(b, "%llu", *(u_longlong_t *)p);
                        break;

                case DATA_TYPE_BYTE:
                        fmd_msg_buf_printf(b, "0x%x", *(uchar_t *)p);
                        break;

                case DATA_TYPE_BOOLEAN_VALUE:
                        fmd_msg_buf_printf(b,
                            *(boolean_t *)p ? "true" : "false");
                        break;

                case DATA_TYPE_HRTIME:
                        fmd_msg_buf_printf(b, "%lld", *(longlong_t *)p);
                        break;

                case DATA_TYPE_STRING:
                        fmd_msg_nv_print_string(b, *(char **)p);
                        break;
                }
        }

        return (0);
}

/*
 * Writes the value of the specified nvpair to the supplied buffer.
 *
 * Returns 0 on success, 1 otherwise.
 */
static int
fmd_msg_nv_print_nvpair(fmd_msg_buf_t *b, nvpair_t *nvp, uint_t idx)
{
        data_type_t type = nvpair_type(nvp);
        const struct fmd_msg_nv_type *nvt = fmd_msg_nv_type_lookup(type);

        uint64_t v;
        void *a;
        uint_t n;
        int err;

        if (nvt->nvt_type == DATA_TYPE_BOOLEAN) {
                fmd_msg_buf_printf(b, "true");
                err = 0;
        } else if (nvt->nvt_array != NULL) {
                (void) nvt->nvt_array(nvp, &a, &n);
                err = fmd_msg_nv_print_items(b, nvp, nvt->nvt_base, a, n, idx);
        } else if (nvt->nvt_value != NULL) {
                (void) nvt->nvt_value(nvp, &v);
                err = fmd_msg_nv_print_items(b, nvp, nvt->nvt_base, &v, 1, idx);
        } else {
                err = fmd_msg_nv_error("unknown data type %u", type);
        }

        return (err);
}

/*
 * Consume a token from the specified string, fill in the specified token
 * struct, and return the new string position from which to continue parsing.
 */
static char *
fmd_msg_nv_parse_token(char *s, fmd_msg_nv_token_t *tp)
{
        char *p = s, *q, c = *s;

        /*
         * Skip whitespace and then look for an integer token first.  We can't
         * use isspace() or isdigit() because we're in setlocale() context now.
         */
        while (c == ' ' || c == '\t' || c == '\v' || c == '\n' || c == '\r')
                c = *++p;

        if (c >= '0' && c <= '9') {
                errno = 0;
                tp->t_data.tu_int = strtoul(p, &q, 0);

                if (errno != 0 || p == q) {
                        tp->t_kind = T_ERR;
                        return (p);
                }

                tp->t_kind = T_INT;
                return (q);
        }

        /*
         * Look for a name-value pair identifier, which we define to be the
         * regular expression [a-zA-Z_][a-zA-Z0-9_-]*  (NOTE: Ideally "-" would
         * not be allowed here and we would require ISO C identifiers, but many
         * FMA event members use hyphens.)  This code specifically cannot use
         * the isspace(), isalnum() etc. macros because we are currently in the
         * context of an earlier call to setlocale() that may have installed a
         * non-C locale, but this code needs to always operate on C characters.
         */
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_') {
                for (q = p + 1; (c = *q) != '\0'; q++) {
                        if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z') &&
                            (c < '0' || c > '9') && (c != '_' && c != '-'))
                                break;
                }

                if (sizeof (tp->t_data.tu_str) <= (size_t)(q - p)) {
                        tp->t_kind = T_ERR;
                        return (p);
                }

                bcopy(p, tp->t_data.tu_str, (size_t)(q - p));
                tp->t_data.tu_str[(size_t)(q - p)] = '\0';
                tp->t_kind = T_IDENT;
                return (q);
        }

        switch (c) {
        case '\0':
                tp->t_kind = T_EOF;
                return (p);
        case '.':
                tp->t_kind = T_DOT;
                return (p + 1);
        case '[':
                tp->t_kind = T_LBRAC;
                return (p + 1);
        case ']':
                tp->t_kind = T_RBRAC;
                return (p + 1);
        default:
                tp->t_kind = T_ERR;
                return (p);
        }
}

static int
fmd_msg_nv_parse_error(const char *s, fmd_msg_nv_token_t *tp)
{
        if (tp->t_kind == T_ERR)
                return (fmd_msg_nv_error("illegal character at \"%s\"\n", s));
        else
                return (fmd_msg_nv_error("syntax error near \"%s\"\n", s));
}

/*
 * Parse an array expression for referencing an element of the specified
 * nvpair_t, which is expected to be of an array type.  If it's an array of
 * intrinsics, print the specified value.  If it's an array of nvlist_t's,
 * call fmd_msg_nv_parse_nvlist() recursively to continue parsing.
 */
static int
fmd_msg_nv_parse_array(fmd_msg_buf_t *b, nvpair_t *nvp, char *s1)
{
        fmd_msg_nv_token_t t;
        nvlist_t **nva;
        uint_t i, n;
        char *s2;

        if (fmd_msg_nv_type_lookup(nvpair_type(nvp))->nvt_array == NULL) {
                return (fmd_msg_nv_error("inappropriate use of operator [ ]: "
                    "element '%s' is not an array\n", nvpair_name(nvp)));
        }

        s2 = fmd_msg_nv_parse_token(s1, &t);
        i = t.t_data.tu_int;

        if (t.t_kind != T_INT)
                return (fmd_msg_nv_error("expected integer index after [\n"));

        s2 = fmd_msg_nv_parse_token(s2, &t);

        if (t.t_kind != T_RBRAC)
                return (fmd_msg_nv_error("expected ] after [ %u\n", i));

        /*
         * An array of nvlist is different from other array types in that it
         * permits us to continue parsing instead of printing a terminal node.
         */
        if (nvpair_type(nvp) == DATA_TYPE_NVLIST_ARRAY) {
                (void) nvpair_value_nvlist_array(nvp, &nva, &n);

                if (i >= n) {
                        return (fmd_msg_nv_error("index %u out-of-range for "
                            "array %s: valid range is [0 .. %u]\n",
                            i, nvpair_name(nvp), n ? n - 1 : 0));
                }

                return (fmd_msg_nv_parse_nvlist(b, nva[i], s2));
        }

        (void) fmd_msg_nv_parse_token(s2, &t);

        if (t.t_kind != T_EOF) {
                return (fmd_msg_nv_error("expected end-of-string "
                    "in expression instead of \"%s\"\n", s2));
        }

        return (fmd_msg_nv_print_nvpair(b, nvp, i));
}

/*
 * Parse an expression rooted at an nvpair_t.  If we see EOF, print the entire
 * nvpair.  If we see LBRAC, parse an array expression.  If we see DOT, call
 * fmd_msg_nv_parse_nvname() recursively to dereference an embedded member.
 */
static int
fmd_msg_nv_parse_nvpair(fmd_msg_buf_t *b, nvpair_t *nvp, char *s1)
{
        fmd_msg_nv_token_t t;
        nvlist_t *nvl;
        char *s2;

        s2 = fmd_msg_nv_parse_token(s1, &t);

        if (t.t_kind == T_EOF)
                return (fmd_msg_nv_print_nvpair(b, nvp, -1));

        if (t.t_kind == T_LBRAC)
                return (fmd_msg_nv_parse_array(b, nvp, s2));

        if (t.t_kind != T_DOT)
                return (fmd_msg_nv_parse_error(s1, &t));

        if (nvpair_type(nvp) != DATA_TYPE_NVLIST) {
                return (fmd_msg_nv_error("inappropriate use of operator '.': "
                    "element '%s' is not of type nvlist\n", nvpair_name(nvp)));
        }

        (void) nvpair_value_nvlist(nvp, &nvl);
        return (fmd_msg_nv_parse_nvname(b, nvl, s2));
}

/*
 * Parse an expression for a name-value pair name (IDENT).  If we find a match
 * continue parsing with the corresponding nvpair_t.
 */
static int
fmd_msg_nv_parse_nvname(fmd_msg_buf_t *b, nvlist_t *nvl, char *s1)
{
        nvpair_t *nvp = NULL;
        fmd_msg_nv_token_t t;
        char *s2;

        s2 = fmd_msg_nv_parse_token(s1, &t);

        if (t.t_kind != T_IDENT)
                return (fmd_msg_nv_parse_error(s1, &t));

        while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
                if (strcmp(nvpair_name(nvp), t.t_data.tu_str) == 0)
                        break;
        }

        if (nvp == NULL) {
                return (fmd_msg_nv_error("no such name-value pair "
                    "member: %s\n", t.t_data.tu_str));
        }

        return (fmd_msg_nv_parse_nvpair(b, nvp, s2));
}

/*
 * Parse an expression rooted at an nvlist: if we see EOF, print nothing.
 * If we see DOT, continue parsing to retrieve a name-value pair name.
 */
static int
fmd_msg_nv_parse_nvlist(fmd_msg_buf_t *b, nvlist_t *nvl, char *s1)
{
        fmd_msg_nv_token_t t;
        char *s2;

        s2 = fmd_msg_nv_parse_token(s1, &t);

        if (t.t_kind == T_EOF)
                return (0);

        if (t.t_kind == T_DOT)
                return (fmd_msg_nv_parse_nvname(b, nvl, s2));

        return (fmd_msg_nv_parse_error(s1, &t));
}

/*
 * This function is the main engine for formatting an event message item, such
 * as the Description field.  It loads the item text from a message object,
 * expands any variables defined in the item text, and then returns a newly-
 * allocated multi-byte string with the localized message text, or NULL with
 * errno set if an error occurred.
 */
static char *
fmd_msg_getitem_locked(fmd_msg_hdl_t *h,
    nvlist_t *nvl, const char *dict, const char *code, fmd_msg_item_t item)
{
        const char *istr = fmd_msg_items[item];
        size_t len = strlen(code) + 1 + strlen(istr) + 1;
        char *key = alloca(len);

        fmd_msg_buf_t buf;
        wchar_t *c, *u, *w, *p, *q;

        const char *url, *txt;
        char *s, *expr;
        size_t elen;
        int i;

        assert(fmd_msg_lock_held(h));

        /*
         * If <dict>.mo defines an item with the key <FMD_MSG_URLKEY> then it
         * is used as the URL; otherwise the default from our handle is used.
         * Once we have the multi-byte URL, convert it to wide-character form.
         */
        if ((url = dgettext(dict, FMD_MSG_URLKEY)) == FMD_MSG_URLKEY)
                url = h->fmh_urlbase;

        /*
         * If the item is FMD_MSG_ITEM_URL, then its value is directly computed
         * as the URL base concatenated with the code.  Otherwise the item text
         * is derived by looking up the key <code>.<istr> in the dict object.
         * Once we're done, convert the 'txt' multi-byte to wide-character.
         */
        if (item == FMD_MSG_ITEM_URL) {
                len = strlen(url) + strlen(code) + 1;
                key = alloca(len);
                (void) snprintf(key, len, "%s%s", url, code);
                txt = key;
        } else {
                len = strlen(code) + 1 + strlen(istr) + 1;
                key = alloca(len);
                (void) snprintf(key, len, "%s.%s", code, istr);
                txt = dgettext(dict, key);
        }

        c = fmd_msg_mbstowcs(code);
        u = fmd_msg_mbstowcs(url);
        w = fmd_msg_mbstowcs(txt);

        if (c == NULL || u == NULL || w == NULL) {
                free(c);
                free(u);
                free(w);
                return (NULL);
        }

        /*
         * Now expand any escape sequences in the string, storing the final
         * text in 'buf' in wide-character format, and then convert it back
         * to multi-byte for return.  We expand the following sequences:
         *
         * %%   - literal % character
         * %s   - base URL for knowledge articles
         * %<x> - expression x in the current event, if any
         *
         * If an invalid sequence is present, it is elided so we can safely
         * reserve any future characters for other types of expansions.
         */
        fmd_msg_buf_init(&buf);

        for (q = w, p = w; (p = wcschr(p, L'%')) != NULL; q = p) {
                if (p > q)
                        fmd_msg_buf_write(&buf, q, (size_t)(p - q));

                switch (p[1]) {
                case L'%':
                        fmd_msg_buf_write(&buf, p, 1);
                        p += 2;
                        break;

                case L's':
                        fmd_msg_buf_write(&buf, u, wcslen(u));
                        fmd_msg_buf_write(&buf, c, wcslen(c));

                        p += 2;
                        break;

                case L'<':
                        q = p + 2;
                        p = wcschr(p + 2, L'>');

                        if (p == NULL)
                                goto eos;

                        /*
                         * The expression in %< > must be an ASCII string: as
                         * such allocate its length in bytes plus an extra
                         * MB_CUR_MAX for slop if a multi-byte character is in
                         * there, plus another byte for \0.  Since we move a
                         * byte at a time, any multi-byte chars will just be
                         * silently overwritten and fail to parse, which is ok.
                         */
                        elen = (size_t)(p - q);
                        expr = malloc(elen + MB_CUR_MAX + 1);

                        if (expr == NULL) {
                                buf.fmb_error = ENOMEM;
                                goto eos;
                        }

                        for (i = 0; i < elen; i++)
                                (void) wctomb(&expr[i], q[i]);

                        expr[i] = '\0';

                        if (nvl != NULL)
                                (void) fmd_msg_nv_parse_nvname(&buf, nvl, expr);
                        else
                                fmd_msg_buf_printf(&buf, "%%<%s>", expr);

                        free(expr);
                        p++;
                        break;

                case L'\0':
                        goto eos;

                default:
                        p += 2;
                        break;
                }
        }
eos:
        fmd_msg_buf_write(&buf, q, wcslen(q) + 1);

        free(c);
        free(u);
        free(w);

        s = fmd_msg_buf_read(&buf);
        fmd_msg_buf_fini(&buf);

        return (s);
}

/*
 * This is a private interface used by the notification daemons to parse tokens
 * in user-supplied message templates.
 */
char *
fmd_msg_decode_tokens(nvlist_t *nvl, const char *msg, const char *url)
{
        fmd_msg_buf_t buf;
        wchar_t *h, *u, *w, *p, *q;

        char *s, *expr, host[MAXHOSTNAMELEN + 1];
        size_t elen;
        int i;

        u = fmd_msg_mbstowcs(url);

        (void) gethostname(host, MAXHOSTNAMELEN + 1);
        h = fmd_msg_mbstowcs(host);

        if ((w = fmd_msg_mbstowcs(msg)) == NULL)
                return (NULL);

        /*
         * Now expand any escape sequences in the string, storing the final
         * text in 'buf' in wide-character format, and then convert it back
         * to multi-byte for return.  We expand the following sequences:
         *
         * %%   - literal % character
         * %h   - hostname
         * %s   - base URL for knowledge articles
         * %<x> - expression x in the current event, if any
         *
         * If an invalid sequence is present, it is elided so we can safely
         * reserve any future characters for other types of expansions.
         */
        fmd_msg_buf_init(&buf);

        for (q = w, p = w; (p = wcschr(p, L'%')) != NULL; q = p) {
                if (p > q)
                        fmd_msg_buf_write(&buf, q, (size_t)(p - q));

                switch (p[1]) {
                case L'%':
                        fmd_msg_buf_write(&buf, p, 1);
                        p += 2;
                        break;

                case L'h':
                        if (h != NULL)
                                fmd_msg_buf_write(&buf, h, wcslen(h));

                        p += 2;
                        break;

                case L's':
                        if (u != NULL)
                                fmd_msg_buf_write(&buf, u, wcslen(u));

                        p += 2;
                        break;

                case L'<':
                        q = p + 2;
                        p = wcschr(p + 2, L'>');

                        if (p == NULL)
                                goto eos;

                        /*
                         * The expression in %< > must be an ASCII string: as
                         * such allocate its length in bytes plus an extra
                         * MB_CUR_MAX for slop if a multi-byte character is in
                         * there, plus another byte for \0.  Since we move a
                         * byte at a time, any multi-byte chars will just be
                         * silently overwritten and fail to parse, which is ok.
                         */
                        elen = (size_t)(p - q);
                        expr = malloc(elen + MB_CUR_MAX + 1);

                        if (expr == NULL) {
                                buf.fmb_error = ENOMEM;
                                goto eos;
                        }

                        for (i = 0; i < elen; i++)
                                (void) wctomb(&expr[i], q[i]);

                        expr[i] = '\0';

                        if (nvl != NULL)
                                (void) fmd_msg_nv_parse_nvname(&buf, nvl, expr);
                        else
                                fmd_msg_buf_printf(&buf, "%%<%s>", expr);

                        free(expr);
                        p++;
                        break;

                case L'\0':
                        goto eos;

                default:
                        p += 2;
                        break;
                }
        }
eos:
        fmd_msg_buf_write(&buf, q, wcslen(q) + 1);

        free(h);
        free(u);
        free(w);

        s = fmd_msg_buf_read(&buf);
        fmd_msg_buf_fini(&buf);

        return (s);
}

/*
 * This function is the main engine for formatting an entire event message.
 * It retrieves the master format string for an event, formats the individual
 * items, and then produces the final string composing all of the items.  The
 * result is a newly-allocated multi-byte string of the localized message
 * text, or NULL with errno set if an error occurred.
 */
static char *
fmd_msg_gettext_locked(fmd_msg_hdl_t *h,
    nvlist_t *nvl, const char *dict, const char *code)
{
        char *items[FMD_MSG_ITEM_MAX];
        const char *format;
        char *buf = NULL;
        size_t len;
        int i;

        nvlist_t *fmri, *auth;
        struct tm tm, *tmp;

        int64_t *tv;
        uint_t tn = 0;
        time_t sec;
        char date[64];

        char *uuid, *src_name, *src_vers;
        char *platform, *server, *csn;

        assert(fmd_msg_lock_held(h));
        bzero(items, sizeof (items));

        for (i = 0; i < FMD_MSG_ITEM_MAX; i++) {
                items[i] = fmd_msg_getitem_locked(h, nvl, dict, code, i);
                if (items[i] == NULL)
                        goto out;
        }

        /*
         * If <dict>.mo defines an item with the key <FMD_MSG_TEMPLATE> then it
         * is used as the format; otherwise the default from FMD.mo is used.
         */
        if ((format = dgettext(dict, FMD_MSG_TEMPLATE)) == FMD_MSG_TEMPLATE)
                format = h->fmh_template;

        if (nvlist_lookup_string(nvl, FM_SUSPECT_UUID, &uuid) != 0)
                uuid = (char *)FMD_MSG_MISSING;

        if (nvlist_lookup_int64_array(nvl, FM_SUSPECT_DIAG_TIME,
            &tv, &tn) == 0 && tn == 2 && (sec = (time_t)tv[0]) != (time_t)-1 &&
            (tmp = localtime_r(&sec, &tm)) != NULL)
                (void) strftime(date, sizeof (date), "%a %b %e %H:%M:%S %Z %Y",
                    tmp);
        else
                (void) strlcpy(date, FMD_MSG_MISSING, sizeof (date));

        /*
         * Extract the relevant identifying elements of the FMRI and authority.
         * Note: for now, we ignore FM_FMRI_AUTH_DOMAIN (only for SPs).
         */
        if (nvlist_lookup_nvlist(nvl, FM_SUSPECT_DE, &fmri) != 0)
                fmri = NULL;

        if (nvlist_lookup_nvlist(fmri, FM_FMRI_AUTHORITY, &auth) != 0)
                auth = NULL;

        if (nvlist_lookup_string(fmri, FM_FMRI_FMD_NAME, &src_name) != 0)
                src_name = (char *)FMD_MSG_MISSING;

        if (nvlist_lookup_string(fmri, FM_FMRI_FMD_VERSION, &src_vers) != 0)
                src_vers = (char *)FMD_MSG_MISSING;

        if (nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, &platform) != 0)
                platform = (char *)FMD_MSG_MISSING;

        if (nvlist_lookup_string(auth, FM_FMRI_AUTH_SERVER, &server) != 0)
                server = (char *)FMD_MSG_MISSING;

        if (nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT_SN, &csn) != 0 &&
            nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, &csn) != 0)
                csn = (char *)FMD_MSG_MISSING;

        /*
         * Format the message once to get its length, allocate a buffer, and
         * then format the message again into the buffer to return it.
         */
        len = snprintf(NULL, 0, format, code,
            items[FMD_MSG_ITEM_TYPE], items[FMD_MSG_ITEM_SEVERITY],
            date, platform, csn, server, src_name, src_vers, uuid,
            items[FMD_MSG_ITEM_DESC], items[FMD_MSG_ITEM_RESPONSE],
            items[FMD_MSG_ITEM_IMPACT], items[FMD_MSG_ITEM_ACTION]);

        if ((buf = malloc(len + 1)) == NULL) {
                errno = ENOMEM;
                goto out;
        }

        (void) snprintf(buf, len + 1, format, code,
            items[FMD_MSG_ITEM_TYPE], items[FMD_MSG_ITEM_SEVERITY],
            date, platform, csn, server, src_name, src_vers, uuid,
            items[FMD_MSG_ITEM_DESC], items[FMD_MSG_ITEM_RESPONSE],
            items[FMD_MSG_ITEM_IMPACT], items[FMD_MSG_ITEM_ACTION]);
out:
        for (i = 0; i < FMD_MSG_ITEM_MAX; i++)
                free(items[i]);

        return (buf);
}

/*
 * Common code for fmd_msg_getitem_nv() and fmd_msg_getitem_id(): this function
 * handles locking, changing locales and domains, and restoring i18n state.
 */
static char *
fmd_msg_getitem(fmd_msg_hdl_t *h,
    const char *locale, nvlist_t *nvl, const char *code, fmd_msg_item_t item)
{
        char *old_b, *old_c;
        char *dict, *key, *p, *s;
        size_t len;
        int err;

        if ((p = strchr(code, '-')) == NULL || p == code) {
                errno = EINVAL;
                return (NULL);
        }

        if (locale != NULL && strcmp(h->fmh_locale, locale) == 0)
                locale = NULL; /* simplify later tests */

        dict = strndupa(code, p - code);

        fmd_msg_lock();

        /*
         * If a non-default text domain binding was requested, save the old
         * binding perform the re-bind now that fmd_msg_lock() is held.
         */
        if (h->fmh_binding != NULL) {
                p = bindtextdomain(dict, NULL);
                old_b = strdupa(p);
                (void) bindtextdomain(dict, h->fmh_binding);
        }

        /*
         * Compute the lookup code for FMD_MSG_ITEM_TYPE: we'll use this to
         * determine if the dictionary contains any data for this code at all.
         */
        len = strlen(code) + 1 + strlen(fmd_msg_items[FMD_MSG_ITEM_TYPE]) + 1;
        key = alloca(len);

        (void) snprintf(key, len, "%s.%s",
            code, fmd_msg_items[FMD_MSG_ITEM_TYPE]);

        /*
         * Save the current locale string, and if we've been asked to fetch
         * the text for a different locale, switch locales now under the lock.
         */
        p = setlocale(LC_ALL, NULL);
        old_c = strdupa(p);

        if (locale != NULL)
                (void) setlocale(LC_ALL, locale);

        /*
         * Prefetch the first item: if this isn't found, and we're in a non-
         * default locale, attempt to fall back to the C locale for this code.
         */
        if (dgettext(dict, key) == key &&
            (locale != NULL || strcmp(h->fmh_locale, "C") != 0)) {
                (void) setlocale(LC_ALL, "C");
                locale = "C"; /* restore locale */
        }

        if (dgettext(dict, key) == key) {
                s = NULL;
                err = ENOENT;
        } else {
                s = fmd_msg_getitem_locked(h, nvl, dict, code, item);
                err = errno;
        }

        if (locale != NULL)
                (void) setlocale(LC_ALL, old_c);

        if (h->fmh_binding != NULL)
                (void) bindtextdomain(dict, old_b);

        fmd_msg_unlock();

        if (s == NULL)
                errno = err;

        return (s);
}

char *
fmd_msg_getitem_nv(fmd_msg_hdl_t *h,
    const char *locale, nvlist_t *nvl, fmd_msg_item_t item)
{
        char *code;

        if (item >= FMD_MSG_ITEM_MAX) {
                errno = EINVAL;
                return (NULL);
        }

        if (nvlist_lookup_string(nvl, FM_SUSPECT_DIAG_CODE, &code) != 0) {
                errno = EINVAL;
                return (NULL);
        }

        return (fmd_msg_getitem(h, locale, nvl, code, item));
}

char *
fmd_msg_getitem_id(fmd_msg_hdl_t *h,
    const char *locale, const char *code, fmd_msg_item_t item)
{
        if (item >= FMD_MSG_ITEM_MAX) {
                errno = EINVAL;
                return (NULL);
        }

        return (fmd_msg_getitem(h, locale, NULL, code, item));
}

char *
fmd_msg_gettext_key(fmd_msg_hdl_t *h,
    const char *locale, const char *dict, const char *key)
{
        char *old_b, *old_c, *p, *s;

        fmd_msg_lock();

        /*
         * If a non-default text domain binding was requested, save the old
         * binding perform the re-bind now that fmd_msg_lock() is held.
         */
        if (h->fmh_binding != NULL) {
                p = bindtextdomain(dict, NULL);
                old_b = alloca(strlen(p) + 1);
                (void) strcpy(old_b, p);
                (void) bindtextdomain(dict, h->fmh_binding);
        }

        /*
         * Save the current locale string, and if we've been asked to fetch
         * the text for a different locale, switch locales now under the lock.
         */
        p = setlocale(LC_ALL, NULL);
        old_c = alloca(strlen(p) + 1);
        (void) strcpy(old_c, p);

        if (locale != NULL)
                (void) setlocale(LC_ALL, locale);

        /*
         * First attempt to fetch the string in the current locale.  If this
         * fails and we're in a non-default locale, attempt to fall back to the
         * C locale and try again.  If it still fails then we return NULL and
         * set errno.
         */
        if ((s = dgettext(dict, key)) == key &&
            (locale != NULL || strcmp(h->fmh_locale, "C") != 0)) {
                (void) setlocale(LC_ALL, "C");
                locale = "C"; /* restore locale */

                if ((s = dgettext(dict, key)) == key) {
                        s = NULL;
                        errno = ENOENT;
                }
        }
        if (locale != NULL)
                (void) setlocale(LC_ALL, old_c);

        if (h->fmh_binding != NULL)
                (void) bindtextdomain(dict, old_b);

        fmd_msg_unlock();

        return (s);
}

/*
 * Common code for fmd_msg_gettext_nv() and fmd_msg_gettext_id(): this function
 * handles locking, changing locales and domains, and restoring i18n state.
 */
static char *
fmd_msg_gettext(fmd_msg_hdl_t *h,
    const char *locale, nvlist_t *nvl, const char *code)
{
        char *old_b, *old_c;
        char *dict, *key, *p, *s;
        size_t len;
        int err;

        if ((p = strchr(code, '-')) == NULL || p == code) {
                errno = EINVAL;
                return (NULL);
        }

        if (locale != NULL && strcmp(h->fmh_locale, locale) == 0)
                locale = NULL; /* simplify later tests */

        dict = strndupa(code, p - code);

        fmd_msg_lock();

        /*
         * If a non-default text domain binding was requested, save the old
         * binding perform the re-bind now that fmd_msg_lock() is held.
         */
        if (h->fmh_binding != NULL) {
                p = bindtextdomain(dict, NULL);
                old_b = strdupa(p);
                (void) bindtextdomain(dict, h->fmh_binding);
        }

        /*
         * Compute the lookup code for FMD_MSG_ITEM_TYPE: we'll use this to
         * determine if the dictionary contains any data for this code at all.
         */
        len = strlen(code) + 1 + strlen(fmd_msg_items[FMD_MSG_ITEM_TYPE]) + 1;
        key = alloca(len);

        (void) snprintf(key, len, "%s.%s",
            code, fmd_msg_items[FMD_MSG_ITEM_TYPE]);

        /*
         * Save the current locale string, and if we've been asked to fetch
         * the text for a different locale, switch locales now under the lock.
         */
        p = setlocale(LC_ALL, NULL);
        old_c = strdupa(p);

        if (locale != NULL)
                (void) setlocale(LC_ALL, locale);

        /*
         * Prefetch the first item: if this isn't found, and we're in a non-
         * default locale, attempt to fall back to the C locale for this code.
         */
        if (dgettext(dict, key) == key &&
            (locale != NULL || strcmp(h->fmh_locale, "C") != 0)) {
                (void) setlocale(LC_ALL, "C");
                locale = "C"; /* restore locale */
        }

        if (dgettext(dict, key) == key) {
                s = NULL;
                err = ENOENT;
        } else {
                s = fmd_msg_gettext_locked(h, nvl, dict, code);
                err = errno;
        }

        if (locale != NULL)
                (void) setlocale(LC_ALL, old_c);

        if (h->fmh_binding != NULL)
                (void) bindtextdomain(dict, old_b);

        fmd_msg_unlock();

        if (s == NULL)
                errno = err;

        return (s);
}

char *
fmd_msg_gettext_nv(fmd_msg_hdl_t *h, const char *locale, nvlist_t *nvl)
{
        char *code;

        if (nvlist_lookup_string(nvl, FM_SUSPECT_DIAG_CODE, &code) != 0) {
                errno = EINVAL;
                return (NULL);
        }

        return (fmd_msg_gettext(h, locale, nvl, code));
}

char *
fmd_msg_gettext_id(fmd_msg_hdl_t *h, const char *locale, const char *code)
{
        return (fmd_msg_gettext(h, locale, NULL, code));
}