/*
 * 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 (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 <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>

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

#include <net-snmp/agent/instance.h>
#include <net-snmp/agent/scalar.h>

#include <string.h>

#ifdef HAVE_DMALLOC_H
static void free_wrapper(void * p)
{
    free(p);
}
#else
#define free_wrapper free
#endif

netsnmp_feature_provide(watcher_all);
netsnmp_feature_child_of(watcher_all, mib_helpers);
netsnmp_feature_child_of(watcher_create_info6, watcher_all);
netsnmp_feature_child_of(watcher_register_timestamp, watcher_all);
netsnmp_feature_child_of(watcher_ulong_scalar, watcher_all);
netsnmp_feature_child_of(watcher_read_only_ulong_scalar, watcher_all);
netsnmp_feature_child_of(watcher_read_only_int_scalar, watcher_all);
netsnmp_feature_child_of(watcher_long_scalar, watcher_all);
netsnmp_feature_child_of(watcher_read_only_long_scalar, watcher_all);
netsnmp_feature_child_of(watcher_int_scalar, watcher_all);
netsnmp_feature_child_of(read_only_counter32_scalar, watcher_all);
netsnmp_feature_child_of(watcher_spinlock, watcher_all);

/** @defgroup watcher watcher
 *  Watch a specified variable and process it as an instance or scalar object
 *  @ingroup leaf
 *  @{
 */
netsnmp_mib_handler *
netsnmp_get_watcher_handler(void)
{
    netsnmp_mib_handler *ret = NULL;
    
    ret = netsnmp_create_handler("watcher",
                                 netsnmp_watcher_helper_handler);
    if (ret) {
        ret->flags |= MIB_HANDLER_AUTO_NEXT;
    }
    return ret;
}

netsnmp_watcher_info *
netsnmp_init_watcher_info6(netsnmp_watcher_info *winfo,
                           void *data, size_t size, u_char type,
                           int flags, size_t max_size, size_t* size_p)
{
    winfo->data = data;
    winfo->data_size = size;
    winfo->max_size = max_size;
    winfo->type = type;
    winfo->flags = flags;
    winfo->data_size_p = size_p;
    return winfo;
}

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_CREATE_INFO6
netsnmp_watcher_info *
netsnmp_create_watcher_info6(void *data, size_t size, u_char type,
                             int flags, size_t max_size, size_t* size_p)
{
    netsnmp_watcher_info *winfo = SNMP_MALLOC_TYPEDEF(netsnmp_watcher_info);
    if (winfo)
        netsnmp_init_watcher_info6(winfo, data, size, type, flags, max_size,
                                   size_p);
    return winfo;
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_CREATE_INFO6 */

netsnmp_watcher_info *
netsnmp_init_watcher_info(netsnmp_watcher_info *winfo,
                          void *data, size_t size, u_char type, int flags)
{
  return netsnmp_init_watcher_info6(winfo, data, size,
				    type, (flags ? flags : WATCHER_FIXED_SIZE),
				    size,  /* Probably wrong for non-fixed
					    * size data */
				    NULL);
}

netsnmp_watcher_info *
netsnmp_create_watcher_info(void *data, size_t size, u_char type, int flags)
{
    netsnmp_watcher_info *winfo = SNMP_MALLOC_TYPEDEF(netsnmp_watcher_info);
    if (winfo)
        netsnmp_init_watcher_info(winfo, data, size, type, flags);
    return winfo;
}

/**
 * Register a watched scalar. The caller remains the owner of watchinfo.
 *
 * @see netsnmp_register_watched_instance2()
 */
int
netsnmp_register_watched_instance(netsnmp_handler_registration *reginfo,
                                  netsnmp_watcher_info         *watchinfo)
{
    netsnmp_mib_handler *whandler = NULL;

    if (reginfo && watchinfo) {
        whandler = netsnmp_get_watcher_handler();
        if (whandler) {
            whandler->myvoid = (void *)watchinfo;
            if (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS)
                return netsnmp_register_instance(reginfo);
        }
    }

    snmp_log(LOG_ERR, "could not create watched instance handler\n");
    netsnmp_handler_free(whandler);
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}

/**
 * Register a watched scalar. Ownership of watchinfo is transferred to the handler.
 *
 * @see netsnmp_register_watched_instance()
 */
int
netsnmp_register_watched_instance2(netsnmp_handler_registration *reginfo,
				   netsnmp_watcher_info         *watchinfo)
{
    netsnmp_mib_handler *whandler = NULL;

    if (reginfo && watchinfo) {
        whandler = netsnmp_get_watcher_handler();
        if (whandler) {
            whandler->myvoid = (void *)watchinfo;
            netsnmp_owns_watcher_info(whandler);
            if (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS)
                return netsnmp_register_instance(reginfo);
        }
    }

    snmp_log(LOG_ERR, "could not create watched instance2 handler\n");
    netsnmp_handler_free(whandler);
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}

/**
 * Register a watched scalar. The caller remains the owner of watchinfo.
 *
 * @see netsnmp_register_watched_scalar2()
 */
int
netsnmp_register_watched_scalar(netsnmp_handler_registration *reginfo,
                                  netsnmp_watcher_info         *watchinfo)
{
    netsnmp_mib_handler *whandler = NULL;

    if (reginfo && watchinfo) {
        whandler = netsnmp_get_watcher_handler();
        if (whandler) {
            whandler->myvoid = (void *)watchinfo;
            if (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS)
                return netsnmp_register_scalar(reginfo);
        }
    }

    snmp_log(LOG_ERR, "could not create watched scalar handler\n");
    netsnmp_handler_free(whandler);
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}

/**
 * Register a watched scalar. Ownership of watchinfo is transferred to the handler.
 *
 * @see netsnmp_register_watched_scalar()
 */
int
netsnmp_register_watched_scalar2(netsnmp_handler_registration *reginfo,
                                  netsnmp_watcher_info         *watchinfo)
{
    netsnmp_mib_handler *whandler = NULL;

    if (reginfo && watchinfo) {
        whandler = netsnmp_get_watcher_handler();
        if (whandler) {
            whandler->myvoid = (void *)watchinfo;
            netsnmp_owns_watcher_info(whandler);
            if (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS)
                return netsnmp_register_scalar(reginfo);
        }
    }

    snmp_log(LOG_ERR, "could not create watched scalar2 handler\n");
    netsnmp_handler_free(whandler);
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}

void
netsnmp_owns_watcher_info(netsnmp_mib_handler *handler)
{
    netsnmp_assert(handler);
    netsnmp_assert(handler->myvoid);
    handler->data_clone = (void *(*)(void *))netsnmp_clone_watcher_info;
    handler->data_free = free;
}

/** @cond */

NETSNMP_STATIC_INLINE size_t
get_data_size(const netsnmp_watcher_info* winfo)
{
    if (winfo->flags & WATCHER_SIZE_STRLEN)
        return strlen((const char*)winfo->data);
    else {
        size_t res;
        if (winfo->flags & WATCHER_SIZE_IS_PTR)
            res = *winfo->data_size_p;
        else
            res = winfo->data_size;
        if (winfo->flags & WATCHER_SIZE_UNIT_OIDS)
          res *= sizeof(oid);
        return res;
    }
}

NETSNMP_STATIC_INLINE void
set_data(netsnmp_watcher_info* winfo, void* data, size_t size)
{
    memcpy(winfo->data, data, size);
    if (winfo->flags & WATCHER_SIZE_STRLEN)
        ((char*)winfo->data)[size] = '\0';
    else {
        if (winfo->flags & WATCHER_SIZE_UNIT_OIDS)
          size /= sizeof(oid);
        if (winfo->flags & WATCHER_SIZE_IS_PTR)
            *winfo->data_size_p = size;
        else
            winfo->data_size = size;
    }
}

typedef struct {
    size_t size;
    char data[1];
} netsnmp_watcher_cache;

NETSNMP_STATIC_INLINE netsnmp_watcher_cache*
netsnmp_watcher_cache_create(const void* data, size_t size)
{
    netsnmp_watcher_cache *res = (netsnmp_watcher_cache*)
        malloc(sizeof(netsnmp_watcher_cache) + size - 1);
    if (res) {
        res->size = size;
        memcpy(res->data, data, size);
    }
    return res;
}

/** @endcond */

int
netsnmp_watcher_helper_handler(netsnmp_mib_handler *handler,
                               netsnmp_handler_registration *reginfo,
                               netsnmp_agent_request_info *reqinfo,
                               netsnmp_request_info *requests)
{
    netsnmp_watcher_info  *winfo = (netsnmp_watcher_info *) handler->myvoid;
#ifndef NETSNMP_NO_WRITE_SUPPORT
    netsnmp_watcher_cache *old_data;
#endif /* NETSNMP_NO_WRITE_SUPPORT */

    DEBUGMSGTL(("helper:watcher", "Got request:  %d\n", reqinfo->mode));
    DEBUGMSGTL(( "helper:watcher", "  oid:"));
    DEBUGMSGOID(("helper:watcher", requests->requestvb->name,
                                   requests->requestvb->name_length));
    DEBUGMSG((   "helper:watcher", "\n"));

    switch (reqinfo->mode) {
        /*
         * data requests 
         */
    case MODE_GET:
        snmp_set_var_typed_value(requests->requestvb,
                                 winfo->type,
                                 winfo->data,
                                 get_data_size(winfo));
        break;

        /*
         * SET requests.  Should only get here if registered RWRITE 
         */
#ifndef NETSNMP_NO_WRITE_SUPPORT
    case MODE_SET_RESERVE1:
        if (requests->requestvb->type != winfo->type) {
            netsnmp_set_request_error(reqinfo, requests, SNMP_ERR_WRONGTYPE);
            handler->flags |= MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
        } else if (((winfo->flags & WATCHER_MAX_SIZE) &&
                     requests->requestvb->val_len > winfo->max_size) ||
            ((winfo->flags & WATCHER_FIXED_SIZE) &&
                requests->requestvb->val_len != get_data_size(winfo))) {
            netsnmp_set_request_error(reqinfo, requests, SNMP_ERR_WRONGLENGTH);
            handler->flags |= MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
        } else if ((winfo->flags & WATCHER_SIZE_STRLEN) &&
            (memchr(requests->requestvb->val.string, '\0',
                requests->requestvb->val_len) != NULL)) {
            netsnmp_set_request_error(reqinfo, requests, SNMP_ERR_WRONGVALUE);
            handler->flags |= MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
        }
        break;

    case MODE_SET_RESERVE2:
        /*
         * store old info for undo later 
         */
        old_data =
            netsnmp_watcher_cache_create(winfo->data, get_data_size(winfo));
        if (old_data == NULL) {
            netsnmp_set_request_error(reqinfo, requests,
                                      SNMP_ERR_RESOURCEUNAVAILABLE);
            handler->flags |= MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
        } else
            netsnmp_request_add_list_data(requests,
                                          netsnmp_create_data_list
                                          ("watcher", old_data, &free_wrapper));
        break;

    case MODE_SET_FREE:
        /*
         * nothing to do 
         */
        break;

    case MODE_SET_ACTION:
        /*
         * update current 
         */
        set_data(winfo, (void *)requests->requestvb->val.string,
                                requests->requestvb->val_len);
        break;

    case MODE_SET_UNDO:
        old_data = (netsnmp_watcher_cache*)netsnmp_request_get_list_data(requests, "watcher");
        set_data(winfo, old_data->data, old_data->size);
        break;

    case MODE_SET_COMMIT:
        break;
#endif /* NETSNMP_NO_WRITE_SUPPORT */

    default:
        snmp_log(LOG_ERR, "watcher handler called with an unknown mode: %d\n",
                 reqinfo->mode);
        return SNMP_ERR_GENERR;

    }

    /* next handler called automatically - 'AUTO_NEXT' */
    return SNMP_ERR_NOERROR;
}


    /***************************
     *
     * A specialised form of the above, reporting
     *   the sysUpTime indicated by a given timestamp
     *
     ***************************/

netsnmp_mib_handler *
netsnmp_get_watched_timestamp_handler(void)
{
    netsnmp_mib_handler *ret = NULL;
    
    ret = netsnmp_create_handler("watcher-timestamp",
                                 netsnmp_watched_timestamp_handler);
    if (ret) {
        ret->flags |= MIB_HANDLER_AUTO_NEXT;
    }
    return ret;
}

int
netsnmp_watched_timestamp_register(netsnmp_mib_handler *whandler,
                                   netsnmp_handler_registration *reginfo,
                                   marker_t timestamp)
{
    if (reginfo && whandler && timestamp) {
        whandler->myvoid = (void *)timestamp;
        if (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS)
            return netsnmp_register_scalar(reginfo);   /* XXX - or instance? */
    }

    snmp_log(LOG_ERR, "could not create watched timestamp handler\n");
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_REGISTER_TIMESTAMP
int
netsnmp_register_watched_timestamp(netsnmp_handler_registration *reginfo,
                                   marker_t timestamp)
{
    netsnmp_mib_handler *whandler;

    whandler         = netsnmp_get_watched_timestamp_handler();

    return netsnmp_watched_timestamp_register(whandler, reginfo, timestamp);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_REGISTER_TIMESTAMP */


int
netsnmp_watched_timestamp_handler(netsnmp_mib_handler *handler,
                               netsnmp_handler_registration *reginfo,
                               netsnmp_agent_request_info *reqinfo,
                               netsnmp_request_info *requests)
{
    marker_t timestamp = (marker_t) handler->myvoid;
    long     uptime;

    DEBUGMSGTL(("helper:watcher:timestamp",
                               "Got request:  %d\n", reqinfo->mode));
    DEBUGMSGTL(( "helper:watcher:timestamp", "  oid:"));
    DEBUGMSGOID(("helper:watcher:timestamp", requests->requestvb->name,
                                   requests->requestvb->name_length));
    DEBUGMSG((   "helper:watcher:timestamp", "\n"));

    switch (reqinfo->mode) {
        /*
         * data requests 
         */
    case MODE_GET:
        if (handler->flags & NETSNMP_WATCHER_DIRECT)
            uptime = * (long*)timestamp;
        else
            uptime = netsnmp_marker_uptime( timestamp );
        snmp_set_var_typed_value(requests->requestvb,
                                 ASN_TIMETICKS,
                                 (u_char *) &uptime,
                                 sizeof(uptime));
        break;

        /*
         * Timestamps are inherently Read-Only,
         *  so don't need to support SET requests.
         */
#ifndef NETSNMP_NO_WRITE_SUPPORT
    case MODE_SET_RESERVE1:
        netsnmp_set_request_error(reqinfo, requests,
                                  SNMP_ERR_NOTWRITABLE);
        handler->flags |= MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
        return SNMP_ERR_NOTWRITABLE;
#endif /* NETSNMP_NO_WRITE_SUPPORT */
    }

    /* next handler called automatically - 'AUTO_NEXT' */
    return SNMP_ERR_NOERROR;
}

    /***************************
     *
     * Another specialised form of the above,
     *   implementing a 'TestAndIncr' spinlock
     *
     ***************************/

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_SPINLOCK

netsnmp_mib_handler *
netsnmp_get_watched_spinlock_handler(void)
{
    netsnmp_mib_handler *ret = NULL;
    
    ret = netsnmp_create_handler("watcher-spinlock",
                                 netsnmp_watched_spinlock_handler);
    if (ret) {
        ret->flags |= MIB_HANDLER_AUTO_NEXT;
    }
    return ret;
}

int
netsnmp_register_watched_spinlock(netsnmp_handler_registration *reginfo,
                                   int *spinlock)
{
    netsnmp_mib_handler  *whandler = NULL;
    netsnmp_watcher_info *winfo = NULL;

    if (reginfo && spinlock) {
        whandler = netsnmp_get_watched_spinlock_handler();
        if (whandler) {
            whandler->myvoid = (void *)spinlock;
            winfo = netsnmp_create_watcher_info((void *)spinlock, sizeof(int),
                                                ASN_INTEGER,
                                                WATCHER_FIXED_SIZE);
            if (winfo &&
                (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS))
                return netsnmp_register_watched_scalar2(reginfo, winfo);
        }
    }

    snmp_log(LOG_ERR, "could not create watched spinlock handler\n");
    SNMP_FREE(winfo);
    netsnmp_handler_free(whandler);
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}


int
netsnmp_watched_spinlock_handler(netsnmp_mib_handler *handler,
                               netsnmp_handler_registration *reginfo,
                               netsnmp_agent_request_info *reqinfo,
                               netsnmp_request_info *requests)
{
#ifndef NETSNMP_NO_WRITE_SUPPORT
    int     *spinlock = (int *) handler->myvoid;
    netsnmp_request_info *request;
#endif /* NETSNMP_NO_WRITE_SUPPORT */

    DEBUGMSGTL(("helper:watcher:spinlock",
                               "Got request:  %d\n", reqinfo->mode));
    DEBUGMSGTL(( "helper:watcher:spinlock", "  oid:"));
    DEBUGMSGOID(("helper:watcher:spinlock", requests->requestvb->name,
                                   requests->requestvb->name_length));
    DEBUGMSG((   "helper:watcher:spinlock", "\n"));

    switch (reqinfo->mode) {
        /*
         * Ensure the assigned value matches the current one
         */
#ifndef NETSNMP_NO_WRITE_SUPPORT
    case MODE_SET_RESERVE1:
        for (request=requests; request; request=request->next) {
            if (request->processed)
                continue;

            if (*request->requestvb->val.integer != *spinlock) {
                netsnmp_set_request_error(reqinfo, requests, SNMP_ERR_WRONGVALUE);
                handler->flags |= MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
                return SNMP_ERR_WRONGVALUE;

            }
        }
        break;

        /*
         * Everything else worked, so increment the spinlock
         */
    case MODE_SET_COMMIT:
	(*spinlock)++;
	break;
#endif /* NETSNMP_NO_WRITE_SUPPORT */
    }

    /* next handler called automatically - 'AUTO_NEXT' */
    return SNMP_ERR_NOERROR;
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_SPINLOCK */

    /***************************
     *
     *   Convenience registration routines - modelled on
     *   the equivalent netsnmp_register_*_instance() calls
     *
     ***************************/

netsnmp_watcher_info *
netsnmp_clone_watcher_info(netsnmp_watcher_info *winfo)
{
    netsnmp_watcher_info *copy = malloc(sizeof(*copy));
    if (copy)
	*copy = *winfo;
    return copy;
}

static int
register_scalar_watcher(const char* name,
                        const oid* reg_oid, size_t reg_oid_len,
                        void *data, size_t size, u_char type,
                        Netsnmp_Node_Handler * subhandler, int mode)
{
    netsnmp_handler_registration *reginfo = NULL;
    netsnmp_mib_handler *whandler = NULL;
    netsnmp_watcher_info* watchinfo;

    if (!name || !reg_oid || !data)
        return MIB_REGISTRATION_FAILED;

    watchinfo = netsnmp_create_watcher_info(data, size, type,
                                            WATCHER_FIXED_SIZE);
    if (watchinfo) {
        whandler = netsnmp_get_watcher_handler();
        if (whandler) {
            whandler->myvoid = watchinfo;
            netsnmp_owns_watcher_info(whandler);
            reginfo =
                netsnmp_create_handler_registration(name, subhandler,
                                                    reg_oid, reg_oid_len,
                                                    mode);
            if (reginfo &&
                (netsnmp_inject_handler(reginfo, whandler) == SNMPERR_SUCCESS))
                return netsnmp_register_scalar(reginfo);
        }
    }

    snmp_log(LOG_ERR, "failed to register scalar watcher\n");
    netsnmp_handler_free(whandler);
    SNMP_FREE(watchinfo);
    netsnmp_handler_registration_free(reginfo);

    return MIB_REGISTRATION_FAILED;
}

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_ULONG_SCALAR
int
netsnmp_register_ulong_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              u_long * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( u_long ),
        ASN_UNSIGNED, subhandler, HANDLER_CAN_RWRITE);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_ULONG_SCALAR */

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_READ_ONLY_ULONG_SCALAR
int
netsnmp_register_read_only_ulong_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              u_long * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( u_long ),
        ASN_UNSIGNED, subhandler, HANDLER_CAN_RONLY);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_READ_ONLY_ULONG_SCALAR */

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_LONG_SCALAR
int
netsnmp_register_long_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              long * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( long ),
        ASN_INTEGER, subhandler, HANDLER_CAN_RWRITE);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_LONG_SCALAR */

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_READ_ONLY_LONG_SCALAR
int
netsnmp_register_read_only_long_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              long * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( long ),
        ASN_INTEGER, subhandler, HANDLER_CAN_RONLY);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_READ_ONLY_LONG_SCALAR */


#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_INT_SCALAR
int
netsnmp_register_int_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              int * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( int ),
        ASN_INTEGER, subhandler, HANDLER_CAN_RWRITE);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_INT_SCALAR */

#ifndef NETSNMP_FEATURE_REMOVE_WATCHER_READ_ONLY_INT_SCALAR
int
netsnmp_register_read_only_int_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              int * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( int ),
        ASN_INTEGER, subhandler, HANDLER_CAN_RONLY);
}
#endif /* NETSNMP_FEATURE_REMOVE_WATCHER_READ_ONLY_INT_SCALAR */

#ifndef NETSNMP_FEATURE_REMOVE_READ_ONLY_COUNTER32_SCALAR
int
netsnmp_register_read_only_counter32_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              u_long * it,
                              Netsnmp_Node_Handler * subhandler)
{
    return register_scalar_watcher(
        name, reg_oid, reg_oid_len,
        (void *)it, sizeof( u_long ),
        ASN_COUNTER, subhandler, HANDLER_CAN_RONLY);
}
#endif /* NETSNMP_FEATURE_REMOVE_READ_ONLY_COUNTER32_SCALAR */
/**  @} */

