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, 2012, 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://support.oracle.com/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[] = FMD_MSG_URL_DEFAULT;
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, *altc;

    const char *url, *txt;
    char *s, *expr, *altcode, *severity = NULL;
    size_t elen;
    int i;
    boolean_t proxied = B_FALSE;

    assert(fmd_msg_lock_held(h));

    if (nvl != NULL) {
        (void) nvlist_lookup_string(nvl, FM_SUSPECT_SEVERITY,
            &severity);
        (void) nvlist_lookup_boolean_value(nvl, FM_SUSPECT_PROXIED,
            &proxied);
    }
    if (proxied == B_TRUE)
        altcode = FMD_MSG_CODE_NOPOMSG_PROXIED;
    else
        altcode = FMD_MSG_CODE_NOPOMSG;

    altc = fmd_msg_mbstowcs(altcode);

    /*
     * 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.  If the
     * item is FMD_MSG_ITEM_SEVERITY then we try to use the severity
     * found in the nvlist passed in.  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 if ((item == FMD_MSG_ITEM_SEVERITY) && (severity != NULL)) {
        txt = severity;
    } else {
        len = strlen(code) + 1 + strlen(istr) + 1;
        key = alloca(len);
        (void) snprintf(key, len, "%s.%s", code, istr);
        txt = dgettext(dict, key);
        /*
         * If the lookup fails then there is no local message content.
         * Substitute the alternate message item instead.
         */
        if (txt == key) {
            len = strlen(altcode) + 1 + strlen(istr) + 1;
            key = alloca(len);
            (void) snprintf(key, len, "%s.%s", altcode, istr);
            txt = dgettext(FMD_MSG_DOMAIN, key);
        }
    }

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

    if (c == NULL || altc == NULL || u == NULL || w == NULL) {
        free(c);
        free(u);
        free(w);
        free(altc);
        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
     * %S   - base URL for alternate knowledge article
     * %<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'S':
            fmd_msg_buf_write(&buf, u, wcslen(u));
            fmd_msg_buf_write(&buf, altc, wcslen(altc));

            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(altc);
    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_V0_DOMAIN_NAME (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_V1_SYS_COMP_NM,
        &platform) != 0)
        platform = (char *)FMD_MSG_MISSING;

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

    if (nvlist_lookup_string(auth, FM_FMRI_AUTH_V1_SYS_COMP_SN, &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, *altcode;
    size_t len;
    int err = 0;
    boolean_t proxied = B_FALSE;

    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);

    if (nvl != NULL)
        (void) nvlist_lookup_boolean_value(nvl, FM_SUSPECT_PROXIED,
            &proxied);
    if (proxied == B_TRUE)
        altcode = FMD_MSG_CODE_NOPOMSG_PROXIED;
    else
        altcode = FMD_MSG_CODE_NOPOMSG;

    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 the lookup fails again then there is no local message content.
     * Check if the alternate message exists.
     */
    if (dgettext(dict, key) == key) {
        len = strlen(altcode) + 1 +
            strlen(fmd_msg_items[FMD_MSG_ITEM_TYPE]) + 1;
        key = alloca(len);
        (void) snprintf(key, len, "%s.%s",
            altcode, fmd_msg_items[FMD_MSG_ITEM_TYPE]);
        if (dgettext(FMD_MSG_DOMAIN, key) == key) {
            s = NULL;
            err = ENOENT;
        }
    }

    if (!err) {
        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. We do not try to lookup the alternate (missing msg) msg
     * here since this function is not used to lookup KA content.
     */
    if (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, *altcode;
    size_t len;
    int err = 0;
    boolean_t proxied = B_FALSE;

    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);

    if (nvl != NULL)
        (void) nvlist_lookup_boolean_value(nvl, FM_SUSPECT_PROXIED,
            &proxied);

    if (proxied == B_TRUE)
        altcode = FMD_MSG_CODE_NOPOMSG_PROXIED;
    else
        altcode = FMD_MSG_CODE_NOPOMSG;

    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 the lookup fails again then there is no local message content.
     * Check if the alternate message exists.
     */
    if (dgettext(dict, key) == key) {
        len = strlen(altcode) + 1 +
            strlen(fmd_msg_items[FMD_MSG_ITEM_TYPE]) + 1;
        key = alloca(len);
        (void) snprintf(key, len, "%s.%s",
            altcode, fmd_msg_items[FMD_MSG_ITEM_TYPE]);
        if (dgettext(FMD_MSG_DOMAIN, key) == key) {
            s = NULL;
            err = ENOENT;
        }
    }

    if (!err) {
        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));
}