/*

 * DisMan Event MIB:

 *     Implementation of the event table configure handling

 */

#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-features.h>

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/agent/net-snmp-agent-includes.h>

#include <net-snmp/agent/agent_callbacks.h>

#include "disman/event/mteObjects.h"

#include "disman/event/mteEvent.h"

#include "disman/event/mteEventConf.h"

netsnmp_feature_require(iquery)

/** Initializes the mteEventsConf module */

void

init_mteEventConf(void)

{

    init_event_table_data();

    /*

     * Register config handlers for user-level (fixed) events....

     */

    snmpd_register_config_handler("notificationEvent",

                                   parse_notificationEvent, NULL,

                                   "eventname notifyOID [-m] [-i OID|-o OID]*");

    snmpd_register_config_handler("setEvent",

                                   parse_setEvent,          NULL,

                                   "eventname [-I] OID = value");

    netsnmp_ds_register_config(ASN_BOOLEAN,

                   netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

                                         NETSNMP_DS_LIB_APPTYPE),

                   "strictDisman", NETSNMP_DS_APPLICATION_ID,

                                   NETSNMP_DS_AGENT_STRICT_DISMAN);

    /*

     * ... and for persistent storage of dynamic event table entries.

     *

     * (The previous implementation didn't store these entries,

     *  so we don't need to worry about backwards compatability)

     */

    snmpd_register_config_handler("_mteETable",

                                   parse_mteETable, NULL, NULL);

    snmpd_register_config_handler("_mteENotTable",

                                   parse_mteENotTable, NULL, NULL);

    snmpd_register_config_handler("_mteESetTable",

                                   parse_mteESetTable, NULL, NULL);

    /*

     * Register to save (non-fixed) entries when the agent shuts down

     */

    snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,

                           store_mteETable, NULL);

    snmp_register_callback(SNMP_CALLBACK_APPLICATION,

                           SNMPD_CALLBACK_PRE_UPDATE_CONFIG,

                           clear_mteETable, NULL);

}

/* ==============================

 *

 *       utility routines

 *

 * ============================== */

    /*

     * Find or create the specified event entry

     */

static struct mteEvent *

_find_mteEvent_entry( const char *owner, const char *ename )

{

    netsnmp_variable_list owner_var, ename_var;

    netsnmp_tdata_row *row;

        /*

         * If there's already an existing entry,

         *   then use that...

         */

    memset(&owner_var, 0, sizeof(netsnmp_variable_list));

    memset(&ename_var, 0, sizeof(netsnmp_variable_list));

    snmp_set_var_typed_value(&owner_var, ASN_OCTET_STR, owner, strlen(owner));

    snmp_set_var_typed_value(&ename_var, ASN_PRIV_IMPLIED_OCTET_STR,

                                                        ename, strlen(ename));

    owner_var.next_variable = &ename_var;

    row = netsnmp_tdata_row_get_byidx( event_table_data, &owner_var );

        /*

         * ... otherwise, create a new one

         */

    if (!row)

        row = mteEvent_createEntry( owner, ename, 0 );

    if (!row)

        return NULL;

    /* return (struct mteEvent *)netsnmp_tdata_row_entry( row ); */

    return (struct mteEvent *)row->data;

}

static struct mteEvent *

_find_typed_mteEvent_entry( const char *owner, const char *ename, int type )

{

    struct mteEvent *entry = _find_mteEvent_entry( owner, ename );

    if (!entry)

        return NULL;

    /*

     *  If this is an existing (i.e. valid) entry of the

     *    same type, then throw an error and discard it.

     *  But allow combined Set/Notification events.

     */

    if ( entry &&

        (entry->flags & MTE_EVENT_FLAG_VALID) &&

        (entry->mteEventActions & type )) {

        config_perror("error: duplicate event name");

        return NULL;

    }

    return entry;

}

/* ==============================

 *

 *  User-configured (static) events

 *

 * ============================== */

void

parse_notificationEvent( const char *token, char *line )

{

    char   ename[MTE_STR1_LEN+1];

    char   buf[SPRINT_MAX_LEN];

    oid    name_buf[MAX_OID_LEN];

    size_t name_buf_len;

    struct mteEvent  *entry;

    struct mteObject *object;

    int    wild = 1;

    int    idx  = 0;

    char  *cp;

#ifndef NETSNMP_DISABLE_MIB_LOADING

    struct tree         *tp;

#endif

    struct varbind_list *var;

    DEBUGMSGTL(("disman:event:conf", "Parsing notificationEvent config\n"));

    /*

     * The event name could be used directly to index the mteObjectsTable.

     * But it's quite possible that the same name could also be used to

     * set up a mteTriggerTable entry (with trigger-specific objects).

     *

     * To avoid such a clash, we'll add a prefix ("_E").

     */

    memset(ename, 0, sizeof(ename));

    ename[0] = '_';

    ename[1] = 'E';

    cp = copy_nword(line, ename+2,  MTE_STR1_LEN-2);

    if (!cp || ename[2] == '\0') {

        config_perror("syntax error: no event name");

        return;

    }

    /*

     *  Parse the notification OID field ...

     */

    cp = copy_nword(cp, buf,  SPRINT_MAX_LEN);

    if ( buf[0] == '\0' ) {

        config_perror("syntax error: no notification OID");

        return;

    }

    name_buf_len = MAX_OID_LEN;

    if (!snmp_parse_oid(buf, name_buf, &name_buf_len)) {

        snmp_log(LOG_ERR, "notificationEvent OID: %s\n", buf);

        config_perror("unknown notification OID");

        return;

    }

    /*

     *  ... and the relevant object/instances.

     */

    if ( cp && *cp=='-' && *(cp+1)=='m' ) {

#ifdef NETSNMP_DISABLE_MIB_LOADING

        config_perror("Can't use -m if MIB loading is disabled");

        return;

#else

        /*

         * Use the MIB definition to add the standard

         *   notification payload to the mteObjectsTable.

         */

        cp = skip_token( cp );

        tp = get_tree( name_buf, name_buf_len, get_tree_head());

        if (!tp) {

            config_perror("Can't locate notification payload info");

            return;

        }

        for (var = tp->varbinds; var; var=var->next) {

            idx++;

            object = mteObjects_addOID( "snmpd.conf", ename, idx,

                                         var->vblabel, wild );

            idx    = object->mteOIndex;

        }

#endif

    }

    while (cp) {

        if ( *cp == '-' ) {

            switch (*(cp+1)) {

            case 'm':

                config_perror("-m option must come first");

                return;

            case 'i':   /* exact instance */

            case 'w':   /* "not-wild" (backward compatability) */

                wild = 0;

                break;

            case 'o':   /* wildcarded object  */

                wild = 1;

                break;

            default:

                config_perror("unrecognised option");

                return;

            }

            cp = skip_token( cp );

            if (!cp) {

                config_perror("missing parameter");

                return;

            }

        }

        idx++;

        cp     = copy_nword(cp, buf,  SPRINT_MAX_LEN);

        object = mteObjects_addOID( "snmpd.conf", ename, idx, buf, wild );

        idx    = object->mteOIndex;

        wild   = 1;    /* default to wildcarded objects */

    }

    /*

     *  If the entry has parsed successfully, then create,

     *     populate and activate the new event entry.

     */

    entry = _find_typed_mteEvent_entry("snmpd.conf", ename+2,

                                       MTE_EVENT_NOTIFICATION);

    if (!entry) {

        mteObjects_removeEntries( "snmpd.conf", ename );

        return;

    }

    entry->mteNotification_len = name_buf_len;

    memcpy( entry->mteNotification, name_buf, name_buf_len*sizeof(oid));

    memcpy( entry->mteNotifyOwner,  "snmpd.conf",  10 );

    memcpy( entry->mteNotifyObjects, ename, MTE_STR1_LEN );

    entry->mteEventActions |= MTE_EVENT_NOTIFICATION;

    entry->flags           |= MTE_EVENT_FLAG_ENABLED |

                              MTE_EVENT_FLAG_ACTIVE  |

                              MTE_EVENT_FLAG_FIXED   |

                              MTE_EVENT_FLAG_VALID;

    return;

}

void

parse_setEvent( const char *token, char *line )

{

    char   ename[MTE_STR1_LEN+1];

    char   buf[SPRINT_MAX_LEN];

    oid    name_buf[MAX_OID_LEN];

    size_t name_buf_len;

    long   value;

    int    wild = 1;

    struct mteEvent  *entry;

    char  *cp;

    DEBUGMSGTL(("disman:event:conf", "Parsing setEvent config...  "));

    memset( ename, 0, sizeof(ename));

    cp = copy_nword(line, ename,  MTE_STR1_LEN);

    if (!cp || ename[0] == '\0') {

        config_perror("syntax error: no event name");

        return;

    }

    if (cp && *cp=='-' && *(cp+1)=='I') {

        wild = 0;               /* an instance assignment */

        cp = skip_token( cp );

    }

    /*

     *  Parse the SET assignment in the form "OID = value"

     */

    cp = copy_nword(cp, buf,  SPRINT_MAX_LEN);

    if ( buf[0] == '\0' ) {

        config_perror("syntax error: no set OID");

        return;

    }

    name_buf_len = MAX_OID_LEN;

    if (!snmp_parse_oid(buf, name_buf, &name_buf_len)) {

        snmp_log(LOG_ERR, "setEvent OID: %s\n", buf);

        config_perror("unknown set OID");

        return;

    }

    if (cp && *cp == '=') {

        cp = skip_token( cp );   /* skip the '=' assignment character */

    }

    if (!cp) {

        config_perror("syntax error: missing set value");

        return;

    }

    value = strtol( cp, NULL, 0);

    /*

     *  If the entry has parsed successfully, then create,

     *     populate and activate the new event entry.

     */

    entry = _find_typed_mteEvent_entry("snmpd.conf", ename, MTE_EVENT_SET);

    if (!entry) {

        return;

    }

    memcpy( entry->mteSetOID, name_buf, name_buf_len*sizeof(oid));

    entry->mteSetOID_len = name_buf_len;

    entry->mteSetValue   = value;

    if (wild)

        entry->flags       |= MTE_SET_FLAG_OBJWILD;

    entry->mteEventActions |= MTE_EVENT_SET;

    entry->flags           |= MTE_EVENT_FLAG_ENABLED |

                              MTE_EVENT_FLAG_ACTIVE  |

                              MTE_EVENT_FLAG_FIXED   |

                              MTE_EVENT_FLAG_VALID;

    return;

}

/* ==============================

 *

 *  Persistent (dynamic) configuration

 *

 * ============================== */

void

parse_mteETable(const char *token, char *line )

{

    char   owner[MTE_STR1_LEN+1];

    char   ename[MTE_STR1_LEN+1];

    void  *vp;

    size_t tmp;

    size_t len;

    struct mteEvent  *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteEventTable config...  "));

    /*

     * Read in the index information for this entry

     *  and create a (non-fixed) data structure for it.

     */

    memset( owner, 0, sizeof(owner));

    memset( ename, 0, sizeof(ename));

    len   = MTE_STR1_LEN; vp = owner;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    len   = MTE_STR1_LEN; vp = ename;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    entry = _find_mteEvent_entry( owner, ename );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, ename));

    /*

     * Read in the accessible (event-independent) column values.

     */

    len   = MTE_STR2_LEN; vp = entry->mteEventComment;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    /*

     * Skip the mteEventAction field, and note that the

     *   boolean values are combined into a single field.

     */

    line  = read_config_read_data(ASN_UNSIGNED,  line, &tmp, NULL);

    entry->flags |= (tmp &

        (MTE_EVENT_FLAG_ENABLED|MTE_EVENT_FLAG_ACTIVE));

    /*

     * XXX - Will need to read in the 'iquery' access information

     */

    entry->flags |= MTE_EVENT_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));

}

void

parse_mteENotTable(const char *token, char *line)

{

    char   owner[MTE_STR1_LEN+1];

    char   ename[MTE_STR1_LEN+1];

    void  *vp;

    size_t len;

    struct mteEvent  *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteENotifyTable config...  "));

    /*

     * Read in the index information for this entry

     *  and create a (non-fixed) data structure for it.

     */

    memset( owner, 0, sizeof(owner));

    memset( ename, 0, sizeof(ename));

    len   = MTE_STR1_LEN; vp = owner;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    len   = MTE_STR1_LEN; vp = ename;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    entry = _find_mteEvent_entry( owner, ename );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, ename));

    /*

     * Read in the accessible column values.

     */

    vp = entry->mteNotification;

    line  = read_config_read_data(ASN_OBJECT_ID, line, &vp,

                                 &entry->mteNotification_len);

    len   = MTE_STR1_LEN; vp = entry->mteNotifyOwner;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    len   = MTE_STR1_LEN; vp = entry->mteNotifyObjects;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    entry->mteEventActions |= MTE_EVENT_NOTIFICATION;

    entry->flags           |= MTE_EVENT_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));

}

void

parse_mteESetTable(const char *token, char *line)

{

    char   owner[MTE_STR1_LEN+1];

    char   ename[MTE_STR1_LEN+1];

    void  *vp;

    size_t len;

    struct mteEvent  *entry;

    DEBUGMSGTL(("disman:event:conf", "Parsing mteESetTable config...  "));

    /*

     * Read in the index information for this entry

     *  and create a (non-fixed) data structure for it.

     */

    memset( owner, 0, sizeof(owner));

    memset( ename, 0, sizeof(ename));

    len   = MTE_STR1_LEN; vp = owner;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    len   = MTE_STR1_LEN; vp = ename;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    entry = _find_mteEvent_entry( owner, ename );

    DEBUGMSG(("disman:event:conf", "(%s, %s) ", owner, ename));

    /*

     * Read in the accessible column values.

     */

    vp = entry->mteSetOID;

    line  = read_config_read_data(ASN_OBJECT_ID, line, &vp,

                                 &entry->mteSetOID_len);

    line  = read_config_read_data(ASN_UNSIGNED,  line,

                                 &entry->mteSetValue, &len;;

    len   = MTE_STR2_LEN; vp = entry->mteSetTarget;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    len   = MTE_STR2_LEN; vp = entry->mteSetContext;

    line  = read_config_read_data(ASN_OCTET_STR, line, &vp,  &len;;

    entry->mteEventActions |= MTE_EVENT_SET;

    entry->flags           |= MTE_EVENT_FLAG_VALID;

    DEBUGMSG(("disman:event:conf", "\n"));

}

int

store_mteETable(int majorID, int minorID, void *serverarg, void *clientarg)

{

    char            line[SNMP_MAXBUF];

    char           *cptr, *cp;

    void           *vp;

    size_t          tint;

    netsnmp_tdata_row *row;

    struct mteEvent  *entry;

    DEBUGMSGTL(("disman:event:conf", "Storing mteEventTable config:\n"));

    for (row = netsnmp_tdata_row_first( event_table_data );

         row;

         row = netsnmp_tdata_row_next( event_table_data, row )) {

        /*

         * Skip entries that were set up via static config directives

         */

        entry = (struct mteEvent *)netsnmp_tdata_row_entry( row );

        if ( entry->flags & MTE_EVENT_FLAG_FIXED )

            continue;

        DEBUGMSGTL(("disman:event:conf", "  Storing (%s %s)\n",

                         entry->mteOwner, entry->mteEName));

        /*

         * Save the basic mteEventTable entry...

         */

        memset(line, 0, sizeof(line));

        strcat(line, "_mteETable ");

        cptr = line + strlen(line);

        cp   = entry->mteOwner;        tint = strlen( cp );

        cptr = read_config_store_data( ASN_OCTET_STR, cptr, &cp,  &tint );

        cp   = entry->mteEName;        tint = strlen( cp );

        cptr = read_config_store_data( ASN_OCTET_STR, cptr, &cp,  &tint );

        cp   = entry->mteEventComment; tint = strlen( cp );

        cptr = read_config_store_data( ASN_OCTET_STR, cptr, &cp,  &tint );

        /* ... (but skip the mteEventAction field)... */

        tint = entry->flags & (MTE_EVENT_FLAG_ENABLED|MTE_EVENT_FLAG_ACTIVE); 

        cptr = read_config_store_data( ASN_UNSIGNED,  cptr, &tint, NULL );

        /* XXX - Need to store the 'iquery' access information */

        snmpd_store_config(line);

        /*

         * ... then save Notify and/or Set entries separately

         *   (The mteEventAction bits will be set when these are read in).

         */

        if ( entry->mteEventActions & MTE_EVENT_NOTIFICATION ) {

            memset(line, 0, sizeof(line));

            strcat(line, "_mteENotTable ");

            cptr = line + strlen(line);

            cp = entry->mteOwner;         tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            cp = entry->mteEName;         tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            vp   = entry->mteNotification;

            cptr = read_config_store_data(ASN_OBJECT_ID, cptr, &vp,

                                          &entry->mteNotification_len);

            cp = entry->mteNotifyOwner;   tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            cp = entry->mteNotifyObjects; tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            snmpd_store_config(line);

        }

        if ( entry->mteEventActions & MTE_EVENT_SET ) {

            memset(line, 0, sizeof(line));

            strcat(line, "_mteESetTable ");

            cptr = line + strlen(line);

            cp = entry->mteOwner;         tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            cp = entry->mteEName;         tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            vp   = entry->mteSetOID;

            cptr = read_config_store_data(ASN_OBJECT_ID, cptr, &vp,

                                          &entry->mteSetOID_len);

            tint = entry->mteSetValue;

            cptr = read_config_store_data(ASN_INTEGER,   cptr, &tint, NULL);

            cp = entry->mteSetTarget;     tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            cp = entry->mteSetContext;    tint = strlen( cp );

            cptr = read_config_store_data(ASN_OCTET_STR, cptr, &cp, &tint );

            tint = entry->flags & (MTE_SET_FLAG_OBJWILD|MTE_SET_FLAG_CTXWILD); 

            cptr = read_config_store_data(ASN_UNSIGNED,  cptr, &tint, NULL);

            snmpd_store_config(line);

        }

    }

    DEBUGMSGTL(("disman:event:conf", "  done.\n"));

    return SNMPERR_SUCCESS;

}

int

clear_mteETable(int majorID, int minorID, void *serverarg, void *clientarg)

{

    netsnmp_tdata_row    *row;

    netsnmp_variable_list owner_var;

    /*

     * We're only interested in entries set up via the config files

     */

    memset( &owner_var, 0, sizeof(netsnmp_variable_list));

    snmp_set_var_typed_value( &owner_var,  ASN_OCTET_STR,

                             "snmpd.conf", strlen("snmpd.conf"));

    while (( row = netsnmp_tdata_row_next_byidx( event_table_data,

                                                &owner_var ))) {

        /*

         * XXX - check for owner of "snmpd.conf"

         *       and break at the end of these

         */

        netsnmp_tdata_remove_and_delete_row( event_table_data, row );

    }

    return SNMPERR_SUCCESS;

}