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

SNMP编程

开发平台:

Unix_Linux

  1. /*
  2.  * TargetParamTable MIB
  3.  * 
  4.  * This file was generated by mib2c and is intended for use as a mib module
  5.  * for the ucd-snmp snmpd agent. Edited by Michael Baer 
  6.  * 
  7.  * last changed 2/2/99.
  8.  */
  9. #include <net-snmp/net-snmp-config.h>
  10. #if HAVE_STRING_H
  11. #include <string.h>
  12. #else
  13. #include <strings.h>
  14. #endif
  15. #include <stdlib.h>
  16. #include <ctype.h>
  17. #if HAVE_WINSOCK_H
  18. #include <winsock.h>
  19. #endif
  20. #include <net-snmp/net-snmp-includes.h>
  21. #include <net-snmp/agent/net-snmp-agent-includes.h>
  22. #include "snmpTargetParamsEntry.h"
  23. #define snmpTargetParamsOIDLen 11       /*This is base+column, 
  24.                                          * i.e. everything but index */
  25. oid             snmpTargetParamsOID[snmpTargetParamsOIDLen] =
  26.     { 1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 0 };
  27. static struct targetParamTable_struct *aPTable = 0;
  28. /*
  29.  * Utility routines 
  30.  */
  31. /*
  32.  * TargetParamTable_create creates and returns a pointer
  33.  * to a targetParamTable_struct with default values set 
  34.  */
  35. struct targetParamTable_struct
  36.                *
  37. snmpTargetParamTable_create(void)
  38. {
  39.     struct targetParamTable_struct *newEntry;
  40.     newEntry = (struct targetParamTable_struct *)
  41.         malloc(sizeof(struct targetParamTable_struct));
  42.     newEntry->paramName = 0;
  43.     newEntry->mpModel = -1;
  44.     newEntry->secModel = -1;
  45.     newEntry->secName = 0;
  46.     newEntry->secLevel = -1;
  47.     newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
  48.     newEntry->rowStatus = SNMP_ROW_NONEXISTENT;
  49.     newEntry->next = 0;
  50.     return newEntry;
  51. }
  52. /*
  53.  * TargetParamTable_dispose frees the space allocated to a
  54.  * targetParamTable_struct 
  55.  */
  56. void
  57. snmpTargetParamTable_dispose(struct targetParamTable_struct *reaped)
  58. {
  59.     free(reaped->paramName);
  60.     free(reaped->secName);
  61.     free(reaped);
  62. }                               /* snmpTargetParamTable_dispose  */
  63. /*
  64.  * snmpTargetParamTable_addToList adds a targetParamTable_struct 
  65.  * to a list passed in. The list is assumed to be in a sorted order,
  66.  * low to high and this procedure inserts a new struct in the proper 
  67.  * location. Sorting uses OID values based on paramName. A new equal value 
  68.  * overwrites a current one. 
  69.  */
  70. void
  71. snmpTargetParamTable_addToList(struct targetParamTable_struct *newEntry,
  72.                                struct targetParamTable_struct **listPtr)
  73. {
  74.     static struct targetParamTable_struct *curr_struct, *prev_struct;
  75.     int             i;
  76.     size_t          newOIDLen = 0, currOIDLen = 0;
  77.     oid             newOID[128], currOID[128];
  78.     /*
  79.      * if the list is empty, add the new entry to the top 
  80.      */
  81.     if ((prev_struct = curr_struct = *listPtr) == 0) {
  82.         *listPtr = newEntry;
  83.         return;
  84.     } else {
  85.         /*
  86.          * get the 'OID' value of the new entry 
  87.          */
  88.         newOIDLen = strlen(newEntry->paramName);
  89.         for (i = 0; i < (int) newOIDLen; i++) {
  90.             newOID[i] = newEntry->paramName[i];
  91.         }
  92.         /*
  93.          * search through the list for an equal or greater OID value 
  94.          */
  95.         while (curr_struct != 0) {
  96.             currOIDLen = strlen(curr_struct->paramName);
  97.             for (i = 0; i < (int) currOIDLen; i++) {
  98.                 currOID[i] = curr_struct->paramName[i];
  99.             }
  100.             i = snmp_oid_compare(newOID, newOIDLen, currOID, currOIDLen);
  101.             if (i == 0) {       /* Exact match, overwrite with new struct */
  102.                 newEntry->next = curr_struct->next;
  103.                 /*
  104.                  * if curr_struct is the top of the list 
  105.                  */
  106.                 if (*listPtr == curr_struct)
  107.                     *listPtr = newEntry;
  108.                 else
  109.                     prev_struct->next = newEntry;
  110.                 snmpTargetParamTable_dispose(curr_struct);
  111.                 return;
  112.             } else if (i < 0) { /* Found a greater OID, insert struct in front of it. */
  113.                 newEntry->next = curr_struct;
  114.                 /*
  115.                  * if curr_struct is the top of the list 
  116.                  */
  117.                 if (*listPtr == curr_struct)
  118.                     *listPtr = newEntry;
  119.                 else
  120.                     prev_struct->next = newEntry;
  121.                 return;
  122.             }
  123.             prev_struct = curr_struct;
  124.             curr_struct = curr_struct->next;
  125.         }
  126.     }
  127.     /*
  128.      * if we're here, no larger OID was ever found, insert on end of list 
  129.      */
  130.     prev_struct->next = newEntry;
  131. }                               /* snmpTargeParamTable_addToList  */
  132. void
  133. snmpTargetParamTable_add(struct targetParamTable_struct *newEntry)
  134. {
  135.     snmpTargetParamTable_addToList(newEntry, &aPTable);
  136. }
  137. /*
  138.  * snmpTargetParamTable_remFromList removes a targetParamTable_struct 
  139.  * from the list passed in 
  140.  */
  141. void
  142. snmpTargetParamTable_remFromList(struct targetParamTable_struct *oldEntry,
  143.                                  struct targetParamTable_struct **listPtr)
  144. {
  145.     struct targetParamTable_struct *tptr;
  146.     if ((tptr = *listPtr) == 0)
  147.         return;
  148.     else if (tptr == oldEntry) {
  149.         *listPtr = (*listPtr)->next;
  150.         snmpTargetParamTable_dispose(tptr);
  151.         return;
  152.     } else {
  153.         while (tptr->next != 0) {
  154.             if (tptr->next == oldEntry) {
  155.                 tptr->next = tptr->next->next;
  156.                 snmpTargetParamTable_dispose(oldEntry);
  157.                 return;
  158.             }
  159.             tptr = tptr->next;
  160.         }
  161.     }
  162. }                               /* snmpTargetParamTable_remFromList  */
  163. /*
  164.  * lookup OID in the link list of Table Entries 
  165.  */
  166. struct targetParamTable_struct *
  167. search_snmpTargetParamsTable(oid * baseName,
  168.                              size_t baseNameLen,
  169.                              oid * name, size_t * length, int exact)
  170. {
  171.     static struct targetParamTable_struct *temp_struct;
  172.     int             i;
  173.     size_t          myOIDLen = 0;
  174.     oid             newNum[128];
  175.     /*
  176.      * lookup entry in p / * Get Current MIB ID 
  177.      */
  178.     memcpy(newNum, baseName, baseNameLen * sizeof(oid));
  179.     for (temp_struct = aPTable; temp_struct != 0;
  180.          temp_struct = temp_struct->next) {
  181.         for (i = 0; i < (int) strlen(temp_struct->paramName); i++) {
  182.             newNum[baseNameLen + i] = temp_struct->paramName[i];
  183.         }
  184.         myOIDLen = baseNameLen + strlen(temp_struct->paramName);
  185.         i = snmp_oid_compare(name, *length, newNum, myOIDLen);
  186.         /*
  187.          * Assumes that the linked list sorted by OID, low to high 
  188.          */
  189.         if ((i == 0 && exact != 0) || (i < 0 && exact == 0)) {
  190.             if (exact == 0) {
  191.                 memcpy(name, newNum, myOIDLen * sizeof(oid));
  192.                 *length = myOIDLen;
  193.             }
  194.             return temp_struct;
  195.         }
  196.     }
  197.     return (0);
  198. }                               /* search_snmpTargetParamsTable */
  199. /*
  200.  * snmpTargetParams_rowStatusCheck is boolean funciton that  checks 
  201.  * the status of a row's values in order to determine whether
  202.  * the row should be notReady or notInService  
  203.  */
  204. int
  205. snmpTargetParams_rowStatusCheck(struct targetParamTable_struct *entry)
  206. {
  207.     if ((entry->mpModel < 0) || (entry->secModel < 0) ||
  208.         (entry->secLevel < 0) || (entry->secName == 0))
  209.         return 0;
  210.     else
  211.         return 1;
  212. }                               /* snmtpTargetParamTable_rowStatusCheck */
  213. /*
  214.  * initialization routines 
  215.  */
  216. /*
  217.  * this variable defines function callbacks and type return information 
  218.  * for the snmpTargetAddrEntry mib 
  219.  */
  220. struct variable2 snmpTargetParamsEntry_variables[] = {
  221.     {SNMPTARGETPARAMSMPMODEL, ASN_INTEGER, RWRITE,
  222.      var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSMPMODELCOLUMN}},
  223.     {SNMPTARGETPARAMSSECURITYMODEL, ASN_INTEGER, RWRITE,
  224.      var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYMODELCOLUMN}},
  225.     {SNMPTARGETPARAMSSECURITYNAME, ASN_OCTET_STR, RWRITE,
  226.      var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYNAMECOLUMN}},
  227.     {SNMPTARGETPARAMSSECURITYLEVEL, ASN_INTEGER, RWRITE,
  228.      var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYLEVELCOLUMN}},
  229.     {SNMPTARGETPARAMSSTORAGETYPE, ASN_INTEGER, RWRITE,
  230.      var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSTORAGETYPECOLUMN}},
  231.     {SNMPTARGETPARAMSROWSTATUS, ASN_INTEGER, RWRITE,
  232.      var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSROWSTATUSCOLUMN}}
  233. };
  234. /*
  235.  * now load this mib into the agents mib table 
  236.  */
  237. oid             snmpTargetParamsEntry_variables_oid[] =
  238.     { 1, 3, 6, 1, 6, 3, 12, 1, 3, 1 };
  239. void
  240. init_snmpTargetParamsEntry(void)
  241. {
  242.     aPTable = 0;
  243.     REGISTER_MIB("target/snmpTargetParamsEntry",
  244.                  snmpTargetParamsEntry_variables, variable2,
  245.                  snmpTargetParamsEntry_variables_oid);
  246.     snmpd_register_config_handler("targetParams",
  247.                                   snmpd_parse_config_targetParams, 0,
  248.                                   NULL);
  249.     /*
  250.      * we need to be called back later 
  251.      */
  252.     snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  253.                            store_snmpTargetParamsEntry, NULL);
  254. }                               /*  init_snmpTargetParmsEntry  */
  255. int
  256. snmpTargetParams_addParamName(struct targetParamTable_struct *entry,
  257.                               char *cptr)
  258. {
  259.     size_t          len;
  260.     if (cptr == 0) {
  261.         DEBUGMSGTL(("snmpTargetParamsEntry",
  262.                     "ERROR snmpTargetParamsEntry: no param name in config stringn"));
  263.         return (0);
  264.     } else {
  265.         len = strlen(cptr);
  266.         /*
  267.          * spec check for string 1-32 
  268.          */
  269.         if (len < 1 || len > 32) {
  270.             DEBUGMSGTL(("snmpTargetParamsEntry",
  271.                         "ERROR snmpTargetParamsEntry: param name out of range in config stringn"));
  272.             return (0);
  273.         }
  274.         entry->paramName = (char *) malloc(len + 1);
  275.         strncpy(entry->paramName, cptr, len);
  276.         entry->paramName[len] = '';
  277.     }
  278.     return (1);
  279. }
  280. int
  281. snmpTargetParams_addMPModel(struct targetParamTable_struct *entry,
  282.                             char *cptr)
  283. {
  284.     if (cptr == 0) {
  285.         DEBUGMSGTL(("snmpTargetParamsEntry",
  286.                     "ERROR snmpTargetParamsEntry: no mp model in config stringn"));
  287.         return (0);
  288.     } else if (!(isdigit(*cptr))) {
  289.         DEBUGMSGTL(("snmpTargetParamsEntry",
  290.                     "ERROR snmpTargeParamsEntry: mp model is not digit in config stringn"));
  291.         return (0);
  292.     }
  293.     /*
  294.      * spec check MP Model >= 0 
  295.      */
  296.     else if ((entry->mpModel = (int) strtol(cptr, (char **) NULL, 0)) < 0) {
  297.         DEBUGMSGTL(("snmpTargetParamsEntry",
  298.                     "ERROR snmpTargeParamsEntry: mp model out of range in config stringn"));
  299.         return (0);
  300.     }
  301.     return (1);
  302. }                               /* snmpTargetParams_addMPModel  */
  303. int
  304. snmpTargetParams_addSecModel(struct targetParamTable_struct *entry,
  305.                              char *cptr)
  306. {
  307.     if (cptr == 0) {
  308.         DEBUGMSGTL(("snmpTargetParamsEntry",
  309.                     "ERROR snmpTargetParamsEntry: no sec model in config stringn"));
  310.         return (0);
  311.     } else if (!(isdigit(*cptr))) {
  312.         DEBUGMSGTL(("snmpTargetParamsEntry",
  313.                     "ERROR snmpTargeParamsEntry: security model is not digit in config stringn"));
  314.         return (0);
  315.     }
  316.     /*
  317.      * spec check Sec. Model > 0 
  318.      */
  319.     else if ((entry->secModel =
  320.               (int) strtol(cptr, (char **) NULL, 0)) <= 0) {
  321.         DEBUGMSGTL(("snmpTargetParamsEntry",
  322.                     "ERROR snmpTargetParamsEntry: security model out of range in config stringn"));
  323.         return (0);
  324.     }
  325.     return (1);
  326. }                               /*  snmpTargetParams_addSecModel  */
  327. int
  328. snmpTargetParams_addSecName(struct targetParamTable_struct *entry,
  329.                             char *cptr)
  330. {
  331.     size_t          len;
  332.     if (cptr == 0) {
  333.         DEBUGMSGTL(("snmpTargetParamsEntry",
  334.                     "ERROR snmpTargetParamsEntry: no security name in config stringn"));
  335.         return (0);
  336.     } else {
  337.         len = strlen(cptr);
  338.         entry->secName = (char *) malloc(len + 1);
  339.         strncpy(entry->secName, cptr, len);
  340.         entry->secName[len] = '';
  341.     }
  342.     return (1);
  343. }                               /* snmpTargetParams_addSecName  */
  344. int
  345. snmpTargetParams_addSecLevel(struct targetParamTable_struct *entry,
  346.                              char *cptr)
  347. {
  348.     if (cptr == 0) {
  349.         DEBUGMSGTL(("snmpTargetParamsEntry",
  350.                     "ERROR snmpTargetParamsEntry: no security level in config stringn"));
  351.         return (0);
  352.     } else if (!(isdigit(*cptr))) {
  353.         DEBUGMSGTL(("snmpTargetParamsEntry",
  354.                     "ERROR snmpTargeParamsEntry: security level is not digit in config stringn"));
  355.         return (0);
  356.     }
  357.     /*
  358.      * no spec range check, but noAuthNoPriv is 1 so... 
  359.      */
  360.     else if ((entry->secLevel =
  361.               (int) strtol(cptr, (char **) NULL, 0)) <= 0) {
  362.         DEBUGMSGTL(("snmpTargetParamsEntry",
  363.                     "ERROR snmpTargeParamsEntry: security level is not greater than 0 in config stringn"));
  364.         return (0);
  365.     }
  366.     return (1);
  367. }                               /*  snmpTargetParams_addSecLevel  */
  368. int
  369. snmpTargetParams_addStorageType(struct targetParamTable_struct *entry,
  370.                                 char *cptr)
  371. {
  372.     if (cptr == 0) {
  373.         DEBUGMSGTL(("snmpTargetParamsEntry",
  374.                     "ERROR snmpTargetParamsEntry: no storage type in config stringn"));
  375.         return (0);
  376.     } else if (!(isdigit(*cptr))) {
  377.         DEBUGMSGTL(("snmpTargetParamsEntry",
  378.                     "ERROR snmpTargeParamsEntry: storage type is not digit in config stringn"));
  379.         return (0);
  380.     }
  381.     /*
  382.      * check that storage type is a possible value 
  383.      */
  384.     else if (((entry->storageType = (int) strtol(cptr, (char **) NULL, 0))
  385.               != SNMP_STORAGE_OTHER) &&
  386.              (entry->storageType != SNMP_STORAGE_VOLATILE) &&
  387.              (entry->storageType != SNMP_STORAGE_NONVOLATILE) &&
  388.              (entry->storageType != SNMP_STORAGE_PERMANENT) &&
  389.              (entry->storageType != SNMP_STORAGE_READONLY)) {
  390.         DEBUGMSGTL(("snmpTargetParamsEntry",
  391.                     "ERROR snmpTargeParamsEntry: storage type is not a valid value of"));
  392.         DEBUGMSG(("snmpTargetParamsEntry",
  393.                   " other(%d), volatile(%d), nonvolatile(%d), permanent(%d), or ",
  394.                   SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
  395.                   SNMP_STORAGE_NONVOLATILE, SNMP_STORAGE_PERMANENT));
  396.         DEBUGMSGTL(("snmpTargetParamsEntry",
  397.                     "readonly(%d) in config string.n",
  398.                     SNMP_STORAGE_READONLY));
  399.         return (0);
  400.     }
  401.     return (1);
  402. }                               /* snmpTargetParams_addStorageType  */
  403. int
  404. snmpTargetParams_addRowStatus(struct targetParamTable_struct *entry,
  405.                               char *cptr)
  406. {
  407.     if (cptr == 0) {
  408.         DEBUGMSGTL(("snmpTargetParamsEntry",
  409.                     "ERROR snmpTargetParamsEntry: no row status in config stringn"));
  410.         return (0);
  411.     } else if (!(isdigit(*cptr))) {
  412.         DEBUGMSGTL(("snmpTargetParamsEntry",
  413.                     "ERROR snmpTargeParamsEntry: row status is not digit in config stringn"));
  414.         return (0);
  415.     }
  416.     /*
  417.      * check that row status is a valid value 
  418.      */
  419.     else if (((entry->rowStatus = (int) strtol(cptr, (char **) NULL, 0))
  420.               != SNMP_ROW_ACTIVE) &&
  421.              (entry->rowStatus != SNMP_ROW_NOTINSERVICE) &&
  422.              (entry->rowStatus != SNMP_ROW_NOTREADY)) {
  423.         DEBUGMSGTL(("snmpTargetParamsEntry",
  424.                     "ERROR snmpTargetParamsEntry: Row Status is not a valid value of "));
  425.         DEBUGMSG(("snmpTargetParamsEntry",
  426.                   "active(%d), notinservice(%d), or notready(%d) in config string.n",
  427.                   SNMP_ROW_ACTIVE, SNMP_ROW_NOTINSERVICE,
  428.                   SNMP_ROW_NOTREADY));
  429.         return (0);
  430.     }
  431.     return (1);
  432. }                               /* snmpTargetParams_addRowStatus  */
  433. /*
  434.  * timestamp the current entry's modification time 
  435.  */
  436. void
  437. update_timestamp(struct targetParamTable_struct *temp_struct)
  438. {
  439.     temp_struct->updateTime = time(NULL);
  440. }
  441. void
  442. snmpd_parse_config_targetParams(const char *token, char *char_ptr)
  443. {
  444.     char           *cptr = char_ptr, buff[1024];
  445.     struct targetParamTable_struct *newEntry;
  446.     newEntry = snmpTargetParamTable_create();
  447.     cptr = copy_nword(cptr, buff, sizeof(buff));
  448.     if (snmpTargetParams_addParamName(newEntry, buff) == 0) {
  449.         snmpTargetParamTable_dispose(newEntry);
  450.         return;
  451.     }
  452.     cptr = copy_nword(cptr, buff, sizeof(buff));
  453.     if (snmpTargetParams_addMPModel(newEntry, buff) == 0) {
  454.         snmpTargetParamTable_dispose(newEntry);
  455.         return;
  456.     }
  457.     cptr = copy_nword(cptr, buff, sizeof(buff));
  458.     if (snmpTargetParams_addSecModel(newEntry, buff) == 0) {
  459.         snmpTargetParamTable_dispose(newEntry);
  460.         return;
  461.     }
  462.     cptr = copy_nword(cptr, buff, sizeof(buff));
  463.     if (snmpTargetParams_addSecName(newEntry, buff) == 0) {
  464.         snmpTargetParamTable_dispose(newEntry);
  465.         return;
  466.     }
  467.     cptr = copy_nword(cptr, buff, sizeof(buff));
  468.     if (snmpTargetParams_addSecLevel(newEntry, buff) == 0) {
  469.         snmpTargetParamTable_dispose(newEntry);
  470.         return;
  471.     }
  472.     cptr = copy_nword(cptr, buff, sizeof(buff));
  473.     if (snmpTargetParams_addStorageType(newEntry, buff) == 0) {
  474.         snmpTargetParamTable_dispose(newEntry);
  475.         return;
  476.     }
  477.     cptr = copy_nword(cptr, buff, sizeof(buff));
  478.     if (snmpTargetParams_addRowStatus(newEntry, buff) == 0) {
  479.         snmpTargetParamTable_dispose(newEntry);
  480.         return;
  481.     }
  482.     snprintf(buff, sizeof(buff),
  483.             "snmp_parse_config_targetParams, read: %s %d %d %s %d %d %dn",
  484.             newEntry->paramName, newEntry->mpModel, newEntry->secModel,
  485.             newEntry->secName, newEntry->secLevel, newEntry->storageType,
  486.             newEntry->rowStatus);
  487.     buff[ sizeof(buff)-1 ] = 0;
  488.     DEBUGMSGTL(("snmpTargetParamsEntry", buff));
  489.     update_timestamp(newEntry);
  490.     snmpTargetParamTable_addToList(newEntry, &aPTable);
  491. }                               /* snmpd_parse_config_target */
  492. /*
  493.  * shutdown routines 
  494.  */
  495. /*
  496.  * store_snmpTargetParamsEntry handles the presistent storage proccess 
  497.  * for this MIB table. It writes out all the non-volatile rows 
  498.  * to permanent storage on a shutdown  
  499.  */
  500. int
  501. store_snmpTargetParamsEntry(int majorID, int minorID, void *serverarg,
  502.                             void *clientarg)
  503. {
  504.     struct targetParamTable_struct *curr_struct;
  505.     char            line[1024];
  506.     strcpy(line, "");
  507.     if ((curr_struct = aPTable) != 0) {
  508.         while (curr_struct != 0) {
  509.             if ((curr_struct->storageType == SNMP_STORAGE_NONVOLATILE ||
  510.                  curr_struct->storageType == SNMP_STORAGE_PERMANENT)
  511.                 &&
  512.                 (curr_struct->rowStatus == SNMP_ROW_ACTIVE ||
  513.                  curr_struct->rowStatus == SNMP_ROW_NOTINSERVICE)) {
  514.                 snprintf(&line[strlen(line)], sizeof(line)-strlen(line)-1,
  515.                         "targetParams %s %i %i %s %i %i %in",
  516.                         curr_struct->paramName, curr_struct->mpModel,
  517.                         curr_struct->secModel, curr_struct->secName,
  518.                         curr_struct->secLevel, curr_struct->storageType,
  519.                         curr_struct->rowStatus);
  520.                 line[ sizeof(line)-1 ] = 0;
  521.                 /*
  522.                  * store to file 
  523.                  */
  524.                 snmpd_store_config(line);
  525.             }
  526.             curr_struct = curr_struct->next;
  527.         }
  528.     }
  529.     return SNMPERR_SUCCESS;
  530. }                               /*  store_snmpTargetParmsEntry  */
  531. /*
  532.  * MIB table access routines 
  533.  */
  534. u_char         *
  535. var_snmpTargetParamsEntry(struct variable * vp,
  536.                           oid * name,
  537.                           size_t * length,
  538.                           int exact,
  539.                           size_t * var_len, WriteMethod ** write_method)
  540. {
  541.     /*
  542.      * variables we may use later 
  543.      */
  544.     static long     long_ret;
  545.     static unsigned char string[1500];
  546.     struct targetParamTable_struct *temp_struct;
  547.     switch (vp->magic) {
  548.     case SNMPTARGETPARAMSMPMODEL:
  549.         *write_method = write_snmpTargetParamsMPModel;
  550.         break;
  551.     case SNMPTARGETPARAMSSECURITYMODEL:
  552.         *write_method = write_snmpTargetParamsSecModel;
  553.         break;
  554.     case SNMPTARGETPARAMSSECURITYNAME:
  555.         *write_method = write_snmpTargetParamsSecName;
  556.         break;
  557.     case SNMPTARGETPARAMSSECURITYLEVEL:
  558.         *write_method = write_snmpTargetParamsSecLevel;
  559.         break;
  560.     case SNMPTARGETPARAMSSTORAGETYPE:
  561.         *write_method = write_snmpTargetParamsStorageType;
  562.         break;
  563.     case SNMPTARGETPARAMSROWSTATUS:
  564.         *write_method = write_snmpTargetParamsRowStatus;
  565.         break;
  566.     default:
  567.         *write_method = NULL;
  568.     }
  569.     *var_len = sizeof(long_ret);        /* assume an integer and change later if not */
  570.     /*
  571.      * look for OID in current table 
  572.      */
  573.     if ((temp_struct = search_snmpTargetParamsTable(vp->name, vp->namelen,
  574.                                                     name, length,
  575.                                                     exact)) == 0) {
  576.         return (0);
  577.     }
  578.     /*
  579.      * We found what we were looking for, either the next OID or the exact OID 
  580.      */
  581.     /*
  582.      * this is where we do the value assignments for the mib results. 
  583.      */
  584.     switch (vp->magic) {
  585.     case SNMPTARGETPARAMSMPMODEL:
  586.         /*
  587.          * if unset value, (i.e. new row) 
  588.          */
  589.         if (temp_struct->mpModel == -1)
  590.             return (0);
  591.         long_ret = temp_struct->mpModel;
  592.         return (unsigned char *) &long_ret;
  593.     case SNMPTARGETPARAMSSECURITYMODEL:
  594.         /*
  595.          * if unset value, (i.e. new row) 
  596.          */
  597.         if (temp_struct->secModel == -1)
  598.             return (0);
  599.         long_ret = temp_struct->secModel;
  600.         return (unsigned char *) &long_ret;
  601.     case SNMPTARGETPARAMSSECURITYNAME:
  602.         /*
  603.          * if unset value, (i.e. new row) 
  604.          */
  605.         if (temp_struct->secName == 0)
  606.             return (0);
  607.         /*
  608.          * including null character. 
  609.          */
  610.         memcpy(string, temp_struct->secName, strlen(temp_struct->secName));
  611.         string[strlen(temp_struct->secName)] = '';
  612.         *var_len = strlen(temp_struct->secName);
  613.         return (unsigned char *) string;
  614.     case SNMPTARGETPARAMSSECURITYLEVEL:
  615.         /*
  616.          * if unset value, (i.e. new row) 
  617.          */
  618.         if (temp_struct->secLevel == -1)
  619.             return (0);
  620.         long_ret = temp_struct->secLevel;
  621.         return (unsigned char *) &long_ret;
  622.     case SNMPTARGETPARAMSSTORAGETYPE:
  623.         long_ret = temp_struct->storageType;
  624.         return (unsigned char *) &long_ret;
  625.     case SNMPTARGETPARAMSROWSTATUS:
  626.         long_ret = temp_struct->rowStatus;
  627.         return (unsigned char *) &long_ret;
  628.     default:
  629.         DEBUGMSGTL(("snmpd",
  630.                     "unknown sub-id %d in var_snmpTargetParamsEntryn",
  631.                     vp->magic));
  632.     }
  633.     return 0;
  634. }                               /* var_snmpTargetParamsEntry */
  635. /*
  636.  * Assign a value to the mpModel variable.  
  637.  */
  638. int
  639. write_snmpTargetParamsMPModel(int action,
  640.                               u_char * var_val,
  641.                               u_char var_val_type,
  642.                               size_t var_val_len,
  643.                               u_char * statP, oid * name, size_t name_len)
  644. {
  645.     long            long_ret = *((long *) var_val);
  646.     static long     old_mp;
  647.     struct targetParamTable_struct *params = NULL;
  648.     if (action == RESERVE1) {
  649.         if (var_val_type != ASN_INTEGER) {
  650.             DEBUGMSGTL(("snmpTargetParamsEntry",
  651.                         "write to snmpTargetParamsMPModel: not ASN_INTEGERn"));
  652.             return SNMP_ERR_WRONGTYPE;
  653.         }
  654.         if (var_val_len != sizeof(long)) {
  655.             DEBUGMSGTL(("snmpTargetParamsEntry",
  656.                         "write to snmpTargetParamsMPModel: bad lengthn"));
  657.             return SNMP_ERR_WRONGLENGTH;
  658.         }
  659.         if (long_ret < 0) {
  660.             DEBUGMSGTL(("snmpTargetParamsEntry",
  661.                         "write to snmpTargetParamsMPModel: MP Model out of rangen"));
  662.             return SNMP_ERR_INCONSISTENTVALUE;
  663.         }
  664.     } else if (action == RESERVE2) {
  665.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  666.             SNMPTARGETPARAMSMPMODELCOLUMN;
  667.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  668.                                               snmpTargetParamsOIDLen,
  669.                                               name, &name_len, 1);
  670.         if (params == NULL) {
  671.             DEBUGMSGTL(("snmpTargetParamsEntry",
  672.                         "write to snmpTargetParamsMPModel: BAD OIDn"));
  673.             return SNMP_ERR_INCONSISTENTNAME;
  674.         } else {
  675.             /*
  676.              * Row exists, check if it is changeable.  
  677.              */
  678.             if (params->storageType == SNMP_STORAGE_READONLY) {
  679.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  680.                             "write to snmpTargetParamMPModel: row is read onlyn"));
  681.                 return SNMP_ERR_NOTWRITABLE;
  682.             }
  683.             /*
  684.              * Check if row is active.  
  685.              */
  686.             if (params->rowStatus == SNMP_ROW_ACTIVE) {
  687.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  688.                             "write to snmpTargetParamsMPModel: this change not allowed in active row.n"));
  689.                 return SNMP_ERR_INCONSISTENTVALUE;
  690.             }
  691.             old_mp = params->mpModel;
  692.             params->mpModel = long_ret;
  693.             if (params->rowStatus == SNMP_ROW_NOTREADY &&
  694.                 snmpTargetParams_rowStatusCheck(params)) {
  695.                 params->rowStatus = SNMP_ROW_NOTINSERVICE;
  696.             }
  697.         }
  698.     } else if (action == COMMIT) {
  699.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  700.             SNMPTARGETPARAMSMPMODELCOLUMN;
  701.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  702.                                                    snmpTargetParamsOIDLen,
  703.                                                    name, &name_len,
  704.                                                    1)) != NULL) {
  705.             update_timestamp(params);
  706.         }
  707.     } else if (action == FREE || action == UNDO) {
  708.         /*
  709.          * Try to undo the SET here (abnormal usage of FREE clause)  
  710.          */
  711.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  712.             SNMPTARGETPARAMSMPMODELCOLUMN;
  713.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  714.                                                    snmpTargetParamsOIDLen,
  715.                                                    name, &name_len,
  716.                                                    1)) != NULL) {
  717.             if (params->storageType != SNMP_STORAGE_READONLY
  718.                 && params->rowStatus != SNMP_ROW_ACTIVE) {
  719.                 params->mpModel = old_mp;
  720.                 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
  721.                     !snmpTargetParams_rowStatusCheck(params)) {
  722.                     params->rowStatus = SNMP_ROW_NOTREADY;
  723.                 }
  724.             }
  725.         }
  726.     }
  727.     return SNMP_ERR_NOERROR;
  728. }                               /* write_snmpTargetParamsMPModel */
  729. /*
  730.  * Assign a value to the secModel variable.  
  731.  */
  732. int
  733. write_snmpTargetParamsSecModel(int action,
  734.                                u_char * var_val,
  735.                                u_char var_val_type,
  736.                                size_t var_val_len,
  737.                                u_char * statP, oid * name, size_t name_len)
  738. {
  739.     long            long_ret = *((long *) var_val);
  740.     static long     old_sec;
  741.     struct targetParamTable_struct *params = NULL;
  742.     if (action == RESERVE1) {
  743.         if (var_val_type != ASN_INTEGER) {
  744.             DEBUGMSGTL(("snmpTargetParamsEntry",
  745.                         "write to snmpTargetParamsSecModel: not ASN_INTEGERn"));
  746.             return SNMP_ERR_WRONGTYPE;
  747.         }
  748.         if (var_val_len != sizeof(long)) {
  749.             DEBUGMSGTL(("snmpTargetParamsEntry",
  750.                         "write to snmpTargetParamsSecModel: bad lengthn"));
  751.             return SNMP_ERR_WRONGLENGTH;
  752.         }
  753.         if (long_ret <= 0) {
  754.             DEBUGMSGTL(("snmpTargetParamsEntry",
  755.                         "write to snmpTargetParamsSecModel: secModel out of rangen"));
  756.             return SNMP_ERR_WRONGVALUE;
  757.         }
  758.         if (find_sec_mod(long_ret) == NULL && long_ret >= 3) {
  759.             DEBUGMSGTL(("snmpTargetParamsEntry",
  760.                         "write to snmpTargetParamsSecModel: secModel %d unsupportedn",
  761.                         long_ret));
  762.             return SNMP_ERR_INCONSISTENTVALUE;
  763.         }
  764.     } else if (action == RESERVE2) {
  765.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  766.             SNMPTARGETPARAMSSECURITYMODELCOLUMN;
  767.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  768.                                               snmpTargetParamsOIDLen,
  769.                                               name, &name_len, 1);
  770.         if (params == NULL) {
  771.             DEBUGMSGTL(("snmpTargetParamsEntry",
  772.                         "write to snmpTargetParamsSecModel: BAD OIDn"));
  773.             return SNMP_ERR_INCONSISTENTNAME;
  774.         } else {
  775.             /*
  776.              * Row exists, check if it is changeable.  
  777.              */
  778.             if (params->storageType == SNMP_STORAGE_READONLY) {
  779.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  780.                             "write to snmpTargetParamSecModel: row is read onlyn"));
  781.                 return SNMP_ERR_NOTWRITABLE;
  782.             }
  783.             /*
  784.              * Check if row is active.  
  785.              */
  786.             if (params->rowStatus == SNMP_ROW_ACTIVE) {
  787.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  788.                             "write to snmpTargetParamsSecModel: this change not allowed in active row.n"));
  789.                 return SNMP_ERR_INCONSISTENTVALUE;
  790.             }
  791.             old_sec = params->secModel;
  792.             params->secModel = long_ret;
  793.             if (params->rowStatus == SNMP_ROW_NOTREADY &&
  794.                 snmpTargetParams_rowStatusCheck(params)) {
  795.                 params->rowStatus = SNMP_ROW_NOTINSERVICE;
  796.             }
  797.         }
  798.     } else if (action == COMMIT) {
  799.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  800.             SNMPTARGETPARAMSSECURITYMODELCOLUMN;
  801.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  802.                                                    snmpTargetParamsOIDLen,
  803.                                                    name, &name_len,
  804.                                                    1)) != NULL) {
  805.             update_timestamp(params);
  806.         }
  807.     } else if (action == FREE || action == UNDO) {
  808.         /*
  809.          * Try to undo the SET here (abnormal usage of FREE clause)  
  810.          */
  811.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  812.             SNMPTARGETPARAMSSECURITYMODELCOLUMN;
  813.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  814.                                                    snmpTargetParamsOIDLen,
  815.                                                    name, &name_len,
  816.                                                    1)) != NULL) {
  817.             if (params->storageType != SNMP_STORAGE_READONLY
  818.                 && params->rowStatus != SNMP_ROW_ACTIVE) {
  819.                 params->secModel = old_sec;
  820.                 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
  821.                     !snmpTargetParams_rowStatusCheck(params)) {
  822.                     params->rowStatus = SNMP_ROW_NOTREADY;
  823.                 }
  824.             }
  825.         }
  826.     }
  827.     return SNMP_ERR_NOERROR;
  828. }                               /* write_snmpTargetParamsSecModel */
  829. /*
  830.  * Assign a value to the SecLevel variable.  
  831.  */
  832. int
  833. write_snmpTargetParamsSecLevel(int action,
  834.                                u_char * var_val,
  835.                                u_char var_val_type,
  836.                                size_t var_val_len,
  837.                                u_char * statP, oid * name, size_t name_len)
  838. {
  839.     long            long_ret = *((long *) var_val);
  840.     static long     old_level;
  841.     struct targetParamTable_struct *params = NULL;
  842.     if (action == RESERVE1) {
  843.         if (var_val_type != ASN_INTEGER) {
  844.             DEBUGMSGTL(("snmpTargetParamsEntry",
  845.                         "write to snmpTargetParamsSecLevel: not ASN_INTEGERn"));
  846.             return SNMP_ERR_WRONGTYPE;
  847.         }
  848.         if (var_val_len != sizeof(long)) {
  849.             DEBUGMSGTL(("snmpTargetParamsEntry",
  850.                         "write to snmpTargetParamsSecLevel: bad lengthn"));
  851.             return SNMP_ERR_WRONGLENGTH;
  852.         }
  853.         if (long_ret <= 0 || long_ret > 3) {
  854.             DEBUGMSGTL(("snmpTargetParamsEntry",
  855.                         "write to snmpTargetParamsSecLevel: security level is not noAuthNoPriv(1), authNopriv(2) or authPriv(3)n"));
  856.             return SNMP_ERR_WRONGVALUE;
  857.         }
  858.     } else if (action == RESERVE2) {
  859.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  860.             SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
  861.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  862.                                               snmpTargetParamsOIDLen,
  863.                                               name, &name_len, 1);
  864.         if (params == NULL) {
  865.             DEBUGMSGTL(("snmpTargetParamsEntry",
  866.                         "write to snmpTargetParamsSecLevel: BAD OIDn"));
  867.             return SNMP_ERR_INCONSISTENTNAME;
  868.         } else {
  869.             /*
  870.              * Row exists, check if it is changeable.  
  871.              */
  872.             if (params->storageType == SNMP_STORAGE_READONLY) {
  873.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  874.                             "write to snmpTargetParamSecLevel: row is read onlyn"));
  875.                 return SNMP_ERR_NOTWRITABLE;
  876.             }
  877.             /*
  878.              * Check if row is active.  
  879.              */
  880.             if (params->rowStatus == SNMP_ROW_ACTIVE) {
  881.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  882.                             "write to snmpTargetParamsSecLevel: this change not allowed in active row.n"));
  883.                 return SNMP_ERR_INCONSISTENTVALUE;
  884.             }
  885.             old_level = params->secLevel;
  886.             params->secLevel = long_ret;
  887.             if (params->rowStatus == SNMP_ROW_NOTREADY &&
  888.                 snmpTargetParams_rowStatusCheck(params)) {
  889.                 params->rowStatus = SNMP_ROW_NOTINSERVICE;
  890.             }
  891.         }
  892.     } else if (action == COMMIT) {
  893.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  894.             SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
  895.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  896.                                                    snmpTargetParamsOIDLen,
  897.                                                    name, &name_len,
  898.                                                    1)) != NULL) {
  899.             update_timestamp(params);
  900.         }
  901.     } else if (action == FREE || action == UNDO) {
  902.         /*
  903.          * Try to undo the SET here (abnormal usage of FREE clause)  
  904.          */
  905.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  906.             SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
  907.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  908.                                                    snmpTargetParamsOIDLen,
  909.                                                    name, &name_len,
  910.                                                    1)) != NULL) {
  911.             if (params->storageType != SNMP_STORAGE_READONLY
  912.                 && params->rowStatus != SNMP_ROW_ACTIVE) {
  913.                 params->secLevel = old_level;
  914.                 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
  915.                     !snmpTargetParams_rowStatusCheck(params)) {
  916.                     params->rowStatus = SNMP_ROW_NOTREADY;
  917.                 }
  918.             }
  919.         }
  920.     }
  921.     return SNMP_ERR_NOERROR;
  922. }                               /* write_snmpTargetParamsSecLevel */
  923. /*
  924.  * Assign a value to the storageType variable.  
  925.  */
  926. int
  927. write_snmpTargetParamsStorageType(int action,
  928.                                   u_char * var_val,
  929.                                   u_char var_val_type,
  930.                                   size_t var_val_len,
  931.                                   u_char * statP,
  932.                                   oid * name, size_t name_len)
  933. {
  934.     long            long_ret = *((long *) var_val);
  935.     static long     old_st;
  936.     struct targetParamTable_struct *params = NULL;
  937.     if (action == RESERVE1) {
  938.         if (var_val_type != ASN_INTEGER) {
  939.             DEBUGMSGTL(("snmpTargetParamsEntry",
  940.                         "write to snmpTargetParamsStorageType: not ASN_INTEGERn"));
  941.             return SNMP_ERR_WRONGTYPE;
  942.         }
  943.         if (var_val_len != sizeof(long)) {
  944.             DEBUGMSGTL(("snmpTargetParamsEntry",
  945.                         "write to snmpTargetParamsStorageType: bad lengthn"));
  946.             return SNMP_ERR_WRONGLENGTH;
  947.         }
  948.         if (long_ret != SNMP_STORAGE_OTHER &&
  949.             long_ret != SNMP_STORAGE_VOLATILE &&
  950.             long_ret != SNMP_STORAGE_NONVOLATILE) {
  951.             DEBUGMSGTL(("snmpTargetParamsEntry",
  952.                         "write to snmpTargetParamsStorageType: attempted storage type not a valid"));
  953.             DEBUGMSG(("snmpTargetParamsEntry",
  954.                       " value of other(%d), volatile(%d), or nonvolatile(%d)n",
  955.                       SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
  956.                       SNMP_STORAGE_NONVOLATILE));
  957.             return SNMP_ERR_WRONGVALUE;
  958.         }
  959.     } else if (action == RESERVE2) {
  960.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  961.             SNMPTARGETPARAMSSTORAGETYPECOLUMN;
  962.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  963.                                               snmpTargetParamsOIDLen,
  964.                                               name, &name_len, 1);
  965.         if (params == NULL) {
  966.             DEBUGMSGTL(("snmpTargetParamsEntry",
  967.                         "write to snmpTargetParamsStorageType: BAD OIDn"));
  968.             return SNMP_ERR_INCONSISTENTNAME;
  969.         } else {
  970.             /*
  971.              * Row exists, check if it is changeable.  
  972.              */
  973.             if (params->storageType == SNMP_STORAGE_READONLY ||
  974.                 params->storageType == SNMP_STORAGE_PERMANENT) {
  975.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  976.                             "write to snmpTargetParamsStorageType: row has unchangeable storage status: %dn",
  977.                             params->storageType));
  978.                 return SNMP_ERR_INCONSISTENTVALUE;
  979.             }
  980.             old_st = params->storageType;
  981.             params->storageType = long_ret;
  982.         }
  983.     } else if (action == FREE || action == UNDO) {
  984.         /*
  985.          * Try to undo the SET here (abnormal usage of FREE clause)  
  986.          */
  987.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  988.             SNMPTARGETPARAMSSTORAGETYPECOLUMN;
  989.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  990.                                                    snmpTargetParamsOIDLen,
  991.                                                    name, &name_len,
  992.                                                    1)) != NULL) {
  993.             if (params->storageType != SNMP_STORAGE_READONLY
  994.                 && params->storageType != SNMP_STORAGE_PERMANENT) {
  995.                 params->storageType = old_st;
  996.             }
  997.         }
  998.     }
  999.     return SNMP_ERR_NOERROR;
  1000. }                               /* write_snmpTargetParamsStorageType */
  1001. /*
  1002.  * Assign a value to the secName variable.  
  1003.  */
  1004. int
  1005. write_snmpTargetParamsSecName(int action,
  1006.                               u_char * var_val,
  1007.                               u_char var_val_type,
  1008.                               size_t var_val_len,
  1009.                               u_char * statP, oid * name, size_t name_len)
  1010. {
  1011.     static char    *old_name;
  1012.     struct targetParamTable_struct *params = NULL;
  1013.     if (action == RESERVE1) {
  1014.         if (var_val_type != ASN_OCTET_STR) {
  1015.             DEBUGMSGTL(("snmpTargetParamsEntry",
  1016.                         "write to snmpTargetParamsSecName: not ASN_OCTET_STRn"));
  1017.             return SNMP_ERR_WRONGTYPE;
  1018.         }
  1019.         if (var_val_len > 255 || var_val_len < 0) {
  1020.             DEBUGMSGTL(("snmpTargetParamsEntry",
  1021.                         "write to snmpTargetParamsSecName: bad lengthn"));
  1022.             return SNMP_ERR_WRONGLENGTH;
  1023.         }
  1024.     } else if (action == RESERVE2) {
  1025.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1026.             SNMPTARGETPARAMSSECURITYNAMECOLUMN;
  1027.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1028.                                               snmpTargetParamsOIDLen,
  1029.                                               name, &name_len, 1);
  1030.         if (params == NULL) {
  1031.             DEBUGMSGTL(("snmpTargetParamsEntry",
  1032.                         "write to snmpTargetParamsSecName: BAD OIDn"));
  1033.             return SNMP_ERR_INCONSISTENTNAME;
  1034.         } else {
  1035.             /*
  1036.              * Row exists, check if it is changeable.  
  1037.              */
  1038.             if (params->storageType == SNMP_STORAGE_READONLY) {
  1039.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  1040.                             "write to snmpTargetParamSecName: row is read onlyn"));
  1041.                 return SNMP_ERR_NOTWRITABLE;
  1042.             }
  1043.             /*
  1044.              * Check if row is active.  
  1045.              */
  1046.             if (params->rowStatus == SNMP_ROW_ACTIVE) {
  1047.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  1048.                             "write to snmpTargetParamsSecName: this change not allowed in active row.n"));
  1049.                 return SNMP_ERR_INCONSISTENTVALUE;
  1050.             }
  1051.             old_name = params->secName;
  1052.             params->secName = (char *) malloc(var_val_len + 1);
  1053.             if (params->secName == NULL) {
  1054.                 return SNMP_ERR_RESOURCEUNAVAILABLE;
  1055.             }
  1056.             memcpy(params->secName, var_val, var_val_len);
  1057.             params->secName[var_val_len] = '';
  1058.             if (params->rowStatus == SNMP_ROW_NOTREADY &&
  1059.                 snmpTargetParams_rowStatusCheck(params)) {
  1060.                 params->rowStatus = SNMP_ROW_NOTINSERVICE;
  1061.             }
  1062.         }
  1063.     } else if (action == COMMIT) {
  1064.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1065.             SNMPTARGETPARAMSSECURITYNAMECOLUMN;
  1066.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1067.                                                    snmpTargetParamsOIDLen,
  1068.                                                    name, &name_len,
  1069.                                                    1)) != NULL) {
  1070.             update_timestamp(params);
  1071.             SNMP_FREE(old_name);
  1072.             old_name = NULL;
  1073.         }
  1074.     } else if (action == FREE || action == UNDO) {
  1075.         /*
  1076.          * Try to undo the SET here (abnormal usage of FREE clause)  
  1077.          */
  1078.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1079.             SNMPTARGETPARAMSSECURITYNAMECOLUMN;
  1080.         if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1081.                                                    snmpTargetParamsOIDLen,
  1082.                                                    name, &name_len,
  1083.                                                    1)) != NULL) {
  1084.             if (params->storageType != SNMP_STORAGE_READONLY
  1085.                 && params->rowStatus != SNMP_ROW_ACTIVE) {
  1086.                 SNMP_FREE(params->secName);
  1087.                 params->secName = old_name;
  1088.                 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
  1089.                     !snmpTargetParams_rowStatusCheck(params)) {
  1090.                     params->rowStatus = SNMP_ROW_NOTREADY;
  1091.                 }
  1092.             }
  1093.         }
  1094.     }
  1095.     return SNMP_ERR_NOERROR;
  1096. }                               /* write_snmpTargetParamsSecName */
  1097. /*
  1098.  * snmpTargeParams_createNewRow is called from write_snmpTargetParamsRowStatus
  1099.  * when a new row is required. It creates a new row with 
  1100.  * the index of the passed in 'name' (i.e. full index OID) and
  1101.  * adds it to the linked list. 'name' should be the full OID of the new index. 
  1102.  * It passes back 0 if unsuccessfull.
  1103.  */
  1104. int
  1105. snmpTargetParams_createNewRow(oid * name, size_t name_len)
  1106. {
  1107.     int             pNameLen, i;
  1108.     struct targetParamTable_struct *temp_struct;
  1109.     /*
  1110.      * setup a new snmpTargetParamTable structure and add it to the list 
  1111.      */
  1112.     pNameLen = name_len - snmpTargetParamsOIDLen;
  1113.     if (pNameLen > 0) {
  1114.         temp_struct = snmpTargetParamTable_create();
  1115.         temp_struct->paramName = (char *) malloc(pNameLen + 1);
  1116.         for (i = 0; i < pNameLen; i++) {
  1117.             temp_struct->paramName[i] =
  1118.                 (char) name[i + snmpTargetParamsOIDLen];
  1119.         }
  1120.         temp_struct->paramName[pNameLen] = '';
  1121.         temp_struct->rowStatus = SNMP_ROW_NOTREADY;
  1122.         update_timestamp(temp_struct);
  1123.         snmpTargetParamTable_addToList(temp_struct, &aPTable);
  1124.         return 1;
  1125.     }
  1126.     return 0;
  1127. }                               /* snmpTargetParams_createNewRow */
  1128. /*
  1129.  * Assign a value to the Row Status variable 
  1130.  */
  1131. int
  1132. write_snmpTargetParamsRowStatus(int action,
  1133.                                 u_char * var_val,
  1134.                                 u_char var_val_type,
  1135.                                 size_t var_val_len,
  1136.                                 u_char * statP,
  1137.                                 oid * name, size_t name_len)
  1138. {
  1139.     static long     value;
  1140.     struct targetParamTable_struct *params = NULL;
  1141.     if (action == RESERVE1) {
  1142.         if (var_val_type != ASN_INTEGER) {
  1143.             DEBUGMSGTL(("snmpTargetParamsEntry",
  1144.                         "write to snmpTargetParamsRowStatus not ASN_INTEGERn"));
  1145.             return SNMP_ERR_WRONGTYPE;
  1146.         }
  1147.         if (var_val_len != sizeof(long)) {
  1148.             DEBUGMSGTL(("snmpTargetParamsEntry",
  1149.                         "write to snmpTargetParamsRowStatus: bad lengthn"));
  1150.             return SNMP_ERR_WRONGLENGTH;
  1151.         }
  1152.         value = *((long *) var_val);
  1153.         if (value == SNMP_ROW_NOTREADY || value < 1 || value > 6) {
  1154.             return SNMP_ERR_WRONGVALUE;
  1155.         }
  1156.         /*
  1157.          * Check index value is reasonable.  
  1158.          */
  1159.         if (name_len < snmpTargetParamsOIDLen + 1 ||
  1160.             name_len > snmpTargetParamsOIDLen + 32) {
  1161.             DEBUGMSGTL(("snmpTargetParamsEntry", "bad index length %dn",
  1162.                         name_len - snmpTargetParamsOIDLen));
  1163.             return SNMP_ERR_NOCREATION;
  1164.         }
  1165.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1166.             SNMPTARGETPARAMSROWSTATUSCOLUMN;
  1167.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1168.                                               snmpTargetParamsOIDLen,
  1169.                                               name, &name_len, 1);
  1170.         if (params != NULL) {
  1171.             if (value == SNMP_ROW_CREATEANDGO
  1172.                 || value == SNMP_ROW_CREATEANDWAIT) {
  1173.                 value = SNMP_ROW_NOTREADY;
  1174.                 return SNMP_ERR_INCONSISTENTVALUE;
  1175.             }
  1176.             if (params->storageType == SNMP_STORAGE_READONLY) {
  1177.                 DEBUGMSGTL(("snmpTargetParamsEntry",
  1178.                             "row is read onlyn"));
  1179.                 return SNMP_ERR_NOTWRITABLE;
  1180.             }
  1181.             if (params->storageType == SNMP_STORAGE_PERMANENT) {
  1182.                 if (value == SNMP_ROW_DESTROY) {
  1183.                     DEBUGMSGTL(("snmpTargetParamsEntry",
  1184.                                 "unable to destroy permanent rown"));
  1185.                     return SNMP_ERR_INCONSISTENTVALUE;
  1186.                 }
  1187.             }
  1188.         } else {
  1189.             if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
  1190.                 return SNMP_ERR_INCONSISTENTVALUE;
  1191.             }
  1192.             if (value == SNMP_ROW_CREATEANDGO
  1193.                 || value == SNMP_ROW_CREATEANDWAIT) {
  1194.                 if (snmpTargetParams_createNewRow(name, name_len) == 0) {
  1195.                     DEBUGMSGTL(("snmpTargetParamsEntry",
  1196.                                 "couldn't malloc() new rown"));
  1197.                     return SNMP_ERR_RESOURCEUNAVAILABLE;
  1198.                 }
  1199.             }
  1200.         }
  1201.     } else if (action == ACTION) {
  1202.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1203.             SNMPTARGETPARAMSROWSTATUSCOLUMN;
  1204.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1205.                                               snmpTargetParamsOIDLen,
  1206.                                               name, &name_len, 1);
  1207.         if (params != NULL) {
  1208.             if (value == SNMP_ROW_CREATEANDGO) {
  1209.                 /*
  1210.                  * Check whether all the required objects have been set.  
  1211.                  */
  1212.                 if (snmpTargetParams_rowStatusCheck(params)) {
  1213.                     params->rowStatus = SNMP_ROW_ACTIVE;
  1214.                 } else {
  1215.                     params->rowStatus = SNMP_ROW_NOTREADY;
  1216.                 }
  1217.             } else if (value == SNMP_ROW_CREATEANDWAIT) {
  1218.                 /*
  1219.                  * Check whether all the required objects have been set.  
  1220.                  */
  1221.                 if (snmpTargetParams_rowStatusCheck(params)) {
  1222.                     params->rowStatus = SNMP_ROW_NOTINSERVICE;
  1223.                 } else {
  1224.                     params->rowStatus = SNMP_ROW_NOTREADY;
  1225.                 }
  1226.             } else if (value == SNMP_ROW_ACTIVE) {
  1227.                 if (params->rowStatus == SNMP_ROW_NOTINSERVICE) {
  1228.                     params->rowStatus = SNMP_ROW_ACTIVE;
  1229.                 } else if (params->rowStatus == SNMP_ROW_NOTREADY) {
  1230.                     return SNMP_ERR_INCONSISTENTVALUE;
  1231.                 }
  1232.             } else if (value == SNMP_ROW_NOTINSERVICE) {
  1233.                 if (params->rowStatus == SNMP_ROW_ACTIVE) {
  1234.                     params->rowStatus = SNMP_ROW_NOTINSERVICE;
  1235.                 } else if (params->rowStatus == SNMP_ROW_NOTREADY) {
  1236.                     return SNMP_ERR_INCONSISTENTVALUE;
  1237.                 }
  1238.             }
  1239.         }
  1240.     } else if (action == COMMIT) {
  1241.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1242.             SNMPTARGETPARAMSROWSTATUSCOLUMN;
  1243.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1244.                                               snmpTargetParamsOIDLen,
  1245.                                               name, &name_len, 1);
  1246.         if (params != NULL) {
  1247.             if (value == SNMP_ROW_DESTROY) {
  1248.                 snmpTargetParamTable_remFromList(params, &aPTable);
  1249.             }
  1250.             if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
  1251.                 update_timestamp(params);
  1252.             }
  1253.         }
  1254.     } else if (action == UNDO || action == FREE) {
  1255.         snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
  1256.             SNMPTARGETPARAMSROWSTATUSCOLUMN;
  1257.         params = search_snmpTargetParamsTable(snmpTargetParamsOID,
  1258.                                               snmpTargetParamsOIDLen,
  1259.                                               name, &name_len, 1);
  1260.         if (value == SNMP_ROW_CREATEANDGO
  1261.             || value == SNMP_ROW_CREATEANDWAIT) {
  1262.             if (params != NULL) {
  1263.                 snmpTargetParamTable_remFromList(params, &aPTable);
  1264.             }
  1265.         }
  1266.     }
  1267.     return SNMP_ERR_NOERROR;
  1268. }
  1269. struct targetParamTable_struct *
  1270. get_paramEntry(char *name)
  1271. {
  1272.     static struct targetParamTable_struct *ptr;
  1273.     for (ptr = aPTable; ptr; ptr = ptr->next) {
  1274.         if (strcmp(ptr->paramName, name) == 0) {
  1275.             return ptr;
  1276.         }
  1277.     }
  1278.     return NULL;
  1279. }