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 }