1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * FMD Message Library
28 *
29 * This library supports a simple set of routines for use in converting FMA
30 * events and message codes to localized human-readable message strings.
31 *
32 * 1. Library API
33 *
34 * The APIs are as follows:
35 *
36 * fmd_msg_init - set up the library and return a handle
37 * fmd_msg_fini - destroy the handle from fmd_msg_init
38 *
39 * fmd_msg_locale_set - set the default locale (initially based on environ(7))
40 * fmd_msg_locale_get - get the default locale
41 *
42 * fmd_msg_url_set - set the default URL for knowledge articles
43 * fmd_msg_url_get - get the default URL for knowledge articles
44 *
45 * fmd_msg_gettext_nv - format the entire message for the given event
46 * fmd_msg_gettext_id - format the entire message for the given event code
47 * fmd_msg_gettext_key - format the entire message for the given dict for the
48 * given explicit message key
49 *
50 * fmd_msg_getitem_nv - format a single message item for the given event
51 * fmd_msg_getitem_id - format a single message item for the given event code
52 *
53 * Upon success, fmd_msg_gettext_* and fmd_msg_getitem_* return newly-allocated
54 * localized strings in multi-byte format. The caller must call free() on the
55 * resulting buffer to deallocate the string after making use of it. Upon
56 * failure, these functions return NULL and set errno as follows:
57 *
58 * ENOMEM - Memory allocation failure while formatting message
59 * ENOENT - No message was found for the specified message identifier
60 * EINVAL - Invalid argument (e.g. bad event code, illegal fmd_msg_item_t)
61 * EILSEQ - Illegal multi-byte sequence detected in message
62 *
63 * 2. Variable Expansion
64 *
65 * The human-readable messages are stored in msgfmt(1) message object files in
66 * the corresponding locale directories. The values for the message items are
67 * permitted to contain variable expansions, currently defined as follows:
68 *
69 * %% - literal % character
70 * %s - knowledge article URL (e.g. http://illumos.org/msg/<MSG-ID>)
71 * %< x > - value x from the current event, using the expression syntax below:
72 *
73 * foo.bar => print nvlist_t member "bar" contained within nvlist_t "foo"
74 * foo[123] => print array element 123 of nvlist_t member "foo"
75 * foo[123].bar => print member "bar" of nvlist_t element 123 in array "foo"
76 *
77 * For example, the msgstr value for FMD-8000-2K might be defined as:
78 *
79 * msgid "FMD-8000-2K.action"
80 * msgstr "Use fmdump -v -u %<uuid> to locate the module. Use fmadm \
81 * reset %<fault-list[0].asru.mod-name> to reset the module."
82 *
83 * 3. Locking
84 *
85 * In order to format a human-readable message, libfmd_msg must get and set
86 * the process locale and potentially alter text domain bindings. At present,
87 * these facilities in libc are not fully MT-safe. As such, a library-wide
88 * lock is provided: fmd_msg_lock() and fmd_msg_unlock(). These locking calls
89 * are made internally as part of the top-level library entry points, but they
90 * can also be used by applications that themselves call setlocale() and wish
91 * to appropriately synchronize with other threads that are calling libfmd_msg.
92 */
93
94
95 #include <sys/fm/protocol.h>
96
97 #include <libintl.h>
98 #include <locale.h>
99 #include <wchar.h>
100
101 #include <alloca.h>
102 #include <assert.h>
103 #include <netdb.h>
104 #include <pthread.h>
105 #include <synch.h>
106 #include <strings.h>
107 #include <stdarg.h>
108 #include <stdlib.h>
109 #include <stdio.h>
110 #include <errno.h>
111 #include <unistd.h>
112 #include <sys/sysmacros.h>
113
114 #include <fmd_msg.h>
115
116 #define FMD_MSGBUF_SZ 256
117
118 struct fmd_msg_hdl {
119 int fmh_version; /* libfmd_msg client abi version number */
120 char *fmh_urlbase; /* base url for all knowledge articles */
121 char *fmh_binding; /* base directory for bindtextdomain() */
122 char *fmh_locale; /* default program locale from environment */
123 const char *fmh_template; /* FMD_MSG_TEMPLATE value for fmh_locale */
124 };
125
126 typedef struct fmd_msg_buf {
127 wchar_t *fmb_data; /* wide-character data buffer */
128 size_t fmb_size; /* size of fmb_data in wchar_t units */
129 size_t fmb_used; /* used portion of fmb_data in wchar_t units */
130 int fmb_error; /* error if any has occurred */
131 } fmd_msg_buf_t;
132
133 static const char *const fmd_msg_items[] = {
134 "type", /* key for FMD_MSG_ITEM_TYPE */
135 "severity", /* key for FMD_MSG_ITEM_SEVERITY */
136 "description", /* key for FMD_MSG_ITEM_DESC */
137 "response", /* key for FMD_MSG_ITEM_RESPONSE */
138 "impact", /* key for FMD_MSG_ITEM_IMPACT */
139 "action", /* key for FMD_MSG_ITEM_ACTION */
140 "url", /* key for FMD_MSG_ITEM_URL */
141 };
142
143 static pthread_rwlock_t fmd_msg_rwlock = PTHREAD_RWLOCK_INITIALIZER;
144
145 static const char FMD_MSG_DOMAIN[] = "FMD";
146 static const char FMD_MSG_TEMPLATE[] = "syslog-msgs-message-template";
147 static const char FMD_MSG_URLKEY[] = "syslog-url";
148 static const char FMD_MSG_URLBASE[] = "http://illumos.org/msg/";
149 static const char FMD_MSG_NLSPATH[] = "NLSPATH=/usr/lib/fm/fmd/fmd.cat";
150 static const char FMD_MSG_MISSING[] = "-";
151
152 /*
153 * An enumeration of token types. The following are valid tokens that can be
154 * embedded into the message content:
155 *
156 * T_INT - integer tokens (for array indices)
157 * T_IDENT - nvpair identifiers
158 * T_DOT - "."
159 * T_LBRAC - "["
160 * T_RBRAC - "]"
161 *
162 * A NULL character (T_EOF) is used to terminate messages.
163 * Invalid tokens are assigned the type T_ERR.
164 */
165 typedef enum {
166 T_EOF,
167 T_ERR,
168 T_IDENT,
169 T_INT,
170 T_DOT,
171 T_LBRAC,
172 T_RBRAC
173 } fmd_msg_nv_tkind_t;
174
175 typedef struct fmd_msg_nv_token {
176 fmd_msg_nv_tkind_t t_kind;
177 union {
178 char tu_str[256];
179 uint_t tu_int;
180 } t_data;
181 } fmd_msg_nv_token_t;
182
183 static const struct fmd_msg_nv_type {
184 data_type_t nvt_type;
185 data_type_t nvt_base;
186 size_t nvt_size;
187 int (*nvt_value)();
188 int (*nvt_array)();
189 } fmd_msg_nv_types[] = {
190 { DATA_TYPE_INT8, DATA_TYPE_INT8,
191 sizeof (int8_t), nvpair_value_int8, NULL },
192 { DATA_TYPE_INT16, DATA_TYPE_INT16,
193 sizeof (int16_t), nvpair_value_int16, NULL },
194 { DATA_TYPE_INT32, DATA_TYPE_INT32,
195 sizeof (int32_t), nvpair_value_int32, NULL },
196 { DATA_TYPE_INT64, DATA_TYPE_INT64,
197 sizeof (int64_t), nvpair_value_int64, NULL },
198 { DATA_TYPE_UINT8, DATA_TYPE_UINT8,
199 sizeof (uint8_t), nvpair_value_uint8, NULL },
200 { DATA_TYPE_UINT16, DATA_TYPE_UINT16,
201 sizeof (uint16_t), nvpair_value_uint16, NULL },
202 { DATA_TYPE_UINT32, DATA_TYPE_UINT32,
203 sizeof (uint32_t), nvpair_value_uint32, NULL },
204 { DATA_TYPE_UINT64, DATA_TYPE_UINT64,
205 sizeof (uint64_t), nvpair_value_uint64, NULL },
206 { DATA_TYPE_BYTE, DATA_TYPE_BYTE,
207 sizeof (uchar_t), nvpair_value_byte, NULL },
208 { DATA_TYPE_BOOLEAN, DATA_TYPE_BOOLEAN,
209 0, NULL, NULL },
210 { DATA_TYPE_BOOLEAN_VALUE, DATA_TYPE_BOOLEAN_VALUE,
211 sizeof (boolean_t), nvpair_value_boolean_value, NULL },
212 { DATA_TYPE_HRTIME, DATA_TYPE_HRTIME,
213 sizeof (hrtime_t), nvpair_value_hrtime, NULL },
214 { DATA_TYPE_STRING, DATA_TYPE_STRING,
215 sizeof (char *), nvpair_value_string, NULL },
216 { DATA_TYPE_NVLIST, DATA_TYPE_NVLIST,
217 sizeof (nvlist_t *), nvpair_value_nvlist, NULL },
218 { DATA_TYPE_INT8_ARRAY, DATA_TYPE_INT8,
219 sizeof (int8_t), NULL, nvpair_value_int8_array },
220 { DATA_TYPE_INT16_ARRAY, DATA_TYPE_INT16,
221 sizeof (int16_t), NULL, nvpair_value_int16_array },
222 { DATA_TYPE_INT32_ARRAY, DATA_TYPE_INT32,
223 sizeof (int32_t), NULL, nvpair_value_int32_array },
224 { DATA_TYPE_INT64_ARRAY, DATA_TYPE_INT64,
225 sizeof (int64_t), NULL, nvpair_value_int64_array },
226 { DATA_TYPE_UINT8_ARRAY, DATA_TYPE_UINT8,
227 sizeof (uint8_t), NULL, nvpair_value_uint8_array },
228 { DATA_TYPE_UINT16_ARRAY, DATA_TYPE_UINT16,
229 sizeof (uint16_t), NULL, nvpair_value_uint16_array },
230 { DATA_TYPE_UINT32_ARRAY, DATA_TYPE_UINT32,
231 sizeof (uint32_t), NULL, nvpair_value_uint32_array },
232 { DATA_TYPE_UINT64_ARRAY, DATA_TYPE_UINT64,
233 sizeof (uint64_t), NULL, nvpair_value_uint64_array },
234 { DATA_TYPE_BYTE_ARRAY, DATA_TYPE_BYTE,
235 sizeof (uchar_t), NULL, nvpair_value_byte_array },
236 { DATA_TYPE_BOOLEAN_ARRAY, DATA_TYPE_BOOLEAN_VALUE,
237 sizeof (boolean_t), NULL, nvpair_value_boolean_array },
238 { DATA_TYPE_STRING_ARRAY, DATA_TYPE_STRING,
239 sizeof (char *), NULL, nvpair_value_string_array },
240 { DATA_TYPE_NVLIST_ARRAY, DATA_TYPE_NVLIST,
241 sizeof (nvlist_t *), NULL, nvpair_value_nvlist_array },
242 { DATA_TYPE_UNKNOWN, DATA_TYPE_UNKNOWN, 0, NULL, NULL }
243 };
244
245 static int fmd_msg_nv_parse_nvpair(fmd_msg_buf_t *, nvpair_t *, char *);
246 static int fmd_msg_nv_parse_nvname(fmd_msg_buf_t *, nvlist_t *, char *);
247 static int fmd_msg_nv_parse_nvlist(fmd_msg_buf_t *, nvlist_t *, char *);
248
249 /*ARGSUSED*/
250 static int
fmd_msg_lock_held(fmd_msg_hdl_t * h)251 fmd_msg_lock_held(fmd_msg_hdl_t *h)
252 {
253 return (RW_WRITE_HELD(&fmd_msg_rwlock));
254 }
255
256 void
fmd_msg_lock(void)257 fmd_msg_lock(void)
258 {
259 if (pthread_rwlock_wrlock(&fmd_msg_rwlock) != 0)
260 abort();
261 }
262
263 void
fmd_msg_unlock(void)264 fmd_msg_unlock(void)
265 {
266 if (pthread_rwlock_unlock(&fmd_msg_rwlock) != 0)
267 abort();
268 }
269
270 static fmd_msg_hdl_t *
fmd_msg_init_err(fmd_msg_hdl_t * h,int err)271 fmd_msg_init_err(fmd_msg_hdl_t *h, int err)
272 {
273 fmd_msg_fini(h);
274 errno = err;
275 return (NULL);
276 }
277
278 fmd_msg_hdl_t *
fmd_msg_init(const char * root,int version)279 fmd_msg_init(const char *root, int version)
280 {
281 fmd_msg_hdl_t *h = NULL;
282 const char *s;
283 size_t len;
284
285 if (version != FMD_MSG_VERSION)
286 return (fmd_msg_init_err(h, EINVAL));
287
288 if ((h = malloc(sizeof (fmd_msg_hdl_t))) == NULL)
289 return (fmd_msg_init_err(h, ENOMEM));
290
291 bzero(h, sizeof (fmd_msg_hdl_t));
292 h->fmh_version = version;
293
294 if ((h->fmh_urlbase = strdup(FMD_MSG_URLBASE)) == NULL)
295 return (fmd_msg_init_err(h, ENOMEM));
296
297 /*
298 * Initialize the program's locale from the environment if it hasn't
299 * already been initialized, and then retrieve the default setting.
300 */
301 (void) setlocale(LC_ALL, "");
302 s = setlocale(LC_ALL, NULL);
303 h->fmh_locale = strdup(s ? s : "C");
304
305 if (h->fmh_locale == NULL)
306 return (fmd_msg_init_err(h, ENOMEM));
307
308 /*
309 * If a non-default root directory is specified, then look up the base
310 * directory for our default catalog, and set fmh_binding as the same
311 * directory prefixed with the new root directory. This simply turns
312 * usr/lib/locale into <rootdir>/usr/lib/locale, but handles all of the
313 * environ(7) settings that can change the default messages binding.
314 */
315 if (root != NULL && root[0] != '\0' && strcmp(root, "/") != 0) {
316 if (root[0] != '/')
317 return (fmd_msg_init_err(h, EINVAL));
318
319 if ((s = bindtextdomain(FMD_MSG_DOMAIN, NULL)) == NULL)
320 s = "/usr/lib/locale"; /* substitute default */
321
322 len = strlen(root) + strlen(s) + 1;
323
324 if ((h->fmh_binding = malloc(len)) == NULL)
325 return (fmd_msg_init_err(h, ENOMEM));
326
327 (void) snprintf(h->fmh_binding, len, "%s%s", root, s);
328 }
329
330 /*
331 * All FMA event dictionaries use msgfmt(1) message objects to produce
332 * messages, even for the C locale. We therefore want to use dgettext
333 * for all message lookups, but its defined behavior in the C locale is
334 * to return the input string. Since our input strings are event codes
335 * and not format strings, this doesn't help us. We resolve this nit
336 * by setting NLSPATH to a non-existent file: the presence of NLSPATH
337 * is defined to force dgettext(3C) to do a full lookup even for C.
338 */
339 if (getenv("NLSPATH") == NULL &&
340 ((s = strdup(FMD_MSG_NLSPATH)) == NULL || putenv((char *)s) != 0))
341 return (fmd_msg_init_err(h, errno));
342
343 /*
344 * Cache the message template for the current locale. This is the
345 * snprintf(3C) format string for the final human-readable message.
346 * If the lookup fails for the current locale, fall back to the C locale
347 * and try again. Then restore the original locale.
348 */
349 if ((h->fmh_template = dgettext(FMD_MSG_DOMAIN, FMD_MSG_TEMPLATE))
350 == FMD_MSG_TEMPLATE && strcmp(h->fmh_locale, "C") != 0) {
351 (void) setlocale(LC_ALL, "C");
352 h->fmh_template = dgettext(FMD_MSG_DOMAIN, FMD_MSG_TEMPLATE);
353 (void) setlocale(LC_ALL, h->fmh_locale);
354 }
355
356 return (h);
357 }
358
359 void
fmd_msg_fini(fmd_msg_hdl_t * h)360 fmd_msg_fini(fmd_msg_hdl_t *h)
361 {
362 if (h == NULL)
363 return; /* simplify caller code */
364
365 free(h->fmh_binding);
366 free(h->fmh_urlbase);
367 free(h->fmh_locale);
368 free(h);
369 }
370
371 int
fmd_msg_locale_set(fmd_msg_hdl_t * h,const char * locale)372 fmd_msg_locale_set(fmd_msg_hdl_t *h, const char *locale)
373 {
374 char *l;
375
376 if (locale == NULL) {
377 errno = EINVAL;
378 return (-1);
379 }
380
381 if ((l = strdup(locale)) == NULL) {
382 errno = ENOMEM;
383 return (-1);
384 }
385
386 fmd_msg_lock();
387
388 if (setlocale(LC_ALL, l) == NULL) {
389 free(l);
390 errno = EINVAL;
391 fmd_msg_unlock();
392 return (-1);
393 }
394
395 h->fmh_template = dgettext(FMD_MSG_DOMAIN, FMD_MSG_TEMPLATE);
396 free(h->fmh_locale);
397 h->fmh_locale = l;
398
399 fmd_msg_unlock();
400 return (0);
401 }
402
403 const char *
fmd_msg_locale_get(fmd_msg_hdl_t * h)404 fmd_msg_locale_get(fmd_msg_hdl_t *h)
405 {
406 return (h->fmh_locale);
407 }
408
409 int
fmd_msg_url_set(fmd_msg_hdl_t * h,const char * url)410 fmd_msg_url_set(fmd_msg_hdl_t *h, const char *url)
411 {
412 char *u;
413
414 if (url == NULL) {
415 errno = EINVAL;
416 return (-1);
417 }
418
419 if ((u = strdup(url)) == NULL) {
420 errno = ENOMEM;
421 return (-1);
422 }
423
424 fmd_msg_lock();
425
426 free(h->fmh_urlbase);
427 h->fmh_urlbase = u;
428
429 fmd_msg_unlock();
430 return (0);
431 }
432
433 const char *
fmd_msg_url_get(fmd_msg_hdl_t * h)434 fmd_msg_url_get(fmd_msg_hdl_t *h)
435 {
436 return (h->fmh_urlbase);
437 }
438
439 static wchar_t *
fmd_msg_mbstowcs(const char * s)440 fmd_msg_mbstowcs(const char *s)
441 {
442 size_t n = strlen(s) + 1;
443 wchar_t *w = malloc(n * sizeof (wchar_t));
444
445 if (w == NULL) {
446 errno = ENOMEM;
447 return (NULL);
448 }
449
450 if (mbstowcs(w, s, n) == (size_t)-1) {
451 free(w);
452 return (NULL);
453 }
454
455 return (w);
456 }
457
458 static void
fmd_msg_buf_init(fmd_msg_buf_t * b)459 fmd_msg_buf_init(fmd_msg_buf_t *b)
460 {
461 bzero(b, sizeof (fmd_msg_buf_t));
462 b->fmb_data = malloc(sizeof (wchar_t) * FMD_MSGBUF_SZ);
463
464 if (b->fmb_data == NULL)
465 b->fmb_error = ENOMEM;
466 else
467 b->fmb_size = FMD_MSGBUF_SZ;
468 }
469
470 static void
fmd_msg_buf_fini(fmd_msg_buf_t * b)471 fmd_msg_buf_fini(fmd_msg_buf_t *b)
472 {
473 free(b->fmb_data);
474 bzero(b, sizeof (fmd_msg_buf_t));
475 }
476
477 static char *
fmd_msg_buf_read(fmd_msg_buf_t * b)478 fmd_msg_buf_read(fmd_msg_buf_t *b)
479 {
480 char *s;
481
482 if (b->fmb_error != 0) {
483 errno = b->fmb_error;
484 return (NULL);
485 }
486
487 if ((s = malloc(b->fmb_used * MB_CUR_MAX)) == NULL) {
488 errno = ENOMEM;
489 return (NULL);
490 }
491
492 if (wcstombs(s, b->fmb_data, b->fmb_used) == (size_t)-1) {
493 free(s);
494 return (NULL);
495 }
496
497 return (s);
498 }
499
500 /*
501 * Buffer utility function to write a wide-character string into the buffer,
502 * appending it at the end, and growing the buffer as needed as we go. Any
503 * allocation errors are stored in fmb_error and deferred until later.
504 */
505 static void
fmd_msg_buf_write(fmd_msg_buf_t * b,const wchar_t * w,size_t n)506 fmd_msg_buf_write(fmd_msg_buf_t *b, const wchar_t *w, size_t n)
507 {
508 if (b->fmb_used + n > b->fmb_size) {
509 size_t size = MAX(b->fmb_size * 2, b->fmb_used + n);
510 wchar_t *data = malloc(sizeof (wchar_t) * size);
511
512 if (data == NULL) {
513 if (b->fmb_error == 0)
514 b->fmb_error = ENOMEM;
515 return;
516 }
517
518 bcopy(b->fmb_data, data, b->fmb_used * sizeof (wchar_t));
519 free(b->fmb_data);
520
521 b->fmb_data = data;
522 b->fmb_size = size;
523 }
524
525 bcopy(w, &b->fmb_data[b->fmb_used], sizeof (wchar_t) * n);
526 b->fmb_used += n;
527 }
528
529 /*
530 * Buffer utility function to printf a multi-byte string, convert to wide-
531 * character form, and then write the result into an fmd_msg_buf_t.
532 */
533 /*PRINTFLIKE2*/
534 static void
fmd_msg_buf_printf(fmd_msg_buf_t * b,const char * format,...)535 fmd_msg_buf_printf(fmd_msg_buf_t *b, const char *format, ...)
536 {
537 ssize_t len;
538 va_list ap;
539 char *buf;
540 wchar_t *w;
541
542 va_start(ap, format);
543 len = vsnprintf(NULL, 0, format, ap);
544 buf = alloca(len + 1);
545 (void) vsnprintf(buf, len + 1, format, ap);
546 va_end(ap);
547
548 if ((w = fmd_msg_mbstowcs(buf)) == NULL) {
549 if (b->fmb_error != 0)
550 b->fmb_error = errno;
551 } else {
552 fmd_msg_buf_write(b, w, wcslen(w));
553 free(w);
554 }
555 }
556
557 /*PRINTFLIKE1*/
558 static int
fmd_msg_nv_error(const char * format,...)559 fmd_msg_nv_error(const char *format, ...)
560 {
561 int err = errno;
562 va_list ap;
563
564 if (getenv("FMD_MSG_DEBUG") == NULL)
565 return (1);
566
567 (void) fprintf(stderr, "libfmd_msg DEBUG: ");
568 va_start(ap, format);
569 (void) vfprintf(stderr, format, ap);
570 va_end(ap);
571
572 if (strchr(format, '\n') == NULL)
573 (void) fprintf(stderr, ": %s\n", strerror(err));
574
575 return (1);
576 }
577
578 static const struct fmd_msg_nv_type *
fmd_msg_nv_type_lookup(data_type_t type)579 fmd_msg_nv_type_lookup(data_type_t type)
580 {
581 const struct fmd_msg_nv_type *t;
582
583 for (t = fmd_msg_nv_types; t->nvt_type != DATA_TYPE_UNKNOWN; t++) {
584 if (t->nvt_type == type)
585 break;
586 }
587
588 return (t);
589 }
590
591 /*
592 * Print the specified string, escaping any unprintable character sequences
593 * using the ISO C character escape sequences.
594 */
595 static void
fmd_msg_nv_print_string(fmd_msg_buf_t * b,const char * s)596 fmd_msg_nv_print_string(fmd_msg_buf_t *b, const char *s)
597 {
598 char c;
599
600 while ((c = *s++) != '\0') {
601 if (c >= ' ' && c <= '~' && c != '\'') {
602 fmd_msg_buf_printf(b, "%c", c);
603 continue;
604 }
605
606 switch (c) {
607 case '\0':
608 fmd_msg_buf_printf(b, "\\0");
609 break;
610 case '\a':
611 fmd_msg_buf_printf(b, "\\a");
612 break;
613 case '\b':
614 fmd_msg_buf_printf(b, "\\b");
615 break;
616 case '\f':
617 fmd_msg_buf_printf(b, "\\f");
618 break;
619 case '\n':
620 fmd_msg_buf_printf(b, "\\n");
621 break;
622 case '\r':
623 fmd_msg_buf_printf(b, "\\r");
624 break;
625 case '\t':
626 fmd_msg_buf_printf(b, "\\t");
627 break;
628 case '\v':
629 fmd_msg_buf_printf(b, "\\v");
630 break;
631 case '\'':
632 fmd_msg_buf_printf(b, "\\'");
633 break;
634 case '"':
635 fmd_msg_buf_printf(b, "\\\"");
636 break;
637 case '\\':
638 fmd_msg_buf_printf(b, "\\\\");
639 break;
640 default:
641 fmd_msg_buf_printf(b, "\\x%02x", (uchar_t)c);
642 }
643 }
644 }
645
646 /*
647 * Print the value of the specified nvpair into the supplied buffer.
648 *
649 * For nvpairs that are arrays types, passing -1 as the idx param indicates
650 * that we want to print all of the elements in the array.
651 *
652 * Returns 0 on success, 1 otherwise.
653 */
654 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)655 fmd_msg_nv_print_items(fmd_msg_buf_t *b, nvpair_t *nvp,
656 data_type_t type, void *p, uint_t n, uint_t idx)
657 {
658 const struct fmd_msg_nv_type *nvt = fmd_msg_nv_type_lookup(type);
659 uint_t i;
660
661 if (idx != -1u) {
662 if (idx >= n) {
663 return (fmd_msg_nv_error("index %u out-of-range for "
664 "array %s: valid range is [0 .. %u]\n",
665 idx, nvpair_name(nvp), n ? n - 1 : 0));
666 }
667 p = (uchar_t *)p + nvt->nvt_size * idx;
668 n = 1;
669 }
670
671 for (i = 0; i < n; i++, p = (uchar_t *)p + nvt->nvt_size) {
672 if (i > 0)
673 fmd_msg_buf_printf(b, " "); /* array item delimiter */
674
675 switch (type) {
676 case DATA_TYPE_INT8:
677 fmd_msg_buf_printf(b, "%d", *(int8_t *)p);
678 break;
679
680 case DATA_TYPE_INT16:
681 fmd_msg_buf_printf(b, "%d", *(int16_t *)p);
682 break;
683
684 case DATA_TYPE_INT32:
685 fmd_msg_buf_printf(b, "%d", *(int32_t *)p);
686 break;
687
688 case DATA_TYPE_INT64:
689 fmd_msg_buf_printf(b, "%lld", *(longlong_t *)p);
690 break;
691
692 case DATA_TYPE_UINT8:
693 fmd_msg_buf_printf(b, "%u", *(uint8_t *)p);
694 break;
695
696 case DATA_TYPE_UINT16:
697 fmd_msg_buf_printf(b, "%u", *(uint16_t *)p);
698 break;
699
700 case DATA_TYPE_UINT32:
701 fmd_msg_buf_printf(b, "%u", *(uint32_t *)p);
702 break;
703
704 case DATA_TYPE_UINT64:
705 fmd_msg_buf_printf(b, "%llu", *(u_longlong_t *)p);
706 break;
707
708 case DATA_TYPE_BYTE:
709 fmd_msg_buf_printf(b, "0x%x", *(uchar_t *)p);
710 break;
711
712 case DATA_TYPE_BOOLEAN_VALUE:
713 fmd_msg_buf_printf(b,
714 *(boolean_t *)p ? "true" : "false");
715 break;
716
717 case DATA_TYPE_HRTIME:
718 fmd_msg_buf_printf(b, "%lld", *(longlong_t *)p);
719 break;
720
721 case DATA_TYPE_STRING:
722 fmd_msg_nv_print_string(b, *(char **)p);
723 break;
724 }
725 }
726
727 return (0);
728 }
729
730 /*
731 * Writes the value of the specified nvpair to the supplied buffer.
732 *
733 * Returns 0 on success, 1 otherwise.
734 */
735 static int
fmd_msg_nv_print_nvpair(fmd_msg_buf_t * b,nvpair_t * nvp,uint_t idx)736 fmd_msg_nv_print_nvpair(fmd_msg_buf_t *b, nvpair_t *nvp, uint_t idx)
737 {
738 data_type_t type = nvpair_type(nvp);
739 const struct fmd_msg_nv_type *nvt = fmd_msg_nv_type_lookup(type);
740
741 uint64_t v;
742 void *a;
743 uint_t n;
744 int err;
745
746 if (nvt->nvt_type == DATA_TYPE_BOOLEAN) {
747 fmd_msg_buf_printf(b, "true");
748 err = 0;
749 } else if (nvt->nvt_array != NULL) {
750 (void) nvt->nvt_array(nvp, &a, &n);
751 err = fmd_msg_nv_print_items(b, nvp, nvt->nvt_base, a, n, idx);
752 } else if (nvt->nvt_value != NULL) {
753 (void) nvt->nvt_value(nvp, &v);
754 err = fmd_msg_nv_print_items(b, nvp, nvt->nvt_base, &v, 1, idx);
755 } else {
756 err = fmd_msg_nv_error("unknown data type %u", type);
757 }
758
759 return (err);
760 }
761
762 /*
763 * Consume a token from the specified string, fill in the specified token
764 * struct, and return the new string position from which to continue parsing.
765 */
766 static char *
fmd_msg_nv_parse_token(char * s,fmd_msg_nv_token_t * tp)767 fmd_msg_nv_parse_token(char *s, fmd_msg_nv_token_t *tp)
768 {
769 char *p = s, *q, c = *s;
770
771 /*
772 * Skip whitespace and then look for an integer token first. We can't
773 * use isspace() or isdigit() because we're in setlocale() context now.
774 */
775 while (c == ' ' || c == '\t' || c == '\v' || c == '\n' || c == '\r')
776 c = *++p;
777
778 if (c >= '0' && c <= '9') {
779 errno = 0;
780 tp->t_data.tu_int = strtoul(p, &q, 0);
781
782 if (errno != 0 || p == q) {
783 tp->t_kind = T_ERR;
784 return (p);
785 }
786
787 tp->t_kind = T_INT;
788 return (q);
789 }
790
791 /*
792 * Look for a name-value pair identifier, which we define to be the
793 * regular expression [a-zA-Z_][a-zA-Z0-9_-]* (NOTE: Ideally "-" would
794 * not be allowed here and we would require ISO C identifiers, but many
795 * FMA event members use hyphens.) This code specifically cannot use
796 * the isspace(), isalnum() etc. macros because we are currently in the
797 * context of an earlier call to setlocale() that may have installed a
798 * non-C locale, but this code needs to always operate on C characters.
799 */
800 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_') {
801 for (q = p + 1; (c = *q) != '\0'; q++) {
802 if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z') &&
803 (c < '0' || c > '9') && (c != '_' && c != '-'))
804 break;
805 }
806
807 if (sizeof (tp->t_data.tu_str) <= (size_t)(q - p)) {
808 tp->t_kind = T_ERR;
809 return (p);
810 }
811
812 bcopy(p, tp->t_data.tu_str, (size_t)(q - p));
813 tp->t_data.tu_str[(size_t)(q - p)] = '\0';
814 tp->t_kind = T_IDENT;
815 return (q);
816 }
817
818 switch (c) {
819 case '\0':
820 tp->t_kind = T_EOF;
821 return (p);
822 case '.':
823 tp->t_kind = T_DOT;
824 return (p + 1);
825 case '[':
826 tp->t_kind = T_LBRAC;
827 return (p + 1);
828 case ']':
829 tp->t_kind = T_RBRAC;
830 return (p + 1);
831 default:
832 tp->t_kind = T_ERR;
833 return (p);
834 }
835 }
836
837 static int
fmd_msg_nv_parse_error(const char * s,fmd_msg_nv_token_t * tp)838 fmd_msg_nv_parse_error(const char *s, fmd_msg_nv_token_t *tp)
839 {
840 if (tp->t_kind == T_ERR)
841 return (fmd_msg_nv_error("illegal character at \"%s\"\n", s));
842 else
843 return (fmd_msg_nv_error("syntax error near \"%s\"\n", s));
844 }
845
846 /*
847 * Parse an array expression for referencing an element of the specified
848 * nvpair_t, which is expected to be of an array type. If it's an array of
849 * intrinsics, print the specified value. If it's an array of nvlist_t's,
850 * call fmd_msg_nv_parse_nvlist() recursively to continue parsing.
851 */
852 static int
fmd_msg_nv_parse_array(fmd_msg_buf_t * b,nvpair_t * nvp,char * s1)853 fmd_msg_nv_parse_array(fmd_msg_buf_t *b, nvpair_t *nvp, char *s1)
854 {
855 fmd_msg_nv_token_t t;
856 nvlist_t **nva;
857 uint_t i, n;
858 char *s2;
859
860 if (fmd_msg_nv_type_lookup(nvpair_type(nvp))->nvt_array == NULL) {
861 return (fmd_msg_nv_error("inappropriate use of operator [ ]: "
862 "element '%s' is not an array\n", nvpair_name(nvp)));
863 }
864
865 s2 = fmd_msg_nv_parse_token(s1, &t);
866 i = t.t_data.tu_int;
867
868 if (t.t_kind != T_INT)
869 return (fmd_msg_nv_error("expected integer index after [\n"));
870
871 s2 = fmd_msg_nv_parse_token(s2, &t);
872
873 if (t.t_kind != T_RBRAC)
874 return (fmd_msg_nv_error("expected ] after [ %u\n", i));
875
876 /*
877 * An array of nvlist is different from other array types in that it
878 * permits us to continue parsing instead of printing a terminal node.
879 */
880 if (nvpair_type(nvp) == DATA_TYPE_NVLIST_ARRAY) {
881 (void) nvpair_value_nvlist_array(nvp, &nva, &n);
882
883 if (i >= n) {
884 return (fmd_msg_nv_error("index %u out-of-range for "
885 "array %s: valid range is [0 .. %u]\n",
886 i, nvpair_name(nvp), n ? n - 1 : 0));
887 }
888
889 return (fmd_msg_nv_parse_nvlist(b, nva[i], s2));
890 }
891
892 (void) fmd_msg_nv_parse_token(s2, &t);
893
894 if (t.t_kind != T_EOF) {
895 return (fmd_msg_nv_error("expected end-of-string "
896 "in expression instead of \"%s\"\n", s2));
897 }
898
899 return (fmd_msg_nv_print_nvpair(b, nvp, i));
900 }
901
902 /*
903 * Parse an expression rooted at an nvpair_t. If we see EOF, print the entire
904 * nvpair. If we see LBRAC, parse an array expression. If we see DOT, call
905 * fmd_msg_nv_parse_nvname() recursively to dereference an embedded member.
906 */
907 static int
fmd_msg_nv_parse_nvpair(fmd_msg_buf_t * b,nvpair_t * nvp,char * s1)908 fmd_msg_nv_parse_nvpair(fmd_msg_buf_t *b, nvpair_t *nvp, char *s1)
909 {
910 fmd_msg_nv_token_t t;
911 nvlist_t *nvl;
912 char *s2;
913
914 s2 = fmd_msg_nv_parse_token(s1, &t);
915
916 if (t.t_kind == T_EOF)
917 return (fmd_msg_nv_print_nvpair(b, nvp, -1));
918
919 if (t.t_kind == T_LBRAC)
920 return (fmd_msg_nv_parse_array(b, nvp, s2));
921
922 if (t.t_kind != T_DOT)
923 return (fmd_msg_nv_parse_error(s1, &t));
924
925 if (nvpair_type(nvp) != DATA_TYPE_NVLIST) {
926 return (fmd_msg_nv_error("inappropriate use of operator '.': "
927 "element '%s' is not of type nvlist\n", nvpair_name(nvp)));
928 }
929
930 (void) nvpair_value_nvlist(nvp, &nvl);
931 return (fmd_msg_nv_parse_nvname(b, nvl, s2));
932 }
933
934 /*
935 * Parse an expression for a name-value pair name (IDENT). If we find a match
936 * continue parsing with the corresponding nvpair_t.
937 */
938 static int
fmd_msg_nv_parse_nvname(fmd_msg_buf_t * b,nvlist_t * nvl,char * s1)939 fmd_msg_nv_parse_nvname(fmd_msg_buf_t *b, nvlist_t *nvl, char *s1)
940 {
941 nvpair_t *nvp = NULL;
942 fmd_msg_nv_token_t t;
943 char *s2;
944
945 s2 = fmd_msg_nv_parse_token(s1, &t);
946
947 if (t.t_kind != T_IDENT)
948 return (fmd_msg_nv_parse_error(s1, &t));
949
950 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
951 if (strcmp(nvpair_name(nvp), t.t_data.tu_str) == 0)
952 break;
953 }
954
955 if (nvp == NULL) {
956 return (fmd_msg_nv_error("no such name-value pair "
957 "member: %s\n", t.t_data.tu_str));
958 }
959
960 return (fmd_msg_nv_parse_nvpair(b, nvp, s2));
961 }
962
963 /*
964 * Parse an expression rooted at an nvlist: if we see EOF, print nothing.
965 * If we see DOT, continue parsing to retrieve a name-value pair name.
966 */
967 static int
fmd_msg_nv_parse_nvlist(fmd_msg_buf_t * b,nvlist_t * nvl,char * s1)968 fmd_msg_nv_parse_nvlist(fmd_msg_buf_t *b, nvlist_t *nvl, char *s1)
969 {
970 fmd_msg_nv_token_t t;
971 char *s2;
972
973 s2 = fmd_msg_nv_parse_token(s1, &t);
974
975 if (t.t_kind == T_EOF)
976 return (0);
977
978 if (t.t_kind == T_DOT)
979 return (fmd_msg_nv_parse_nvname(b, nvl, s2));
980
981 return (fmd_msg_nv_parse_error(s1, &t));
982 }
983
984 /*
985 * This function is the main engine for formatting an event message item, such
986 * as the Description field. It loads the item text from a message object,
987 * expands any variables defined in the item text, and then returns a newly-
988 * allocated multi-byte string with the localized message text, or NULL with
989 * errno set if an error occurred.
990 */
991 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)992 fmd_msg_getitem_locked(fmd_msg_hdl_t *h,
993 nvlist_t *nvl, const char *dict, const char *code, fmd_msg_item_t item)
994 {
995 const char *istr = fmd_msg_items[item];
996 size_t len = strlen(code) + 1 + strlen(istr) + 1;
997 char *key = alloca(len);
998
999 fmd_msg_buf_t buf;
1000 wchar_t *c, *u, *w, *p, *q;
1001
1002 const char *url, *txt;
1003 char *s, *expr;
1004 size_t elen;
1005 int i;
1006
1007 assert(fmd_msg_lock_held(h));
1008
1009 /*
1010 * If <dict>.mo defines an item with the key <FMD_MSG_URLKEY> then it
1011 * is used as the URL; otherwise the default from our handle is used.
1012 * Once we have the multi-byte URL, convert it to wide-character form.
1013 */
1014 if ((url = dgettext(dict, FMD_MSG_URLKEY)) == FMD_MSG_URLKEY)
1015 url = h->fmh_urlbase;
1016
1017 /*
1018 * If the item is FMD_MSG_ITEM_URL, then its value is directly computed
1019 * as the URL base concatenated with the code. Otherwise the item text
1020 * is derived by looking up the key <code>.<istr> in the dict object.
1021 * Once we're done, convert the 'txt' multi-byte to wide-character.
1022 */
1023 if (item == FMD_MSG_ITEM_URL) {
1024 len = strlen(url) + strlen(code) + 1;
1025 key = alloca(len);
1026 (void) snprintf(key, len, "%s%s", url, code);
1027 txt = key;
1028 } else {
1029 len = strlen(code) + 1 + strlen(istr) + 1;
1030 key = alloca(len);
1031 (void) snprintf(key, len, "%s.%s", code, istr);
1032 txt = dgettext(dict, key);
1033 }
1034
1035 c = fmd_msg_mbstowcs(code);
1036 u = fmd_msg_mbstowcs(url);
1037 w = fmd_msg_mbstowcs(txt);
1038
1039 if (c == NULL || u == NULL || w == NULL) {
1040 free(c);
1041 free(u);
1042 free(w);
1043 return (NULL);
1044 }
1045
1046 /*
1047 * Now expand any escape sequences in the string, storing the final
1048 * text in 'buf' in wide-character format, and then convert it back
1049 * to multi-byte for return. We expand the following sequences:
1050 *
1051 * %% - literal % character
1052 * %s - base URL for knowledge articles
1053 * %<x> - expression x in the current event, if any
1054 *
1055 * If an invalid sequence is present, it is elided so we can safely
1056 * reserve any future characters for other types of expansions.
1057 */
1058 fmd_msg_buf_init(&buf);
1059
1060 for (q = w, p = w; (p = wcschr(p, L'%')) != NULL; q = p) {
1061 if (p > q)
1062 fmd_msg_buf_write(&buf, q, (size_t)(p - q));
1063
1064 switch (p[1]) {
1065 case L'%':
1066 fmd_msg_buf_write(&buf, p, 1);
1067 p += 2;
1068 break;
1069
1070 case L's':
1071 fmd_msg_buf_write(&buf, u, wcslen(u));
1072 fmd_msg_buf_write(&buf, c, wcslen(c));
1073
1074 p += 2;
1075 break;
1076
1077 case L'<':
1078 q = p + 2;
1079 p = wcschr(p + 2, L'>');
1080
1081 if (p == NULL)
1082 goto eos;
1083
1084 /*
1085 * The expression in %< > must be an ASCII string: as
1086 * such allocate its length in bytes plus an extra
1087 * MB_CUR_MAX for slop if a multi-byte character is in
1088 * there, plus another byte for \0. Since we move a
1089 * byte at a time, any multi-byte chars will just be
1090 * silently overwritten and fail to parse, which is ok.
1091 */
1092 elen = (size_t)(p - q);
1093 expr = malloc(elen + MB_CUR_MAX + 1);
1094
1095 if (expr == NULL) {
1096 buf.fmb_error = ENOMEM;
1097 goto eos;
1098 }
1099
1100 for (i = 0; i < elen; i++)
1101 (void) wctomb(&expr[i], q[i]);
1102
1103 expr[i] = '\0';
1104
1105 if (nvl != NULL)
1106 (void) fmd_msg_nv_parse_nvname(&buf, nvl, expr);
1107 else
1108 fmd_msg_buf_printf(&buf, "%%<%s>", expr);
1109
1110 free(expr);
1111 p++;
1112 break;
1113
1114 case L'\0':
1115 goto eos;
1116
1117 default:
1118 p += 2;
1119 break;
1120 }
1121 }
1122 eos:
1123 fmd_msg_buf_write(&buf, q, wcslen(q) + 1);
1124
1125 free(c);
1126 free(u);
1127 free(w);
1128
1129 s = fmd_msg_buf_read(&buf);
1130 fmd_msg_buf_fini(&buf);
1131
1132 return (s);
1133 }
1134
1135 /*
1136 * This is a private interface used by the notification daemons to parse tokens
1137 * in user-supplied message templates.
1138 */
1139 char *
fmd_msg_decode_tokens(nvlist_t * nvl,const char * msg,const char * url)1140 fmd_msg_decode_tokens(nvlist_t *nvl, const char *msg, const char *url)
1141 {
1142 fmd_msg_buf_t buf;
1143 wchar_t *h, *u, *w, *p, *q;
1144
1145 char *s, *expr, host[MAXHOSTNAMELEN + 1];
1146 size_t elen;
1147 int i;
1148
1149 u = fmd_msg_mbstowcs(url);
1150
1151 (void) gethostname(host, MAXHOSTNAMELEN + 1);
1152 h = fmd_msg_mbstowcs(host);
1153
1154 if ((w = fmd_msg_mbstowcs(msg)) == NULL)
1155 return (NULL);
1156
1157 /*
1158 * Now expand any escape sequences in the string, storing the final
1159 * text in 'buf' in wide-character format, and then convert it back
1160 * to multi-byte for return. We expand the following sequences:
1161 *
1162 * %% - literal % character
1163 * %h - hostname
1164 * %s - base URL for knowledge articles
1165 * %<x> - expression x in the current event, if any
1166 *
1167 * If an invalid sequence is present, it is elided so we can safely
1168 * reserve any future characters for other types of expansions.
1169 */
1170 fmd_msg_buf_init(&buf);
1171
1172 for (q = w, p = w; (p = wcschr(p, L'%')) != NULL; q = p) {
1173 if (p > q)
1174 fmd_msg_buf_write(&buf, q, (size_t)(p - q));
1175
1176 switch (p[1]) {
1177 case L'%':
1178 fmd_msg_buf_write(&buf, p, 1);
1179 p += 2;
1180 break;
1181
1182 case L'h':
1183 if (h != NULL)
1184 fmd_msg_buf_write(&buf, h, wcslen(h));
1185
1186 p += 2;
1187 break;
1188
1189 case L's':
1190 if (u != NULL)
1191 fmd_msg_buf_write(&buf, u, wcslen(u));
1192
1193 p += 2;
1194 break;
1195
1196 case L'<':
1197 q = p + 2;
1198 p = wcschr(p + 2, L'>');
1199
1200 if (p == NULL)
1201 goto eos;
1202
1203 /*
1204 * The expression in %< > must be an ASCII string: as
1205 * such allocate its length in bytes plus an extra
1206 * MB_CUR_MAX for slop if a multi-byte character is in
1207 * there, plus another byte for \0. Since we move a
1208 * byte at a time, any multi-byte chars will just be
1209 * silently overwritten and fail to parse, which is ok.
1210 */
1211 elen = (size_t)(p - q);
1212 expr = malloc(elen + MB_CUR_MAX + 1);
1213
1214 if (expr == NULL) {
1215 buf.fmb_error = ENOMEM;
1216 goto eos;
1217 }
1218
1219 for (i = 0; i < elen; i++)
1220 (void) wctomb(&expr[i], q[i]);
1221
1222 expr[i] = '\0';
1223
1224 if (nvl != NULL)
1225 (void) fmd_msg_nv_parse_nvname(&buf, nvl, expr);
1226 else
1227 fmd_msg_buf_printf(&buf, "%%<%s>", expr);
1228
1229 free(expr);
1230 p++;
1231 break;
1232
1233 case L'\0':
1234 goto eos;
1235
1236 default:
1237 p += 2;
1238 break;
1239 }
1240 }
1241 eos:
1242 fmd_msg_buf_write(&buf, q, wcslen(q) + 1);
1243
1244 free(h);
1245 free(u);
1246 free(w);
1247
1248 s = fmd_msg_buf_read(&buf);
1249 fmd_msg_buf_fini(&buf);
1250
1251 return (s);
1252 }
1253
1254 /*
1255 * This function is the main engine for formatting an entire event message.
1256 * It retrieves the master format string for an event, formats the individual
1257 * items, and then produces the final string composing all of the items. The
1258 * result is a newly-allocated multi-byte string of the localized message
1259 * text, or NULL with errno set if an error occurred.
1260 */
1261 static char *
fmd_msg_gettext_locked(fmd_msg_hdl_t * h,nvlist_t * nvl,const char * dict,const char * code)1262 fmd_msg_gettext_locked(fmd_msg_hdl_t *h,
1263 nvlist_t *nvl, const char *dict, const char *code)
1264 {
1265 char *items[FMD_MSG_ITEM_MAX];
1266 const char *format;
1267 char *buf = NULL;
1268 size_t len;
1269 int i;
1270
1271 nvlist_t *fmri, *auth;
1272 struct tm tm, *tmp;
1273
1274 int64_t *tv;
1275 uint_t tn = 0;
1276 time_t sec;
1277 char date[64];
1278
1279 char *uuid, *src_name, *src_vers;
1280 char *platform, *server, *csn;
1281
1282 assert(fmd_msg_lock_held(h));
1283 bzero(items, sizeof (items));
1284
1285 for (i = 0; i < FMD_MSG_ITEM_MAX; i++) {
1286 items[i] = fmd_msg_getitem_locked(h, nvl, dict, code, i);
1287 if (items[i] == NULL)
1288 goto out;
1289 }
1290
1291 /*
1292 * If <dict>.mo defines an item with the key <FMD_MSG_TEMPLATE> then it
1293 * is used as the format; otherwise the default from FMD.mo is used.
1294 */
1295 if ((format = dgettext(dict, FMD_MSG_TEMPLATE)) == FMD_MSG_TEMPLATE)
1296 format = h->fmh_template;
1297
1298 if (nvlist_lookup_string(nvl, FM_SUSPECT_UUID, &uuid) != 0)
1299 uuid = (char *)FMD_MSG_MISSING;
1300
1301 if (nvlist_lookup_int64_array(nvl, FM_SUSPECT_DIAG_TIME,
1302 &tv, &tn) == 0 && tn == 2 && (sec = (time_t)tv[0]) != (time_t)-1 &&
1303 (tmp = localtime_r(&sec, &tm)) != NULL)
1304 (void) strftime(date, sizeof (date), "%a %b %e %H:%M:%S %Z %Y",
1305 tmp);
1306 else
1307 (void) strlcpy(date, FMD_MSG_MISSING, sizeof (date));
1308
1309 /*
1310 * Extract the relevant identifying elements of the FMRI and authority.
1311 * Note: for now, we ignore FM_FMRI_AUTH_DOMAIN (only for SPs).
1312 */
1313 if (nvlist_lookup_nvlist(nvl, FM_SUSPECT_DE, &fmri) != 0)
1314 fmri = NULL;
1315
1316 if (nvlist_lookup_nvlist(fmri, FM_FMRI_AUTHORITY, &auth) != 0)
1317 auth = NULL;
1318
1319 if (nvlist_lookup_string(fmri, FM_FMRI_FMD_NAME, &src_name) != 0)
1320 src_name = (char *)FMD_MSG_MISSING;
1321
1322 if (nvlist_lookup_string(fmri, FM_FMRI_FMD_VERSION, &src_vers) != 0)
1323 src_vers = (char *)FMD_MSG_MISSING;
1324
1325 if (nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT, &platform) != 0)
1326 platform = (char *)FMD_MSG_MISSING;
1327
1328 if (nvlist_lookup_string(auth, FM_FMRI_AUTH_SERVER, &server) != 0)
1329 server = (char *)FMD_MSG_MISSING;
1330
1331 if (nvlist_lookup_string(auth, FM_FMRI_AUTH_PRODUCT_SN, &csn) != 0 &&
1332 nvlist_lookup_string(auth, FM_FMRI_AUTH_CHASSIS, &csn) != 0)
1333 csn = (char *)FMD_MSG_MISSING;
1334
1335 /*
1336 * Format the message once to get its length, allocate a buffer, and
1337 * then format the message again into the buffer to return it.
1338 */
1339 len = snprintf(NULL, 0, format, code,
1340 items[FMD_MSG_ITEM_TYPE], items[FMD_MSG_ITEM_SEVERITY],
1341 date, platform, csn, server, src_name, src_vers, uuid,
1342 items[FMD_MSG_ITEM_DESC], items[FMD_MSG_ITEM_RESPONSE],
1343 items[FMD_MSG_ITEM_IMPACT], items[FMD_MSG_ITEM_ACTION]);
1344
1345 if ((buf = malloc(len + 1)) == NULL) {
1346 errno = ENOMEM;
1347 goto out;
1348 }
1349
1350 (void) snprintf(buf, len + 1, format, code,
1351 items[FMD_MSG_ITEM_TYPE], items[FMD_MSG_ITEM_SEVERITY],
1352 date, platform, csn, server, src_name, src_vers, uuid,
1353 items[FMD_MSG_ITEM_DESC], items[FMD_MSG_ITEM_RESPONSE],
1354 items[FMD_MSG_ITEM_IMPACT], items[FMD_MSG_ITEM_ACTION]);
1355 out:
1356 for (i = 0; i < FMD_MSG_ITEM_MAX; i++)
1357 free(items[i]);
1358
1359 return (buf);
1360 }
1361
1362 /*
1363 * Common code for fmd_msg_getitem_nv() and fmd_msg_getitem_id(): this function
1364 * handles locking, changing locales and domains, and restoring i18n state.
1365 */
1366 static char *
fmd_msg_getitem(fmd_msg_hdl_t * h,const char * locale,nvlist_t * nvl,const char * code,fmd_msg_item_t item)1367 fmd_msg_getitem(fmd_msg_hdl_t *h,
1368 const char *locale, nvlist_t *nvl, const char *code, fmd_msg_item_t item)
1369 {
1370 char *old_b, *old_c;
1371 char *dict, *key, *p, *s;
1372 size_t len;
1373 int err;
1374
1375 if ((p = strchr(code, '-')) == NULL || p == code) {
1376 errno = EINVAL;
1377 return (NULL);
1378 }
1379
1380 if (locale != NULL && strcmp(h->fmh_locale, locale) == 0)
1381 locale = NULL; /* simplify later tests */
1382
1383 dict = strndupa(code, p - code);
1384
1385 fmd_msg_lock();
1386
1387 /*
1388 * If a non-default text domain binding was requested, save the old
1389 * binding perform the re-bind now that fmd_msg_lock() is held.
1390 */
1391 if (h->fmh_binding != NULL) {
1392 p = bindtextdomain(dict, NULL);
1393 old_b = strdupa(p);
1394 (void) bindtextdomain(dict, h->fmh_binding);
1395 }
1396
1397 /*
1398 * Compute the lookup code for FMD_MSG_ITEM_TYPE: we'll use this to
1399 * determine if the dictionary contains any data for this code at all.
1400 */
1401 len = strlen(code) + 1 + strlen(fmd_msg_items[FMD_MSG_ITEM_TYPE]) + 1;
1402 key = alloca(len);
1403
1404 (void) snprintf(key, len, "%s.%s",
1405 code, fmd_msg_items[FMD_MSG_ITEM_TYPE]);
1406
1407 /*
1408 * Save the current locale string, and if we've been asked to fetch
1409 * the text for a different locale, switch locales now under the lock.
1410 */
1411 p = setlocale(LC_ALL, NULL);
1412 old_c = strdupa(p);
1413
1414 if (locale != NULL)
1415 (void) setlocale(LC_ALL, locale);
1416
1417 /*
1418 * Prefetch the first item: if this isn't found, and we're in a non-
1419 * default locale, attempt to fall back to the C locale for this code.
1420 */
1421 if (dgettext(dict, key) == key &&
1422 (locale != NULL || strcmp(h->fmh_locale, "C") != 0)) {
1423 (void) setlocale(LC_ALL, "C");
1424 locale = "C"; /* restore locale */
1425 }
1426
1427 if (dgettext(dict, key) == key) {
1428 s = NULL;
1429 err = ENOENT;
1430 } else {
1431 s = fmd_msg_getitem_locked(h, nvl, dict, code, item);
1432 err = errno;
1433 }
1434
1435 if (locale != NULL)
1436 (void) setlocale(LC_ALL, old_c);
1437
1438 if (h->fmh_binding != NULL)
1439 (void) bindtextdomain(dict, old_b);
1440
1441 fmd_msg_unlock();
1442
1443 if (s == NULL)
1444 errno = err;
1445
1446 return (s);
1447 }
1448
1449 char *
fmd_msg_getitem_nv(fmd_msg_hdl_t * h,const char * locale,nvlist_t * nvl,fmd_msg_item_t item)1450 fmd_msg_getitem_nv(fmd_msg_hdl_t *h,
1451 const char *locale, nvlist_t *nvl, fmd_msg_item_t item)
1452 {
1453 char *code;
1454
1455 if (item >= FMD_MSG_ITEM_MAX) {
1456 errno = EINVAL;
1457 return (NULL);
1458 }
1459
1460 if (nvlist_lookup_string(nvl, FM_SUSPECT_DIAG_CODE, &code) != 0) {
1461 errno = EINVAL;
1462 return (NULL);
1463 }
1464
1465 return (fmd_msg_getitem(h, locale, nvl, code, item));
1466 }
1467
1468 char *
fmd_msg_getitem_id(fmd_msg_hdl_t * h,const char * locale,const char * code,fmd_msg_item_t item)1469 fmd_msg_getitem_id(fmd_msg_hdl_t *h,
1470 const char *locale, const char *code, fmd_msg_item_t item)
1471 {
1472 if (item >= FMD_MSG_ITEM_MAX) {
1473 errno = EINVAL;
1474 return (NULL);
1475 }
1476
1477 return (fmd_msg_getitem(h, locale, NULL, code, item));
1478 }
1479
1480 char *
fmd_msg_gettext_key(fmd_msg_hdl_t * h,const char * locale,const char * dict,const char * key)1481 fmd_msg_gettext_key(fmd_msg_hdl_t *h,
1482 const char *locale, const char *dict, const char *key)
1483 {
1484 char *old_b, *old_c, *p, *s;
1485
1486 fmd_msg_lock();
1487
1488 /*
1489 * If a non-default text domain binding was requested, save the old
1490 * binding perform the re-bind now that fmd_msg_lock() is held.
1491 */
1492 if (h->fmh_binding != NULL) {
1493 p = bindtextdomain(dict, NULL);
1494 old_b = alloca(strlen(p) + 1);
1495 (void) strcpy(old_b, p);
1496 (void) bindtextdomain(dict, h->fmh_binding);
1497 }
1498
1499 /*
1500 * Save the current locale string, and if we've been asked to fetch
1501 * the text for a different locale, switch locales now under the lock.
1502 */
1503 p = setlocale(LC_ALL, NULL);
1504 old_c = alloca(strlen(p) + 1);
1505 (void) strcpy(old_c, p);
1506
1507 if (locale != NULL)
1508 (void) setlocale(LC_ALL, locale);
1509
1510 /*
1511 * First attempt to fetch the string in the current locale. If this
1512 * fails and we're in a non-default locale, attempt to fall back to the
1513 * C locale and try again. If it still fails then we return NULL and
1514 * set errno.
1515 */
1516 if ((s = dgettext(dict, key)) == key &&
1517 (locale != NULL || strcmp(h->fmh_locale, "C") != 0)) {
1518 (void) setlocale(LC_ALL, "C");
1519 locale = "C"; /* restore locale */
1520
1521 if ((s = dgettext(dict, key)) == key) {
1522 s = NULL;
1523 errno = ENOENT;
1524 }
1525 }
1526 if (locale != NULL)
1527 (void) setlocale(LC_ALL, old_c);
1528
1529 if (h->fmh_binding != NULL)
1530 (void) bindtextdomain(dict, old_b);
1531
1532 fmd_msg_unlock();
1533
1534 return (s);
1535 }
1536
1537 /*
1538 * Common code for fmd_msg_gettext_nv() and fmd_msg_gettext_id(): this function
1539 * handles locking, changing locales and domains, and restoring i18n state.
1540 */
1541 static char *
fmd_msg_gettext(fmd_msg_hdl_t * h,const char * locale,nvlist_t * nvl,const char * code)1542 fmd_msg_gettext(fmd_msg_hdl_t *h,
1543 const char *locale, nvlist_t *nvl, const char *code)
1544 {
1545 char *old_b, *old_c;
1546 char *dict, *key, *p, *s;
1547 size_t len;
1548 int err;
1549
1550 if ((p = strchr(code, '-')) == NULL || p == code) {
1551 errno = EINVAL;
1552 return (NULL);
1553 }
1554
1555 if (locale != NULL && strcmp(h->fmh_locale, locale) == 0)
1556 locale = NULL; /* simplify later tests */
1557
1558 dict = strndupa(code, p - code);
1559
1560 fmd_msg_lock();
1561
1562 /*
1563 * If a non-default text domain binding was requested, save the old
1564 * binding perform the re-bind now that fmd_msg_lock() is held.
1565 */
1566 if (h->fmh_binding != NULL) {
1567 p = bindtextdomain(dict, NULL);
1568 old_b = strdupa(p);
1569 (void) bindtextdomain(dict, h->fmh_binding);
1570 }
1571
1572 /*
1573 * Compute the lookup code for FMD_MSG_ITEM_TYPE: we'll use this to
1574 * determine if the dictionary contains any data for this code at all.
1575 */
1576 len = strlen(code) + 1 + strlen(fmd_msg_items[FMD_MSG_ITEM_TYPE]) + 1;
1577 key = alloca(len);
1578
1579 (void) snprintf(key, len, "%s.%s",
1580 code, fmd_msg_items[FMD_MSG_ITEM_TYPE]);
1581
1582 /*
1583 * Save the current locale string, and if we've been asked to fetch
1584 * the text for a different locale, switch locales now under the lock.
1585 */
1586 p = setlocale(LC_ALL, NULL);
1587 old_c = strdupa(p);
1588
1589 if (locale != NULL)
1590 (void) setlocale(LC_ALL, locale);
1591
1592 /*
1593 * Prefetch the first item: if this isn't found, and we're in a non-
1594 * default locale, attempt to fall back to the C locale for this code.
1595 */
1596 if (dgettext(dict, key) == key &&
1597 (locale != NULL || strcmp(h->fmh_locale, "C") != 0)) {
1598 (void) setlocale(LC_ALL, "C");
1599 locale = "C"; /* restore locale */
1600 }
1601
1602 if (dgettext(dict, key) == key) {
1603 s = NULL;
1604 err = ENOENT;
1605 } else {
1606 s = fmd_msg_gettext_locked(h, nvl, dict, code);
1607 err = errno;
1608 }
1609
1610 if (locale != NULL)
1611 (void) setlocale(LC_ALL, old_c);
1612
1613 if (h->fmh_binding != NULL)
1614 (void) bindtextdomain(dict, old_b);
1615
1616 fmd_msg_unlock();
1617
1618 if (s == NULL)
1619 errno = err;
1620
1621 return (s);
1622 }
1623
1624 char *
fmd_msg_gettext_nv(fmd_msg_hdl_t * h,const char * locale,nvlist_t * nvl)1625 fmd_msg_gettext_nv(fmd_msg_hdl_t *h, const char *locale, nvlist_t *nvl)
1626 {
1627 char *code;
1628
1629 if (nvlist_lookup_string(nvl, FM_SUSPECT_DIAG_CODE, &code) != 0) {
1630 errno = EINVAL;
1631 return (NULL);
1632 }
1633
1634 return (fmd_msg_gettext(h, locale, nvl, code));
1635 }
1636
1637 char *
fmd_msg_gettext_id(fmd_msg_hdl_t * h,const char * locale,const char * code)1638 fmd_msg_gettext_id(fmd_msg_hdl_t *h, const char *locale, const char *code)
1639 {
1640 return (fmd_msg_gettext(h, locale, NULL, code));
1641 }
1642