/* Portions of this file are subject to the following copyright(s).  See

 * the Net-SNMP's COPYING file for more details and other copyrights

 * that may apply:

 */

/*

 * Portions of this file are copyrighted by:

 * Copyright © 2003 Sun Microsystems, Inc. All rights reserved.

 * Use is subject to license terms specified in the COPYING file

 * distributed with the Net-SNMP package.

 *

 * Portions of this file are copyrighted by:

 * Copyright (c) 2016 VMware, Inc. All rights reserved.

 * Use is subject to license terms specified in the COPYING file

 * distributed with the Net-SNMP package.

 */

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

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

#include <sys/types.h>

#if HAVE_STRING_H

#include <string.h>

#endif

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

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

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

netsnmp_feature_child_of(agent_handler, libnetsnmpagent)

netsnmp_feature_child_of(handler_mark_requests_as_delegated, agent_handler)

static netsnmp_mib_handler *_clone_handler(netsnmp_mib_handler *it);

/***********************************************************************/

/*

 * New Handler based API 

 */

/***********************************************************************/

/** @defgroup handler Net-SNMP Agent handler and extensibility API

 *  @ingroup agent

 *

 *  The basic theory goes something like this: In the past, with the

 *  original mib module api (which derived from the original CMU SNMP

 *  code) the underlying mib modules were passed very little

 *  information (only the truly most basic information about a

 *  request).  This worked well at the time but in todays world of

 *  subagents, device instrumentation, low resource consumption, etc,

 *  it just isn't flexible enough.  "handlers" are here to fix all that.

 *

 *  With the rewrite of the agent internals for the net-snmp 5.0

 *  release, we introduce a modular calling scheme that allows agent

 *  modules to be written in a very flexible manner, and more

 *  importantly allows reuse of code in a decent way (and without the

 *  memory and speed overheads of OO languages like C++).

 *

 *  Functionally, the notion of what a handler does is the same as the

 *  older api: A handler is @link netsnmp_create_handler() created@endlink and

 *  then @link netsnmp_register_handler() registered@endlink with the main

 *  agent at a given OID in the OID tree and gets called any time a

 *  request is made that it should respond to.  You probably should

 *  use one of the convenience helpers instead of doing anything else

 *  yourself though:

 *

 *  Most importantly, though, is that the handlers are built on the

 *  notion of modularity and reuse.  Specifically, rather than do all

 *  the really hard work (like parsing table indexes out of an

 *  incoming oid request) in each module, the API is designed to make

 *  it easy to write "helper" handlers that merely process some aspect

 *  of the request before passing it along to the final handler that

 *  returns the real answer.  Most people will want to make use of the

 *  @link instance instance@endlink, @link table table@endlink, @link

 *  table_iterator table_iterator@endlink, @link table_data

 *  table_data@endlink, or @link table_dataset table_dataset@endlink

 *  helpers to make their life easier.  These "helpers" interpert

 *  important aspects of the request and pass them on to you.

 *

 *  For instance, the @link table table@endlink helper is designed to

 *  hand you a list of extracted index values from an incoming

 *  request.  THe @link table_iterator table_iterator@endlink helper

 *  is built on top of the table helper, and is designed to help you

 *  iterate through data stored elsewhere (like in a kernel) that is

 *  not in OID lexographical order (ie, don't write your own index/oid

 *  sorting routine, use this helper instead).  The beauty of the

 *  @link table_iterator table_iterator helper@endlink, as well as the @link

 *  instance instance@endlink helper is that they take care of the complex

 *  GETNEXT processing entirely for you and hand you everything you

 *  need to merely return the data as if it was a GET request.  Much

 *  less code and hair pulling.  I've pulled all my hair out to help

 *  you so that only one of us has to be bald.

 *

 * @{

 */

/** Creates a MIB handler structure.

 *  The new structure is allocated and filled using the given name

 *  and access method.

 *  The returned handler should then be @link netsnmp_register_handler()

 *  registered @endlink.

 *

 *  @param name is the handler name and is copied then assigned to

 *              netsnmp_mib_handler->handler_name

 *

 *  @param handler_access_method is a function pointer used as the access

 *	   method for this handler registration instance for whatever required

 *         needs.

 *

 *  @return a pointer to a populated netsnmp_mib_handler struct to be

 *          registered

 *

 *  @see netsnmp_create_handler_registration()

 *  @see netsnmp_register_handler()

 */

netsnmp_mib_handler *

netsnmp_create_handler(const char *name,

                       Netsnmp_Node_Handler * handler_access_method)

{

    netsnmp_mib_handler *ret = SNMP_MALLOC_TYPEDEF(netsnmp_mib_handler);

    if (ret) {

        ret->access_method = handler_access_method;

        if (NULL != name) {

            ret->handler_name = strdup(name);

            if (NULL == ret->handler_name)

                SNMP_FREE(ret);

        }

    }

    return ret;

}

/** Creates a MIB handler structure.

 *  The new structure is allocated and filled using the given name,

 *  access function, registration location OID and list of modes that

 *  the handler supports. If modes == 0, then modes will automatically

 *  be set to the default value of only HANDLER_CAN_DEFAULT, which is

 *  by default read-only GET and GETNEXT requests. A hander which supports

 *  sets but not row creation should set us a mode of HANDLER_CAN_SET_ONLY.

 *  @note This ends up calling netsnmp_create_handler(name, handler_access_method)

 *  @param name is the handler name and is copied then assigned to

 *              netsnmp_handler_registration->handlerName.

 *

 *  @param handler is a function pointer used as the access

 *	method for this handler registration instance for whatever required

 *	needs.

 *

 *  @param reg_oid is the registration location oid.

 *

 *  @param reg_oid_len is the length of reg_oid; can use the macro,

 *         OID_LENGTH

 *

 *  @param modes is used to configure read/write access.  If modes == 0, 

 *	then modes will automatically be set to the default 

 *	value of only HANDLER_CAN_DEFAULT, which is by default read-only GET 

 *	and GETNEXT requests.  The other two mode options are read only, 

 *	HANDLER_CAN_RONLY, and read/write, HANDLER_CAN_RWRITE.

 *

 *		- HANDLER_CAN_GETANDGETNEXT

 *		- HANDLER_CAN_SET

 *		- HANDLER_CAN_GETBULK      

 *

 *		- HANDLER_CAN_RONLY   (HANDLER_CAN_GETANDGETNEXT)

 *		- HANDLER_CAN_RWRITE  (HANDLER_CAN_GETANDGETNEXT | 

 *			HANDLER_CAN_SET)

 *		- HANDLER_CAN_DEFAULT HANDLER_CAN_RONLY

 *

 *  @return Returns a pointer to a netsnmp_handler_registration struct.

 *          NULL is returned only when memory could not be allocated for the 

 *          netsnmp_handler_registration struct.

 *

 *

 *  @see netsnmp_create_handler()

 *  @see netsnmp_register_handler()

 */

netsnmp_handler_registration *

netsnmp_handler_registration_create(const char *name,

                                    netsnmp_mib_handler *handler,

                                    const oid * reg_oid, size_t reg_oid_len,

                                    int modes)

{

    netsnmp_handler_registration *the_reg;

    the_reg = SNMP_MALLOC_TYPEDEF(netsnmp_handler_registration);

    if (!the_reg)

        return NULL;

    if (modes)

        the_reg->modes = modes;

    else

        the_reg->modes = HANDLER_CAN_DEFAULT;

    the_reg->handler = handler;

    the_reg->priority = DEFAULT_MIB_PRIORITY;

    if (name)

        the_reg->handlerName = strdup(name);

    the_reg->rootoid = snmp_duplicate_objid(reg_oid, reg_oid_len);

    the_reg->rootoid_len = reg_oid_len;

    return the_reg;

}

/** Creates a handler registration structure with a new MIB handler.

 *  This function first @link netsnmp_create_handler() creates @endlink

 *  a MIB handler, then @link netsnmp_handler_registration_create()

 *  makes registation structure @endlink for it.

 *

 *  @param name is the handler name for netsnmp_create_handler()

 *

 *  @param handler_access_method is a function pointer used as the access

 *     method for netsnmp_create_handler()

 *

 *  @param reg_oid is the registration location oid.

 *

 *  @param reg_oid_len is the length of reg_oid; can use the macro,

 *         OID_LENGTH

 *

 *  @param modes is used to configure read/write access, as in

 *         netsnmp_handler_registration_create()

 *

 *  @return Returns a pointer to a netsnmp_handler_registration struct.

 *          If the structures creation failed, NULL is returned.

 *

 *  @see netsnmp_create_handler()

 *  @see netsnmp_handler_registration_create()

 */

netsnmp_handler_registration *

netsnmp_create_handler_registration(const char *name,

                                    Netsnmp_Node_Handler *

                                    handler_access_method, const oid * reg_oid,

                                    size_t reg_oid_len, int modes)

{

    netsnmp_handler_registration *rv = NULL;

    netsnmp_mib_handler *handler =

        netsnmp_create_handler(name, handler_access_method);

    if (handler) {

        rv = netsnmp_handler_registration_create(

            name, handler, reg_oid, reg_oid_len, modes);

        if (!rv)

            netsnmp_handler_free(handler);

    }

    return rv;

}

/** Registers a MIB handler inside the registration structure.

 *  Checks given registation handler for sanity, then

 *  @link netsnmp_register_mib() performs registration @endlink

 *  in the MIB tree, as defined by the netsnmp_handler_registration

 *  pointer. On success, SNMP_CALLBACK_APPLICATION is called.

 *  The registration struct may be created by call of

 *  netsnmp_create_handler_registration().

 *

 *  @param reginfo Pointer to a netsnmp_handler_registration struct.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 *

 *  @see netsnmp_create_handler_registration()

 *  @see netsnmp_register_mib()

 */

int

netsnmp_register_handler(netsnmp_handler_registration *reginfo)

{

    netsnmp_mib_handler *handler;

    int flags = 0;

    if (reginfo == NULL) {

        snmp_log(LOG_ERR, "netsnmp_register_handler() called illegally\n");

        netsnmp_assert(reginfo != NULL);

        return SNMP_ERR_GENERR;

    }

    DEBUGIF("handler::register") {

        DEBUGMSGTL(("handler::register", "Registering %s (", reginfo->handlerName));

        for (handler = reginfo->handler; handler; handler = handler->next) {

            DEBUGMSG(("handler::register", "::%s", handler->handler_name));

        }

        DEBUGMSG(("handler::register", ") at "));

        if (reginfo->rootoid && reginfo->range_subid) {

            DEBUGMSGOIDRANGE(("handler::register", reginfo->rootoid,

                              reginfo->rootoid_len, reginfo->range_subid,

                              reginfo->range_ubound));

        } else if (reginfo->rootoid) {

            DEBUGMSGOID(("handler::register", reginfo->rootoid,

                         reginfo->rootoid_len));

        } else {

            DEBUGMSG(("handler::register", "[null]"));

        }

        DEBUGMSG(("handler::register", "\n"));

    }

    /*

     * don't let them register for absolutely nothing.  Probably a mistake 

     */

    if (0 == reginfo->modes) {

        reginfo->modes = HANDLER_CAN_DEFAULT;

        snmp_log(LOG_WARNING, "no registration modes specified for %s. "

                 "Defaulting to 0x%x\n", reginfo->handlerName, reginfo->modes);

    }

    /*

     * for handlers that can't GETBULK, force a conversion handler on them 

     */

    if (!(reginfo->modes & HANDLER_CAN_GETBULK)) {

        handler = netsnmp_get_bulk_to_next_handler();

        if (!handler ||

            (netsnmp_inject_handler(reginfo, handler) != SNMPERR_SUCCESS)) {

            snmp_log(LOG_WARNING, "could not inject bulk to next handler\n");

            if (handler)

                netsnmp_handler_free(handler);

            /** should this be a critical error? */

            netsnmp_handler_registration_free(reginfo);

            return SNMP_ERR_GENERR;

        }

    }

    for (handler = reginfo->handler; handler; handler = handler->next) {

        if (handler->flags & MIB_HANDLER_INSTANCE)

            flags = FULLY_QUALIFIED_INSTANCE;

    }

    return netsnmp_register_mib(reginfo->handlerName,

                                NULL, 0, 0,

                                reginfo->rootoid, reginfo->rootoid_len,

                                reginfo->priority,

                                reginfo->range_subid,

                                reginfo->range_ubound, NULL,

                                reginfo->contextName, reginfo->timeout, flags,

                                reginfo, 1);

}

/** Unregisters a MIB handler described inside the registration structure.

 *  Removes a registration, performed earlier by

 *  netsnmp_register_handler(), from the MIB tree.

 *  Uses unregister_mib_context() to do the task.

 *

 *  @param reginfo Pointer to a netsnmp_handler_registration struct.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 *

 *  @see netsnmp_register_handler()

 *  @see unregister_mib_context()

 */

int

netsnmp_unregister_handler(netsnmp_handler_registration *reginfo)

{

    if (!reginfo)

        return SNMPERR_SUCCESS;

    return unregister_mib_context(reginfo->rootoid, reginfo->rootoid_len,

                                  reginfo->priority,

                                  reginfo->range_subid, reginfo->range_ubound,

                                  reginfo->contextName);

}

/** Registers a MIB handler inside the registration structure.

 *  Checks given registation handler for sanity, then

 *  @link netsnmp_register_mib() performs registration @endlink

 *  in the MIB tree, as defined by the netsnmp_handler_registration

 *  pointer. Never calls SNMP_CALLBACK_APPLICATION.

 *  The registration struct may be created by call of

 *  netsnmp_create_handler_registration().

 *

 *  @param reginfo Pointer to a netsnmp_handler_registration struct.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 *

 *  @see netsnmp_create_handler_registration()

 *  @see netsnmp_register_mib()

 */

int

netsnmp_register_handler_nocallback(netsnmp_handler_registration *reginfo)

{

    netsnmp_mib_handler *handler;

    if (reginfo == NULL) {

        snmp_log(LOG_ERR, "netsnmp_register_handler_nocallback() called illegally\n");

        netsnmp_assert(reginfo != NULL);

        return SNMP_ERR_GENERR;

    }

    DEBUGIF("handler::register") {

        DEBUGMSGTL(("handler::register",

                    "Registering (with no callback) "));

        for (handler = reginfo->handler; handler; handler = handler->next) {

            DEBUGMSG(("handler::register", "::%s", handler->handler_name));

        }

        DEBUGMSG(("handler::register", " at "));

        if (reginfo->rootoid && reginfo->range_subid) {

            DEBUGMSGOIDRANGE(("handler::register", reginfo->rootoid,

                              reginfo->rootoid_len, reginfo->range_subid,

                              reginfo->range_ubound));

        } else if (reginfo->rootoid) {

            DEBUGMSGOID(("handler::register", reginfo->rootoid,

                         reginfo->rootoid_len));

        } else {

            DEBUGMSG(("handler::register", "[null]"));

        }

        DEBUGMSG(("handler::register", "\n"));

    }

    /*

     * don't let them register for absolutely nothing.  Probably a mistake 

     */

    if (0 == reginfo->modes) {

        reginfo->modes = HANDLER_CAN_DEFAULT;

    }

    return netsnmp_register_mib(reginfo->handler->handler_name,

                                NULL, 0, 0,

                                reginfo->rootoid, reginfo->rootoid_len,

                                reginfo->priority,

                                reginfo->range_subid,

                                reginfo->range_ubound, NULL,

                                reginfo->contextName, reginfo->timeout, 0,

                                reginfo, 0);

}

/** Injects handler into the calling chain of handlers.

 *  The given MIB handler is inserted after the handler named before_what.

 *  If before_what is NULL, the handler is put at the top of the list,

 *  and hence will be the handler to be called first.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 *

 *  @see netsnmp_create_handler_registration()

 *  @see netsnmp_inject_handler()

 */

int

netsnmp_inject_handler_before(netsnmp_handler_registration *reginfo,

                              netsnmp_mib_handler *handler,

                              const char *before_what)

{

    netsnmp_mib_handler *handler2 = handler;

    if (handler == NULL || reginfo == NULL) {

        snmp_log(LOG_ERR, "netsnmp_inject_handler() called illegally\n");

        netsnmp_assert(reginfo != NULL);

        netsnmp_assert(handler != NULL);

        return SNMP_ERR_GENERR;

    }

    while (handler2->next) {

        handler2 = handler2->next;  /* Find the end of a handler sub-chain */

    }

    if (reginfo->handler == NULL) {

        DEBUGMSGTL(("handler:inject", "injecting %s\n", handler->handler_name));

    }

    else {

        DEBUGMSGTL(("handler:inject", "injecting %s before %s\n",

                    handler->handler_name, reginfo->handler->handler_name));

    }

    if (before_what) {

        netsnmp_mib_handler *nexth, *prevh = NULL;

        if (reginfo->handler == NULL) {

            snmp_log(LOG_ERR, "no handler to inject before\n");

            return SNMP_ERR_GENERR;

        }

        for(nexth = reginfo->handler; nexth;

            prevh = nexth, nexth = nexth->next) {

            if (strcmp(nexth->handler_name, before_what) == 0)

                break;

        }

        if (!nexth) {

	    snmp_log(LOG_ERR, "Cannot inject '%s' before '%s': not found\n", handler->handler_name, before_what);

	    snmp_log(LOG_ERR, "The handlers are:\n");

	    for (nexth = reginfo->handler; nexth; nexth = nexth->next)

		snmp_log(LOG_ERR, "  %s\n", nexth->handler_name);

            return SNMP_ERR_GENERR;

	}

        if (prevh) {

            /* after prevh and before nexth */

            prevh->next = handler;

            handler2->next = nexth;

            handler->prev = prevh;

            nexth->prev = handler2;

            return SNMPERR_SUCCESS;

        }

        /* else we're first, which is what we do next anyway so fall through */

    }

    handler2->next = reginfo->handler;

    if (reginfo->handler)

        reginfo->handler->prev = handler2;

    reginfo->handler = handler;

    return SNMPERR_SUCCESS;

}

/** Injects handler into the calling chain of handlers.

 *  The given MIB handler is put at the top of the list,

 *  and hence will be the handler to be called first.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 *

 *  @see netsnmp_create_handler_registration()

 *  @see netsnmp_inject_handler_before()

 */

int

netsnmp_inject_handler(netsnmp_handler_registration *reginfo,

                       netsnmp_mib_handler *handler)

{

    return netsnmp_inject_handler_before(reginfo, handler, NULL);

}

/** Calls a MIB handlers chain, starting with specific handler.

 *  The given arguments and MIB handler are checked

 *  for sanity, then the handlers are called, one by one,

 *  until next handler is NULL.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 */

NETSNMP_INLINE int

netsnmp_call_handler(netsnmp_mib_handler *next_handler,

                     netsnmp_handler_registration *reginfo,

                     netsnmp_agent_request_info *reqinfo,

                     netsnmp_request_info *requests)

{

    Netsnmp_Node_Handler *nh;

    int             ret;

    if (next_handler == NULL || reginfo == NULL || reqinfo == NULL ||

        requests == NULL) {

        snmp_log(LOG_ERR, "netsnmp_call_handler() called illegally\n");

        netsnmp_assert(next_handler != NULL);

        netsnmp_assert(reqinfo != NULL);

        netsnmp_assert(reginfo != NULL);

        netsnmp_assert(requests != NULL);

        return SNMP_ERR_GENERR;

    }

    do {

        nh = next_handler->access_method;

        if (!nh) {

            if (next_handler->next) {

                snmp_log(LOG_ERR, "no access method specified in handler %s.",

                         next_handler->handler_name);

                return SNMP_ERR_GENERR;

            }

            /*

             * The final handler registration in the chain may well not need

             * to include a handler routine, if the processing of this object

             * is handled completely by the agent toolkit helpers.

             */

            return SNMP_ERR_NOERROR;

        }

        DEBUGMSGTL(("handler:calling", "calling handler %s for mode %s\n",

                    next_handler->handler_name,

                    se_find_label_in_slist("agent_mode", reqinfo->mode)));

        /*

         * XXX: define acceptable return statuses

         */

        ret = (*nh) (next_handler, reginfo, reqinfo, requests);

        DEBUGMSGTL(("handler:returned", "handler %s returned %d\n",

                    next_handler->handler_name, ret));

        if (! (next_handler->flags & MIB_HANDLER_AUTO_NEXT))

            break;

        /*

         * did handler signal that it didn't want auto next this time around?

         */

        if(next_handler->flags & MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE) {

            next_handler->flags &= ~MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;

            break;

        }

        next_handler = next_handler->next;

    } while(next_handler);

    return ret;

}

/** @private

 *  Calls all the MIB Handlers in registration struct for a given mode.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 */

int

netsnmp_call_handlers(netsnmp_handler_registration *reginfo,

                      netsnmp_agent_request_info *reqinfo,

                      netsnmp_request_info *requests)

{

    netsnmp_request_info *request;

    int             status;

    if (reginfo == NULL || reqinfo == NULL || requests == NULL) {

        snmp_log(LOG_ERR, "netsnmp_call_handlers() called illegally\n");

        netsnmp_assert(reqinfo != NULL);

        netsnmp_assert(reginfo != NULL);

        netsnmp_assert(requests != NULL);

        return SNMP_ERR_GENERR;

    }

    if (reginfo->handler == NULL) {

        snmp_log(LOG_ERR, "no handler specified.");

        return SNMP_ERR_GENERR;

    }

    switch (reqinfo->mode) {

    case MODE_GETBULK:

    case MODE_GET:

    case MODE_GETNEXT:

        if (!(reginfo->modes & HANDLER_CAN_GETANDGETNEXT))

            return SNMP_ERR_NOERROR;    /* legal */

        break;

#ifndef NETSNMP_NO_WRITE_SUPPORT

    case MODE_SET_RESERVE1:

    case MODE_SET_RESERVE2:

    case MODE_SET_ACTION:

    case MODE_SET_COMMIT:

    case MODE_SET_FREE:

    case MODE_SET_UNDO:

        if (!(reginfo->modes & HANDLER_CAN_SET)) {

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

                netsnmp_set_request_error(reqinfo, requests,

                                          SNMP_ERR_NOTWRITABLE);

            }

            return SNMP_ERR_NOERROR;

        }

        break;

#endif /* NETSNMP_NO_WRITE_SUPPORT */

    default:

        snmp_log(LOG_ERR, "unknown mode in netsnmp_call_handlers! bug!\n");

        return SNMP_ERR_GENERR;

    }

    DEBUGMSGTL(("handler:calling", "main handler %s\n",

                reginfo->handler->handler_name));

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

        request->processed = 0;

    }

    status = netsnmp_call_handler(reginfo->handler, reginfo, reqinfo, requests);

    return status;

}

/** @private

 *  Calls the next MIB handler in the chain, after the current one.

 *  The given arguments and MIB handler are checked

 *  for sanity, then the next handler is called.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 */

NETSNMP_INLINE int

netsnmp_call_next_handler(netsnmp_mib_handler *current,

                          netsnmp_handler_registration *reginfo,

                          netsnmp_agent_request_info *reqinfo,

                          netsnmp_request_info *requests)

{

    if (current == NULL || reginfo == NULL || reqinfo == NULL ||

        requests == NULL) {

        snmp_log(LOG_ERR, "netsnmp_call_next_handler() called illegally\n");

        netsnmp_assert(current != NULL);

        netsnmp_assert(reginfo != NULL);

        netsnmp_assert(reqinfo != NULL);

        netsnmp_assert(requests != NULL);

        return SNMP_ERR_GENERR;

    }

    return netsnmp_call_handler(current->next, reginfo, reqinfo, requests);

}

/** @private

 *  Calls the next MIB handler in the chain, after the current one.

 *  The given arguments and MIB handler are not validated before

 *  the call, only request is checked.

 *

 *  @return Returns SNMPERR_SUCCESS or SNMP_ERR_* error code.

 */

netsnmp_feature_child_of(netsnmp_call_next_handler_one_request,netsnmp_unused)

#ifndef NETSNMP_FEATURE_REMOVE_NETSNMP_CALL_NEXT_HANDLER_ONE_REQUEST

NETSNMP_INLINE int

netsnmp_call_next_handler_one_request(netsnmp_mib_handler *current,

                                      netsnmp_handler_registration *reginfo,

                                      netsnmp_agent_request_info *reqinfo,

                                      netsnmp_request_info *requests)

{

    netsnmp_request_info *request;

    int ret;

    if (!requests) {

        snmp_log(LOG_ERR, "netsnmp_call_next_handler_ONE_REQUEST() called illegally\n");

        netsnmp_assert(requests != NULL);

        return SNMP_ERR_GENERR;

    }

    request = requests->next;

    requests->next = NULL;

    ret = netsnmp_call_handler(current->next, reginfo, reqinfo, requests);

    requests->next = request;

    return ret;

}

#endif /* NETSNMP_FEATURE_REMOVE_NETSNMP_CALL_NEXT_HANDLER_ONE_REQUEST */

/** Deallocates resources associated with a given handler.

 *  The handler is removed from chain and then freed.

 *  After calling this function, the handler pointer is invalid

 *  and should be set to NULL.

 *

 *  @param handler is the MIB Handler to be freed

 */

void

netsnmp_handler_free(netsnmp_mib_handler *handler)

{

    if (handler != NULL) {

        if (handler->next != NULL) {

            /** make sure we aren't pointing to ourselves.  */

            netsnmp_assert(handler != handler->next); /* bugs caught: 1 */

            netsnmp_handler_free(handler->next);

            handler->next = NULL;

        }

        if ((handler->myvoid != NULL) && (handler->data_free != NULL))

        {

            handler->data_free(handler->myvoid);

        }

        SNMP_FREE(handler->handler_name);

        SNMP_FREE(handler);

    }

}

/** Duplicates a MIB handler and all subsequent handlers.

 *  Creates a copy of all data in given handlers chain.

 *

 *  @param handler is the MIB Handler to be duplicated

 *

 *  @return Returns a pointer to the complete copy,

 *         or NULL if any problem occured.

 *

 * @see _clone_handler()

 */

netsnmp_mib_handler *

netsnmp_handler_dup(netsnmp_mib_handler *handler)

{

    netsnmp_mib_handler *h = NULL;

    if (!handler)

        goto err;

    h = _clone_handler(handler);

    if (!h)

        goto err;

    /*

     * Providing a clone function without a free function is asking for

     * memory leaks, and providing a free function without clone function

     * is asking for memory corruption. Hence the log statement below.

     */

    if (!!handler->data_clone != !!handler->data_free)

        snmp_log(LOG_ERR, "data_clone / data_free inconsistent (%s)\n",

                 handler->handler_name);

    if (handler->myvoid && handler->data_clone) {

        h->myvoid = handler->data_clone(handler->myvoid);

        if (!h->myvoid)

            goto err;

    } else

        h->myvoid = handler->myvoid;

    h->data_clone = handler->data_clone;

    h->data_free = handler->data_free;

    if (handler->next != NULL) {

        h->next = netsnmp_handler_dup(handler->next);

        if (!h->next)

            goto err;

        h->next->prev = h;

    }

    h->prev = NULL;

    return h;

err:

    netsnmp_handler_free(h);

    return NULL;

}

/** Free resources associated with a handler registration object.

 *  The registration object and all MIB Handlers in the chain are

 *  freed. When the function ends, given pointer is no longer valid

 *  and should be set to NULL.

 *

 *  @param reginfo is the handler registration object to be freed

 */

void

netsnmp_handler_registration_free(netsnmp_handler_registration *reginfo)

{

    if (reginfo != NULL) {

        netsnmp_handler_free(reginfo->handler);

        SNMP_FREE(reginfo->handlerName);

        SNMP_FREE(reginfo->contextName);

        SNMP_FREE(reginfo->rootoid);

        reginfo->rootoid_len = 0;

        SNMP_FREE(reginfo);

    }

}

/** Duplicates handler registration object and all subsequent handlers.

 *  Creates a copy of the handler registration object and all its data.

 *

 *  @param reginfo is the handler registration object to be duplicated

 *

 *  @return Returns a pointer to the complete copy,

 *         or NULL if any problem occured.

 *

 * @see netsnmp_handler_dup()

 */

netsnmp_handler_registration *

netsnmp_handler_registration_dup(netsnmp_handler_registration *reginfo)

{

    netsnmp_handler_registration *r = NULL;

    if (reginfo == NULL) {

        return NULL;

    }

    r = (netsnmp_handler_registration *) calloc(1,

                                                sizeof

                                                (netsnmp_handler_registration));

    if (r != NULL) {

        r->modes = reginfo->modes;

        r->priority = reginfo->priority;

        r->range_subid = reginfo->range_subid;

        r->timeout = reginfo->timeout;

        r->range_ubound = reginfo->range_ubound;

        r->rootoid_len = reginfo->rootoid_len;

        if (reginfo->handlerName != NULL) {

            r->handlerName = strdup(reginfo->handlerName);

            if (r->handlerName == NULL) {

                netsnmp_handler_registration_free(r);

                return NULL;

            }

        }

        if (reginfo->contextName != NULL) {

            r->contextName = strdup(reginfo->contextName);

            if (r->contextName == NULL) {

                netsnmp_handler_registration_free(r);

                return NULL;

            }

        }

        if (reginfo->rootoid != NULL) {

            r->rootoid =

                snmp_duplicate_objid(reginfo->rootoid, reginfo->rootoid_len);

            if (r->rootoid == NULL) {

                netsnmp_handler_registration_free(r);

                return NULL;

            }

        }

        r->handler = netsnmp_handler_dup(reginfo->handler);

        if (r->handler == NULL) {

            netsnmp_handler_registration_free(r);

            return NULL;

        }

        return r;

    }

    return NULL;

}

/** Creates a cache of information which can be saved for future reference.

 *  The cache is filled with pointers from parameters. Note that

 *  the input structures are not duplicated, but put directly into

 *  the new cache struct.

 *  Use netsnmp_handler_check_cache() later to make sure it's still

 *  valid before referencing it in the future.

 *

 * @see netsnmp_handler_check_cache()

 * @see netsnmp_free_delegated_cache()

 */

NETSNMP_INLINE netsnmp_delegated_cache *

netsnmp_create_delegated_cache(netsnmp_mib_handler *handler,

                               netsnmp_handler_registration *reginfo,

                               netsnmp_agent_request_info *reqinfo,

                               netsnmp_request_info *requests,

                               void *localinfo)

{

    netsnmp_delegated_cache *ret;