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) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <sys/fm/protocol.h> 27 #include <sys/strlog.h> 28 #include <sys/log.h> 29 #include <libscf.h> 30 31 #include <fm/fmd_api.h> 32 #include <fm/fmd_msg.h> 33 34 #include <stropts.h> 35 #include <strings.h> 36 #include <syslog.h> 37 #include <alloca.h> 38 #include <unistd.h> 39 #include <stdlib.h> 40 #include <errno.h> 41 #include <fcntl.h> 42 43 static struct stats { 44 fmd_stat_t bad_vers; 45 fmd_stat_t bad_code; 46 fmd_stat_t log_err; 47 fmd_stat_t msg_err; 48 fmd_stat_t no_msg; 49 } syslog_stats = { 50 { "bad_vers", FMD_TYPE_UINT64, "event version is missing or invalid" }, 51 { "bad_code", FMD_TYPE_UINT64, "event code has no dictionary name" }, 52 { "log_err", FMD_TYPE_UINT64, "failed to log message to log(7D)" }, 53 { "msg_err", FMD_TYPE_UINT64, "failed to log message to sysmsg(7D)" }, 54 { "no_msg", FMD_TYPE_UINT64, "message logging suppressed" } 55 }; 56 57 static const struct facility { 58 const char *fac_name; 59 int fac_value; 60 } syslog_facs[] = { 61 { "LOG_DAEMON", LOG_DAEMON }, 62 { "LOG_LOCAL0", LOG_LOCAL0 }, 63 { "LOG_LOCAL1", LOG_LOCAL1 }, 64 { "LOG_LOCAL2", LOG_LOCAL2 }, 65 { "LOG_LOCAL3", LOG_LOCAL3 }, 66 { "LOG_LOCAL4", LOG_LOCAL4 }, 67 { "LOG_LOCAL5", LOG_LOCAL5 }, 68 { "LOG_LOCAL6", LOG_LOCAL6 }, 69 { "LOG_LOCAL7", LOG_LOCAL7 }, 70 { NULL, 0 } 71 }; 72 73 static fmd_msg_hdl_t *syslog_msghdl; /* handle for libfmd_msg calls */ 74 static int syslog_msgall; /* set to message all faults */ 75 static log_ctl_t syslog_ctl; /* log(7D) meta-data for each msg */ 76 static int syslog_logfd = -1; /* log(7D) file descriptor */ 77 static int syslog_msgfd = -1; /* sysmsg(7D) file descriptor */ 78 static int syslog_file; /* log to syslog_logfd */ 79 static int syslog_cons; /* log to syslog_msgfd */ 80 static const char SYSLOG_POINTER[] = "syslog-msgs-pointer"; 81 82 /* 83 * Ideally we would just use syslog(3C) for outputting our messages, but our 84 * messaging standard defines a nice multi-line format and syslogd(1M) is very 85 * inflexible and stupid when it comes to multi-line messages. It pulls data 86 * out of log(7D) and splits it up by \n, printing each line to the console 87 * with its usual prefix of date and sender; it uses the same behavior for the 88 * messages file as well. Further, syslog(3C) provides no CE_CONT equivalent 89 * for userland callers (which at least works around repeated file prefixing). 90 * So with a multi-line message format, your file and console end up like this: 91 * 92 * Dec 02 18:08:40 hostname this is my nicely formatted 93 * Dec 02 18:08:40 hostname message designed for 80 cols 94 * ... 95 * 96 * To resolve these issues, we use our own syslog_emit() wrapper to emit 97 * messages and some knowledge of how the Solaris log drivers work. We first 98 * construct an enlarged format string containing the appropriate msgid(1). 99 * We then format the caller's message using the provided format and buffer. 100 * We send this message to log(7D) using putmsg() with SL_CONSOLE | SL_LOGONLY 101 * set in the log_ctl_t. The log driver allows us to set SL_LOGONLY when we 102 * construct messages ourself, indicating that syslogd should only emit the 103 * message to /var/adm/messages and any remote hosts, and skip the console. 104 * Then we emit the message a second time, without the special prefix, to the 105 * sysmsg(7D) device, which handles console redirection and also permits us 106 * to output any characters we like to the console, including \n and \r. 107 */ 108 static void 109 syslog_emit(fmd_hdl_t *hdl, const char *msg) 110 { 111 struct strbuf ctl, dat; 112 uint32_t msgid; 113 114 char *buf; 115 size_t buflen; 116 117 const char *format = "fmd: [ID %u FACILITY_AND_PRIORITY] %s"; 118 STRLOG_MAKE_MSGID(format, msgid); 119 120 buflen = snprintf(NULL, 0, format, msgid, msg); 121 buf = alloca(buflen + 1); 122 (void) snprintf(buf, buflen + 1, format, msgid, msg); 123 124 ctl.buf = (void *)&syslog_ctl; 125 ctl.len = sizeof (syslog_ctl); 126 127 dat.buf = buf; 128 dat.len = buflen + 1; 129 130 /* 131 * The underlying log driver won't accept messages longer than 132 * LOG_MAXPS bytes. Therefore, messages which exceed this limit will 133 * be truncated and appended with a pointer to the full message. 134 */ 135 if (dat.len > LOG_MAXPS) { 136 char *syslog_pointer, *p; 137 size_t plen; 138 139 if ((syslog_pointer = fmd_msg_gettext_id(syslog_msghdl, NULL, 140 SYSLOG_POINTER)) == NULL) { 141 /* 142 * This shouldn't happen, but if it does we'll just 143 * truncate the message. 144 */ 145 buf[LOG_MAXPS - 1] = '\0'; 146 dat.len = LOG_MAXPS; 147 } else { 148 plen = strlen(syslog_pointer) + 1; 149 buf[LOG_MAXPS - plen] = '\0'; 150 /* 151 * If possible, the pointer is appended after a newline 152 */ 153 if ((p = strrchr(buf, '\n')) == NULL) 154 p = &buf[LOG_MAXPS - plen]; 155 156 (void) strcpy(p, syslog_pointer); 157 free(syslog_pointer); 158 dat.len = strlen(buf) + 1; 159 } 160 } 161 if (syslog_file && putmsg(syslog_logfd, &ctl, &dat, 0) != 0) { 162 fmd_hdl_debug(hdl, "putmsg failed: %s\n", strerror(errno)); 163 syslog_stats.log_err.fmds_value.ui64++; 164 } 165 166 dat.buf = strchr(buf, ']'); 167 dat.len -= (size_t)(dat.buf - buf); 168 169 dat.buf[0] = '\r'; /* overwrite ']' with carriage return */ 170 dat.buf[1] = '\n'; /* overwrite ' ' with newline */ 171 172 if (syslog_cons && write(syslog_msgfd, dat.buf, dat.len) != dat.len) { 173 fmd_hdl_debug(hdl, "write failed: %s\n", strerror(errno)); 174 syslog_stats.msg_err.fmds_value.ui64++; 175 } 176 } 177 178 static void 179 free_notify_prefs(fmd_hdl_t *hdl, nvlist_t **prefs, uint_t nprefs) 180 { 181 int i; 182 183 for (i = 0; i < nprefs; i++) { 184 if (prefs[i]) 185 nvlist_free(prefs[i]); 186 } 187 188 fmd_hdl_free(hdl, prefs, sizeof (nvlist_t *) * nprefs); 189 } 190 191 static int 192 get_notify_prefs(fmd_hdl_t *hdl, nvlist_t *ev_nvl, nvlist_t ***pref_nvl, 193 uint_t *nprefs) 194 { 195 nvlist_t *top_nvl, **np_nvlarr, *mech_nvl; 196 nvlist_t **tmparr; 197 int ret, i; 198 uint_t nelem, nslelem; 199 200 if ((ret = smf_notify_get_params(&top_nvl, ev_nvl)) != SCF_SUCCESS) { 201 ret = scf_error(); 202 if (ret != SCF_ERROR_NOT_FOUND) { 203 fmd_hdl_debug(hdl, "Error looking up notification " 204 "preferences (%s)", scf_strerror(ret)); 205 return (ret); 206 } 207 return (ret); 208 } 209 210 if (nvlist_lookup_nvlist_array(top_nvl, SCF_NOTIFY_PARAMS, &np_nvlarr, 211 &nelem) != 0) { 212 fmd_hdl_debug(hdl, "Malformed preference nvlist\n"); 213 ret = SCF_ERROR_INVALID_ARGUMENT; 214 goto pref_done; 215 } 216 217 tmparr = fmd_hdl_alloc(hdl, nelem * sizeof (nvlist_t *), FMD_SLEEP); 218 nslelem = 0; 219 220 for (i = 0; i < nelem; i++) { 221 if (nvlist_lookup_nvlist(np_nvlarr[i], "syslog", &mech_nvl) 222 == 0) 223 tmparr[nslelem++] = fmd_nvl_dup(hdl, mech_nvl, 224 FMD_SLEEP); 225 } 226 227 if (nslelem != 0) { 228 size_t sz = nslelem * sizeof (nvlist_t *); 229 230 *pref_nvl = fmd_hdl_zalloc(hdl, sz, FMD_SLEEP); 231 *nprefs = nslelem; 232 bcopy(tmparr, *pref_nvl, sz); 233 ret = 0; 234 } else { 235 *pref_nvl = NULL; 236 *nprefs = 0; 237 ret = SCF_ERROR_NOT_FOUND; 238 } 239 240 fmd_hdl_free(hdl, tmparr, nelem * sizeof (nvlist_t *)); 241 pref_done: 242 nvlist_free(top_nvl); 243 return (ret); 244 } 245 246 /*ARGSUSED*/ 247 static void 248 syslog_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class) 249 { 250 uint8_t version; 251 boolean_t domsg, *active; 252 char *msg; 253 nvlist_t **prefs; 254 uint_t nprefs, nelems; 255 int ret; 256 257 if (nvlist_lookup_uint8(nvl, FM_VERSION, &version) != 0 || 258 version > FM_SUSPECT_VERSION) { 259 fmd_hdl_debug(hdl, "invalid event version: %u\n", version); 260 syslog_stats.bad_vers.fmds_value.ui64++; 261 return; /* invalid event version */ 262 } 263 264 if (!syslog_msgall && nvlist_lookup_boolean_value(nvl, 265 FM_SUSPECT_MESSAGE, &domsg) == 0 && !domsg) { 266 fmd_hdl_debug(hdl, "%s requested no message\n", class); 267 syslog_stats.no_msg.fmds_value.ui64++; 268 return; /* event is not to be messaged */ 269 } 270 271 ret = get_notify_prefs(hdl, nvl, &prefs, &nprefs); 272 if (ret == SCF_ERROR_NOT_FOUND) { 273 /* 274 * No syslog notification preferences specified for this type of 275 * event, so we're done 276 */ 277 fmd_hdl_debug(hdl, "No syslog notification preferences " 278 "configured for class %s\n", class); 279 syslog_stats.no_msg.fmds_value.ui64++; 280 return; 281 } else if (ret != 0 || nvlist_lookup_boolean_array(prefs[0], "active", 282 &active, &nelems)) { 283 fmd_hdl_debug(hdl, "Failed to retrieve notification " 284 "preferences for class %s\n", class); 285 if (ret == 0) 286 free_notify_prefs(hdl, prefs, nprefs); 287 return; 288 } else if (!active[0]) { 289 fmd_hdl_debug(hdl, "Syslog notifications disabled for " 290 "class %s\n", class); 291 syslog_stats.no_msg.fmds_value.ui64++; 292 free_notify_prefs(hdl, prefs, nprefs); 293 return; 294 } 295 free_notify_prefs(hdl, prefs, nprefs); 296 297 if ((msg = fmd_msg_gettext_nv(syslog_msghdl, NULL, nvl)) == NULL) { 298 fmd_hdl_debug(hdl, "failed to format message"); 299 syslog_stats.bad_code.fmds_value.ui64++; 300 return; /* libfmd_msg error */ 301 } 302 303 syslog_ctl.pri &= LOG_FACMASK; 304 if (strcmp(class, FM_LIST_ISOLATED_CLASS) == 0 || 305 strcmp(class, FM_LIST_RESOLVED_CLASS) == 0 || 306 strcmp(class, FM_LIST_REPAIRED_CLASS) == 0 || 307 strcmp(class, FM_LIST_UPDATED_CLASS) == 0) 308 syslog_ctl.pri |= LOG_NOTICE; 309 else 310 syslog_ctl.pri |= LOG_ERR; 311 312 syslog_emit(hdl, msg); 313 free(msg); 314 } 315 316 static const fmd_prop_t fmd_props[] = { 317 { "console", FMD_TYPE_BOOL, "true" }, 318 { "facility", FMD_TYPE_STRING, "LOG_DAEMON" }, 319 { "gmt", FMD_TYPE_BOOL, "false" }, 320 { "syslogd", FMD_TYPE_BOOL, "true" }, 321 { "url", FMD_TYPE_STRING, "http://illumos.org/msg/" }, 322 { "message_all", FMD_TYPE_BOOL, "false" }, 323 { NULL, 0, NULL } 324 }; 325 326 static const fmd_hdl_ops_t fmd_ops = { 327 syslog_recv, /* fmdo_recv */ 328 NULL, /* fmdo_timeout */ 329 NULL, /* fmdo_close */ 330 NULL, /* fmdo_stats */ 331 NULL, /* fmdo_gc */ 332 }; 333 334 static const fmd_hdl_info_t fmd_info = { 335 "Syslog Messaging Agent", "1.1", &fmd_ops, fmd_props 336 }; 337 338 void 339 _fmd_init(fmd_hdl_t *hdl) 340 { 341 const struct facility *fp; 342 char *facname, *tz, *rootdir, *urlbase; 343 344 if (fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info) != 0) 345 return; /* invalid data in configuration file */ 346 347 (void) fmd_stat_create(hdl, FMD_STAT_NOALLOC, sizeof (syslog_stats) / 348 sizeof (fmd_stat_t), (fmd_stat_t *)&syslog_stats); 349 350 if ((syslog_logfd = open("/dev/conslog", O_WRONLY | O_NOCTTY)) == -1) 351 fmd_hdl_abort(hdl, "syslog-msgs failed to open /dev/conslog"); 352 353 if ((syslog_msgfd = open("/dev/sysmsg", O_WRONLY | O_NOCTTY)) == -1) 354 fmd_hdl_abort(hdl, "syslog-msgs failed to open /dev/sysmsg"); 355 356 /* 357 * If the "gmt" property is set to true, force our EVENT-TIME to be 358 * reported in GMT time; otherwise we use localtime. tzset() affects 359 * the results of subsequent calls to strftime(3C) above. 360 */ 361 if (fmd_prop_get_int32(hdl, "gmt") == FMD_B_TRUE && 362 ((tz = getenv("TZ")) == NULL || strcmp(tz, "GMT") != 0)) { 363 (void) putenv(fmd_hdl_strdup(hdl, "TZ=GMT", FMD_SLEEP)); 364 tzset(); /* reload env */ 365 } 366 367 /* 368 * Look up the value of the "facility" property and use it to determine 369 * what syslog LOG_* facility value we use to fill in our log_ctl_t. 370 * The details of our logging method are described above syslog_emit(). 371 */ 372 facname = fmd_prop_get_string(hdl, "facility"); 373 374 for (fp = syslog_facs; fp->fac_name != NULL; fp++) { 375 if (strcmp(fp->fac_name, facname) == 0) 376 break; 377 } 378 379 if (fp->fac_name == NULL) 380 fmd_hdl_abort(hdl, "invalid 'facility' setting: %s\n", facname); 381 382 fmd_prop_free_string(hdl, facname); 383 syslog_ctl.pri = fp->fac_value; 384 syslog_ctl.flags = SL_CONSOLE | SL_LOGONLY; 385 386 /* 387 * Cache any properties we use every time we receive an event and 388 * subscribe to list.suspect events regardless of the .conf file. 389 */ 390 syslog_file = fmd_prop_get_int32(hdl, "syslogd"); 391 syslog_cons = fmd_prop_get_int32(hdl, "console"); 392 syslog_msgall = fmd_prop_get_int32(hdl, "message_all"); 393 394 rootdir = fmd_prop_get_string(hdl, "fmd.rootdir"); 395 syslog_msghdl = fmd_msg_init(rootdir, FMD_MSG_VERSION); 396 fmd_prop_free_string(hdl, rootdir); 397 398 if (syslog_msghdl == NULL) 399 fmd_hdl_abort(hdl, "failed to initialize libfmd_msg"); 400 401 urlbase = fmd_prop_get_string(hdl, "url"); 402 (void) fmd_msg_url_set(syslog_msghdl, urlbase); 403 fmd_prop_free_string(hdl, urlbase); 404 405 /* 406 * We subscribe to all FM events and then consult the notification 407 * preferences in the serice configuration repo to determine whether 408 * or not to emit a console message. 409 */ 410 fmd_hdl_subscribe(hdl, FM_LIST_SUSPECT_CLASS); 411 fmd_hdl_subscribe(hdl, FM_LIST_REPAIRED_CLASS); 412 fmd_hdl_subscribe(hdl, FM_LIST_RESOLVED_CLASS); 413 fmd_hdl_subscribe(hdl, FM_LIST_ISOLATED_CLASS); 414 fmd_hdl_subscribe(hdl, FM_LIST_UPDATED_CLASS); 415 } 416 417 /*ARGSUSED*/ 418 void 419 _fmd_fini(fmd_hdl_t *hdl) 420 { 421 fmd_msg_fini(syslog_msghdl); 422 (void) close(syslog_logfd); 423 (void) close(syslog_msgfd); 424 } 425