#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>

netsnmp_feature_provide(stash_cache);

netsnmp_feature_child_of(stash_cache, mib_helpers);

#ifdef NETSNMP_FEATURE_REQUIRE_STASH_CACHE

netsnmp_feature_require(oid_stash);

netsnmp_feature_require(oid_stash_iterate);

netsnmp_feature_require(oid_stash_get_data);

#endif

#ifndef NETSNMP_FEATURE_REMOVE_STASH_CACHE

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

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

extern NetsnmpCacheLoad _netsnmp_stash_cache_load;

extern NetsnmpCacheFree _netsnmp_stash_cache_free;

/** @defgroup stash_cache stash_cache

 *  Automatically caches data for certain handlers.

 *  This handler caches data in an optimized way which may alleviate

 *  the need for the lower level handlers to perform as much

 *  optimization.  Specifically, somewhere in the lower level handlers

 *  must be a handler that supports the MODE_GET_STASH operation.

 *  Note that the table_iterator helper supports this.

 *  @ingroup handler

 *  @{

 */

netsnmp_stash_cache_info *

netsnmp_get_new_stash_cache(void)

{

    netsnmp_stash_cache_info *cinfo;

    cinfo = SNMP_MALLOC_TYPEDEF(netsnmp_stash_cache_info);

    if (cinfo != NULL)

        cinfo->cache_length = 30;

    return cinfo;

}

/** returns a stash_cache handler that can be injected into a given

 *  handler chain (with the specified timeout and root OID values),

 *  but *only* if that handler chain explicitly supports stash cache processing.

 */

netsnmp_mib_handler *

netsnmp_get_timed_bare_stash_cache_handler(int timeout, oid *rootoid, size_t rootoid_len)

{

    netsnmp_mib_handler *handler;

    netsnmp_cache       *cinfo;

    cinfo = netsnmp_cache_create( timeout, _netsnmp_stash_cache_load,

                                 _netsnmp_stash_cache_free, rootoid, rootoid_len );

    if (!cinfo)

        return NULL;

    handler = netsnmp_cache_handler_get( cinfo );

    if (!handler) {

        free(cinfo);

        return NULL;

    }

    handler->next = netsnmp_create_handler("stash_cache", netsnmp_stash_cache_helper);

    if (!handler->next) {

        netsnmp_handler_free(handler);

        free(cinfo);

        return NULL;

    }

    handler->myvoid = cinfo;

    netsnmp_cache_handler_owns_cache(handler);

    return handler;

}

/** returns a single stash_cache handler that can be injected into a given

 *  handler chain (with a fixed timeout), but *only* if that handler chain

 *  explicitly supports stash cache processing.

 */

netsnmp_mib_handler *

netsnmp_get_bare_stash_cache_handler(void)

{

    return netsnmp_get_timed_bare_stash_cache_handler( 30, NULL, 0 );

}

/** returns a stash_cache handler sub-chain that can be injected into a given

 *  (arbitrary) handler chain, using a fixed cache timeout.

 */

netsnmp_mib_handler *

netsnmp_get_stash_cache_handler(void)

{

    netsnmp_mib_handler *handler = netsnmp_get_bare_stash_cache_handler();

    if (handler && handler->next) {

        handler->next->next = netsnmp_get_stash_to_next_handler();

    }

    return handler;

}

/** returns a stash_cache handler sub-chain that can be injected into a given

 *  (arbitrary) handler chain, using a configurable cache timeout.

 */

netsnmp_mib_handler *

netsnmp_get_timed_stash_cache_handler(int timeout, oid *rootoid, size_t rootoid_len)

{

    netsnmp_mib_handler *handler = 

       netsnmp_get_timed_bare_stash_cache_handler(timeout, rootoid, rootoid_len);

    if (handler && handler->next) {

        handler->next->next = netsnmp_get_stash_to_next_handler();

    }

    return handler;

}

/** extracts a pointer to the stash_cache info from the reqinfo structure. */

netsnmp_oid_stash_node  **

netsnmp_extract_stash_cache(netsnmp_agent_request_info *reqinfo)

{

    return (netsnmp_oid_stash_node**)netsnmp_agent_get_list_data(reqinfo, STASH_CACHE_NAME);

}

/** @internal Implements the stash_cache handler */

int

netsnmp_stash_cache_helper(netsnmp_mib_handler *handler,

                           netsnmp_handler_registration *reginfo,

                           netsnmp_agent_request_info *reqinfo,

                           netsnmp_request_info *requests)

{

    netsnmp_cache            *cache;

    netsnmp_stash_cache_info *cinfo;

    netsnmp_oid_stash_node   *cnode;

    netsnmp_variable_list    *cdata;

    netsnmp_request_info     *request;

    DEBUGMSGTL(("helper:stash_cache", "Got request\n"));

    cache = netsnmp_cache_reqinfo_extract( reqinfo, reginfo->handlerName );

    if (!cache) {

        DEBUGMSGTL(("helper:stash_cache", "No cache structure\n"));

        return SNMP_ERR_GENERR;

    }

    cinfo = (netsnmp_stash_cache_info *) cache->magic;

    switch (reqinfo->mode) {

    case MODE_GET:

        DEBUGMSGTL(("helper:stash_cache", "Processing GET request\n"));

        for(request = requests; request; request = request->next) {

            cdata = (netsnmp_variable_list*)

                netsnmp_oid_stash_get_data(cinfo->cache,

                                           requests->requestvb->name,

                                           requests->requestvb->name_length);

            if (cdata && cdata->val.string && cdata->val_len) {

                DEBUGMSGTL(("helper:stash_cache", "Found cached GET varbind\n"));

                DEBUGMSGOID(("helper:stash_cache", cdata->name, cdata->name_length));

                DEBUGMSG(("helper:stash_cache", "\n"));

                snmp_set_var_typed_value(request->requestvb, cdata->type,

                                         cdata->val.string, cdata->val_len);

            }

        }

        break;

    case MODE_GETNEXT:

        DEBUGMSGTL(("helper:stash_cache", "Processing GETNEXT request\n"));

        for(request = requests; request; request = request->next) {

            cnode =

                netsnmp_oid_stash_getnext_node(cinfo->cache,

                                               requests->requestvb->name,

                                               requests->requestvb->name_length);

            if (cnode && cnode->thedata) {

                cdata =  (netsnmp_variable_list*)cnode->thedata;

                if (cdata->val.string && cdata->name && cdata->name_length) {

                    DEBUGMSGTL(("helper:stash_cache", "Found cached GETNEXT varbind\n"));

                    DEBUGMSGOID(("helper:stash_cache", cdata->name, cdata->name_length));

                    DEBUGMSG(("helper:stash_cache", "\n"));

                    snmp_set_var_typed_value(request->requestvb, cdata->type,

                                             cdata->val.string, cdata->val_len);

                    snmp_set_var_objid(request->requestvb, cdata->name,

                                       cdata->name_length);

                }

            }

        }

        break;

    default:

        cinfo->cache_valid = 0;

        return netsnmp_call_next_handler(handler, reginfo, reqinfo,

                                         requests);

    }

    return SNMP_ERR_NOERROR;

}

/** updates a given cache depending on whether it needs to or not.

 */

int

_netsnmp_stash_cache_load( netsnmp_cache *cache, void *magic )

{

    netsnmp_mib_handler          *handler  = cache->cache_hint->handler;

    netsnmp_handler_registration *reginfo  = cache->cache_hint->reginfo;

    netsnmp_agent_request_info   *reqinfo  = cache->cache_hint->reqinfo;

    netsnmp_request_info         *requests = cache->cache_hint->requests;

    netsnmp_stash_cache_info     *cinfo    = (netsnmp_stash_cache_info*) magic;

    int old_mode;

    int ret;

    if (!cinfo) {

        cinfo = netsnmp_get_new_stash_cache();

        cache->magic = cinfo;

    }

    /* change modes to the GET_STASH mode */

    old_mode = reqinfo->mode;

    reqinfo->mode = MODE_GET_STASH;

    netsnmp_agent_add_list_data(reqinfo,

                                netsnmp_create_data_list(STASH_CACHE_NAME,

                                                         &cinfo->cache, NULL));

    /* have the next handler fill stuff in and switch modes back */

    ret = netsnmp_call_next_handler(handler->next, reginfo, reqinfo, requests);

    reqinfo->mode = old_mode;

    return ret;

}

void

_netsnmp_stash_cache_free( netsnmp_cache *cache, void *magic )

{

    netsnmp_stash_cache_info *cinfo = (netsnmp_stash_cache_info*) magic;

    netsnmp_oid_stash_free(&cinfo->cache,

                          (NetSNMPStashFreeNode *) snmp_free_var);

    return;

}

/** initializes the stash_cache helper which then registers a stash_cache

 *  handler as a run-time injectable handler for configuration file

 *  use.

 */

void

netsnmp_init_stash_cache_helper(void)

{

    netsnmp_register_handler_by_name("stash_cache",

                                     netsnmp_get_stash_cache_handler());

}

/**  @} */

#else /* NETSNMP_FEATURE_REMOVE_STASH_CACHE */

netsnmp_feature_unused(stash_cache);

#endif /* NETSNMP_FEATURE_REMOVE_STASH_CACHE */