开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
lookupCtlTable.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：50k
源码类别：

SNMP编程

开发平台：

Unix_Linux

lookupCtlTable.c：源码内容
  1. /*
  2.  *Copyright(c)2004,Cisco URP imburses and Network Information Center in Beijing University of Posts and Telecommunications researches.
  3.  *
  4.  *All right reserved
  5.  *
  6.  *File Name:lookupCtlTable.c
  7.  *File Description:Rows of the lookupCtlTable MIB add , delete and read.Rows of lookupResultsTable
  8.  *              MIB add and delete.
  9.  
  10.  *
  11.  *Current Version:1.0
  12.  *Author:ChenJing
  13.  *Date:2004.8.20
  14.  */
  16. /*
  17.  * This should always be included first before anything else 
  18.  */
  19. #if HAVE_STDLIB_H
  20. #include <stdlib.h>
  21. #endif
  22. #if HAVE_STRING_H
  23. #include <string.h>
  24. #else
  25. #include <strings.h>
  26. #endif
  27. #ifdef HAVE_LIMITS_H
  28. #include <limits.h>
  29. #endif
  31. #include <netdb.h>
  32. #include <netinet/in.h>
  34. #include <sys/types.h>
  35. #include <sys/socket.h>
  36. #include <arpa/inet.h>
  38. #include <net-snmp/net-snmp-config.h>
  39. #include <net-snmp/net-snmp-includes.h>
  40. #include <net-snmp/agent/net-snmp-agent-includes.h>
  42. #include "lookupCtlTable.h"
  43. #include "lookupResultsTable.h"
  44. #include "header_complex.h"
  46. /*
  47.  *For discontinuity checking.
  48.  */
  50. oid             lookupCtlTable_variables_oid[] =
  51.     { 1, 3, 6, 1, 2, 1, 82, 1, 3 };
  54. struct variable2 lookupCtlTable_variables[] = {
  55.     /*
  56.      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
  57.      */
  58.     {COLUMN_LOOKUPCTLTARGETADDRESSTYPE, ASN_INTEGER, RWRITE, var_lookupCtlTable, 2, {1, 3}},
  59.     {COLUMN_LOOKUPCTLTARGETADDRESS,   ASN_OCTET_STR, RWRITE, var_lookupCtlTable, 2, {1, 4}},
  60.     {COLUMN_LOOKUPCTLOPERSTATUS, ASN_INTEGER, RONLY, var_lookupCtlTable, 2, {1, 5}},
  61.     {COLUMN_LOOKUPCTLTIME,      ASN_UNSIGNED, RONLY, var_lookupCtlTable, 2, {1, 6}},
  62.     {COLUMN_LOOKUPCTLRC,         ASN_INTEGER, RONLY, var_lookupCtlTable, 2, {1, 7}},
  63.     {COLUMN_LOOKUPCTLROWSTATUS, ASN_INTEGER, RWRITE, var_lookupCtlTable, 2, {1, 8}}
  64. };
  67. /*
  68.  * global storage of our data, saved in and configured by header_complex() 
  69.  */
  72. struct header_complex_index *lookupCtlTableStorage = NULL;
  73. struct header_complex_index *lookupResultsTableStorage = NULL;
  75. void
  76. init_lookupCtlTable(void)
  77. {
  78.     DEBUGMSGTL(("lookupCtlTable", "initializing...  "));
  79.     /*
  80.      * register ourselves with the agent to handle our mib tree 
  81.      */
  82.     REGISTER_MIB("lookupCtlTable", lookupCtlTable_variables, variable2,
  83.                  lookupCtlTable_variables_oid);
  86.     /*
  87.      * register our config handler(s) to deal with registrations 
  88.      */
  89.     snmpd_register_config_handler("lookupCtlTable", parse_lookupCtlTable,
  90.                                   NULL, NULL);
  92.     /*
  93.      * we need to be called back later to store our data 
  94.      */
  95.     snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  96.                            store_lookupCtlTable, NULL);
  98.     DEBUGMSGTL(("lookupCtlTable", "done.n"));
  99. }
  101. struct lookupTable_data *
  102. create_lookupTable_data(void)
  103. {
  104.     struct lookupTable_data *StorageNew = NULL;
  105.     StorageNew = SNMP_MALLOC_STRUCT(lookupTable_data);
  106.     if (StorageNew == NULL) {
  107.         exit(1);
  108.     }
  109.     StorageNew->lookupCtlTargetAddress = strdup("");
  110.     StorageNew->lookupCtlTargetAddressLen = 0;
  111.     StorageNew->lookupCtlOperStatus = 2l;
  112.     StorageNew->lookupCtlTime = 0;
  113.     StorageNew->storagetype = ST_NONVOLATILE;
  114.     return StorageNew;
  115. }
  117. /*
  118.  * lookupCtlTable_add(): adds a structure node to our data set 
  119.  */
  120. int
  121. lookupCtlTable_add(struct lookupTable_data *thedata)
  122. {
  123.     netsnmp_variable_list *vars = NULL;
  126.     DEBUGMSGTL(("lookupCtlTable", "adding data...  "));
  127.     /*
  128.      * add the index variables to the varbind list, which is 
  129.      * used by header_complex to index the data 
  130.      */
  133.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
  134.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */
  137.     if (header_complex_add_data(&lookupCtlTableStorage, vars, thedata) ==
  138.         NULL) {
  139.         return SNMPERR_GENERR;
  140.     }
  141.     DEBUGMSGTL(("lookupCtlTable", "registered an entryn"));
  142.     vars = NULL;
  144.     DEBUGMSGTL(("lookupCtlTable", "done.n"));
  145.     return SNMPERR_SUCCESS;
  146. }
  148. int
  149. lookupResultsTable_add(struct lookupTable_data *thedata)
  150. {
  151.     netsnmp_variable_list *vars_list = NULL;
  152.     struct lookupResultsTable_data *p = NULL;
  153.     p = thedata->ResultsTable;
  154.     if (thedata->ResultsTable != NULL)
  155.         do {
  156.             snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->lookupCtlOwnerIndex, p->lookupCtlOwnerIndexLen);  /* lookupCtlOwnerIndex */
  157.             snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->lookupCtlOperationName, p->lookupCtlOperationNameLen);    /* lookupCtlOperationName */
  158.             snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &p->lookupResultsIndex, sizeof(p->lookupResultsIndex));       /* lookupResultsIndex */
  161.             DEBUGMSGTL(("lookupResultsTable", "adding data...  "));
  162.             /*
  163.              * add the index variables to the varbind list, which is 
  164.              * used by header_complex to index the data 
  165.              */
  167.             if (header_complex_add_data
  168.                 (&lookupResultsTableStorage, vars_list, p) == NULL) {
  169.                 return SNMPERR_GENERR;
  170.             }
  172.             DEBUGMSGTL(("lookupResultsTable", "out finishedn"));
  173.             vars_list = NULL;
  174.             p = p->next;
  175.         } while (p != NULL);
  178.     DEBUGMSGTL(("lookupResultsTable", "done.n"));
  179. }
  181. void
  182. lookupCtlTable_cleaner(struct header_complex_index *thestuff)
  183. {
  184.     struct header_complex_index *hciptr = NULL;
  185.     struct lookupTable_data *StorageDel = NULL;
  186.     DEBUGMSGTL(("lookupCtlTable", "cleanerout  "));
  187.     for (hciptr = thestuff; hciptr != NULL; hciptr = hciptr->next) {
  188.         StorageDel =
  189.             header_complex_extract_entry(&lookupCtlTableStorage, hciptr);
  190.         if (StorageDel != NULL) {
  191.             free(StorageDel->lookupCtlOwnerIndex);
  192.             StorageDel->lookupCtlOwnerIndex = NULL;
  193.             free(StorageDel->lookupCtlOperationName);
  194.             StorageDel->lookupCtlOperationName = NULL;
  195.             free(StorageDel->lookupCtlTargetAddress);
  196.             StorageDel->lookupCtlTargetAddress = NULL;
  197.             free(StorageDel);
  198.             StorageDel = NULL;
  200.         }
  201.         DEBUGMSGTL(("lookupCtlTable", "cleaner  "));
  202.     }
  203. }
  205. /*
  206.  * parse_lookupCtlTable():
  207.  *   parses .conf file entries needed to configure the mib.
  208.  */
  209. void
  210. parse_lookupCtlTable(const char *token, char *line)
  211. {
  212.     size_t          tmpint;
  213.     struct lookupTable_data *StorageTmp =
  214.         SNMP_MALLOC_STRUCT(lookupTable_data);
  216.     DEBUGMSGTL(("lookupCtlTable", "parsing config...  "));
  219.     if (StorageTmp == NULL) {
  220.         config_perror("malloc failure");
  221.         return;
  222.     }
  225.     line =
  226.         read_config_read_data(ASN_OCTET_STR, line,
  227.                               &StorageTmp->lookupCtlOwnerIndex,
  228.                               &StorageTmp->lookupCtlOwnerIndexLen);
  229.     if (StorageTmp->lookupCtlOwnerIndex == NULL) {
  230.         config_perror("invalid specification for lookupCtlOwnerIndex");
  231.         return;
  232.     }
  234.     line =
  235.         read_config_read_data(ASN_OCTET_STR, line,
  236.                               &StorageTmp->lookupCtlOperationName,
  237.                               &StorageTmp->lookupCtlOperationNameLen);
  238.     if (StorageTmp->lookupCtlOperationName == NULL) {
  239.         config_perror("invalid specification for lookupCtlOperationName");
  240.         return;
  241.     }
  243.     line =
  244.         read_config_read_data(ASN_INTEGER, line,
  245.                               &StorageTmp->lookupCtlTargetAddressType,
  246.                               &tmpint);
  248.     line =
  249.         read_config_read_data(ASN_OCTET_STR, line,
  250.                               &StorageTmp->lookupCtlTargetAddress,
  251.                               &StorageTmp->lookupCtlTargetAddressLen);
  252.     if (StorageTmp->lookupCtlTargetAddress == NULL) {
  253.         config_perror("invalid specification for lookupCtlTargetAddress");
  254.         return;
  255.     }
  257.     line =
  258.         read_config_read_data(ASN_INTEGER, line,
  259.                               &StorageTmp->lookupCtlOperStatus, &tmpint);
  261.     line =
  262.         read_config_read_data(ASN_UNSIGNED, line,
  263.                               &StorageTmp->lookupCtlTime, &tmpint);
  265.     line =
  266.         read_config_read_data(ASN_INTEGER, line,
  267.                               &StorageTmp->lookupCtlRc, &tmpint);
  269.     line =
  270.         read_config_read_data(ASN_INTEGER, line,
  271.                               &StorageTmp->lookupCtlRowStatus, &tmpint);
  274.     StorageTmp->storagetype = ST_NONVOLATILE;
  275.     lookupCtlTable_add(StorageTmp);
  276.     /* lookupCtlTable_cleaner(lookupCtlTableStorage); */
  278.     DEBUGMSGTL(("lookupCtlTable", "done.n"));
  279. }
  283. /*
  284.  * store_lookupCtlTable():
  285.  *   stores .conf file entries needed to configure the mib.
  286.  */
  287. int
  288. store_lookupCtlTable(int majorID, int minorID, void *serverarg,
  289.                      void *clientarg)
  290. {
  291.     char            line[SNMP_MAXBUF];
  292.     char           *cptr;
  293.     size_t          tmpint;
  294.     struct lookupTable_data *StorageTmp;
  295.     struct header_complex_index *hcindex;
  298.     DEBUGMSGTL(("lookupCtlTable", "storing data...  "));
  301.     for (hcindex = lookupCtlTableStorage; hcindex != NULL;
  302.          hcindex = hcindex->next) {
  303.         StorageTmp = (struct lookupTable_data *) hcindex->data;
  305.         if (StorageTmp->storagetype != ST_READONLY) {
  306.             memset(line, 0, sizeof(line));
  307.             strcat(line, "lookupCtlTable ");
  308.             cptr = line + strlen(line);
  311.             cptr =
  312.                 read_config_store_data(ASN_OCTET_STR, cptr,
  313.                                        &StorageTmp->lookupCtlOwnerIndex,
  314.                                        &StorageTmp->
  315.                                        lookupCtlOwnerIndexLen);
  316.             cptr =
  317.                 read_config_store_data(ASN_OCTET_STR, cptr,
  318.                                        &StorageTmp->lookupCtlOperationName,
  319.                                        &StorageTmp->
  320.                                        lookupCtlOperationNameLen);
  321.             cptr =
  322.                 read_config_store_data(ASN_INTEGER, cptr,
  323.                                        &StorageTmp->
  324.                                        lookupCtlTargetAddressType,
  325.                                        &tmpint);
  326.             cptr =
  327.                 read_config_store_data(ASN_OCTET_STR, cptr,
  328.                                        &StorageTmp->lookupCtlTargetAddress,
  329.                                        &StorageTmp->
  330.                                        lookupCtlTargetAddressLen);
  332.             cptr =
  333.                 read_config_store_data(ASN_INTEGER, cptr,
  334.                                        &StorageTmp->lookupCtlOperStatus,
  335.                                        &tmpint);
  336.             cptr =
  337.                 read_config_store_data(ASN_UNSIGNED, cptr,
  338.                                        &StorageTmp->lookupCtlTime,
  339.                                        &tmpint);
  340.             cptr =
  341.                 read_config_store_data(ASN_INTEGER, cptr,
  342.                                        &StorageTmp->lookupCtlRc, &tmpint);
  343.             cptr =
  344.                 read_config_store_data(ASN_INTEGER, cptr,
  345.                                        &StorageTmp->lookupCtlRowStatus,
  346.                                        &tmpint);
  350.             snmpd_store_config(line);
  351.         }
  352.     }
  353.     DEBUGMSGTL(("lookupCtlTable", "done.n"));
  354.     return SNMPERR_SUCCESS;
  355. }
  360. /*
  361.  * var_lookupCtlTable():
  362.  *   Handle this table separately from the scalar value case.
  363.  *   The workings of this are basically the same as for var_mteObjectsTable above.
  364.  */
  365. unsigned char  *
  366. var_lookupCtlTable(struct variable *vp,
  367.                    oid * name,
  368.                    size_t *length,
  369.                    int exact, size_t *var_len, WriteMethod ** write_method)
  370. {
  373.     struct lookupTable_data *StorageTmp = NULL;
  375.     /*
  376.      * this assumes you have registered all your data properly
  377.      */
  378.     if ((StorageTmp =
  379.          header_complex(lookupCtlTableStorage, vp, name, length, exact,
  380.                         var_len, write_method)) == NULL) {
  381.         if (vp->magic == COLUMN_LOOKUPCTLROWSTATUS)
  382.             *write_method = write_lookupCtlRowStatus;
  383.         return NULL;
  384.     }
  386.     /*
  387.      * this is where we do the value assignments for the mib results.
  388.      */
  389.     switch (vp->magic) {
  392.     case COLUMN_LOOKUPCTLTARGETADDRESSTYPE:
  393.         *write_method = write_lookupCtlTargetAddressType;
  394.         *var_len = sizeof(StorageTmp->lookupCtlTargetAddressType);
  395.         return (u_char *) & StorageTmp->lookupCtlTargetAddressType;
  397.     case COLUMN_LOOKUPCTLTARGETADDRESS:
  398.         *write_method = write_lookupCtlTargetAddress;
  399.         *var_len = (StorageTmp->lookupCtlTargetAddressLen);
  401.         return (u_char *) StorageTmp->lookupCtlTargetAddress;
  403.     case COLUMN_LOOKUPCTLOPERSTATUS:
  404.         *var_len = sizeof(StorageTmp->lookupCtlOperStatus);
  406.         return (u_char *) & StorageTmp->lookupCtlOperStatus;
  408.     case COLUMN_LOOKUPCTLTIME:
  409.         *var_len = sizeof(StorageTmp->lookupCtlTime);
  411.         return (u_char *) & StorageTmp->lookupCtlTime;
  413.     case COLUMN_LOOKUPCTLRC:
  414.         *var_len = sizeof(StorageTmp->lookupCtlRc);
  416.         return (u_char *) & StorageTmp->lookupCtlRc;
  418.     case COLUMN_LOOKUPCTLROWSTATUS:
  419.         *write_method = write_lookupCtlRowStatus;
  420.         *var_len = sizeof(StorageTmp->lookupCtlRowStatus);
  422.         return (u_char *) & StorageTmp->lookupCtlRowStatus;
  424.     default:
  425.         ERROR_MSG("");
  426.     }
  427.     return NULL;
  428. }
  431. void
  432. run_lookup(struct lookupTable_data *item)
  433. {
  435.     long            addressType;
  436.     char           *address = NULL;
  437.     size_t          addresslen;
  438.     struct lookupResultsTable_data *head = NULL;
  439.     struct lookupResultsTable_data *current = NULL;
  440.     struct lookupResultsTable_data *temp = NULL;
  441.     int             i = 0, n = 1, t = 0;
  443.     /* for ipv4,ipv6 */
  444.     unsigned int    addr_in, addr_in6;
  445.     struct hostent *lookup = NULL;
  446.     struct sockaddr_in *addr = NULL;
  448.     struct timeval  tpstart, tpend;
  449.     unsigned long   timeuse, timeuse4, timeuse6;
  451.     /* for dns */
  453.     struct in_addr  a;
  454.     struct in6_addr a6;
  455.     char           *strptr = NULL;
  456.     struct addrinfo hints, *res = NULL, *tempinfo = NULL;
  457.     struct sockaddr_in6 myaddress6;
  458.     char            buf[BUFSIZ];
  461.     if (item == NULL)
  462.         return;
  464.     addressType = (long) item->lookupCtlTargetAddressType;
  465.     addresslen = (size_t) item->lookupCtlTargetAddressLen;
  466.     address = (char *) malloc(addresslen + 1);
  467.     memcpy(address, item->lookupCtlTargetAddress, addresslen + 1);
  468.     address[addresslen] = '';
  470.     if (addressType == 1) {
  471.         addr_in = inet_addr(address);
  472.         if (addr_in == 0xffffffff
  473.             && strcmp(address, "255.255.255.255") != 0) {
  474.             DEBUGMSGTL(("lookupResultsTable", "Invalid argument: %sn",
  475.                         address));
  476.             return;
  477.         }
  479.         gettimeofday(&tpstart, NULL);
  480.         lookup = gethostbyaddr((char *) &addr_in, 4, AF_INET);
  481.         gettimeofday(&tpend, NULL);
  482.         timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
  483.             tpend.tv_usec - tpstart.tv_usec;
  484.         timeuse /= 1000;
  485.         modify_lookupCtlTime(item, timeuse);
  486.         modify_lookupCtlOperStatus(item, 3l);
  488.         if (lookup == NULL) {
  489.             DEBUGMSGTL(("lookupCtlTable",
  490.                         "Can't get a network host entry for ipv4 address: %sn",
  491.                         address));
  492.             modify_lookupCtlRc(item, 1l);
  493.             return;
  494.         } else {
  495.             modify_lookupCtlRc(item, 0l);
  496.             if (lookup->h_name != NULL) {
  497.                 current = temp =
  498.                     SNMP_MALLOC_STRUCT(lookupResultsTable_data);
  499.                 if (temp == NULL) {
  500.                     exit(1);
  501.                 }
  502.                 temp->lookupResultsIndex = n;
  504.                 temp->lookupCtlOwnerIndex =
  505.                     (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
  506.                 if (temp->lookupCtlOwnerIndex == NULL) {
  507.                     exit(1);
  508.                 }
  509.                 memcpy(temp->lookupCtlOwnerIndex,
  510.                        item->lookupCtlOwnerIndex,
  511.                        item->lookupCtlOwnerIndexLen + 1);
  512.                 temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
  513.                     '';
  514.                 temp->lookupCtlOwnerIndexLen =
  515.                     item->lookupCtlOwnerIndexLen;
  517.                 temp->lookupCtlOperationName =
  518.                     (char *) malloc(item->lookupCtlOperationNameLen + 1);
  519.                 if (temp->lookupCtlOperationName == NULL) {
  520.                     exit(1);
  521.                 }
  522.                 memcpy(temp->lookupCtlOperationName,
  523.                        item->lookupCtlOperationName,
  524.                        item->lookupCtlOperationNameLen + 1);
  525.                 temp->lookupCtlOperationName[item->
  526.                                              lookupCtlOperationNameLen] =
  527.                     '';
  528.                 temp->lookupCtlOperationNameLen =
  529.                     item->lookupCtlOperationNameLen;
  531.                 temp->lookupResultsAddressType = 16;
  532.                 temp->lookupResultsAddress =
  533.                     (char *) malloc(strlen(lookup->h_name) + 1);
  534.                 memcpy(temp->lookupResultsAddress, lookup->h_name,
  535.                        strlen(lookup->h_name) + 1);
  536.                 temp->lookupResultsAddress[strlen(lookup->h_name)] = '';
  537.                 temp->lookupResultsAddressLen = strlen(lookup->h_name);
  538.                 item->ResultsTable = temp;
  539.                 n = n + 1;
  541.             }
  543.             i = 0;
  544.             while (lookup->h_aliases[i]) {
  545.                 temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
  546.                 if (temp == NULL) {
  547.                     exit(1);
  548.                 }
  549.                 temp->lookupCtlOwnerIndex =
  550.                     (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
  551.                 if (temp->lookupCtlOwnerIndex == NULL) {
  552.                     exit(1);
  553.                 }
  554.                 memcpy(temp->lookupCtlOwnerIndex,
  555.                        item->lookupCtlOwnerIndex,
  556.                        item->lookupCtlOwnerIndexLen + 1);
  557.                 temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
  558.                     '';
  559.                 temp->lookupCtlOwnerIndexLen =
  560.                     item->lookupCtlOwnerIndexLen;
  562.                 temp->lookupCtlOperationName =
  563.                     (char *) malloc(item->lookupCtlOperationNameLen + 1);
  564.                 if (temp->lookupCtlOperationName == NULL) {
  565.                     exit(1);
  566.                 }
  567.                 memcpy(temp->lookupCtlOperationName,
  568.                        item->lookupCtlOperationName,
  569.                        item->lookupCtlOperationNameLen + 1);
  570.                 temp->lookupCtlOperationName[item->
  571.                                              lookupCtlOperationNameLen] =
  572.                     '';
  573.                 temp->lookupCtlOperationNameLen =
  574.                     item->lookupCtlOperationNameLen;
  576.                 temp->lookupResultsIndex = n;
  577.                 temp->lookupResultsAddressType = 16;
  578.                 temp->lookupResultsAddress =
  579.                     (char *) malloc(strlen(lookup->h_aliases[i]) + 1);
  580.                 memcpy(temp->lookupResultsAddress, lookup->h_aliases[i],
  581.                        strlen(lookup->h_aliases[i]) + 1);
  582.                 temp->lookupResultsAddress[strlen(lookup->h_aliases[i])] =
  583.                     '';
  584.                 temp->lookupResultsAddressLen =
  585.                     strlen(lookup->h_aliases[i]);
  586.                 current->next = temp;
  587.                 current = temp;
  588.                 i = i + 1;
  589.                 n = n + 1;
  590.             }
  591.             current->next = NULL;
  593.         }
  596.         if (item->ResultsTable != NULL)
  597.             if (lookupResultsTable_add(item) != SNMPERR_SUCCESS)
  598.                 DEBUGMSGTL(("lookupResultsTable",
  599.                             "registered an entry errorn"));
  601.         SNMP_FREE(address);
  602.         address = NULL;
  603.         return;
  604.     }
  606.     else if (addressType == 16) {
  608.         gettimeofday(&tpstart, NULL);
  609.         lookup = gethostbyname(address);
  610.         gettimeofday(&tpend, NULL);
  611.         timeuse4 = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
  612.             tpend.tv_usec - tpstart.tv_usec;
  613.         timeuse4 /= 1000;
  614.         if (lookup == NULL) {
  615.             DEBUGMSGTL(("lookupCtlTable",
  616.                         "Can't get a network host entry for %sn",
  617.                         address));
  618.         } else {
  619.             while (*lookup->h_addr_list) {
  620.                 bcopy(*lookup->h_addr_list++, (char *) &a, sizeof(a));
  622.                 temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
  623.                 if (temp == NULL) {
  624.                     exit(1);
  625.                 }
  626.                 temp->lookupResultsIndex = n;
  628.                 temp->lookupCtlOwnerIndex =
  629.                     (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
  630.                 if (temp->lookupCtlOwnerIndex == NULL) {
  631.                     exit(1);
  632.                 }
  633.                 memcpy(temp->lookupCtlOwnerIndex,
  634.                        item->lookupCtlOwnerIndex,
  635.                        item->lookupCtlOwnerIndexLen + 1);
  636.                 temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
  637.                     '';
  638.                 temp->lookupCtlOwnerIndexLen =
  639.                     item->lookupCtlOwnerIndexLen;
  641.                 temp->lookupCtlOperationName =
  642.                     (char *) malloc(item->lookupCtlOperationNameLen + 1);
  643.                 if (temp->lookupCtlOperationName == NULL) {
  644.                     exit(1);
  645.                 }
  647.                 memcpy(temp->lookupCtlOperationName,
  648.                        item->lookupCtlOperationName,
  649.                        item->lookupCtlOperationNameLen + 1);
  650.                 temp->lookupCtlOperationName[item->
  651.                                              lookupCtlOperationNameLen] =
  652.                     '';
  653.                 temp->lookupCtlOperationNameLen =
  654.                     item->lookupCtlOperationNameLen;
  656.                 temp->lookupResultsAddressType = 1;
  657.                 temp->lookupResultsAddress =
  658.                     (char *) malloc(strlen(inet_ntoa(a)) + 1);
  659.                 if (temp->lookupResultsAddress == NULL) {
  660.                     exit(1);
  661.                 }
  662.                 memcpy(temp->lookupResultsAddress, inet_ntoa(a),
  663.                        strlen(inet_ntoa(a)) + 1);
  664.                 temp->lookupResultsAddress[strlen(inet_ntoa(a))] = '';
  665.                 temp->lookupResultsAddressLen = strlen(inet_ntoa(a));
  666.                 if (n == 1)
  667.                     item->ResultsTable = temp;
  668.                 else
  669.                     current->next = temp;
  670.                 current = temp;
  671.                 n = n + 1;
  673.             }
  674.             current->next = NULL;
  675.             t = n;
  677.         }
  679.         struct hostent *hp;
  680.         char            pa[64];
  681.         char           *hostname = NULL;
  683.         gettimeofday(&tpstart, NULL);
  684.         hp = gethostbyname2(address, AF_INET6);
  685.         gettimeofday(&tpend, NULL);
  686.         timeuse6 = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
  687.             tpend.tv_usec - tpstart.tv_usec;
  688.         timeuse6 /= 1000;
  690.         if (hp == NULL) {
  691.             DEBUGMSGTL(("lookupCtlTable",
  692.                         "Can't get a ipv6 network host entry for %sn",
  693.                         address));
  694.         } else {
  695.             while (*hp->h_addr_list) {
  696.                 memmove((caddr_t) & a6, *hp->h_addr_list++, 16);
  697.                 hostname = (char *) hp->h_name;
  699.                 temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
  700.                 if (temp == NULL) {
  701.                     exit(1);
  702.                 }
  703.                 temp->lookupResultsIndex = n;
  705.                 temp->lookupCtlOwnerIndex =
  706.                     (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
  707.                 if (temp->lookupCtlOwnerIndex == NULL) {
  708.                     exit(1);
  709.                 }
  710.                 memcpy(temp->lookupCtlOwnerIndex,
  711.                        item->lookupCtlOwnerIndex,
  712.                        item->lookupCtlOwnerIndexLen + 1);
  713.                 temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
  714.                     '';
  715.                 temp->lookupCtlOwnerIndexLen =
  716.                     item->lookupCtlOwnerIndexLen;
  718.                 temp->lookupCtlOperationName =
  719.                     (char *) malloc(item->lookupCtlOperationNameLen + 1);
  720.                 if (temp->lookupCtlOperationName == NULL) {
  721.                     exit(1);
  722.                 }
  723.                 memcpy(temp->lookupCtlOperationName,
  724.                        item->lookupCtlOperationName,
  725.                        item->lookupCtlOperationNameLen + 1);
  726.                 temp->lookupCtlOperationName[item->
  727.                                              lookupCtlOperationNameLen] =
  728.                     '';
  729.                 temp->lookupCtlOperationNameLen =
  730.                     item->lookupCtlOperationNameLen;
  732.                 temp->lookupResultsAddressType = 2;
  733.                 temp->lookupResultsAddress =
  734.                     (char *)
  735.                     malloc(strlen(inet_ntop(AF_INET6, &a6, pa, 64)) + 1);
  736.                 memcpy(temp->lookupResultsAddress,
  737.                        inet_ntop(AF_INET6, &a6, pa, 64),
  738.                        strlen(inet_ntop(AF_INET6, &a6, pa, 64)) + 1);
  739.                 temp->
  740.                     lookupResultsAddress[strlen
  741.                                          (inet_ntop
  742.                                           (AF_INET6, &a6, pa, 64))] = '';
  743.                 temp->lookupResultsAddressLen =
  744.                     strlen(inet_ntop(AF_INET6, &a6, pa, 64));
  745.                 if (n == 1)
  746.                     item->ResultsTable = temp;
  747.                 else
  748.                     current->next = temp;
  749.                 current = temp;
  750.                 n = n + 1;
  752.             }
  753.             current->next = NULL;
  754.         }
  755.         timeuse = timeuse4 + timeuse6;
  756.         modify_lookupCtlTime(item, timeuse);
  757.         modify_lookupCtlOperStatus(item, 3l);
  759.         if (item->ResultsTable != NULL) {
  761.             modify_lookupCtlRc(item, 0l);
  762.             if (lookupResultsTable_add(item) != SNMPERR_SUCCESS)
  763.                 DEBUGMSGTL(("lookupResultsTable",
  764.                             "registered an entry errorn"));
  765.         } else {
  766.             modify_lookupCtlRc(item, 1l);
  767.         }
  768.         SNMP_FREE(address);
  769.         address = NULL;
  771.         return;
  773.     }
  776.     else if (addressType == 2) {
  777.         if (inet_pton(AF_INET6, address, &addr_in6) == 1)
  778.             DEBUGMSGTL(("lookupCtlTable", "success! n"));
  779.         else
  780.             DEBUGMSGTL(("lookupCtlTable", "error! n"));
  783.         gettimeofday(&tpstart, NULL);
  784.         lookup = gethostbyaddr((char *) &addr_in6, 16, AF_INET6);
  785.         gettimeofday(&tpend, NULL);
  786.         timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
  787.             tpend.tv_usec - tpstart.tv_usec;
  788.         timeuse /= 1000;
  789.         modify_lookupCtlTime(item, timeuse);
  790.         modify_lookupCtlOperStatus(item, 3l);
  792.         if (lookup == NULL) {
  793.             DEBUGMSGTL(("lookupCtlTable",
  794.                         "Can't get a network host entry for %sn",
  795.                         address));
  796.             modify_lookupCtlRc(item, 1l);
  797.             return;
  798.         } else {
  799.             modify_lookupCtlRc(item, 0l);
  800.             if (lookup->h_name != NULL) {
  801.                 current = temp =
  802.                     SNMP_MALLOC_STRUCT(lookupResultsTable_data);
  803.                 if (temp == NULL) {
  804.                     exit(1);
  805.                 }
  806.                 temp->lookupResultsIndex = n;
  808.                 temp->lookupCtlOwnerIndex =
  809.                     (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
  810.                 if (temp->lookupCtlOwnerIndex == NULL) {
  811.                     exit(1);
  812.                 }
  813.                 memcpy(temp->lookupCtlOwnerIndex,
  814.                        item->lookupCtlOwnerIndex,
  815.                        item->lookupCtlOwnerIndexLen + 1);
  816.                 temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
  817.                     '';
  818.                 temp->lookupCtlOwnerIndexLen =
  819.                     item->lookupCtlOwnerIndexLen;
  821.                 temp->lookupCtlOperationName =
  822.                     (char *) malloc(item->lookupCtlOperationNameLen + 1);
  823.                 if (temp->lookupCtlOperationName == NULL) {
  824.                     exit(1);
  825.                 }
  826.                 memcpy(temp->lookupCtlOperationName,
  827.                        item->lookupCtlOperationName,
  828.                        item->lookupCtlOperationNameLen + 1);
  829.                 temp->lookupCtlOperationName[item->
  830.                                              lookupCtlOperationNameLen] =
  831.                     '';
  832.                 temp->lookupCtlOperationNameLen =
  833.                     item->lookupCtlOperationNameLen;
  835.                 temp->lookupResultsAddressType = 16;
  836.                 temp->lookupResultsAddress =
  837.                     (char *) malloc(strlen(lookup->h_name) + 1);
  838.                 memcpy(temp->lookupResultsAddress, lookup->h_name,
  839.                        strlen(lookup->h_name) + 1);
  840.                 temp->lookupResultsAddress[strlen(lookup->h_name)] = '';
  841.                 temp->lookupResultsAddressLen = strlen(lookup->h_name);
  842.                 item->ResultsTable = temp;
  843.                 n = n + 1;
  845.             }
  847.             i = 0;
  848.             while (lookup->h_aliases[i]) {
  849.                 temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
  850.                 if (temp == NULL) {
  851.                     exit(1);
  852.                 }
  853.                 temp->lookupCtlOwnerIndex =
  854.                     (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
  855.                 if (temp->lookupCtlOwnerIndex == NULL) {
  856.                     exit(1);
  857.                 }
  858.                 memcpy(temp->lookupCtlOwnerIndex,
  859.                        item->lookupCtlOwnerIndex,
  860.                        item->lookupCtlOwnerIndexLen + 1);
  861.                 temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
  862.                     '';
  863.                 temp->lookupCtlOwnerIndexLen =
  864.                     item->lookupCtlOwnerIndexLen;
  866.                 temp->lookupCtlOperationName =
  867.                     (char *) malloc(item->lookupCtlOperationNameLen + 1);
  868.                 if (temp->lookupCtlOperationName == NULL) {
  869.                     exit(1);
  870.                 }
  871.                 memcpy(temp->lookupCtlOperationName,
  872.                        item->lookupCtlOperationName,
  873.                        item->lookupCtlOperationNameLen + 1);
  874.                 temp->lookupCtlOperationName[item->
  875.                                              lookupCtlOperationNameLen] =
  876.                     '';
  877.                 temp->lookupCtlOperationNameLen =
  878.                     item->lookupCtlOperationNameLen;
  880.                 temp->lookupResultsIndex = n;
  881.                 temp->lookupResultsAddressType = 16;
  882.                 temp->lookupResultsAddress =
  883.                     (char *) malloc(strlen(lookup->h_aliases[i]) + 1);
  884.                 if (temp->lookupResultsAddress == NULL) {
  885.                     exit(1);
  886.                 }
  887.                 memcpy(temp->lookupResultsAddress, lookup->h_aliases[i],
  888.                        strlen(lookup->h_aliases[i]) + 1);
  889.                 temp->lookupResultsAddress[strlen(lookup->h_aliases[i])] =
  890.                     '';
  891.                 temp->lookupResultsAddressLen =
  892.                     strlen(lookup->h_aliases[i]);
  893.                 current->next = temp;
  894.                 current = temp;
  895.                 i = i + 1;
  896.                 n = n + 1;
  898.             }
  900.             if (item->ResultsTable != NULL)
  901.                 current->next = NULL;
  902.             else
  903.                 current = NULL;
  905.         }
  908.         if (item->ResultsTable != NULL)
  909.             if (lookupResultsTable_add(item) != SNMPERR_SUCCESS)
  910.                 DEBUGMSGTL(("lookupResultsTable",
  911.                             "registered an entry errorn"));
  912.         SNMP_FREE(address);
  913.         address = NULL;
  914.         return;
  915.     } else {
  916.         SNMP_FREE(address);
  917.         address = NULL;
  918.         return;
  919.     }
  920. }
  923. int
  924. modify_lookupCtlOperStatus(struct lookupTable_data *thedata, long val)
  925. {
  926.     netsnmp_variable_list *vars = NULL;
  927.     struct lookupTable_data *StorageTmp = NULL;
  929.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
  930.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */
  933.     if ((StorageTmp =
  934.          header_complex_get(lookupCtlTableStorage, vars)) == NULL) {
  935.         snmp_free_varbind(vars);
  936.         vars = NULL;
  937.         return SNMP_ERR_NOSUCHNAME;
  938.     }
  939.     StorageTmp->lookupCtlOperStatus = val;
  941.     snmp_free_varbind(vars);
  942.     vars = NULL;
  944.     DEBUGMSGTL(("lookupOperStatus", "done.n"));
  945.     return SNMPERR_SUCCESS;
  946. }
  948. int
  949. modify_lookupCtlTime(struct lookupTable_data *thedata, unsigned long val)
  950. {
  951.     netsnmp_variable_list *vars = NULL;
  952.     struct lookupTable_data *StorageTmp = NULL;
  954.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
  955.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */
  958.     if ((StorageTmp =
  959.          header_complex_get(lookupCtlTableStorage, vars)) == NULL) {
  960.         snmp_free_varbind(vars);
  961.         vars = NULL;
  962.         return SNMP_ERR_NOSUCHNAME;
  963.     }
  964.     StorageTmp->lookupCtlTime = val;
  966.     snmp_free_varbind(vars);
  967.     vars = NULL;
  969.     DEBUGMSGTL(("lookupCtlTime", "done.n"));
  970.     return SNMPERR_SUCCESS;
  971. }
  973. int
  974. modify_lookupCtlRc(struct lookupTable_data *thedata, long val)
  975. {
  976.     netsnmp_variable_list *vars = NULL;
  977.     struct lookupTable_data *StorageTmp = NULL;
  979.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
  980.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */
  983.     if ((StorageTmp =
  984.          header_complex_get(lookupCtlTableStorage, vars)) == NULL) {
  985.         snmp_free_varbind(vars);
  986.         vars = NULL;
  987.         return SNMP_ERR_NOSUCHNAME;
  988.     }
  989.     StorageTmp->lookupCtlRc = val;
  991.     snmp_free_varbind(vars);
  992.     vars = NULL;
  993.     DEBUGMSGTL(("lookupOperStatus", "done.n"));
  994.     return SNMPERR_SUCCESS;
  995. }
  998. int
  999. lookupResultsTable_del(struct lookupTable_data *thedata)
  1000. {
  1001.     struct header_complex_index *hciptr2 = NULL;
  1002.     struct lookupResultsTable_data *StorageDel = NULL;
  1003.     netsnmp_variable_list *vars = NULL;
  1004.     oid             newoid[MAX_OID_LEN];
  1005.     size_t          newoid_len;
  1007.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
  1008.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */
  1009.     bzero(newoid, MAX_OID_LEN * sizeof(oid));
  1010.     header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);
  1013.     snmp_free_varbind(vars);
  1014.     vars = NULL;
  1015.     for (hciptr2 = lookupResultsTableStorage; hciptr2 != NULL;
  1016.          hciptr2 = hciptr2->next) {
  1017.         if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
  1018.             == 0) {
  1019.             StorageDel =
  1020.                 header_complex_extract_entry(&lookupResultsTableStorage,
  1021.                                              hciptr2);
  1022.             if (StorageDel != NULL) {
  1023.                 SNMP_FREE(StorageDel->lookupCtlOwnerIndex);
  1024.                 SNMP_FREE(StorageDel->lookupCtlOperationName);
  1025.                 SNMP_FREE(StorageDel->lookupResultsAddress);
  1026.                 SNMP_FREE(StorageDel);
  1027.             }
  1028.             DEBUGMSGTL(("lookupResultsTable", "delete  success!n"));
  1030.         }
  1031.     }
  1032.     return SNMPERR_SUCCESS;
  1033. }
  1036. int
  1037. write_lookupCtlTargetAddressType(int action,
  1038.                                  u_char * var_val,
  1039.                                  u_char var_val_type,
  1040.                                  size_t var_val_len,
  1041.                                  u_char * statP, oid * name,
  1042.                                  size_t name_len)
  1043. {
  1044.     static size_t   tmpvar;
  1045.     struct lookupTable_data *StorageTmp = NULL;
  1046.     static size_t   tmplen;
  1047.     size_t          newlen =
  1048.         name_len - (sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
  1049.                     3 - 1);
  1051.     if ((StorageTmp =
  1052.          header_complex(lookupCtlTableStorage, NULL,
  1053.                         &name[sizeof(lookupCtlTable_variables_oid) /
  1054.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1055.                         NULL)) == NULL)
  1056.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1058.     if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
  1059.         return SNMP_ERR_NOTWRITABLE;
  1060.     }
  1062.     if (StorageTmp && StorageTmp->lookupCtlRowStatus == RS_ACTIVE) {
  1063.         return SNMP_ERR_NOTWRITABLE;
  1064.     }
  1065.     switch (action) {
  1066.     case RESERVE1:
  1067.         if (var_val_type != ASN_INTEGER) {
  1068.             snmp_log(LOG_ERR,
  1069.                      "write to lookupCtlTargetAddressType not ASN_INTEGERn");
  1070.             return SNMP_ERR_WRONGTYPE;
  1071.         }
  1072.         break;
  1075.     case RESERVE2:
  1076.         /*
  1077.          * memory reseveration, final preparation... 
  1078.          */
  1079.         break;
  1082.     case FREE:
  1083.         /*
  1084.          * Release any resources that have been allocated 
  1085.          */
  1086.         break;
  1089.     case ACTION:
  1090.         /*
  1091.          * The variable has been stored in objid for
  1092.          * you to use, and you have just been asked to do something with
  1093.          * it.  Note that anything done here must be reversable in the UNDO case 
  1094.          */
  1095.         tmpvar = StorageTmp->lookupCtlTargetAddressType;
  1096.         StorageTmp->lookupCtlTargetAddressType = *((long *) var_val);
  1097.         break;
  1100.     case UNDO:
  1101.         /*
  1102.          * Back out any changes made in the ACTION case 
  1103.          */
  1104.         StorageTmp->lookupCtlTargetAddressType = tmpvar;
  1105.         break;
  1108.     case COMMIT:
  1109.         /*
  1110.          * Things are working well, so it's now safe to make the change
  1111.          * permanently.  Make sure that anything done here can't fail! 
  1112.          */
  1113.         break;
  1114.     }
  1115.     return SNMP_ERR_NOERROR;
  1116. }
  1120. int
  1121. write_lookupCtlTargetAddress(int action,
  1122.                              u_char * var_val,
  1123.                              u_char var_val_type,
  1124.                              size_t var_val_len,
  1125.                              u_char * statP, oid * name, size_t name_len)
  1126. {
  1127.     static char    *tmpvar = NULL;
  1128.     static size_t   tmplen;
  1129.     struct lookupTable_data *StorageTmp = NULL;
  1130.     size_t          newlen =
  1131.         name_len - (sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
  1132.                     3 - 1);
  1133.     if ((StorageTmp =
  1134.          header_complex(lookupCtlTableStorage, NULL,
  1135.                         &name[sizeof(lookupCtlTable_variables_oid) /
  1136.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  1137.                         NULL)) == NULL)
  1138.         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
  1140.     if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
  1141.         return SNMP_ERR_NOTWRITABLE;
  1142.     }
  1144.     if (StorageTmp && StorageTmp->lookupCtlRowStatus == RS_ACTIVE) {
  1145.         return SNMP_ERR_NOTWRITABLE;
  1146.     }
  1148.     switch (action) {
  1149.     case RESERVE1:
  1150.         if (var_val_type != ASN_OCTET_STR) {
  1151.             snmp_log(LOG_ERR,
  1152.                      "write to lookupCtlTargetAddress not ASN_OCTET_STRn");
  1153.             return SNMP_ERR_WRONGTYPE;
  1154.         }
  1156.         break;
  1159.     case RESERVE2:
  1160.         /*
  1161.          * memory reseveration, final preparation... 
  1162.          */
  1164.         break;
  1167.     case FREE:
  1168.         /*
  1169.          * Release any resources that have been allocated 
  1170.          */
  1172.         break;
  1175.     case ACTION:
  1176.         /*
  1177.          * The variable has been stored in long_ret for
  1178.          * you to use, and you have just been asked to do something with
  1179.          * it.  Note that anything done here must be reversable in the UNDO case 
  1180.          */
  1181.         tmpvar = StorageTmp->lookupCtlTargetAddress;
  1182.         tmplen = StorageTmp->lookupCtlTargetAddressLen;
  1184.         if ((StorageTmp->lookupCtlTargetAddress =
  1185.              (char *) malloc(var_val_len + 1)) == NULL) {
  1186.             exit(1);
  1187.         }
  1188.         memcpy(StorageTmp->lookupCtlTargetAddress, var_val, var_val_len);
  1189.         StorageTmp->lookupCtlTargetAddress[var_val_len] = '';
  1190.         StorageTmp->lookupCtlTargetAddressLen = var_val_len;
  1192.         break;
  1195.     case UNDO:
  1196.         /*
  1197.          * Back out any changes made in the ACTION case 
  1198.          */
  1199.         free(StorageTmp->lookupCtlTargetAddress);
  1200.         StorageTmp->lookupCtlTargetAddress = NULL;
  1201.         StorageTmp->lookupCtlTargetAddress = tmpvar;
  1202.         StorageTmp->lookupCtlTargetAddressLen = tmplen;
  1204.         break;
  1207.     case COMMIT:
  1208.         /*
  1209.          * Things are working well, so it's now safe to make the change
  1210.          * permanently.  Make sure that anything done here can't fail! 
  1211.          */
  1213.         free(tmpvar);
  1214.         tmpvar = NULL;
  1216.         break;
  1217.     }
  1218.     return SNMP_ERR_NOERROR;
  1219. }
  1226. int
  1227. write_lookupCtlRowStatus(int action,
  1228.                          u_char * var_val,
  1229.                          u_char var_val_type,
  1230.                          size_t var_val_len,
  1231.                          u_char * statP, oid * name, size_t name_len)
  1232. {
  1233.     struct lookupTable_data *StorageTmp = NULL;
  1234.     static struct lookupTable_data *StorageNew, *StorageDel = NULL;
  1235.     size_t          newlen =
  1236.         name_len - (sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
  1237.                     3 - 1);
  1238.     static int      old_value;
  1239.     int             set_value;
  1240.     static netsnmp_variable_list *vars, *vp;
  1241.     struct header_complex_index *hciptr = NULL;
  1243.     StorageTmp =
  1244.         header_complex(lookupCtlTableStorage, NULL,
  1245.                        &name[sizeof(lookupCtlTable_variables_oid) /
  1246.                              sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
  1248.     if (var_val_type != ASN_INTEGER || var_val == NULL) {
  1249.         snmp_log(LOG_ERR, "write to lookupCtlRowStatus not ASN_INTEGERn");
  1250.         return SNMP_ERR_WRONGTYPE;
  1251.     }
  1252.     if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
  1253.         return SNMP_ERR_NOTWRITABLE;
  1254.     }
  1256.     set_value = *((long *) var_val);
  1259.     /*
  1260.      * check legal range, and notReady is reserved for us, not a user 
  1261.      */
  1262.     if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
  1263.         return SNMP_ERR_INCONSISTENTVALUE;
  1266.     switch (action) {
  1267.     case RESERVE1:
  1268.         /*
  1269.          * stage one: test validity 
  1270.          */
  1271.         if (StorageTmp == NULL) {
  1272.             /*
  1273.              * create the row now? 
  1274.              */
  1277.             /*
  1278.              * ditch illegal values now 
  1279.              */
  1280.             if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
  1282.                 return SNMP_ERR_INCONSISTENTVALUE;
  1283.             }
  1285.             /*
  1286.              * destroying a non-existent row is actually legal 
  1287.              */
  1288.             if (set_value == RS_DESTROY) {
  1289.                 return SNMP_ERR_NOERROR;
  1290.             }
  1293.             /*
  1294.              * illegal creation values 
  1295.              */
  1296.             if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
  1297.                 return SNMP_ERR_INCONSISTENTVALUE;
  1298.             }
  1299.         } else {
  1300.             /*
  1301.              * row exists.  Check for a valid state change 
  1302.              */
  1303.             if (set_value == RS_CREATEANDGO
  1304.                 || set_value == RS_CREATEANDWAIT) {
  1305.                 /*
  1306.                  * can't create a row that exists 
  1307.                  */
  1308.                 return SNMP_ERR_INCONSISTENTVALUE;
  1309.             }
  1311.             /*
  1312.              * XXX: interaction with row storage type needed 
  1313.              */
  1315.             if (StorageTmp->lookupCtlRowStatus == RS_ACTIVE &&
  1316.                 set_value != RS_DESTROY) {
  1317.                 /*
  1318.                  * "Once made active an entry may not be modified except to 
  1319.                  * delete it."  XXX: doesn't this in fact apply to ALL
  1320.                  * columns of the table and not just this one?  
  1321.                  */
  1322.                 return SNMP_ERR_INCONSISTENTVALUE;
  1323.             }
  1324.             if (StorageTmp->storagetype != ST_NONVOLATILE)
  1325.                 return SNMP_ERR_NOTWRITABLE;
  1326.         }
  1327.         break;
  1332.     case RESERVE2:
  1333.         /*
  1334.          * memory reseveration, final preparation... 
  1335.          */
  1336.         if (StorageTmp == NULL) {
  1337.             /*
  1338.              * creation 
  1339.              */
  1340.             if (set_value == RS_DESTROY) {
  1341.                 return SNMP_ERR_NOERROR;
  1342.             }
  1343.             vars = NULL;
  1345.             /*
  1346.              * 将name为空的三个索引字段加到var变量列表的末尾 
  1347.              */
  1348.             snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0);  /* lookupCtlOwnerIndex */
  1349.             snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0);  /* lookupCtlOperationName */
  1351.             if (header_complex_parse_oid
  1352.                 (&
  1353.                  (name
  1354.                   [sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
  1355.                    2]), newlen, vars) != SNMPERR_SUCCESS) {
  1356.                 /*
  1357.                  * XXX: free, zero vars 
  1358.                  */
  1359.                 snmp_free_varbind(vars);
  1360.                 vars = NULL;
  1361.                 return SNMP_ERR_INCONSISTENTNAME;
  1362.             }
  1363.             vp = vars;
  1364.             StorageNew = create_lookupTable_data();
  1365.             StorageNew->lookupCtlOwnerIndex = malloc(vp->val_len + 1);
  1366.             memcpy(StorageNew->lookupCtlOwnerIndex, vp->val.string,
  1367.                    vp->val_len);
  1368.             StorageNew->lookupCtlOwnerIndex[vp->val_len] = '';
  1369.             StorageNew->lookupCtlOwnerIndexLen = vp->val_len;
  1370.             vp = vp->next_variable;
  1372.             StorageNew->lookupCtlOperationName = malloc(vp->val_len + 1);
  1373.             memcpy(StorageNew->lookupCtlOperationName, vp->val.string,
  1374.                    vp->val_len);
  1375.             StorageNew->lookupCtlOperationName[vp->val_len] = '';
  1376.             StorageNew->lookupCtlOperationNameLen = vp->val_len;
  1377.             vp = vp->next_variable;
  1379.             /*
  1380.              * XXX: fill in default row values here into StorageNew 
  1381.              */
  1383.             StorageNew->lookupCtlTargetAddressType = 1; /* ipv4 */
  1385.             StorageNew->lookupCtlRowStatus = set_value;
  1387.             snmp_free_varbind(vars);
  1388.             vars = NULL;
  1390.             /*
  1391.              * XXX: free, zero vars, no longer needed? 
  1392.              */
  1393.         }
  1396.         break;
  1401.     case FREE:
  1402.         /*
  1403.          * XXX: free, zero vars 
  1404.          */
  1405.         /*
  1406.          * Release any resources that have been allocated 
  1407.          */
  1408.         break;
  1413.     case ACTION:
  1414.         /*
  1415.          * The variable has been stored in set_value for you to
  1416.          * use, and you have just been asked to do something with
  1417.          * it.  Note that anything done here must be reversable in
  1418.          * the UNDO case 
  1419.          */
  1422.         if (StorageTmp == NULL) {
  1423.             /*
  1424.              * row creation, so add it 
  1425.              */
  1426.             if (set_value == RS_DESTROY) {
  1427.                 return SNMP_ERR_NOERROR;
  1428.             }
  1429.             if (StorageNew != NULL)
  1430. #if 1
  1431.                 DEBUGMSGTL(("lookupCtlTable",
  1432.                             "write_lookupCtlRowStatus entering new=%d...  n",
  1433.                             action));
  1434. #endif
  1435.             lookupCtlTable_add(StorageNew);
  1436.             /*
  1437.              * XXX: ack, and if it is NULL? 
  1438.              */
  1439.         } else if (set_value != RS_DESTROY) {
  1440.             /*
  1441.              * set the flag? 
  1442.              */
  1443.             old_value = StorageTmp->lookupCtlRowStatus;
  1444.             StorageTmp->lookupCtlRowStatus = *((long *) var_val);
  1445.         } else {
  1446.             /*
  1447.              * destroy...  extract it for now 
  1448.              */
  1449.             DEBUGMSGTL(("lookupCtlTable",
  1450.                         "write_lookupCtlTable_delete 1 n"));
  1451.             hciptr =
  1452.                 header_complex_find_entry(lookupCtlTableStorage,
  1453.                                           StorageTmp);
  1455.             StorageDel =
  1456.                 header_complex_extract_entry(&lookupCtlTableStorage,
  1457.                                              hciptr);
  1458.             lookupResultsTable_del(StorageTmp);
  1460.             DEBUGMSGTL(("lookupCtlTable",
  1461.                         "write_lookupCtlTable_delete  n"));
  1463.         }
  1464.         break;
  1469.     case UNDO:
  1470.         /*
  1471.          * Back out any changes made in the ACTION case 
  1472.          */
  1473.         if (StorageTmp == NULL) {
  1474.             /*
  1475.              * row creation, so remove it again 
  1476.              */
  1477.             hciptr =
  1478.                 header_complex_find_entry(lookupCtlTableStorage,
  1479.                                           StorageTmp);
  1480.             StorageDel =
  1481.                 header_complex_extract_entry(&lookupCtlTableStorage,
  1482.                                              hciptr);
  1484.             lookupResultsTable_del(StorageTmp);
  1486.             /*
  1487.              * XXX: free it 
  1488.              */
  1489.         } else if (StorageDel != NULL) {
  1490.             /*
  1491.              * row deletion, so add it again 
  1492.              */
  1493.             lookupCtlTable_add(StorageDel);
  1494.             lookupResultsTable_add(StorageDel);
  1495.         } else {
  1496.             StorageTmp->lookupCtlRowStatus = old_value;
  1497.         }
  1498.         break;
  1503.     case COMMIT:
  1504.         /*
  1505.          * Things are working well, so it's now safe to make the change
  1506.          * permanently.  Make sure that anything done here can't fail! 
  1507.          */
  1508.         if (StorageTmp == NULL) {
  1509.             if (set_value == RS_DESTROY) {
  1510.                 return SNMP_ERR_NOERROR;
  1511.             }
  1512.         }
  1514.         if (StorageDel != NULL) {
  1515.             SNMP_FREE(StorageDel->lookupCtlOwnerIndex);
  1516.             StorageDel->lookupCtlOwnerIndex = NULL;
  1517.             SNMP_FREE(StorageDel->lookupCtlOperationName);
  1518.             StorageDel->lookupCtlOperationName = NULL;
  1519.             SNMP_FREE(StorageDel->lookupCtlTargetAddress);
  1520.             StorageDel->lookupCtlTargetAddress = NULL;
  1521.             SNMP_FREE(StorageDel);
  1522.             StorageDel = NULL;
  1524.             StorageDel = 0;
  1525.             /*
  1526.              * XXX: free it, its dead 
  1527.              */
  1528.         } else {
  1529.             if (StorageTmp
  1530.                 && StorageTmp->lookupCtlRowStatus == RS_CREATEANDGO) {
  1531.                 StorageTmp->lookupCtlRowStatus = RS_ACTIVE;
  1532.             } else if (StorageTmp &&
  1533.                        StorageTmp->lookupCtlRowStatus ==
  1534.                        RS_CREATEANDWAIT) {
  1536.                 StorageTmp->lookupCtlRowStatus = RS_NOTINSERVICE;
  1537.             }
  1538.         }
  1539.         if (StorageTmp && StorageTmp->lookupCtlRowStatus == RS_ACTIVE) {
  1540. #if 1
  1541.             DEBUGMSGTL(("lookupCtlTable",
  1542.                         "write_lookupCtlRowStatus entering runbefore=%ld...  n",
  1543.                         StorageTmp->lookupCtlTargetAddressType));
  1545. #endif
  1546.             modify_lookupCtlOperStatus(StorageTmp, 2l);
  1547.             run_lookup((struct lookupTable_data *) StorageTmp);
  1549.         }
  1551.         break;
  1552.     }
  1553.     return SNMP_ERR_NOERROR;
  1554. }