inetNetToMediaTable_data_access.c
上传用户:wxp200602
上传日期:2007-10-30
资源大小:4028k
文件大小:10k
源码类别:

SNMP编程

开发平台:

Unix_Linux

  1. /*
  2.  * Note: this file originally auto-generated by mib2c using
  3.  *       version : 1.12 $ of : mfd-data-access.m2c,v $ 
  4.  *
  5.  * $Id: inetNetToMediaTable_data_access.c,v 1.6.2.2 2005/03/28 19:29:25 rstory Exp $
  6.  */
  7. /*
  8.  * standard Net-SNMP includes 
  9.  */
  10. #include <net-snmp/net-snmp-config.h>
  11. #include <net-snmp/net-snmp-includes.h>
  12. #include <net-snmp/agent/net-snmp-agent-includes.h>
  13. /*
  14.  * include our parent header 
  15.  */
  16. #include "inetNetToMediaTable.h"
  17. #include "inetNetToMediaTable_data_access.h"
  18. /** @defgroup data_access data_access: Routines to access data
  19.  *
  20.  * These routines are used to locate the data used to satisfy
  21.  * requests.
  22.  * 
  23.  * @{
  24.  */
  25. /**********************************************************************
  26.  **********************************************************************
  27.  ***
  28.  *** Table inetNetToMediaTable
  29.  ***
  30.  **********************************************************************
  31.  **********************************************************************/
  32. /*
  33.  * inetNetToMediaTable is subid 35 of ip.
  34.  * Its status is Current.
  35.  * OID: .1.3.6.1.2.1.4.35, length: 8
  36.  */
  37. /**
  38.  * initialization for inetNetToMediaTable data access
  39.  *
  40.  * This function is called during startup to allow you to
  41.  * allocate any resources you need for the data table.
  42.  *
  43.  * @param inetNetToMediaTable_reg
  44.  *        Pointer to inetNetToMediaTable_registration
  45.  *
  46.  * @retval MFD_SUCCESS : success.
  47.  * @retval MFD_ERROR   : unrecoverable error.
  48.  */
  49. int
  50. inetNetToMediaTable_init_data(inetNetToMediaTable_registration_ptr
  51.                               inetNetToMediaTable_reg)
  52. {
  53.     DEBUGMSGTL(("verbose:inetNetToMediaTable:inetNetToMediaTable_init_data", "calledn"));
  54.     /*
  55.      * TODO:303:o: Initialize inetNetToMediaTable data.
  56.      */
  57.     return MFD_SUCCESS;
  58. }                               /* inetNetToMediaTable_init_data */
  59. /**
  60.  * container-cached overview
  61.  *
  62.  */
  63. /***********************************************************************
  64.  *
  65.  * cache
  66.  *
  67.  ***********************************************************************/
  68. /**
  69.  * container initialization
  70.  *
  71.  * @param container_ptr_ptr A pointer to a container pointer. If you
  72.  *        create a custom container, use this parameter to return it
  73.  *        to the MFD helper. If set to NULL, the MFD helper will
  74.  *        allocate a container for you.
  75.  * @param  cache A pointer to a cache structure. You can set the timeout
  76.  *         and other cache flags using this pointer.
  77.  *
  78.  *  This function is called at startup to allow you to customize certain
  79.  *  aspects of the access method. For the most part, it is for advanced
  80.  *  users. The default code should suffice for most cases. If no custom
  81.  *  container is allocated, the MFD code will create one for your.
  82.  *
  83.  *  This is also the place to set up cache behavior. The default, to
  84.  *  simply set the cache timeout, will work well with the default
  85.  *  container. If you are using a custom container, you may want to
  86.  *  look at the cache helper documentation to see if there are any
  87.  *  flags you want to set.
  88.  *
  89.  * @remark
  90.  *  This would also be a good place to do any initialization needed
  91.  *  for you data source. For example, opening a connection to another
  92.  *  process that will supply the data, opening a database, etc.
  93.  */
  94. void
  95. inetNetToMediaTable_container_init(netsnmp_container ** container_ptr_ptr,
  96.                                    netsnmp_cache * cache)
  97. {
  98.     DEBUGMSGTL(("verbose:inetNetToMediaTable:inetNetToMediaTable_container_init", "calledn"));
  99.     if ((NULL == cache) || (NULL == container_ptr_ptr)) {
  100.         snmp_log(LOG_ERR,
  101.                  "bad params to inetNetToMediaTable_container_initn");
  102.         return;
  103.     }
  104.     /*
  105.      * For advanced users, you can use a custom container. If you
  106.      * do not create one, one will be created for you.
  107.      */
  108.     *container_ptr_ptr = NULL;
  109.     /*
  110.      * TODO:345:A: Set up inetNetToMediaTable cache properties.
  111.      *
  112.      * Also for advanced users, you can set parameters for the
  113.      * cache. Do not change the magic pointer, as it is used
  114.      * by the MFD helper.
  115.      */
  116.     cache->timeout = INETNETTOMEDIATABLE_CACHE_TIMEOUT; /* seconds */
  117. }                               /* inetNetToMediaTable_container_init */
  118. /**
  119.  * check entry for update
  120.  *
  121.  */
  122. static void
  123. _snarf_arp_entry(netsnmp_arp_entry * arp_entry,
  124.                  netsnmp_container * container)
  125. {
  126.     inetNetToMediaTable_rowreq_ctx *rowreq_ctx;
  127.     int inetAddressType;
  128.     DEBUGTRACE;
  129.     netsnmp_assert(NULL != arp_entry);
  130.     netsnmp_assert(NULL != container);
  131.     /*
  132.      * convert the addr len to an inetAddressType
  133.      */
  134.     switch(arp_entry->arp_ipaddress_len) {
  135.         case 4:
  136.             inetAddressType = INETADDRESSTYPE_IPV4;
  137.             break;
  138.             
  139.         case 6:
  140.             inetAddressType = INETADDRESSTYPE_IPV6;
  141.             break;
  142.         default:
  143.             netsnmp_access_arp_entry_free(arp_entry);
  144.             snmp_log(LOG_ERR, "unsupported address typen");
  145.             return;
  146.     }
  147.     /*
  148.      * allocate an row context and set the index(es), then add it to
  149.      * the container
  150.      */
  151.     rowreq_ctx = inetNetToMediaTable_allocate_rowreq_ctx(arp_entry);
  152.     if ((NULL != rowreq_ctx) &&
  153.         (MFD_SUCCESS == inetNetToMediaTable_indexes_set
  154.          (rowreq_ctx, rowreq_ctx->data->if_index, inetAddressType,
  155.           rowreq_ctx->data->arp_ipaddress,
  156.           rowreq_ctx->data->arp_ipaddress_len))) {
  157.         CONTAINER_INSERT(container, rowreq_ctx);
  158.     } else {
  159.         if (rowreq_ctx) {
  160.             snmp_log(LOG_ERR, "error setting index while loading "
  161.                      "inetNetToMediaTable cache.n");
  162.             inetNetToMediaTable_release_rowreq_ctx(rowreq_ctx);
  163.         } else
  164.             netsnmp_access_arp_entry_free(arp_entry);
  165.     }
  166. }
  167. /**
  168.  * load cache data
  169.  *
  170.  * TODO:350:M: Implement inetNetToMediaTable cache load
  171.  *
  172.  * @param container container to which items should be inserted
  173.  *
  174.  * @retval MFD_SUCCESS              : success.
  175.  * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source
  176.  * @retval MFD_ERROR                : other error.
  177.  *
  178.  *  This function is called to cache the index(es) (and data, optionally)
  179.  *  for the every row in the data set.
  180.  *
  181.  * @remark
  182.  *  While loading the cache, the only important thing is the indexes.
  183.  *  If access to your data is cheap/fast (e.g. you have a pointer to a
  184.  *  structure in memory), it would make sense to update the data here.
  185.  *  If, however, the accessing the data invovles more work (e.g. parsing
  186.  *  some other existing data, or peforming calculations to derive the data),
  187.  *  then you can limit yourself to setting the indexes and saving any
  188.  *  information you will need later. Then use the saved information in
  189.  *  inetNetToMediaTable_row_prep() for populating data.
  190.  *
  191.  * @note
  192.  *  If you need consistency between rows (like you want statistics
  193.  *  for each row to be from the same time frame), you should set all
  194.  *  data here.
  195.  *
  196.  */
  197. int
  198. inetNetToMediaTable_cache_load(netsnmp_container * container)
  199. {
  200.     netsnmp_container *arp_container;
  201.     DEBUGMSGTL(("verbose:inetNetToMediaTable:inetNetToMediaTable_cache_load", "calledn"));
  202.     /*
  203.      * TODO:351:M: |-> Load/update data in the inetNetToMediaTable container.
  204.      * loop over your inetNetToMediaTable data, allocate a rowreq context,
  205.      * set the index(es) [and data, optionally] and insert into
  206.      * the container.
  207.      */
  208.     arp_container =
  209.         netsnmp_access_arp_container_load(NULL,
  210.                                           NETSNMP_ACCESS_ARP_LOAD_NOFLAGS);
  211.     if (NULL == arp_container)
  212.         return MFD_RESOURCE_UNAVAILABLE;        /* msg already logged */
  213.     /*
  214.      * we just got a fresh copy of data. snarf data
  215.      */
  216.     CONTAINER_FOR_EACH(arp_container,
  217.                        (netsnmp_container_obj_func *) _snarf_arp_entry,
  218.                        container);
  219.     /*
  220.      * free the container. we've either claimed each entry, or released it,
  221.      * so the access function doesn't need to clear the container.
  222.      */
  223.     netsnmp_access_arp_container_free(arp_container,
  224.                                       NETSNMP_ACCESS_ARP_FREE_DONT_CLEAR);
  225.     DEBUGMSGT(("verbose:inetNetToMediaTable:inetNetToMediaTable_cache_load", "%d recordsn", CONTAINER_SIZE(container)));
  226.     return MFD_SUCCESS;
  227. }                               /* inetNetToMediaTable_cache_load */
  228. /**
  229.  * cache clean up
  230.  *
  231.  * @param container container with all current items
  232.  *
  233.  *  This optional callback is called prior to all
  234.  *  item's being removed from the container. If you
  235.  *  need to do any processing before that, do it here.
  236.  *
  237.  * @note
  238.  *  The MFD helper will take care of releasing all the row contexts.
  239.  *
  240.  */
  241. void
  242. inetNetToMediaTable_cache_free(netsnmp_container * container)
  243. {
  244.     DEBUGMSGTL(("verbose:inetNetToMediaTable:inetNetToMediaTable_cache_free", "calledn"));
  245.     /*
  246.      * TODO:380:M: Free inetNetToMediaTable cache.
  247.      */
  248. }                               /* inetNetToMediaTable_cache_free */
  249. /**
  250.  * prepare row for processing.
  251.  *
  252.  *  When the agent has located the row for a request, this function is
  253.  *  called to prepare the row for processing. If you fully populated
  254.  *  the data context during the index setup phase, you may not need to
  255.  *  do anything.
  256.  *
  257.  * @param rowreq_ctx pointer to a context.
  258.  *
  259.  * @retval MFD_SUCCESS     : success.
  260.  * @retval MFD_ERROR       : other error.
  261.  */
  262. int
  263. inetNetToMediaTable_row_prep(inetNetToMediaTable_rowreq_ctx * rowreq_ctx)
  264. {
  265.     DEBUGMSGTL(("verbose:inetNetToMediaTable:inetNetToMediaTable_row_prep",
  266.                 "calledn"));
  267.     netsnmp_assert(NULL != rowreq_ctx);
  268.     /*
  269.      * TODO:390:o: Prepare row for request.
  270.      * If populating row data was delayed, this is the place to
  271.      * fill in the row for this request.
  272.      */
  273.     return MFD_SUCCESS;
  274. }                               /* inetNetToMediaTable_row_prep */
  275. /** @} */