/*

* Note: this file originally auto-generated by mib2c using

* version : 14170 $ of $

*

* $Id:$

*/

/* standard Net-SNMP includes */

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

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

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

#include <X11/Xlib.h>

#include "NVCtrl.h"

#include "NVCtrlLib.h"

/* include our parent header */

#include "nvCtrlTable.h"

#include "nvCtrlTable_data_access.h"

/** @ingroup interface

* @addtogroup data_access data_access: Routines to access data

*

* These routines are used to locate the data used to satisfy

* requests.

*

* @{

*/

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

**********************************************************************

***

*** Table nvCtrlTable

***

**********************************************************************

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

/*

* NV-CTRL-MIB::nvCtrlTable is subid 2 of nvCtrl.

* Its status is Current.

* OID: .1.3.6.1.4.1.2021.13.42.2, length: 10

*/

/**

* initialization for nvCtrlTable data access

*

* This function is called during startup to allow you to

* allocate any resources you need for the data table.

*

* @param nvCtrlTable_reg

* Pointer to nvCtrlTable_registration

*

* @retval MFD_SUCCESS : success.

* @retval MFD_ERROR : unrecoverable error.

*/

int

nvCtrlTable_init_data(nvCtrlTable_registration * nvCtrlTable_reg)

{

DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_init_data","called\n"));

/*

* TODO:303:o: Initialize nvCtrlTable data.

*/

/*

***************************************************

*** START EXAMPLE CODE ***

***---------------------------------------------***/

/*

* if you are the sole writer for the file, you could

* open it here. However, as stated earlier, we are assuming

* the worst case, which in this case means that the file is

* written to by someone else, and might not even exist when

* we start up. So we can't do anything here.

*/

/*

***---------------------------------------------***

*** END EXAMPLE CODE ***

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

return MFD_SUCCESS;

} /* nvCtrlTable_init_data */

/**

* container overview

*

*/

/**

* container initialization

*

* @param container_ptr_ptr A pointer to a container pointer. If you

* create a custom container, use this parameter to return it

* to the MFD helper. If set to NULL, the MFD helper will

* allocate a container for you.

* @param cache A pointer to a cache structure. You can set the timeout

* and other cache flags using this pointer.

*

* This function is called at startup to allow you to customize certain

* aspects of the access method. For the most part, it is for advanced

* users. The default code should suffice for most cases. If no custom

* container is allocated, the MFD code will create one for your.

*

* This is also the place to set up cache behavior. The default, to

* simply set the cache timeout, will work well with the default

* container. If you are using a custom container, you may want to

* look at the cache helper documentation to see if there are any

* flags you want to set.

*

* @remark

* This would also be a good place to do any initialization needed

* for you data source. For example, opening a connection to another

* process that will supply the data, opening a database, etc.

*/

void

nvCtrlTable_container_init(netsnmp_container **container_ptr_ptr,

netsnmp_cache *cache)

{

DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_container_init","called\n"));

if (NULL == container_ptr_ptr) {

snmp_log(LOG_ERR,"bad container param to nvCtrlTable_container_init\n");

return;

}

/*

* For advanced users, you can use a custom container. If you

* do not create one, one will be created for you.

*/

*container_ptr_ptr = NULL;

if (NULL == cache) {

snmp_log(LOG_ERR,"bad cache param to nvCtrlTable_container_init\n");

return;

}

/*

* TODO:345:A: Set up nvCtrlTable cache properties.

*

* Also for advanced users, you can set parameters for the

* cache. Do not change the magic pointer, as it is used

* by the MFD helper. To completely disable caching, set

* cache->enabled to 0.

*/

cache->timeout = NV_CTRL_TABLE_CACHE_TIMEOUT; /* seconds */

} /* nvCtrlTable_container_init */

/**

* container shutdown

*

* @param container_ptr A pointer to the container.

*

* This function is called at shutdown to allow you to customize certain

* aspects of the access method. For the most part, it is for advanced

* users. The default code should suffice for most cases.

*

* This function is called before nvCtrlTable_container_free().

*

* @remark

* This would also be a good place to do any cleanup needed

* for you data source. For example, closing a connection to another

* process that supplied the data, closing a database, etc.

*/

void

nvCtrlTable_container_shutdown(netsnmp_container *container_ptr)

{

DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_container_shutdown","called\n"));

if (NULL == container_ptr) {

snmp_log(LOG_ERR,"bad params to nvCtrlTable_container_shutdown\n");

return;

}

} /* nvCtrlTable_container_shutdown */

/**

* load initial data

*

* TODO:350:M: Implement nvCtrlTable data load

* This function will also be called by the cache helper to load

* the container again (after the container free function has been

* called to free the previous contents).

*

* @param container container to which items should be inserted

*

* @retval MFD_SUCCESS : success.

* @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source

* @retval MFD_ERROR : other error.

*

* This function is called to load the index(es) (and data, optionally)

* for the every row in the data set.

*

* @remark

* While loading the data, the only important thing is the indexes.

* If access to your data is cheap/fast (e.g. you have a pointer to a

* structure in memory), it would make sense to update the data here.

* If, however, the accessing the data invovles more work (e.g. parsing

* some other existing data, or peforming calculations to derive the data),

* then you can limit yourself to setting the indexes and saving any

* information you will need later. Then use the saved information in

* nvCtrlTable_row_prep() for populating data.

*

* @note

* If you need consistency between rows (like you want statistics

* for each row to be from the same time frame), you should set all

* data here.

*

*/

int

nvCtrlTable_container_load(netsnmp_container *container)

{

nvCtrlTable_rowreq_ctx *rowreq_ctx;

size_t count = 0;

Display *dpy;

Bool ret;

int event_base, error_base, major, minor, gpus;

int gpu, retval, len;

char *str;

DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_container_load", "called\n"));

/*

* open a connection to the X server indicated by the DISPLAY

* environment variable

*/

dpy = XOpenDisplay(NULL);

if (!dpy) {

DEBUGMSGTL(("nvCtrlTable:nvCtrlTable_container_load",

"Cannot open display '%s'.\n", XDisplayName(NULL)));

return MFD_RESOURCE_UNAVAILABLE;

}

/*

* check if the NV-CONTROL X extension is present on this X server

*/

ret = XNVCTRLQueryExtension(dpy, &event_base, &error_base);

if (ret != True) {

DEBUGMSGTL(("nvCtrlTable:nvCtrlTable_container_load",

"The NV-CONTROL X extension does not exist on '%s'.\n",

XDisplayName(NULL)));

return MFD_RESOURCE_UNAVAILABLE;

}

/*

* query the major and minor extension version

*/

ret = XNVCTRLQueryVersion(dpy, &major, &minor);

if (ret != True) {

DEBUGMSGTL(("nvCtrlTable:nvCtrlTable_container_load",

"The NV-CONTROL X extension does not exist on '%s'.\n",

XDisplayName(NULL)));

return MFD_RESOURCE_UNAVAILABLE;

}

/*

* query number of GPUs via the NV-CONTROL X extension; then, allocate

* a rowreq context, set the index(es) and data, and insert into the

* container.

*/

if (!XNVCTRLQueryTargetCount(dpy, NV_CTRL_TARGET_TYPE_GPU, &gpus)) {

snmp_log(LOG_ERR, "failed to query number of GPUs\n");

return MFD_ERROR;

}

for (gpu = 0; gpu < gpus; gpu++) {

rowreq_ctx = nvCtrlTable_allocate_rowreq_ctx();

if (NULL == rowreq_ctx) {

snmp_log(LOG_ERR, "memory allocation failed\n");

return MFD_RESOURCE_UNAVAILABLE;

}

if (MFD_SUCCESS != nvCtrlTable_indexes_set(rowreq_ctx, gpu)) {

snmp_log(LOG_ERR, "error setting index while loading"

"nvCtrlTable data.\n");

nvCtrlTable_release_rowreq_ctx(rowreq_ctx);

continue;

}

/*

* setup/save data for nvCtrlProductName

* nvCtrlProductName(2)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H

*/

ret = XNVCTRLQueryTargetStringAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_STRING_PRODUCT_NAME,

&str);

if (ret) {

len = strlen(str);

if (sizeof(rowreq_ctx->data.nvCtrlProductName) < len) {

snmp_log(LOG_ERR,"not enough space for value\n");

return MFD_ERROR;

}

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_PRODUCT_NAME_FLAG;

rowreq_ctx->data.nvCtrlProductName_len = len;

memcpy(rowreq_ctx->data.nvCtrlProductName, str, len);

XFree(str);

}

/*

* setup/save data for nvCtrlVBiosVersion

* nvCtrlVBiosVersion(3)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H

*/

ret = XNVCTRLQueryTargetStringAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_STRING_VBIOS_VERSION,

&str);

if (ret) {

len = strlen(str);

if (sizeof(rowreq_ctx->data.nvCtrlVBiosVersion) < len) {

snmp_log(LOG_ERR,"not enough space for value\n");

return MFD_ERROR;

}

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_VBIOS_VERSION_FLAG;

rowreq_ctx->data.nvCtrlVBiosVersion_len = len;

memcpy(rowreq_ctx->data.nvCtrlVBiosVersion, str, len);

XFree(str);

}

/*

* setup/save data for nvCtrlNvidiaDriverVersion

* nvCtrlNvidiaDriverVersion(4)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H

*/

ret = XNVCTRLQueryTargetStringAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_STRING_NVIDIA_DRIVER_VERSION,

&str);

if (ret) {

len = strlen(str);

if (sizeof(rowreq_ctx->data.nvCtrlNvidiaDriverVersion) < len) {

snmp_log(LOG_ERR,"not enough space for value\n");

return MFD_ERROR;

}

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_NVIDIA_DRIVER_VERSION_FLAG;

rowreq_ctx->data.nvCtrlNvidiaDriverVersion_len = len;

memcpy(rowreq_ctx->data.nvCtrlNvidiaDriverVersion, str, len);

XFree(str);

}

/*

* setup/save data for nvCtrlVersion

* nvCtrlVersion(5)/DisplayString/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H

*/

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_VERSION_FLAG;

snprintf(rowreq_ctx->data.nvCtrlVersion, sizeof(rowreq_ctx->data.nvCtrlVersion), "%d.%d", major, minor);

rowreq_ctx->data.nvCtrlVersion_len = strlen(rowreq_ctx->data.nvCtrlVersion);

/*

* setup/save data for nvCtrlBusType

* nvCtrlBusType(6)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_BUS_TYPE,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_BUS_TYPE_FLAG;

rowreq_ctx->data.nvCtrlBusType = retval;

}

/*

* setup/save data for nvCtrlBusRate

* nvCtrlBusRate(7)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_BUS_RATE,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_BUS_RATE_FLAG;

rowreq_ctx->data.nvCtrlBusRate = retval;

}

/*

* setup/save data for nvCtrlVideoRam

* nvCtrlVideoRam(8)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_VIDEO_RAM,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_VIDEO_RAM_FLAG;

rowreq_ctx->data.nvCtrlVideoRam = retval;

}

/*

* setup/save data for nvCtrlIrq

* nvCtrlIrq(9)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_IRQ,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_IRQ_FLAG;

rowreq_ctx->data.nvCtrlIrq = retval;

}

/*

* setup/save data for nvCtrlGPUCoreTemp

* nvCtrlGPUCoreTemp(10)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_CORE_TEMPERATURE,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CORE_TEMP_FLAG;

rowreq_ctx->data.nvCtrlGPUCoreTemp = retval;

}

/*

* setup/save data for nvCtrlGPUCoreThreshold

* nvCtrlGPUCoreThreshold(11)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_CORE_THRESHOLD,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CORE_THRESHOLD_FLAG;

rowreq_ctx->data.nvCtrlGPUCoreThreshold = retval;

}

/*

* setup/save data for nvCtrlGPUDefaultCoreThreshold

* nvCtrlGPUDefaultCoreThreshold(12)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_DEFAULT_CORE_THRESHOLD,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_CORE_THRESHOLD_FLAG;

rowreq_ctx->data.nvCtrlGPUDefaultCoreThreshold = retval;

}

/*

* setup/save data for nvCtrlGPUMaxCoreThreshold

* nvCtrlGPUMaxCoreThreshold(13)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_MAX_CORE_THRESHOLD,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_MAX_CORE_THRESHOLD_FLAG;

rowreq_ctx->data.nvCtrlGPUMaxCoreThreshold = retval;

}

/*

* setup/save data for nvCtrlGPUAmbientTemp

* nvCtrlGPUAmbientTemp(14)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_AMBIENT_TEMPERATURE,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_AMBIENT_TEMP_FLAG;

rowreq_ctx->data.nvCtrlGPUAmbientTemp = retval;

}

/*

* setup/save data for nvCtrlGPUOverclockingState

* nvCtrlGPUOverclockingState(15)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_OVERCLOCKING_STATE,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_OVERCLOCKING_STATE_FLAG;

rowreq_ctx->data.nvCtrlGPUOverclockingState = retval;

}

/*

* setup/save data for nvCtrlGPU2DGPUClockFreq

* nvCtrlGPU2DGPUClockFreq(16)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_2D_CLOCK_FREQS,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_2D_GPU_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPU2DGPUClockFreq = (retval >> 16) & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPU2DMemClockFreq

* nvCtrlGPU2DMemClockFreq(17)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_2D_MEM_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPU2DMemClockFreq = retval & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPU3DGPUClockFreq

* nvCtrlGPU3DGPUClockFreq(18)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_3D_CLOCK_FREQS,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_3D_GPU_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPU3DGPUClockFreq = (retval >> 16) & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPU3DMemClockFreq

* nvCtrlGPU3DMemClockFreq(19)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_3D_MEM_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPU3DMemClockFreq = retval & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPUDefault2DGPUClockFreq

* nvCtrlGPUDefault2DGPUClockFreq(20)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_DEFAULT_2D_CLOCK_FREQS,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_2D_GPU_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPUDefault2DGPUClockFreq = (retval >> 16) & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPUDefault2DMemClockFreq

* nvCtrlGPUDefault2DMemClockFreq(21)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_2D_MEM_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPUDefault2DMemClockFreq = retval & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPUDefault3DGPUClockFreq

* nvCtrlGPUDefault3DGPUClockFreq(22)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_DEFAULT_3D_CLOCK_FREQS,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_3D_GPU_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPUDefault3DGPUClockFreq = (retval >> 16) & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPUDefault3DMemClockFreq

* nvCtrlGPUDefault3DMemClockFreq(23)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_DEFAULT_3D_MEM_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPUDefault3DMemClockFreq = retval & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPUCurrentGPUClockFreq

* nvCtrlGPUCurrentGPUClockFreq(24)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

ret = XNVCTRLQueryTargetAttribute(dpy,

NV_CTRL_TARGET_TYPE_GPU,

gpu,

0,

NV_CTRL_GPU_CURRENT_CLOCK_FREQS,

&retval);

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CURRENT_GPU_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPUCurrentGPUClockFreq = (retval >> 16) & 0xFFFF;

}

/*

* setup/save data for nvCtrlGPUCurrentMemClockFreq

* nvCtrlGPUCurrentMemClockFreq(25)/INTEGER32/ASN_INTEGER/long(long)//l/A/w/e/r/d/h

*/

if (ret) {

rowreq_ctx->column_exists_flags |= COLUMN_NV_CTRL_GPU_CURRENT_MEM_CLOCK_FREQ_FLAG;

rowreq_ctx->data.nvCtrlGPUCurrentMemClockFreq = retval & 0xFFFF;

}

/*

* insert into table container

*/

CONTAINER_INSERT(container, rowreq_ctx);

++count;

}

/*

* close the display connection

*/

XCloseDisplay(dpy);

DEBUGMSGT(("verbose:nvCtrlTable:nvCtrlTable_container_load",

"inserted %d records\n", count));

return MFD_SUCCESS;

} /* nvCtrlTable_container_load */

/**

* container clean up

*

* @param container container with all current items

*

* This optional callback is called prior to all

* item's being removed from the container. If you

* need to do any processing before that, do it here.

*

* @note

* The MFD helper will take care of releasing all the row contexts.

*

*/

void

nvCtrlTable_container_free(netsnmp_container *container)

{

DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_container_free","called\n"));

/*

* TODO:380:M: Free nvCtrlTable container data.

*/

} /* nvCtrlTable_container_free */

/**

* prepare row for processing.

*

* When the agent has located the row for a request, this function is

* called to prepare the row for processing. If you fully populated

* the data context during the index setup phase, you may not need to

* do anything.

*

* @param rowreq_ctx pointer to a context.

*

* @retval MFD_SUCCESS : success.

* @retval MFD_ERROR : other error.

*/

int

nvCtrlTable_row_prep( nvCtrlTable_rowreq_ctx *rowreq_ctx)

{

DEBUGMSGTL(("verbose:nvCtrlTable:nvCtrlTable_row_prep","called\n"));

netsnmp_assert(NULL != rowreq_ctx);

/*

* TODO:390:o: Prepare row for request.

* If populating row data was delayed, this is the place to

* fill in the row for this request.

*/

return MFD_SUCCESS;

} /* nvCtrlTable_row_prep */

/** @} */