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

/*
 * Copyright (c) 2018, Joyent, Inc.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <alloca.h>
#include <errno.h>
#include <fcntl.h>
#include <libscf.h>
#include <priv_utils.h>
#include <netdb.h>
#include <signal.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include <zone.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fm/fmd_msg.h>
#include <fm/libfmevent.h>
#include "libfmnotify.h"

#define SENDMAIL        "/usr/sbin/sendmail"
#define SVCNAME         "system/fm/smtp-notify"

#define XHDR_HOSTNAME           "X-FMEV-HOSTNAME"
#define XHDR_CLASS              "X-FMEV-CLASS"
#define XHDR_UUID               "X-FMEV-UUID"
#define XHDR_MSGID              "X-FMEV-CODE"
#define XHDR_SEVERITY           "X-FMEV-SEVERITY"
#define XHDR_FMRI               "X-FMEV-FMRI"
#define XHDR_FROM_STATE         "X-FMEV-FROM-STATE"
#define XHDR_TO_STATE           "X-FMEV-TO-STATE"

/*
 * Debug messages can be enabled by setting the debug property to true
 *
 * # svccfg -s svc:/system/fm/smtp-notify setprop config/debug=true
 *
 * Debug messages will be spooled to the service log at:
 * <root>/var/svc/log/system-fm-smtp-notify:default.log
 */
#define PP_SCRIPT "usr/lib/fm/notify/process_msg_template.sh"

typedef struct email_pref
{
        int ep_num_recips;
        char **ep_recips;
        char *ep_reply_to;
        char *ep_template_path;
        char *ep_template;
} email_pref_t;

static nd_hdl_t *nhdl;
static char hostname[MAXHOSTNAMELEN + 1];
static const char optstr[] = "dfR:";
static const char DEF_SUBJ_TEMPLATE[] = "smtp-notify-subject-template";
static const char SMF_SUBJ_TEMPLATE[] = "smtp-notify-smf-subject-template";
static const char FM_SUBJ_TEMPLATE[] = "smtp-notify-fm-subject-template";
static const char IREPORT_MSG_TEMPLATE[] = "ireport-msg-template";
static const char SMF_MSG_TEMPLATE[] = "ireport.os.smf-msg-template";

static int
usage(const char *pname)
{
        (void) fprintf(stderr, "Usage: %s [-df] [-R <altroot>]\n", pname);

        (void) fprintf(stderr,
            "\t-d  enable debug mode\n"
            "\t-f  stay in foreground\n"
            "\t-R  specify alternate root\n");

        return (1);
}

/*
 * This function simply reads the file specified by "template" into a buffer
 * and returns a pointer to that buffer (or NULL on failure).  The caller is
 * responsible for free'ing the returned buffer.
 */
static char *
read_template(const char *template)
{
        int fd;
        struct stat statb;
        char *buf;

        if (stat(template, &statb) != 0) {
                nd_error(nhdl, "Failed to stat %s (%s)", template,
                    strerror(errno));
                return (NULL);
        }
        if ((fd = open(template, O_RDONLY)) < 0) {
                nd_error(nhdl, "Failed to open %s (%s)", template,
                    strerror(errno));
                return (NULL);
        }
        if ((buf = malloc(statb.st_size + 1)) == NULL) {
                nd_error(nhdl, "Failed to allocate %d bytes", statb.st_size);
                (void) close(fd);
                return (NULL);
        }
        if (read(fd, buf, statb.st_size) < 0) {
                nd_error(nhdl, "Failed to read in template (%s)",
                    strerror(errno));
                free(buf);
                (void) close(fd);
                return (NULL);
        }
        buf[statb.st_size] = '\0';
        (void) close(fd);
        return (buf);
}

/*
 * This function runs a user-supplied message body template through a script
 * which replaces the "committed" expansion macros with actual libfmd_msg
 * expansion macros.
 */
static int
process_template(nd_ev_info_t *ev_info, email_pref_t *eprefs)
{
        char pp_script[PATH_MAX], tmpfile[PATH_MAX], pp_cli[PATH_MAX];
        int ret = -1;

        (void) snprintf(pp_script, sizeof (pp_script), "%s%s",
            nhdl->nh_rootdir, PP_SCRIPT);
        (void) snprintf(tmpfile, sizeof (tmpfile), "%s%s",
            nhdl->nh_rootdir, tmpnam(NULL));

        /*
         * If it's an SMF event, then the diagcode and severity won't be part
         * of the event payload and so libfmd_msg won't be able to expand them.
         * Therefore we pass the code and severity into the script and let the
         * script do the expansion.
         */
        /* LINTED: E_SEC_SPRINTF_UNBOUNDED_COPY */
        (void) sprintf(pp_cli, "%s %s %s %s %s", pp_script,
            eprefs->ep_template_path, tmpfile, ev_info->ei_diagcode,
            ev_info->ei_severity);

        nd_debug(nhdl, "Executing %s", pp_cli);
        if (system(pp_cli) != -1)
                if ((eprefs->ep_template = read_template(tmpfile)) != NULL)
                        ret = 0;

        (void) unlink(tmpfile);
        return (ret);
}

/*
 * If someone does an "svcadm refresh" on us, then this function gets called,
 * which rereads our service configuration.
 */
static void
get_svc_config()
{
        int s = 0;
        uint8_t val;

        s = nd_get_boolean_prop(nhdl, SVCNAME, "config", "debug", &val);
        nhdl->nh_debug = val;

        s += nd_get_astring_prop(nhdl, SVCNAME, "config", "rootdir",
            &(nhdl->nh_rootdir));

        if (s != 0)
                nd_error(nhdl, "Failed to read retrieve service "
                    "properties\n");
}

static void
nd_sighandler(int sig)
{
        if (sig == SIGHUP)
                get_svc_config();
        else
                nd_cleanup(nhdl);
}

/*
 * This function constructs all the email headers and puts them into the
 * "headers" buffer handle.  The caller is responsible for free'ing this
 * buffer.
 */
static int
build_headers(nd_hdl_t *nhdl, nd_ev_info_t *ev_info, email_pref_t *eprefs,
    char **headers)
{
        const char *subj_key;
        char *subj_fmt, *subj = NULL;
        size_t len;
        boolean_t is_smf_event = B_FALSE, is_fm_event = B_FALSE;

        /*
         * Fetch and format the email subject.
         */
        if (strncmp(ev_info->ei_class, "list.", 5) == 0) {
                is_fm_event = B_TRUE;
                subj_key = FM_SUBJ_TEMPLATE;
        } else if (strncmp(ev_info->ei_class, "ireport.os.smf", 14) == 0) {
                is_smf_event = B_TRUE;
                subj_key = SMF_SUBJ_TEMPLATE;
        } else {
                subj_key = DEF_SUBJ_TEMPLATE;
        }

        if ((subj_fmt = fmd_msg_gettext_key(nhdl->nh_msghdl, NULL,
            FMNOTIFY_MSG_DOMAIN, subj_key)) == NULL) {
                nd_error(nhdl, "Failed to contruct subject format");
                return (-1); /* libfmd_msg error */
        }

        if (is_fm_event) {
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                len = snprintf(NULL, 0, subj_fmt, hostname,
                    ev_info->ei_diagcode);
                subj = alloca(len + 1);
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                (void) snprintf(subj, len + 1, subj_fmt, hostname,
                    ev_info->ei_diagcode);
        } else if (is_smf_event) {
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                len = snprintf(NULL, 0, subj_fmt, hostname, ev_info->ei_fmri,
                    ev_info->ei_from_state, ev_info->ei_to_state);
                subj = alloca(len + 1);
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                (void) snprintf(subj, len + 1, subj_fmt, hostname,
                    ev_info->ei_fmri, ev_info->ei_from_state,
                    ev_info->ei_to_state);
        } else {
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                len = snprintf(NULL, 0, subj_fmt, hostname);
                subj = alloca(len + 1);
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                (void) snprintf(subj, len + 1, subj_fmt, hostname);
        }

        /*
         * Here we add some X-headers to our mail message for use by mail
         * filtering agents.  We add headers for the following bits of event
         * data for all events
         *
         * hostname
         * msg id (diagcode)
         * event class
         * event severity
         * event uuid
         *
         * For SMF transition events, we'll have the following add'l X-headers
         *
         * from-state
         * to-state
         * service fmri
         *
         * We follow the X-headers with standard Reply-To and Subject headers.
         */
        if (is_fm_event) {
                len = snprintf(NULL, 0, "%s: %s\n%s: %s\n%s: %s\n%s: %s\n"
                    "%s: %s\nReply-To: %s\nSubject: %s\n\n", XHDR_HOSTNAME,
                    hostname, XHDR_CLASS, ev_info->ei_class, XHDR_UUID,
                    ev_info->ei_uuid, XHDR_MSGID, ev_info->ei_diagcode,
                    XHDR_SEVERITY, ev_info->ei_severity, eprefs->ep_reply_to,
                    subj);

                *headers = calloc(len + 1, sizeof (char));

                (void) snprintf(*headers, len + 1, "%s: %s\n%s: %s\n%s: %s\n"
                    "%s: %s\n%s: %s\nReply-To: %s\nSubject: %s\n\n",
                    XHDR_HOSTNAME, hostname, XHDR_CLASS, ev_info->ei_class,
                    XHDR_UUID, ev_info->ei_uuid, XHDR_MSGID,
                    ev_info->ei_diagcode, XHDR_SEVERITY, ev_info->ei_severity,
                    eprefs->ep_reply_to, subj);
        } else if (is_smf_event) {
                len = snprintf(NULL, 0, "%s: %s\n%s: %s\n%s: %s\n%s: %s\n"
                    "%s: %s\n%s: %s\n%s: %s\nReply-To: %s\n"
                    "Subject: %s\n\n", XHDR_HOSTNAME, hostname, XHDR_CLASS,
                    ev_info->ei_class, XHDR_MSGID, ev_info->ei_diagcode,
                    XHDR_SEVERITY, ev_info->ei_severity, XHDR_FMRI,
                    ev_info->ei_fmri, XHDR_FROM_STATE, ev_info->ei_from_state,
                    XHDR_TO_STATE, ev_info->ei_to_state, eprefs->ep_reply_to,
                    subj);

                *headers = calloc(len + 1, sizeof (char));

                (void) snprintf(*headers, len + 1, "%s: %s\n%s: %s\n%s: %s\n"
                    "%s: %s\n%s: %s\n%s: %s\n%s: %s\nReply-To: %s\n"
                    "Subject: %s\n\n", XHDR_HOSTNAME, hostname, XHDR_CLASS,
                    ev_info->ei_class, XHDR_MSGID, ev_info->ei_diagcode,
                    XHDR_SEVERITY, ev_info->ei_severity, XHDR_FMRI,
                    ev_info->ei_fmri, XHDR_FROM_STATE, ev_info->ei_from_state,
                    XHDR_TO_STATE, ev_info->ei_to_state, eprefs->ep_reply_to,
                    subj);
        } else {
                len = snprintf(NULL, 0, "%s: %s\n%s: %s\n%s: %s\n%s: %s\n"
                    "Reply-To: %s\nSubject: %s\n\n", XHDR_HOSTNAME,
                    hostname, XHDR_CLASS, ev_info->ei_class, XHDR_MSGID,
                    ev_info->ei_diagcode, XHDR_SEVERITY, ev_info->ei_severity,
                    eprefs->ep_reply_to, subj);

                *headers = calloc(len + 1, sizeof (char));

                (void) snprintf(*headers, len + 1, "%s: %s\n%s: %s\n%s: %s\n"
                    "%s: %s\nReply-To: %s\nSubject: %s\n\n",
                    XHDR_HOSTNAME, hostname, XHDR_CLASS, ev_info->ei_class,
                    XHDR_MSGID, ev_info->ei_diagcode, XHDR_SEVERITY,
                    ev_info->ei_severity, eprefs->ep_reply_to, subj);
        }
        return (0);
}

static void
send_email(nd_hdl_t *nhdl, const char *headers, const char *body,
    const char *recip)
{
        FILE *mp;
        char sm_cli[PATH_MAX];

        /*
         * Open a pipe to sendmail and pump out the email message
         */
        (void) snprintf(sm_cli, PATH_MAX, "%s -t %s", SENDMAIL, recip);

        nd_debug(nhdl, "Sending email notification to %s", recip);
        if ((mp = popen(sm_cli, "w")) == NULL) {
                nd_error(nhdl, "Failed to open pipe to %s (%s)", SENDMAIL,
                    strerror(errno));
                return;
        }
        if (fprintf(mp, "%s", headers) < 0)
                nd_error(nhdl, "Failed to write to pipe (%s)", strerror(errno));

        if (fprintf(mp, "%s\n.\n", body) < 0)
                nd_error(nhdl, "Failed to write to pipe (%s)",
                    strerror(errno));

        (void) pclose(mp);
}

static void
send_email_template(nd_hdl_t *nhdl, nd_ev_info_t *ev_info, email_pref_t *eprefs)
{
        char *msg, *headers;

        if (build_headers(nhdl, ev_info, eprefs, &headers) != 0)
                return;

        /*
         * If the user specified a message body template, then we pass it
         * through a private interface in libfmd_msg, which will return a string
         * with any expansion tokens decoded.
         */
        if ((msg = fmd_msg_decode_tokens(ev_info->ei_payload,
            eprefs->ep_template, ev_info->ei_url)) == NULL) {
                nd_error(nhdl, "Failed to parse msg template");
                free(headers);
                return;
        }
        for (int i = 0; i < eprefs->ep_num_recips; i++)
                send_email(nhdl, headers, msg, eprefs->ep_recips[i]);

        free(msg);
        free(headers);
}

static int
get_email_prefs(nd_hdl_t *nhdl, fmev_t ev, email_pref_t **eprefs)
{
        nvlist_t **p_nvl = NULL;
        email_pref_t *ep;
        uint_t npref, tn1 = 0, tn2 = 0;
        char **tmparr1, **tmparr2;
        int r, ret = -1;

        r = nd_get_notify_prefs(nhdl, "smtp", ev, &p_nvl, &npref);
        if (r == SCF_ERROR_NOT_FOUND) {
                /*
                 * No email notification preferences specified for this type of
                 * event, so we're done
                 */
                return (-1);
        } else if (r != 0) {
                nd_error(nhdl, "Failed to retrieve notification preferences "
                    "for this event");
                return (-1);
        }

        if ((ep = malloc(sizeof (email_pref_t))) == NULL) {
                nd_error(nhdl, "Failed to allocate space for email preferences "
                    "(%s)", strerror(errno));
                goto eprefs_done;
        }
        (void) memset(ep, 0, sizeof (email_pref_t));

        /*
         * For SMF state transition events, pref_nvl may contain two sets of
         * preferences, which will have to be merged.
         *
         * The "smtp" nvlist can contain up to four members:
         *
         * "active"     - boolean - used to toggle notfications
         * "to"         - a string array of email recipients
         * "reply-to"   - a string array containing the reply-to addresses
         *              - this is optional and defaults to root@localhost
         * "msg_template" - the pathname of a user-supplied message body
         *              template
         *
         * In the case that we have two sets of preferences, we will merge them
         * using the following rules:
         *
         * "active" will be set to true, if it is true in either set
         *
         * The "reply-to" and "to" lists will be merged, with duplicate email
         * addresses removed.
         */
        if (npref == 2) {
                boolean_t *act1, *act2;
                char **arr1, **arr2, **strarr, **reparr1, **reparr2;
                uint_t n1, n2, arrsz, repsz;

                r = nvlist_lookup_boolean_array(p_nvl[0], "active", &act1, &n1);
                r += nvlist_lookup_boolean_array(p_nvl[1], "active", &act2,
                    &n2);
                r += nvlist_lookup_string_array(p_nvl[0], "to", &arr1, &n1);
                r += nvlist_lookup_string_array(p_nvl[1], "to", &arr2, &n2);

                if (r != 0) {
                        nd_error(nhdl, "Malformed email notification "
                            "preferences");
                        nd_dump_nvlist(nhdl, p_nvl[0]);
                        nd_dump_nvlist(nhdl, p_nvl[1]);
                        goto eprefs_done;
                } else if (!act1[0] && !act2[0]) {
                        nd_debug(nhdl, "Email notification is disabled");
                        goto eprefs_done;
                }

                if (nd_split_list(nhdl, arr1[0], ",", &tmparr1, &tn1) != 0 ||
                    nd_split_list(nhdl, arr2[0], ",", &tmparr2, &tn2) != 0) {
                        nd_error(nhdl, "Error parsing \"to\" lists");
                        nd_dump_nvlist(nhdl, p_nvl[0]);
                        nd_dump_nvlist(nhdl, p_nvl[1]);
                        goto eprefs_done;
                }

                if ((ep->ep_num_recips = nd_merge_strarray(nhdl, tmparr1, tn1,
                    tmparr2, tn2, &ep->ep_recips)) < 0) {
                        nd_error(nhdl, "Error merging email recipient lists");
                        goto eprefs_done;
                }

                r = nvlist_lookup_string_array(p_nvl[0], "reply-to", &arr1,
                    &n1);
                r += nvlist_lookup_string_array(p_nvl[1], "reply-to", &arr2,
                    &n2);
                repsz = n1 = n2 = 0;
                if (!r &&
                    nd_split_list(nhdl, arr1[0], ",", &reparr1, &n1) != 0 ||
                    nd_split_list(nhdl, arr2[0], ",", &reparr2, &n2) != 0 ||
                    (repsz = nd_merge_strarray(nhdl, tmparr1, n1, tmparr2, n2,
                    &strarr)) != 0 ||
                    nd_join_strarray(nhdl, strarr, repsz, &ep->ep_reply_to)
                    != 0) {

                        ep->ep_reply_to = strdup("root@localhost");
                }
                if (n1)
                        nd_free_strarray(reparr1, n1);
                if (n2)
                        nd_free_strarray(reparr2, n2);
                if (repsz > 0)
                        nd_free_strarray(strarr, repsz);

                if (nvlist_lookup_string_array(p_nvl[0], "msg_template",
                    &strarr, &arrsz) == 0)
                        ep->ep_template_path = strdup(strarr[0]);
        } else {
                char **strarr, **tmparr;
                uint_t arrsz;
                boolean_t *active;

                /*
                 * Both the "active" and "to" notification preferences are
                 * required, so if we have trouble looking either of these up
                 * we return an error.  We will also return an error if "active"
                 * is set to false.  Returning an error will cause us to not
                 * send a notification for this event.
                 */
                r = nvlist_lookup_boolean_array(p_nvl[0], "active", &active,
                    &arrsz);
                r += nvlist_lookup_string_array(p_nvl[0], "to", &strarr,
                    &arrsz);

                if (r != 0) {
                        nd_error(nhdl, "Malformed email notification "
                            "preferences");
                        nd_dump_nvlist(nhdl, p_nvl[0]);
                        goto eprefs_done;
                } else if (!active[0]) {
                        nd_debug(nhdl, "Email notification is disabled");
                        goto eprefs_done;
                }

                if (nd_split_list(nhdl, strarr[0], ",", &tmparr, &arrsz)
                    != 0) {
                        nd_error(nhdl, "Error parsing \"to\" list");
                        goto eprefs_done;
                }
                ep->ep_num_recips = arrsz;
                ep->ep_recips = tmparr;

                if (nvlist_lookup_string_array(p_nvl[0], "msg_template",
                    &strarr, &arrsz) == 0)
                        ep->ep_template_path = strdup(strarr[0]);

                if (nvlist_lookup_string_array(p_nvl[0], "reply-to", &strarr,
                    &arrsz) == 0)
                        ep->ep_reply_to = strdup(strarr[0]);
                else
                        ep->ep_reply_to = strdup("root@localhost");
        }
        ret = 0;
        *eprefs = ep;
eprefs_done:
        if (ret != 0) {
                if (ep->ep_recips)
                        nd_free_strarray(ep->ep_recips, ep->ep_num_recips);
                if (ep->ep_reply_to)
                        free(ep->ep_reply_to);
                free(ep);
        }
        if (tn1)
                nd_free_strarray(tmparr1, tn1);
        if (tn2)
                nd_free_strarray(tmparr2, tn2);
        nd_free_nvlarray(p_nvl, npref);

        return (ret);
}

/*ARGSUSED*/
static void
irpt_cbfunc(fmev_t ev, const char *class, nvlist_t *nvl, void *arg)
{
        char *body_fmt, *headers = NULL, *body = NULL, tstamp[32];
        struct tm ts;
        size_t len;
        nd_ev_info_t *ev_info = NULL;
        email_pref_t *eprefs;

        nd_debug(nhdl, "Received event of class %s", class);

        if (get_email_prefs(nhdl, ev, &eprefs) < 0)
                return;

        if (nd_get_event_info(nhdl, class, ev, &ev_info) != 0)
                goto irpt_done;

        /*
         * If the user specified a template, then we pass it through a script,
         * which post-processes any expansion macros.  Then we attempt to read
         * it in and then send the message.  Otherwise we carry on with the rest
         * of this function which will contruct the message body from one of the
         * default templates.
         */
        if (eprefs->ep_template != NULL)
                free(eprefs->ep_template);

        if (eprefs->ep_template_path != NULL &&
            process_template(ev_info, eprefs) == 0) {
                send_email_template(nhdl, ev_info, eprefs);
                goto irpt_done;
        }

        /*
         * Fetch and format the event timestamp
         */
        if (fmev_localtime(ev, &ts) == NULL) {
                nd_error(nhdl, "Malformed event: failed to retrieve "
                    "timestamp");
                goto irpt_done;
        }
        (void) strftime(tstamp, sizeof (tstamp), NULL, &ts);

        /*
         * We have two message body templates to choose from.  One for SMF
         * service transition events and a generic one for any other
         * uncommitted ireport.
         */
        if (strncmp(class, "ireport.os.smf", 14) == 0) {
                /*
                 * For SMF state transition events we have a standard message
                 * template that we fill in based on the payload of the event.
                 */
                if ((body_fmt = fmd_msg_gettext_key(nhdl->nh_msghdl, NULL,
                    FMNOTIFY_MSG_DOMAIN, SMF_MSG_TEMPLATE)) == NULL) {
                        nd_error(nhdl, "Failed to format message body");
                        goto irpt_done;
                }

                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                len = snprintf(NULL, 0, body_fmt, hostname, tstamp,
                    ev_info->ei_fmri, ev_info->ei_from_state,
                    ev_info->ei_to_state, ev_info->ei_descr,
                    ev_info->ei_reason);
                body = calloc(len, sizeof (char));
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                (void) snprintf(body, len, body_fmt, hostname, tstamp,
                    ev_info->ei_fmri, ev_info->ei_from_state,
                    ev_info->ei_to_state, ev_info->ei_descr,
                    ev_info->ei_reason);
        } else {
                if ((body_fmt = fmd_msg_gettext_key(nhdl->nh_msghdl, NULL,
                    FMNOTIFY_MSG_DOMAIN, IREPORT_MSG_TEMPLATE)) == NULL) {
                        nd_error(nhdl, "Failed to format message body");
                        goto irpt_done;
                }
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                len = snprintf(NULL, 0, body_fmt, hostname, tstamp, class);
                body = calloc(len, sizeof (char));
                /* LINTED: E_SEC_PRINTF_VAR_FMT */
                (void) snprintf(body, len, body_fmt, hostname, tstamp, class);
        }

        if (build_headers(nhdl, ev_info, eprefs, &headers) != 0)
                goto irpt_done;

        /*
         * Everything is ready, so now we just iterate through the list of
         * recipents, sending an email notification to each one.
         */
        for (int i = 0; i < eprefs->ep_num_recips; i++)
                send_email(nhdl, headers, body, eprefs->ep_recips[i]);

irpt_done:
        free(headers);
        free(body);
        if (ev_info)
                nd_free_event_info(ev_info);
        if (eprefs->ep_recips)
                nd_free_strarray(eprefs->ep_recips, eprefs->ep_num_recips);
        if (eprefs->ep_reply_to)
                free(eprefs->ep_reply_to);
        free(eprefs);
}

/*
 * There is a lack of uniformity in how the various entries in our diagnosis
 * are terminated.  Some end with one newline, others with two.  This makes the
 * output look a bit ugly.  Therefore we postprocess the message before sending
 * it, removing consecutive occurences of newlines.
 */
static void
postprocess_msg(char *msg)
{
        int i = 0, j = 0;
        char *buf;

        if ((buf = malloc(strlen(msg) + 1)) == NULL)
                return;

        buf[j++] = msg[i++];
        for (i = 1; i < strlen(msg); i++) {
                if (!(msg[i] == '\n' && msg[i - 1] == '\n'))
                        buf[j++] = msg[i];
        }
        buf[j] = '\0';
        (void) strncpy(msg, buf, j+1);
        free(buf);
}

/*ARGSUSED*/
static void
listev_cb(fmev_t ev, const char *class, nvlist_t *nvl, void *arg)
{
        char *body = NULL, *headers = NULL;
        nd_ev_info_t *ev_info = NULL;
        boolean_t domsg;
        email_pref_t *eprefs;

        nd_debug(nhdl, "Received event of class %s", class);

        if (get_email_prefs(nhdl, ev, &eprefs) < 0)
                return;

        if (nd_get_event_info(nhdl, class, ev, &ev_info) != 0)
                goto listcb_done;

        /*
         * If the message payload member is set to 0, then it's an event we
         * typically suppress messaging on, so we won't send an email for it.
         */
        if (nvlist_lookup_boolean_value(ev_info->ei_payload, FM_SUSPECT_MESSAGE,
            &domsg) == 0 && !domsg) {
                nd_debug(nhdl, "Messaging suppressed for this event");
                goto listcb_done;
        }

        /*
         * If the user specified a template, then we pass it through a script,
         * which post-processes any expansion macros.  Then we attempt to read
         * it in and then send the message.  Otherwise we carry on with the rest
         * of this function which will contruct the message body from one of the
         * default templates.
         */
        if (eprefs->ep_template != NULL)
                free(eprefs->ep_template);

        if (eprefs->ep_template_path != NULL &&
            process_template(ev_info, eprefs) == 0) {
                send_email_template(nhdl, ev_info, eprefs);
                goto listcb_done;
        }

        /*
         * Format the message body
         *
         * For FMA list.* events we use the same message that the
         * syslog-msgs agent would emit as the message body
         *
         */
        if ((body = fmd_msg_gettext_nv(nhdl->nh_msghdl, NULL,
            ev_info->ei_payload)) == NULL) {
                nd_error(nhdl, "Failed to format message body");
                nd_dump_nvlist(nhdl, ev_info->ei_payload);
                goto listcb_done;
        }
        postprocess_msg(body);

        if (build_headers(nhdl, ev_info, eprefs, &headers) != 0)
                goto listcb_done;

        /*
         * Everything is ready, so now we just iterate through the list of
         * recipents, sending an email notification to each one.
         */
        for (int i = 0; i < eprefs->ep_num_recips; i++)
                send_email(nhdl, headers, body, eprefs->ep_recips[i]);

listcb_done:
        free(headers);
        free(body);
        if (ev_info)
                nd_free_event_info(ev_info);
        if (eprefs->ep_recips)
                nd_free_strarray(eprefs->ep_recips, eprefs->ep_num_recips);
        if (eprefs->ep_reply_to)
                free(eprefs->ep_reply_to);
        free(eprefs);
}

int
main(int argc, char *argv[])
{
        struct rlimit rlim;
        struct sigaction act;
        sigset_t set;
        int c;
        boolean_t run_fg = B_FALSE;

        if ((nhdl = malloc(sizeof (nd_hdl_t))) == NULL) {
                (void) fprintf(stderr, "Failed to allocate space for notifyd "
                    "handle (%s)", strerror(errno));
                return (1);
        }
        (void) memset(nhdl, 0, sizeof (nd_hdl_t));

        nhdl->nh_keep_running = B_TRUE;
        nhdl->nh_log_fd = stderr;
        nhdl->nh_pname = argv[0];

        get_svc_config();

        /*
         * In the case where we get started outside of SMF, args passed on the
         * command line override SMF property setting
         */
        while (optind < argc) {
                while ((c = getopt(argc, argv, optstr)) != -1) {
                        switch (c) {
                        case 'd':
                                nhdl->nh_debug = B_TRUE;
                                break;
                        case 'f':
                                run_fg = B_TRUE;
                                break;
                        case 'R':
                                nhdl->nh_rootdir = strdup(optarg);
                                break;
                        default:
                                free(nhdl);
                                return (usage(argv[0]));
                        }
                }
        }

        /*
         * Set up a signal handler for SIGTERM (and SIGINT if we'll
         * be running in the foreground) to ensure sure we get a chance to exit
         * in an orderly fashion.  We also catch SIGHUP, which will be sent to
         * us by SMF if the service is refreshed.
         */
        (void) sigfillset(&set);
        (void) sigfillset(&act.sa_mask);
        act.sa_handler = nd_sighandler;
        act.sa_flags = 0;

        (void) sigaction(SIGTERM, &act, NULL);
        (void) sigdelset(&set, SIGTERM);
        (void) sigaction(SIGHUP, &act, NULL);
        (void) sigdelset(&set, SIGHUP);

        if (run_fg) {
                (void) sigaction(SIGINT, &act, NULL);
                (void) sigdelset(&set, SIGINT);
        } else
                nd_daemonize(nhdl);

        rlim.rlim_cur = RLIM_INFINITY;
        rlim.rlim_max = RLIM_INFINITY;
        (void) setrlimit(RLIMIT_CORE, &rlim);

        /*
         * We need to be root to initialize our libfmevent handle (because that
         * involves reading/writing to /dev/sysevent), so we do this before
         * calling __init_daemon_priv.
         */
        nhdl->nh_evhdl = fmev_shdl_init(LIBFMEVENT_VERSION_2, NULL, NULL, NULL);
        if (nhdl->nh_evhdl == NULL) {
                (void) sleep(5);
                nd_abort(nhdl, "failed to initialize libfmevent: %s",
                    fmev_strerror(fmev_errno));
        }

        /*
         * If we're in the global zone, reset all of our privilege sets to
         * the minimum set of required privileges.  Since we've already
         * initialized our libmevent handle, we no no longer need to run as
         * root, so we change our uid/gid to noaccess (60002).
         *
         * __init_daemon_priv will also set the process core path for us
         *
         */
        if (getzoneid() == GLOBAL_ZONEID)
                if (__init_daemon_priv(
                    PU_RESETGROUPS | PU_LIMITPRIVS | PU_INHERITPRIVS,
                    60002, 60002, PRIV_PROC_SETID, NULL) != 0)
                        nd_abort(nhdl, "additional privileges required to run");

        nhdl->nh_msghdl = fmd_msg_init(nhdl->nh_rootdir, FMD_MSG_VERSION);
        if (nhdl->nh_msghdl == NULL)
                nd_abort(nhdl, "failed to initialize libfmd_msg");

        (void) gethostname(hostname, MAXHOSTNAMELEN + 1);
        /*
         * Set up our event subscriptions.  We subscribe to everything and then
         * consult libscf when we receive an event to determine whether to send
         * an email notification.
         */
        nd_debug(nhdl, "Subscribing to ireport.* events");
        if (fmev_shdl_subscribe(nhdl->nh_evhdl, "ireport.*", irpt_cbfunc,
            NULL) != FMEV_SUCCESS) {
                nd_abort(nhdl, "fmev_shdl_subscribe failed: %s",
                    fmev_strerror(fmev_errno));
        }

        nd_debug(nhdl, "Subscribing to list.* events");
        if (fmev_shdl_subscribe(nhdl->nh_evhdl, "list.*", listev_cb,
            NULL) != FMEV_SUCCESS) {
                nd_abort(nhdl, "fmev_shdl_subscribe failed: %s",
                    fmev_strerror(fmev_errno));
        }

        /*
         * We run until someone kills us
         */
        while (nhdl->nh_keep_running)
                (void) sigsuspend(&set);

        free(nhdl->nh_rootdir);
        free(nhdl);

        return (0);
}