/*
 * 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.
 */

/*
 * Receive (on GPEC channels) raw events published by a few select producers
 * using the private libfmevent publication interfaces, and massage those
 * raw events into full protocol events.  Each raw event selects a "ruleset"
 * by which to perform the transformation into a protocol event.
 *
 * Only publication from userland running privileged is supported; two
 * channels are used - one for high-value and one for low-value events.
 * There is some planning in the implementation below for kernel hi and low
 * value channels, and for non-privileged userland low and hi value channels.
 */

#include <fm/fmd_api.h>
#include <fm/libfmevent.h>
#include <uuid/uuid.h>
#include <libsysevent.h>
#include <pthread.h>
#include <libnvpair.h>
#include <strings.h>
#include <zone.h>

#include "fmevt.h"

static struct fmevt_inbound_stats {
        fmd_stat_t raw_callbacks;
        fmd_stat_t raw_noattrlist;
        fmd_stat_t raw_nodetector;
        fmd_stat_t pp_bad_ruleset;
        fmd_stat_t pp_explicitdrop;
        fmd_stat_t pp_fallthrurule;
        fmd_stat_t pp_fanoutmax;
        fmd_stat_t pp_intldrop;
        fmd_stat_t pp_badclass;
        fmd_stat_t pp_nvlallocfail;
        fmd_stat_t pp_nvlbuildfail;
        fmd_stat_t pp_badreturn;
        fmd_stat_t xprt_posted;
} inbound_stats = {
        { "raw_callbacks", FMD_TYPE_UINT64,
            "total raw event callbacks from producers" },
        { "raw_noattrlist", FMD_TYPE_UINT64,
            "missing attribute list" },
        { "raw_nodetector", FMD_TYPE_UINT64,
            "unable to add detector" },
        { "pp_bad_ruleset", FMD_TYPE_UINT64,
            "post-process bad ruleset" },
        { "pp_explicitdrop", FMD_TYPE_UINT64,
            "ruleset drops event with NULL func" },
        { "pp_fanoutmax", FMD_TYPE_UINT64,
            "post-processing produced too many events" },
        { "pp_intldrop", FMD_TYPE_UINT64,
            "post-processing requested event drop" },
        { "pp_badclass", FMD_TYPE_UINT64,
            "post-processing produced invalid event class" },
        { "pp_nvlallocfail", FMD_TYPE_UINT64,
            "fmd_nvl_alloc failed" },
        { "pp_nvlbuildfail", FMD_TYPE_UINT64,
            "nvlist_add_foo failed in building event" },
        { "pp_badreturn", FMD_TYPE_UINT64,
            "inconsistent number of events returned" },
        { "xprt_posted", FMD_TYPE_UINT64,
            "protocol events posted with fmd_xprt_post" },
};

static int isglobalzone;
static char zonename[ZONENAME_MAX];

#define BUMPSTAT(stat)  inbound_stats.stat.fmds_value.ui64++

#define CBF_USER        0x1U
#define CBF_PRIV        0x2U
#define CBF_LV          0x4U
#define CBF_HV          0x8U
#define CBF_ALL         (CBF_USER | CBF_PRIV | CBF_LV | CBF_HV)

static struct fmevt_chaninfo {
        const char *ci_propname;        /* property to get channel name */
        evchan_t *ci_binding;           /* GPEC binding for this channel */
        char ci_sid[MAX_SUBID_LEN];     /* subscriber id */
        uint32_t ci_cbarg;              /* callback cookie */
        uint32_t ci_sflags;             /* subscription flags to use */
} chaninfo[] = {
        { "user_priv_highval_channel", NULL, { 0 },
                CBF_USER | CBF_PRIV | CBF_HV, EVCH_SUB_KEEP },
        { "user_priv_lowval_channel", NULL, { 0 },
                CBF_USER | CBF_PRIV | CBF_LV, EVCH_SUB_KEEP },
};

static pthread_cond_t fmevt_cv = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t fmevt_lock = PTHREAD_MUTEX_INITIALIZER;
static int fmevt_exiting;

static fmd_xprt_t *fmevt_xprt;
static uint32_t fmevt_xprt_refcnt;
static sysevent_subattr_t *subattr;

/*
 * Rulesets we recognize and who handles them.  Additions and changes
 * must follow the Portfolio Review process.  At ths time only
 * the FMEV_RULESET_ON_SUNOS and FMEVT_RULESET_SMF rulesets are
 * formally recognized by that process - the others here are experimental.
 */
static struct fmevt_rs {
        char *rs_pat;
        fmevt_pp_func_t *rs_ppfunc;
        char *rs_namespace;
        char *rs_subsys;
} rulelist[] = {
        { FMEV_RULESET_SMF, fmevt_pp_smf },
        { FMEV_RULESET_ON_EREPORT, fmevt_pp_on_ereport },
        { FMEV_RULESET_ON_SUNOS, fmevt_pp_on_sunos },
        { FMEV_RULESET_ON_PRIVATE, fmevt_pp_on_private },
        { FMEV_RULESET_UNREGISTERED, fmevt_pp_unregistered }
};

/*
 * Take a ruleset specification string and separate it into namespace
 * and subsystem components.
 */
static int
fmevt_rs_burst(fmd_hdl_t *hdl, char *ruleset, char **nsp, char **subsysp,
    boolean_t alloc)
{
        char *ns, *s;
        size_t len;

        if (ruleset == NULL || *ruleset == '\0' ||
            strnlen(ruleset, FMEV_MAX_RULESET_LEN) == FMEV_MAX_RULESET_LEN)
                return (0);

        if (alloc == B_FALSE) {
                s = ruleset;
                ns = strsep(&s, FMEV_RS_SEPARATOR);

                if (s == NULL || s == ns + 1)
                        return (0);
        } else {
                if ((s = strstr(ruleset, FMEV_RS_SEPARATOR)) == NULL ||
                    s == ruleset + strlen(ruleset) - 1)
                        return (0);

                len = s - ruleset;

                ns = fmd_hdl_alloc(hdl, len + 1, FMD_SLEEP);
                (void) strncpy(ns, ruleset, len);
                ns[len] = '\0';

                s++;
        }

        if (nsp)
                *nsp = ns;      /* caller must free if alloc == B_TRUE */

        if (subsysp)
                *subsysp = s;   /* always within original ruleset string */

        return (1);
}

static int
fmevt_rs_init(fmd_hdl_t *hdl)
{
        int i;

        for (i = 0; i < sizeof (rulelist) / sizeof (rulelist[0]); i++) {
                struct fmevt_rs *rsp = &rulelist[i];

                if (!fmevt_rs_burst(hdl, rsp->rs_pat, &rsp->rs_namespace,
                    &rsp->rs_subsys, B_TRUE))
                        return (0);
        }

        return (1);
}

/*
 * Construct a "sw" scheme detector FMRI.
 *
 * We make no use of priv or pri.
 */
/*ARGSUSED3*/
static nvlist_t *
fmevt_detector(nvlist_t *attr, char *ruleset, int user, int priv,
    fmev_pri_t pri)
{
        char buf[FMEV_MAX_RULESET_LEN + 1];
        char *ns, *subsys;
        nvlist_t *obj, *dtcr, *site, *ctxt;
        char *execname = NULL;
        int32_t i32;
        int64_t i64;
        int err = 0;
        char *str;

        (void) strncpy(buf, ruleset, sizeof (buf));
        if (!fmevt_rs_burst(NULL, buf, &ns, &subsys, B_FALSE))
                return (NULL);

        obj = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP);
        dtcr = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP);
        site = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP);
        ctxt = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP);

        if (obj == NULL || dtcr == NULL || site == NULL || ctxt == NULL) {
                err++;
                goto done;
        }

        /*
         * Build up 'object' nvlist.
         */
        if (nvlist_lookup_string(attr, "__fmev_execname", &execname) == 0)
                err += nvlist_add_string(obj, FM_FMRI_SW_OBJ_PATH, execname);

        /*
         * Build up 'site' nvlist.  We should have source file and line
         * number and, if the producer was compiled with C99, function name.
         */
        if (nvlist_lookup_string(attr, "__fmev_file", &str) == 0) {
                err += nvlist_add_string(site, FM_FMRI_SW_SITE_FILE, str);
                (void) nvlist_remove(attr, "__fmev_file", DATA_TYPE_STRING);
        }

        if (nvlist_lookup_string(attr, "__fmev_func", &str) == 0) {
                err += nvlist_add_string(site, FM_FMRI_SW_SITE_FUNC, str);
                (void) nvlist_remove(attr, "__fmev_func", DATA_TYPE_STRING);
        }

        if (nvlist_lookup_int64(attr, "__fmev_line", &i64) == 0) {
                err += nvlist_add_int64(site, FM_FMRI_SW_SITE_LINE, i64);
                (void) nvlist_remove(attr, "__fmev_line", DATA_TYPE_INT64);
        }

        /*
         * Build up 'context' nvlist.  We do not include contract id at
         * this time.
         */

        err += nvlist_add_string(ctxt, FM_FMRI_SW_CTXT_ORIGIN,
            user ? "userland" : "kernel");

        if (execname) {
                err += nvlist_add_string(ctxt, FM_FMRI_SW_CTXT_EXECNAME,
                    execname);
                (void) nvlist_remove(attr, "__fmev_execname", DATA_TYPE_STRING);
        }

        if (nvlist_lookup_int32(attr, "__fmev_pid", &i32) == 0) {
                err += nvlist_add_int32(ctxt, FM_FMRI_SW_CTXT_PID, i32);
                (void) nvlist_remove(attr, "__fmev_pid", DATA_TYPE_INT32);
        }

        if (!isglobalzone)
                err += nvlist_add_string(ctxt, FM_FMRI_SW_CTXT_ZONE, zonename);

        /* Put it all together */

        err += nvlist_add_uint8(dtcr, FM_VERSION, SW_SCHEME_VERSION0);
        err += nvlist_add_string(dtcr, FM_FMRI_SCHEME, FM_FMRI_SCHEME_SW);
        err += nvlist_add_nvlist(dtcr, FM_FMRI_SW_OBJ, obj);
        err += nvlist_add_nvlist(dtcr, FM_FMRI_SW_SITE, site);
        err += nvlist_add_nvlist(dtcr, FM_FMRI_SW_CTXT, ctxt);

done:
        nvlist_free(obj);
        nvlist_free(site);
        nvlist_free(ctxt);

        if (err == 0) {
                return (dtcr);
        } else {
                nvlist_free(dtcr);
                return (NULL);
        }
}

static int
class_ok(char *class)
{
        static const char *approved[] = {
                FM_IREPORT_CLASS ".",
                FM_EREPORT_CLASS "."
        };

        int i;

        for (i = 0; i < sizeof (approved) / sizeof (approved[0]); i++) {
                if (strncmp(class, approved[i], strlen(approved[i])) == 0)
                        return (1);
        }

        return (0);
}

static void
fmevt_postprocess(char *ruleset, nvlist_t *dtcr, nvlist_t *rawattr,
    struct fmevt_ppargs *eap)
{
        uint_t expected = 0, processed = 0;
        char rs2burst[FMEV_MAX_RULESET_LEN + 1];
        char *class[FMEVT_FANOUT_MAX];
        nvlist_t *attr[FMEVT_FANOUT_MAX];
        fmevt_pp_func_t *dispf = NULL;
        char buf[FMEV_MAX_CLASS];
        char *ns, *subsys;
        int i, found = 0;
        uuid_t uu;

        (void) strncpy(rs2burst, ruleset, sizeof (rs2burst));
        if (!fmevt_rs_burst(NULL, rs2burst, &ns, &subsys, B_FALSE)) {
                BUMPSTAT(pp_bad_ruleset);
                return;
        }

        /*
         * Lookup a matching rule in our table.
         */
        for (i = 0; i < sizeof (rulelist) / sizeof (rulelist[0]); i++) {
                struct fmevt_rs *rsp = &rulelist[i];

                if (*ns != '*' && *rsp->rs_namespace != '*' &&
                    strcmp(ns, rsp->rs_namespace) != 0)
                        continue;

                if (*subsys != '*' && *rsp->rs_subsys != '*' &&
                    strcmp(subsys, rsp->rs_subsys) != 0)
                        continue;

                dispf = rsp->rs_ppfunc;
                found = 1;
                break;

        }

        /*
         * If a ruleset matches but specifies a NULL function then
         * it's electing to drop the event.  If no rule was matched
         * then default to unregistered processing.
         */
        if (dispf == NULL) {
                if (found) {
                        BUMPSTAT(pp_explicitdrop);
                        return;
                } else {
                        BUMPSTAT(pp_fallthrurule);
                        dispf = fmevt_pp_unregistered;
                }
        }

        /*
         * Clear the arrays in which class strings and attribute
         * nvlists can be returned.  Pass a pointer to our stack buffer
         * that the callee can use for the first event class (for others
         * it must fmd_hdl_alloc and we'll free below).  We will free
         * and nvlists that are returned.
         */
        bzero(class, sizeof (class));
        bzero(attr, sizeof (attr));
        class[0] = buf;

        /*
         * Generate an event UUID which will be used for the first
         * event generated by post-processing; if post-processing
         * fans out into more than one event the additional events
         * can reference this uuid (but we don't generate their
         * UUIDs until later).
         */
        uuid_generate(uu);
        uuid_unparse(uu, eap->pp_uuidstr);

        /*
         * Call selected post-processing function.  See block comment
         * in fmevt.h for a description of this process.
         */
        expected = (*dispf)(class, attr, ruleset,
            (const nvlist_t *)dtcr, rawattr,
            (const struct fmevt_ppargs *)eap);

        if (expected > FMEVT_FANOUT_MAX) {
                BUMPSTAT(pp_fanoutmax);
                return; /* without freeing class and nvl - could leak */
        } else if (expected == 0) {
                BUMPSTAT(pp_intldrop);
                return;
        }

        /*
         * Post as many events as the callback completed.
         */
        for (i = 0; i < FMEVT_FANOUT_MAX; i++) {
                char uuidstr[36 + 1];
                char *uuidstrp;
                nvlist_t *nvl;
                int err = 0;

                if (class[i] == NULL)
                        continue;

                if (!class_ok(class[i])) {
                        BUMPSTAT(pp_badclass);
                        continue;
                }

                if (processed++ == 0) {
                        uuidstrp = eap->pp_uuidstr;
                } else {
                        uuid_generate(uu);
                        uuid_unparse(uu, uuidstr);
                        uuidstrp = uuidstr;
                }

                if ((nvl = fmd_nvl_alloc(fmevt_hdl, FMD_SLEEP)) == NULL) {
                        BUMPSTAT(pp_nvlallocfail);
                        continue;
                }

                err += nvlist_add_uint8(nvl, FM_VERSION, 0);
                err += nvlist_add_string(nvl, FM_CLASS, (const char *)class[i]);
                err += nvlist_add_string(nvl, FM_IREPORT_UUID, uuidstrp);
                err += nvlist_add_nvlist(nvl, FM_IREPORT_DETECTOR, dtcr);
                err += nvlist_add_string(nvl, FM_IREPORT_PRIORITY,
                    fmev_pri_string(eap->pp_pri) ?
                    fmev_pri_string(eap->pp_pri) : "?");

                if (attr[i] != NULL)
                        err += nvlist_add_nvlist(nvl, FM_IREPORT_ATTRIBUTES,
                            attr[i]);

                /*
                 * If we post the event into fmd_xport_post then the
                 * transport code is responsible for freeing the nvl we
                 * posted.
                 */
                if (err == 0) {
                        fmd_xprt_post(fmevt_hdl, fmevt_xprt, nvl,
                            eap->pp_hrt);
                } else {
                        BUMPSTAT(pp_nvlbuildfail);
                        nvlist_free(nvl);
                }
        }

        if (processed != expected)
                BUMPSTAT(pp_badreturn);

        for (i = 0; i < FMEVT_FANOUT_MAX; i++) {
                /*
                 * We provided storage for class[0] but any
                 * additional events have allocated a string.
                 */
                if (i > 0 && class[i] != NULL)
                        fmd_hdl_strfree(fmevt_hdl, class[i]);

                /*
                 * Free all attribute lists passed in if they are not
                 * just a pointer to the raw attributes
                 */
                if (attr[i] != NULL && attr[i] != rawattr)
                        nvlist_free(attr[i]);
        }
}

static int
fmevt_cb(sysevent_t *sep, void *arg)
{
        char *ruleset = NULL, *rawclass, *rawsubclass;
        uint32_t cbarg = (uint32_t)arg;
        nvlist_t *rawattr = NULL;
        struct fmevt_ppargs ea;
        nvlist_t *dtcr;
        int user, priv;
        fmev_pri_t pri;

        BUMPSTAT(raw_callbacks);

        if (cbarg & ~CBF_ALL)
                fmd_hdl_abort(fmevt_hdl, "event receipt callback with "
                    "invalid flags\n");

        user = (cbarg & CBF_USER) != 0;
        priv = (cbarg & CBF_PRIV) != 0;
        pri = (cbarg & CBF_HV ? FMEV_HIPRI : FMEV_LOPRI);

        (void) pthread_mutex_lock(&fmevt_lock);

        if (fmevt_exiting) {
                while (fmevt_xprt_refcnt > 0)
                        (void) pthread_cond_wait(&fmevt_cv, &fmevt_lock);
                (void) pthread_mutex_unlock(&fmevt_lock);
                return (0);     /* discard event */
        }

        fmevt_xprt_refcnt++;
        (void) pthread_mutex_unlock(&fmevt_lock);

        ruleset = sysevent_get_vendor_name(sep);        /* must free */
        rawclass = sysevent_get_class_name(sep);        /* valid with sep */
        rawsubclass = sysevent_get_subclass_name(sep);  /* valid with sep */

        if (sysevent_get_attr_list(sep, &rawattr) != 0) {
                BUMPSTAT(raw_noattrlist);
                goto done;
        }

        if ((dtcr = fmevt_detector(rawattr, ruleset, user, priv,
            pri)) == NULL) {
                BUMPSTAT(raw_nodetector);
                goto done;
        }

        ea.pp_rawclass = rawclass;
        ea.pp_rawsubclass = rawsubclass;
        sysevent_get_time(sep, &ea.pp_hrt);
        ea.pp_user = user;
        ea.pp_priv = priv;
        ea.pp_pri = pri;

        fmevt_postprocess(ruleset, dtcr, rawattr, &ea);
        nvlist_free(dtcr);
done:
        (void) pthread_mutex_lock(&fmevt_lock);

        if (--fmevt_xprt_refcnt == 0 && fmevt_exiting)
                (void) pthread_cond_broadcast(&fmevt_cv);

        (void) pthread_mutex_unlock(&fmevt_lock);

        if (ruleset)
                free(ruleset);

        nvlist_free(rawattr);

        return (0);     /* in all cases consider the event delivered */
}

void
fmevt_init_inbound(fmd_hdl_t *hdl)
{
        char *sidpfx;
        zoneid_t zoneid;
        int i;

        if (!fmevt_rs_init(hdl))
                fmd_hdl_abort(hdl, "error in fmevt_rs_init\n");

        (void) fmd_stat_create(hdl, FMD_STAT_NOALLOC, sizeof (inbound_stats) /
            sizeof (fmd_stat_t), (fmd_stat_t *)&inbound_stats);

        zoneid = getzoneid();
        isglobalzone = (zoneid == GLOBAL_ZONEID);
        if (getzonenamebyid(zoneid, zonename, sizeof (zonename)) == -1)
                fmd_hdl_abort(hdl, "getzonenamebyid failed");

        if ((subattr = sysevent_subattr_alloc()) == NULL)
                fmd_hdl_abort(hdl, "failed to allocate subscription "
                    "attributes: %s");

        sysevent_subattr_thrcreate(subattr, fmd_doorthr_create, NULL);
        sysevent_subattr_thrsetup(subattr, fmd_doorthr_setup, NULL);

        sidpfx = fmd_prop_get_string(hdl, "sidprefix");
        fmevt_xprt = fmd_xprt_open(hdl, FMD_XPRT_RDONLY, NULL, NULL);

        for (i = 0; i < sizeof (chaninfo) / sizeof (chaninfo[0]); i++) {
                struct fmevt_chaninfo *cip = &chaninfo[i];
                char *channel = fmd_prop_get_string(hdl, cip->ci_propname);
                int err;

                if (sysevent_evc_bind(channel, &cip->ci_binding,
                    EVCH_CREAT | EVCH_HOLD_PEND_INDEF) != 0)
                        fmd_hdl_abort(hdl, "failed to bind GPEC channel for "
                            "channel %s", channel);

                (void) snprintf(cip->ci_sid, sizeof (cip->ci_sid),
                    "%s_%c%c%c", sidpfx,
                    cip->ci_cbarg & CBF_USER ? 'u' : 'k',
                    cip->ci_cbarg & CBF_PRIV ? 'p' : 'n',
                    cip->ci_cbarg & CBF_HV ? 'h' : 'l');

                err = sysevent_evc_xsubscribe(cip->ci_binding, cip->ci_sid,
                    EC_ALL, fmevt_cb, (void *)cip->ci_cbarg,
                    cip->ci_sflags, subattr);

                if (err == EEXIST)
                        fmd_hdl_abort(hdl, "another fmd is active on "
                            "channel %s\n", channel);
                else if (err != 0)
                        fmd_hdl_abort(hdl, "failed to subscribe to channel %s",
                            channel);

                fmd_prop_free_string(hdl, channel);
        }

        fmd_prop_free_string(hdl, sidpfx);
}

void
fmevt_fini_inbound(fmd_hdl_t *hdl)
{
        int i;

        for (i = 0; i < sizeof (chaninfo) / sizeof (chaninfo[0]); i++) {
                struct fmevt_chaninfo *cip = &chaninfo[i];

                if (cip->ci_binding) {
                        (void) sysevent_evc_unsubscribe(cip->ci_binding,
                            cip->ci_sid);
                        (void) sysevent_evc_unbind(cip->ci_binding);
                        cip->ci_binding = NULL;
                }
        }

        if (subattr) {
                sysevent_subattr_free(subattr);
                subattr = NULL;
        }

        if (fmevt_xprt) {
                /* drain before destruction */
                (void) pthread_mutex_lock(&fmevt_lock);
                fmevt_exiting = 1;
                while (fmevt_xprt_refcnt > 0)
                        (void) pthread_cond_wait(&fmevt_cv, &fmevt_lock);
                (void) pthread_mutex_unlock(&fmevt_lock);

                fmd_xprt_close(hdl, fmevt_xprt);
        }

}