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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
snmpTargetParamsEntry.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：39k
源码类别：

SNMP编程

开发平台：

C/C++

snmpTargetParamsEntry.c：源码内容
  1. /* TargetParamTable MIB
  3.    This file was generated by mib2c and is intended for use as a mib module
  4.    for the ucd-snmp snmpd agent. Edited by Michael Baer 
  6.    last changed 2/2/99.
  7. */
  9. #include <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 <ip/socket.h>
  19. #endif
  21. #include "mibincl.h"
  22. #include "snmpTargetParamsEntry.h"
  23. #include "read_config.h"
  24. #include "callback.h"
  26. #define snmpTargetParamsOIDLen 11  /*This is base+column, 
  27.      i.e. everything but index*/
  28. extern char *strdup (const char *);
  29. extern void  snmpTargetTryToAddTrap (char *name);
  30. extern void  snmpTargetTryToDelTrap (char *name);
  32. oid snmpTargetParamsOID[snmpTargetParamsOIDLen] = {1,3,6,1,6,3,12,1,3,1,0};
  34. static struct targetParamTable_struct *aPTable=0;
  37. /* Utility routines */
  40. /* TargetParamTable_create creates and returns a pointer
  41.    to a targetParamTable_struct with default values set */
  42. struct targetParamTable_struct 
  43. *snmpTargetParamTable_create(void)
  44. {
  45. struct targetParamTable_struct *newEntry;
  47. newEntry = (struct targetParamTable_struct *)
  48. malloc(sizeof(struct targetParamTable_struct));
  49. if (newEntry == NULL)
  50. return NULL;
  51. newEntry->paramName   = 0;
  52. newEntry->mpModel     = -1;
  54. newEntry->secModel    = -1;
  55. newEntry->secName     = 0;
  56. newEntry->secLevel    = -1;
  58. newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
  59. newEntry->rowStatus   = SNMP_ROW_NONEXISTENT;
  60. newEntry->next        = 0;
  61. return newEntry;
  62. }
  65. /* TargetParamTable_dispose frees the space allocated to a
  66.    targetParamTable_struct */
  67. void snmpTargetParamTable_dispose(
  68.      struct targetParamTable_struct *reaped)
  69. {
  70.   free(reaped->paramName);
  71.   free(reaped->secName);
  72.   
  73.   free(reaped);
  74. }  /* snmpTargetParamTable_dispose  */
  77. /* snmpTargetParamTable_addToList adds a targetParamTable_struct 
  78.    to a list passed in. The list is assumed to be in a sorted order,
  79.    low to high and this procedure inserts a new struct in the proper 
  80.    location. Sorting uses OID values based on paramName. A new equal value 
  81.    overwrites a current one. */
  82. void snmpTargetParamTable_addToList(
  83.      struct targetParamTable_struct *newEntry,
  84.      struct targetParamTable_struct **listPtr)
  85. {
  86.   static struct targetParamTable_struct *curr_struct, *prev_struct;
  87.   int    i;
  88.   int newOIDLen, currOIDLen;
  89.   oid    newOID[128], currOID[128];
  90.   
  91.   /* if the list is empty, add the new entry to the top */
  92.   if ( (prev_struct = curr_struct = *listPtr) == 0 ) {
  93.     *listPtr = newEntry;
  94.     return;
  95.   }
  96.   else {
  97.     /* get the 'OID' value of the new entry */
  98.     newOIDLen = strlen(newEntry->paramName);
  99.     for(i=0; i < (int)newOIDLen ;i++) {
  100.       newOID[i] = newEntry->paramName[i];
  101.     }
  103.     /* search through the list for an equal or greater OID value */
  104.     while (curr_struct != 0) {
  105.       currOIDLen = strlen(curr_struct->paramName);
  106.       for(i=0; i < (int)currOIDLen ;i++) {
  107. currOID[i] = curr_struct->paramName[i];
  108.       }
  110.       i=snmp_oid_compare(newOID, newOIDLen, currOID, currOIDLen);
  111.       if (i==0) {  /* Exact match, overwrite with new struct */
  112. newEntry->next = curr_struct->next;
  113. /* if curr_struct is the top of the list */
  114. if (*listPtr == curr_struct)  *listPtr = newEntry;
  115. else prev_struct->next = newEntry;
  116. snmpTargetParamTable_dispose(curr_struct);
  117. return;
  118.       }
  119.       else if (i < 0) { /* Found a greater OID, insert struct in front of it.*/
  120. newEntry->next = curr_struct;
  121. /* if curr_struct is the top of the list */
  122. if (*listPtr == curr_struct) *listPtr = newEntry;
  123. else prev_struct->next = newEntry;
  124. return;
  125.       }
  126.       prev_struct = curr_struct;
  127.       curr_struct = curr_struct->next;
  128.     }
  129.   }
  130.   /* if we're here, no larger OID was ever found, insert on end of list */
  131.   prev_struct->next = newEntry;
  132. }  /* snmpTargeParamTable_addToList  */
  135. /* snmpTargetParamTable_remFromList removes a targetParamTable_struct 
  136.    from the list passed in */
  137. void snmpTargetParamTable_remFromList(
  138.      struct targetParamTable_struct *oldEntry,
  139.      struct targetParamTable_struct **listPtr)
  140. {
  141.   struct targetParamTable_struct *tptr;
  143.   if ( (tptr = *listPtr) == 0 ) return;
  144.   else if (tptr == oldEntry) {
  145.     *listPtr = (*listPtr)->next;
  146.     snmpTargetParamTable_dispose(tptr);
  147.     return;
  148.   }
  149.   else  {
  150.     while (tptr->next != 0) {
  151.       if (tptr->next == oldEntry) {
  152. tptr->next = tptr->next->next;
  153. snmpTargetParamTable_dispose(oldEntry);
  154. return;
  155.       }
  156.       tptr = tptr->next;
  157.     }
  158.   }
  159. }  /* snmpTargetParamTable_remFromList  */
  162. /* lookup OID in the link list of Table Entries */
  163. struct targetParamTable_struct *
  164. search_snmpTargetParamsTable(
  165.      oid    *baseName,
  166.      int baseNameLen,
  167.      oid    *name,
  168.      int *length,
  169.      int    exact)
  170. {
  171.    static struct targetParamTable_struct *temp_struct;
  172.    int    i;
  173.    int myOIDLen;
  174.    oid    newNum[128];
  176.    /* lookup entry in p / * Get Current MIB ID */
  177.    memcpy(newNum, baseName, baseNameLen*sizeof(oid));
  178.   
  179.    for( temp_struct = aPTable; temp_struct != 0; temp_struct = temp_struct->next) {
  180.      for(i=0; i < (int)strlen(temp_struct->paramName) ;i++) {
  181.        newNum[baseNameLen+i] = temp_struct->paramName[i];
  182.      }
  183.      myOIDLen = baseNameLen+strlen(temp_struct->paramName);
  184.      i=snmp_oid_compare(name, *length, newNum, myOIDLen);
  185.      /* Assumes that the linked list sorted by OID, low to high */
  186.      if ( (i==0 && exact!=0) || (i<0 && exact==0) ) {
  187.        if (exact == 0) {
  188.  memcpy(name, newNum, myOIDLen*sizeof(oid));
  189.  *length = myOIDLen;
  190.        }
  191.        return temp_struct;
  192.      }
  193.    }
  194.    return(0);
  195. }  /* search_snmpTargetParamsTable */
  198. /* snmpTargetParams_rowStatusCheck is boolean funciton that  checks 
  199.    the status of a row's values in order to determine whether
  200.    the row should be notReady or notInService  */
  201. int snmpTargetParams_rowStatusCheck(
  202.      struct targetParamTable_struct *entry)
  203. {
  204.   if ( (entry->mpModel  < 0) || (entry->secModel < 0) ||
  205.        (entry->secLevel < 0) || (entry->secName == 0)   )
  206.     return 0;
  207.   else
  208.     return 1;
  209. }  /* snmtpTargetParamTable_rowStatusCheck */
  212. /* initialization routines */
  215. /* this variable defines function callbacks and type return information 
  216.    for the snmpTargetAddrEntry mib */
  218. struct variable2 snmpTargetParamsEntry_variables[] = {
  219.   { SNMPTARGETPARAMSMPMODEL,       ASN_INTEGER,   RWRITE, 
  220.     var_snmpTargetParamsEntry, 1, { SNMPTARGETPARAMSMPMODELCOLUMN } },
  221.   { SNMPTARGETPARAMSSECURITYMODEL, ASN_INTEGER,   RWRITE, 
  222.     var_snmpTargetParamsEntry, 1, { SNMPTARGETPARAMSSECURITYMODELCOLUMN } },
  223.   { SNMPTARGETPARAMSSECURITYNAME,  ASN_OCTET_STR, RWRITE, 
  224.     var_snmpTargetParamsEntry, 1, { SNMPTARGETPARAMSSECURITYNAMECOLUMN } },
  225.   { SNMPTARGETPARAMSSECURITYLEVEL, ASN_INTEGER,   RWRITE, 
  226.     var_snmpTargetParamsEntry, 1, { SNMPTARGETPARAMSSECURITYLEVELCOLUMN } },
  227.   { SNMPTARGETPARAMSSTORAGETYPE,   ASN_INTEGER,   RWRITE, 
  228.     var_snmpTargetParamsEntry, 1, { SNMPTARGETPARAMSSTORAGETYPECOLUMN } },
  229.   { SNMPTARGETPARAMSROWSTATUS,     ASN_INTEGER,   RWRITE, 
  230.     var_snmpTargetParamsEntry, 1, { SNMPTARGETPARAMSROWSTATUSCOLUMN } }
  231. };
  233. /* now load this mib into the agents mib table */
  234. oid snmpTargetParamsEntry_variables_oid[] = { 1,3,6,1,6,3,12,1,3,1 };
  237. void 
  238. init_snmpTargetParamsEntry(void)
  239. {
  240.   aPTable = 0;
  242.   REGISTER_MIB("target/snmpTargetParamsEntry", snmpTargetParamsEntry_variables,
  243. variable2, snmpTargetParamsEntry_variables_oid);
  245.   snmpd_register_config_handler("targetParams", snmpd_parse_config_targetParams,0,"");
  247.   /* we need to be called back later */
  248.   snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  249.                          store_snmpTargetParamsEntry, NULL);
  250. }  /*  init_snmpTargetParmsEntry  */
  253. int snmpTargetParams_addParamName(
  254.      struct targetParamTable_struct *entry,
  255.      char   *cptr)
  256. {
  257.   int len;
  258.   if (cptr == 0) {
  259.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no param name in config stringn"));
  260.     return(0);
  261.   }
  262.   else {
  263.     len = strlen(cptr);    
  264.     /* spec check for string 1-32 */
  265.     if (len < 1 || len > 32)  {
  266.       DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: param name out of range in config stringn"));
  267.       return(0);
  268.     }
  269.     entry->paramName = (char *)malloc(len + 1);
  270. if (entry->paramName == NULL)
  271. return 0;
  272.     strncpy(entry->paramName, cptr, len);
  273.     entry->paramName[len] = '';
  274.   }
  275.   return(1);
  276. }
  277.   
  279. int snmpTargetParams_addMPModel(
  280.      struct targetParamTable_struct *entry,
  281.      char   *cptr)
  282. {
  283.   if (cptr == 0) {
  284.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no mp model in config stringn"));
  285.     return(0);
  286.   }
  287.   else if (!(isdigit(*cptr))) {
  288.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: mp model is not digit in config stringn"));
  289.     return(0);
  290.   }
  291.   /* spec check MP Model >= 0 */
  292.   else if ( (entry->mpModel = (int)strtol(cptr, (char **)NULL, 0)) < 0) {
  293.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: mp model out of range in config stringn"));
  294.     return(0);
  295.   }
  296.   return(1);
  297. }  /* snmpTargetParams_addMPModel  */
  298.   
  300. int snmpTargetParams_addSecModel(
  301.      struct targetParamTable_struct *entry,
  302.      char   *cptr)
  303. {
  304.   if (cptr == 0) {
  305.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no sec model in config stringn"));
  306.     return(0);
  307.   }
  308.   else if (!(isdigit(*cptr))) {
  309.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: security model is not digit in config stringn"));
  310.     return(0);
  311.   }
  312.   /* spec check Sec. Model > 0 */
  313.   else if ( (entry->secModel = (int)strtol(cptr, (char **)NULL, 0)) <= 0) {
  314.       DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: security model out of range in config stringn"));
  315.       return(0);
  316.   }
  317.   return(1);
  318. }  /*  snmpTargetParams_addSecModel  */
  321. int snmpTargetParams_addSecName(
  322.      struct targetParamTable_struct *entry,
  323.      char   *cptr)
  324. {
  325.   int len;
  326.   if (cptr == 0) {
  327.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no security name in config stringn"));
  328.     return(0);
  329.   }
  330.   else {
  331.     len = strlen(cptr);
  332.     entry->secName = (char *)malloc(len + 1);
  333. if (entry->secName == NULL)
  334. return 0;
  335.     strncpy(entry->secName, cptr, len);
  336.     entry->secName[len] = '';
  337.   }
  338.   return(1);
  339. }  /* snmpTargetParams_addSecName  */
  342. int snmpTargetParams_addSecLevel(
  343.      struct targetParamTable_struct *entry,
  344.      char   *cptr)
  345. {
  346.   if (cptr == 0) {
  347.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no security level in config stringn"));
  348.     return(0);
  349.   }
  350.   else if (!(isdigit(*cptr)))  {
  351.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: security level is not digit in config stringn"));
  352.     return(0);
  353.    }
  354.   /* no spec range check, but noAuthNoPriv is 1 so... */
  355.   else if ( (entry->secLevel = (int)strtol(cptr, (char **)NULL, 0)) <= 0 ) {
  356.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: security level is not greater than 0 in config stringn"));
  357.     return(0);
  358.   }
  359.   return(1);
  360. }  /*  snmpTargetParams_addSecLevel  */
  361.   
  363. int snmpTargetParams_addStorageType(
  364.      struct targetParamTable_struct *entry,
  365.      char   *cptr)
  366. {
  367.   if (cptr == 0) {
  368.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no storage type in config stringn"));
  369.     return(0);
  370.   }
  371.   else if (!(isdigit(*cptr))) {
  372.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: storage type is not digit in config stringn"));
  373.     return(0);
  374.   }
  375.   /* check that storage type is a possible value */
  376.   else if ( ((entry->storageType = (int)strtol(cptr, (char **)NULL, 0)) 
  377.      != SNMP_STORAGE_OTHER) &&
  378.     (entry->storageType != SNMP_STORAGE_VOLATILE) && 
  379.     (entry->storageType != SNMP_STORAGE_NONVOLATILE)  &&
  380.     (entry->storageType != SNMP_STORAGE_PERMANENT) && 
  381.     (entry->storageType != SNMP_STORAGE_READONLY) )  {
  382.     DEBUGMSGTL(("snmpTargetParamsEntry", "ERROR snmpTargeParamsEntry: storage type is not a valid value of"));
  383.     DEBUGMSG(("snmpTargetParamsEntry", " other(%d), volatile(%d), nonvolatile(%d), permanent(%d), or ",
  384.    SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE, SNMP_STORAGE_NONVOLATILE,
  385.    SNMP_STORAGE_PERMANENT));
  386.     DEBUGMSGTL(("snmpTargetParamsEntry","readonly(%d) in config string.n", SNMP_STORAGE_READONLY));
  388.     return(0);
  389.   }
  390.   return(1);
  391. }  /* snmpTargetParams_addStorageType  */
  394. int snmpTargetParams_addRowStatus(
  395.      struct targetParamTable_struct *entry,
  396.      char   *cptr)
  397. {
  398.   if (cptr == 0) {
  399.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargetParamsEntry: no row status in config stringn"));
  400.     return(0);
  401.   }
  402.   else if (!(isdigit(*cptr)))  {
  403.     DEBUGMSGTL(("snmpTargetParamsEntry","ERROR snmpTargeParamsEntry: row status is not digit in config stringn"));
  404.     return(0);
  405.   }
  406.   /* check that row status is a valid value */
  407.   else if ( ((entry->rowStatus = (int)strtol(cptr, (char **)NULL, 0)) 
  408.      != SNMP_ROW_ACTIVE) &&
  409.     (entry->rowStatus != SNMP_ROW_NOTINSERVICE) &&
  410.     (entry->rowStatus != SNMP_ROW_NOTREADY) ) {
  411.     DEBUGMSGTL(("snmpTargetParamsEntry", "ERROR snmpTargetParamsEntry: Row Status is not a valid value of "));
  412.     DEBUGMSG(("snmpTargetParamsEntry", "active(%d), notinservice(%d), or notready(%d) in config string.n",
  413.    SNMP_ROW_ACTIVE, SNMP_ROW_NOTINSERVICE, SNMP_ROW_NOTREADY));
  415.     return(0);
  416.   }
  417.   return(1);
  418. }  /* snmpTargetParams_addRowStatus  */
  419.     
  421. void snmpd_parse_config_targetParams(
  422.      const char *token, char *char_ptr)
  423. {
  424.   char *cptr = char_ptr, buff[1024];
  425.   struct targetParamTable_struct *newEntry;
  427.   newEntry = snmpTargetParamTable_create();
  428.   if (newEntry == NULL)
  429.   return;
  430.   cptr = copy_word(cptr, buff);
  431.   if (snmpTargetParams_addParamName(newEntry, buff) == 0) {
  432.     snmpTargetParamTable_dispose(newEntry);
  433.     return;
  434.   }
  435.   cptr = copy_word(cptr, buff);
  436.   if (snmpTargetParams_addMPModel(newEntry, buff) == 0) {
  437.     snmpTargetParamTable_dispose(newEntry);
  438.     return;
  439.   }
  440.   cptr = copy_word(cptr, buff);
  441.   if (snmpTargetParams_addSecModel(newEntry, buff) == 0) {
  442.     snmpTargetParamTable_dispose(newEntry);
  443.     return;
  444.   }
  445.   cptr = copy_word(cptr, buff);
  446.   if (snmpTargetParams_addSecName(newEntry, buff) == 0) {
  447.     snmpTargetParamTable_dispose(newEntry);
  448.     return;
  449.   }
  450.   cptr = copy_word(cptr, buff);
  451.   if (snmpTargetParams_addSecLevel(newEntry, buff) == 0) {
  452.     snmpTargetParamTable_dispose(newEntry);
  453.     return;
  454.   }
  455.   cptr = copy_word(cptr, buff);
  456.   if (snmpTargetParams_addStorageType(newEntry, buff) == 0) {
  457.     snmpTargetParamTable_dispose(newEntry);
  458.     return;
  459.   }
  460.   cptr = copy_word(cptr, buff);
  461.   if (snmpTargetParams_addRowStatus(newEntry, buff) == 0) {
  462.     snmpTargetParamTable_dispose(newEntry);
  463.     return;
  464.   }
  465.   sprintf(buff, "snmp_parse_config_targetParams, read: %s %d %d %s %d %d %dn",
  466.   newEntry->paramName, newEntry->mpModel,  newEntry->secModel, 
  467.   newEntry->secName,   newEntry->secLevel, newEntry->storageType,
  468.   newEntry->rowStatus);
  469.   DEBUGMSGTL(("snmpTargetParamsEntry", buff));
  471.   snmpTargetParamTable_addToList(newEntry, &aPTable);
  472. } /* snmpd_parse_config_target */
  475. /* shutdown routines */
  478. /* store_snmpTargetParamsEntry handles the presistent storage proccess 
  479.    for this MIB table. It writes out all the non-volatile rows 
  480.    to permanent storage on a shutdown  */
  481. int 
  482. store_snmpTargetParamsEntry(int majorID, int minorID, void *serverarg,
  483.                             void *clientarg)
  484. {
  485.   struct targetParamTable_struct *curr_struct;
  486.   char line[1024];
  488.   strcpy(line, "");
  489.   if ( (curr_struct = aPTable) != 0) {
  490.     while (curr_struct != 0) {
  491.       if ( (curr_struct->storageType == SNMP_STORAGE_NONVOLATILE || 
  492.     curr_struct->storageType == SNMP_STORAGE_PERMANENT) 
  493.                         &&
  494.    (curr_struct->rowStatus == SNMP_ROW_ACTIVE ||
  495.     curr_struct->rowStatus == SNMP_ROW_NOTINSERVICE) ) {
  496. sprintf(&line[strlen(line)], "targetParams %s %i %i %s %i %i %in",
  497.  curr_struct->paramName, curr_struct->mpModel,
  498.  curr_struct->secModel,  curr_struct->secName,
  499.  curr_struct->secLevel,  curr_struct->storageType,
  500.  curr_struct->rowStatus  );
  502. /* store to file */
  503. snmpd_store_config(line);
  504.       }
  505.       curr_struct = curr_struct->next;
  506.     }
  507.   }
  508.   return SNMPERR_SUCCESS;
  509. }  /*  store_snmpTargetParmsEntry  */
  512. /* MIB table access routines */
  515. u_char *
  516. var_snmpTargetParamsEntry(
  517.     struct  variable *vp,
  518.     oid     *name,
  519.     int  *length,
  520.     int     exact,
  521.     int  *var_len,
  522.     WriteMethod **write_method)
  523. {
  524.   /* variables we may use later */
  525.   static long long_ret;
  526.   static unsigned char string[1500];
  527.   struct targetParamTable_struct *temp_struct;
  528.   
  529.   *write_method = 0;           /* assume it isnt writable for the time being */
  530.   *var_len = sizeof(long_ret); /* assume an integer and change later if not */
  531.   
  532.   /* look for OID in current table */
  533.   if ( (temp_struct = search_snmpTargetParamsTable(vp->name, vp->namelen, 
  534.       name, length, exact)) == 0 ) {
  535.     if (vp->magic == SNMPTARGETPARAMSROWSTATUS)  {
  536.       *write_method = write_snmpTargetParamsRowStatus;
  537.     }
  538.     return(0);
  539.   }
  540.   
  541.   /* We found what we were looking for, either the next OID or the exact OID */
  542.   /* this is where we do the value assignments for the mib results. */
  543.   switch(vp->magic) {
  545.     case SNMPTARGETPARAMSMPMODEL:
  546.       *write_method = write_snmpTargetParamsMPModel;
  547.       /* if unset value, (i.e. new row) */
  548.       if (temp_struct->mpModel == -1)  return(0);
  549.       long_ret = temp_struct->mpModel;
  550.       return (unsigned char *) &long_ret;
  552.     case SNMPTARGETPARAMSSECURITYMODEL:
  553.       *write_method = write_snmpTargetParamsSecurityModel;
  554.       /* if unset value, (i.e. new row) */
  555.       if (temp_struct->secModel == -1)  return(0);
  556.       long_ret = temp_struct->secModel;
  557.       return (unsigned char *) &long_ret;
  559.     case SNMPTARGETPARAMSSECURITYNAME:
  560.       *write_method = write_snmpTargetParamsSecurityName;
  561.       /* if unset value, (i.e. new row) */
  562.       if (temp_struct->secName == 0)  return(0);
  563.       /* including null character. */
  564.       memcpy(string, temp_struct->secName, 
  565.      strlen(temp_struct->secName));
  566.       string[strlen(temp_struct->secName)] = '';
  567.       *var_len = strlen(temp_struct->secName);
  568.       return (unsigned char *) string;
  570.     case SNMPTARGETPARAMSSECURITYLEVEL:
  571.       *write_method = write_snmpTargetParamsSecurityLevel;
  572.       /* if unset value, (i.e. new row) */
  573.       if (temp_struct->secLevel == -1)  return(0);
  574.       long_ret = temp_struct->secLevel;
  575.       return (unsigned char *) &long_ret;
  577.     case SNMPTARGETPARAMSSTORAGETYPE:
  578.       *write_method = write_snmpTargetParamsStorageType;
  579.       long_ret = temp_struct->storageType;
  580.       return (unsigned char *) &long_ret;
  582.     case SNMPTARGETPARAMSROWSTATUS:
  583.       *write_method = write_snmpTargetParamsRowStatus;
  584.       long_ret = temp_struct->rowStatus;
  585.       return (unsigned char *) &long_ret;
  587.     default:
  588.       DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_snmpTargetParamsEntryn", vp->magic));
  589.   }
  590.   return 0;
  591. }  /* var_snmpTargetParamsEntry */
  594. /* Assign a value to the mpModel variable */
  595. int
  596. write_snmpTargetParamsMPModel(
  597.    int      action,
  598.    u_char   *var_val,
  599.    u_char   var_val_type,
  600.    int   var_val_len,
  601.    u_char   *statP,
  602.    oid      *name,
  603.    int   name_len)
  604. {
  605.   static long                    long_ret;
  606.   struct targetParamTable_struct *temp_struct;
  608.   /* check incoming variable */
  609.   if (var_val_type != ASN_INTEGER) {
  610.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsMPModel : not ASN_INTEGERn"));
  611.       return SNMP_ERR_WRONGTYPE;
  612.   }
  613.   if (var_val_len > (sizeof(long_ret))) {
  614.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsMPModel : bad lengthn"));
  615.       return SNMP_ERR_WRONGLENGTH;
  616.   }
  617.   long_ret = *((long *) var_val);
  618.   /* spec check range */
  619.   if (long_ret < 0) {
  620.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsMPModel : MP Model out of rangen"));
  621.     return SNMP_ERR_INCONSISTENTVALUE;
  622.   }
  624.   /* Find row in linked list and check pertinent status... */
  625.   snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = SNMPTARGETPARAMSMPMODELCOLUMN;
  626.   if ((temp_struct = search_snmpTargetParamsTable(snmpTargetParamsOID, snmpTargetParamsOIDLen, 
  627.      name, &name_len, 1)) == 0 ) {
  628.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsMPModel : BAD OIDn"));
  629.     return SNMP_ERR_NOSUCHNAME;
  630.   }
  631.   /* row exists, check if it is changeable */
  632.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  633.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamMPModel : row is read onlyn"));
  634.     return SNMP_ERR_READONLY;
  635.   }
  636.   /* check if row is active */
  637.   if (temp_struct->rowStatus == SNMP_ROW_ACTIVE) {
  638.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsMPModel : This change not allowed in active row.n"));
  639.     return SNMP_ERR_INCONSISTENTVALUE;
  640.   }
  641.   /* Finally, we're golden, should we save value? */
  642.   if (action == COMMIT)  {
  643.     temp_struct->mpModel = long_ret;
  644.     /* If row is new, check if its status can be updated */
  645.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  646.  (snmpTargetParams_rowStatusCheck(temp_struct) != 0) )
  647.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  648.   }
  649.   return SNMP_ERR_NOERROR;
  650. }  /* write_snmpTargetParamsMPModel */
  653. /* Assign a value to the Security Model variable */
  654. int
  655. write_snmpTargetParamsSecurityModel(
  656.    int      action,
  657.    u_char   *var_val,
  658.    u_char   var_val_type,
  659.    int   var_val_len,
  660.    u_char   *statP,
  661.    oid      *name,
  662.    int   name_len)
  663. {
  664.   static long                    long_ret;
  665.   struct targetParamTable_struct *temp_struct;
  667.   /* check incoming variable */
  668.   if (var_val_type != ASN_INTEGER) {
  669.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityModel : not ASN_INTEGERn"));
  670.       return SNMP_ERR_WRONGTYPE;
  671.   }
  672.   if (var_val_len > (sizeof(long_ret))) {
  673.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityModel : bad lengthn"));
  674.       return SNMP_ERR_WRONGLENGTH;
  675.   }
  676.   long_ret = *((long *) var_val);
  677.   /* spec check range */
  678.   if (long_ret <= 0)  {
  679.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecModel : Security Model out of rangen"));
  680.     return SNMP_ERR_INCONSISTENTVALUE;
  681.   }
  683.   /* Find struct in linked list and check row status */
  684.   snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = SNMPTARGETPARAMSSECURITYMODELCOLUMN;
  685.   if ((temp_struct = search_snmpTargetParamsTable(snmpTargetParamsOID, snmpTargetParamsOIDLen, 
  686.      name, &name_len, 1)) == 0 ) {
  687.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamSecurityModel : BAD OID!n"));
  688.       return SNMP_ERR_NOSUCHNAME;
  689.   }
  690.   /* row exists, check if it is changeable */
  691.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  692.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamSecurityModel : row is read onlyn"));
  693.     return SNMP_ERR_READONLY;
  694.   }
  695.   /* check if row active */
  696.   if (temp_struct->rowStatus == SNMP_ROW_ACTIVE) {
  697.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamSecurityModel : This change not allowed in active row.n"));
  698.     return SNMP_ERR_INCONSISTENTVALUE;
  699.   }
  701.   /* Finally, we're golden, check if we should save value */
  702.   if (action == COMMIT)  {    
  703.     temp_struct->secModel = long_ret;
  704.     /* If row is new, check if its status can be updated */
  705.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  706.  (snmpTargetParams_rowStatusCheck(temp_struct) != 0) )
  707.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  708.   }
  710.   return SNMP_ERR_NOERROR;
  711. }  /* write_snmpTargetParamsSecurityModel */
  714. /* Assign a value to the Security Name variable */
  715. int
  716. write_snmpTargetParamsSecurityName(
  717.    int      action,
  718.    u_char   *var_val,
  719.    u_char   var_val_type,
  720.    int   var_val_len,
  721.    u_char   *statP,
  722.    oid      *name,
  723.    int   name_len)
  724. {
  725.   static unsigned char           string[1500];
  726.   int  size;
  727.   struct targetParamTable_struct *temp_struct;
  729.   /* check incoming variable */
  730.   if (var_val_type != ASN_OCTET_STR) {
  731.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityName : not ASN_OCTET_STRn"));
  732.       return SNMP_ERR_WRONGTYPE;
  733.   }
  734.   if (var_val_len > (sizeof(string))) {
  735.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityName : bad lengthn"));
  736.       return SNMP_ERR_WRONGLENGTH;
  737.   }
  739.   /* spec check, 0-255, this means EMPTY STRINGS ALLOWED! */
  740.   size = var_val_len;
  741.   memcpy(string, var_val, var_val_len);
  742.   if (size > 255 || size < 0) {
  743.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityName : bad lengthn"));
  744.     return SNMP_ERR_WRONGLENGTH;
  745.   }
  747.   /* Find the struct in the linked list and check row status */
  748.   snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = SNMPTARGETPARAMSSECURITYNAMECOLUMN;
  749.   if ((temp_struct = search_snmpTargetParamsTable(snmpTargetParamsOID, snmpTargetParamsOIDLen, 
  750.      name, &name_len, 1)) == 0 ) {
  751.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityName : BAD OID!n"));
  752.     return SNMP_ERR_NOSUCHNAME;
  753.   }
  754.   /* row exists, check if it is changeable */
  755.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  756.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityName : row is read onlyn"));
  757.     return SNMP_ERR_READONLY;
  758.   }
  759.   /* check if row active */
  760.   if (temp_struct->rowStatus == SNMP_ROW_ACTIVE) {
  761.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityName : This change not allowed in active row.n"));
  762.     return SNMP_ERR_INCONSISTENTVALUE;
  763.   }
  765.   /* Finally, we're golden, check if we should save value */
  766.   if (action == COMMIT)  {    
  767.     free(temp_struct->secName);
  768.     temp_struct->secName = (char *)malloc(size + 1);
  769. if (temp_struct->secName == NULL)
  770. return SNMP_ERR_COMMITFAILED;
  771.     memcpy(temp_struct->secName, string, size);
  772.     temp_struct->secName[size] = '';
  773.     
  774.     /* If row is new, check if its status can be updated */
  775.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  776.  (snmpTargetParams_rowStatusCheck(temp_struct) != 0) )
  777.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  778.   }
  779.   return SNMP_ERR_NOERROR;
  780. }  /* write_snmpTargetParamsSecurityName */
  783. int
  784. write_snmpTargetParamsSecurityLevel(
  785.    int      action,
  786.    u_char   *var_val,
  787.    u_char   var_val_type,
  788.    int   var_val_len,
  789.    u_char   *statP,
  790.    oid      *name,
  791.    int   name_len)
  792. {
  793.   static long                    long_ret;
  794.   struct targetParamTable_struct *temp_struct;
  795.  
  796.   /* check incoming variable */
  797.   if (var_val_type != ASN_INTEGER) {
  798.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityLevel : not ASN_INTEGERn"));
  799.       return SNMP_ERR_WRONGTYPE;
  800.   }
  801.   if (var_val_len > (sizeof(long_ret))) {
  802.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityLevel : bad lengthn"));
  803.       return SNMP_ERR_WRONGLENGTH;
  804.   }
  805.   long_ret = *((long *) var_val);
  806.   /* spec check, no spec check, but noAuthNoPriv is 1 so... */
  807.   if (long_ret <= 0 )  {
  808.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargeParamsSecurityLevel: security level is not noAuthNoPriv(1) or highern"));
  809.     return SNMP_ERR_INCONSISTENTVALUE;
  810.   }
  812.   /* Find the struct in linked list and check its status */
  813.   snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
  814.   if ((temp_struct = search_snmpTargetParamsTable(snmpTargetParamsOID, snmpTargetParamsOIDLen, 
  815.      name, &name_len, 1)) == 0 ) {
  816.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityLevel : BAD OID!n"));
  817.     return SNMP_ERR_NOSUCHNAME;
  818.   }
  819.   /* row exists, check if it is changeable */
  820.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  821.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityLevel : row is read onlyn"));
  822.     return SNMP_ERR_READONLY;
  823.   }
  824.   /* check if row active */
  825.   if (temp_struct->rowStatus == SNMP_ROW_ACTIVE) {
  826.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsSecurityLevel : This change not allowed in active row.n"));
  827.     return SNMP_ERR_INCONSISTENTVALUE;
  828.   }
  830.   /* Finally, we're golden, check if we should save value */
  831.   if (action == COMMIT) {
  832.     temp_struct->secLevel = long_ret;
  833.     
  834.     /* If row is new, check if its status can be updated */
  835.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  836.  (snmpTargetParams_rowStatusCheck(temp_struct) != 0) )
  837.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  838.   }
  839.   return SNMP_ERR_NOERROR;
  840. } /* write_snmpTargetParamsSecurityLevel */
  843. /* Assign a value to the Storage Type variable */
  844. int
  845. write_snmpTargetParamsStorageType(
  846.    int      action,
  847.    u_char   *var_val,
  848.    u_char   var_val_type,
  849.    int   var_val_len,
  850.    u_char   *statP,
  851.    oid      *name,
  852.    int   name_len)
  853. {
  854.   static long                    long_ret;
  855.   struct targetParamTable_struct *temp_struct;
  857.   if (var_val_type != ASN_INTEGER) {
  858.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsStorageType not ASN_INTEGERn"));
  859.       return SNMP_ERR_WRONGTYPE;
  860.   }
  861.   if (var_val_len > (sizeof(long_ret))) {
  862.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsStorageType: bad lengthn"));
  863.       return SNMP_ERR_WRONGLENGTH;
  864.   }
  865.   long_ret = *((long *) var_val);
  866.   
  867.   if ( (long_ret != SNMP_STORAGE_OTHER) && (long_ret != SNMP_STORAGE_VOLATILE) &&
  868.        (long_ret != SNMP_STORAGE_NONVOLATILE) )  {
  869.     DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsStorageType : attempted storage type not a valid"));
  870.     DEBUGMSG(("snmpTargetParamsEntry", "  value of other(%d), volatile(%d), or nonvolatile(%d)n", 
  871.    SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE, SNMP_STORAGE_NONVOLATILE));
  872.     return SNMP_ERR_INCONSISTENTVALUE;
  873.   }
  875.   /* Find the struct in the linked list and check status */
  876.   snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = SNMPTARGETPARAMSSTORAGETYPECOLUMN;
  877.   if ((temp_struct = search_snmpTargetParamsTable(snmpTargetParamsOID, snmpTargetParamsOIDLen, 
  878.      name, &name_len, 1)) == 0 ) {
  879.     DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamStorageType : BAD OIDn"));
  880.     return SNMP_ERR_NOSUCHNAME;
  881.   }
  882.   if ( (temp_struct->storageType == SNMP_STORAGE_PERMANENT) || 
  883.        (temp_struct->storageType == SNMP_STORAGE_READONLY) )  {
  884.     DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsStorageType : row has unchangeable storage status: %dn",
  885.    temp_struct->storageType));
  886.     return SNMP_ERR_INCONSISTENTVALUE;
  887.   }
  889.   /* Finally, we're golden, check if we should save new value */
  890.   if (action == COMMIT) {      
  891.     temp_struct->storageType = long_ret;
  892.   }
  894.   return SNMP_ERR_NOERROR;
  895. }  /* write_snmpTargetParamsStorageType */
  898. /* snmpTargeParams_createNewRow is called from write_snmpTargetParamsRowStatus
  899.    when a new row is required. It creates a new row with 
  900.    the index of the passed in 'name' (i.e. full index OID) and
  901.    adds it to the linked list. 'name' should be the full OID of the new index. 
  902.    It passes back 0 if unsuccessfull.*/
  903. int snmpTargetParams_createNewRow(
  904.      oid  *name,
  905.      int name_len)
  906. {
  907.   int    pNameLen, i;
  908.   struct targetParamTable_struct *temp_struct;
  910.   /* setup a new snmpTargetParamTable structure and add it to the list */
  911.   pNameLen = name_len - snmpTargetParamsOIDLen;
  912.   if (pNameLen > 0) {
  913.     temp_struct            = snmpTargetParamTable_create();
  914. if (temp_struct == NULL)
  915. return 0;
  916.     temp_struct->paramName = (char *)malloc(pNameLen + 1);
  917. if (temp_struct->paramName == NULL)
  918. {
  919. free (temp_struct);
  920. return 0;
  921. }
  923.     for (i = 0; i < pNameLen; i++) {
  924.       temp_struct->paramName[i] = (char)name[i+snmpTargetParamsOIDLen];
  925.     }
  927.     temp_struct->paramName[pNameLen]  = '';
  928.     temp_struct->rowStatus            = SNMP_ROW_NOTREADY;
  929.     
  930.     snmpTargetParamTable_addToList(temp_struct, &aPTable);
  932.     return 1;
  933.   }
  935.   return 0;
  936. }  /* snmpTargetParams_createNewRow */
  939. /* Assign a value to the Row Status variable */
  940. int
  941. write_snmpTargetParamsRowStatus(
  942.    int      action,
  943.    u_char   *var_val,
  944.    u_char   var_val_type,
  945.    int   var_val_len,
  946.    u_char   *statP,
  947.    oid      *name,
  948.    int   name_len)
  949. {
  950.   enum commit_action_enum        {NOTHING, DESTROY, CREATE, CHANGE};
  951.   enum commit_action_enum        onCommitDo; 
  952.   static long                    long_ret;
  954.   struct targetParamTable_struct *temp_struct; /*also treated as boolean for row lookup*/
  956.   if (var_val_type != ASN_INTEGER) {
  957.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsRowStatus not ASN_INTEGERn"));
  958.       return SNMP_ERR_WRONGTYPE;
  959.   }
  960.   if (var_val_len > (sizeof(long_ret))) {
  961.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamsRowStatus: bad lengthn"));
  962.       return SNMP_ERR_WRONGLENGTH;
  963.   }
  964.   long_ret = *((long *) var_val);
  966.   /* search for struct in linked list */
  967.   snmpTargetParamsOID[snmpTargetParamsOIDLen-1] = SNMPTARGETPARAMSROWSTATUSCOLUMN;
  968.   if ((temp_struct = search_snmpTargetParamsTable(snmpTargetParamsOID, snmpTargetParamsOIDLen, 
  969.      name, &name_len, 1)) == 0) {
  970.     /* row doesn't exist, check valid possibilities */
  971.     if (long_ret == SNMP_ROW_DESTROY)  
  972.       /* re: RFC 1903, destroying a non-existent row is noError, whatever */
  973.       onCommitDo = NOTHING;
  974.     /* check if this is for a new row creation */
  975.     else if (long_ret == SNMP_ROW_CREATEANDGO || long_ret == SNMP_ROW_CREATEANDWAIT) 
  976.       onCommitDo = CREATE;
  977.     else /* no valid sets for no row being found so... */
  978.       return SNMP_ERR_NOSUCHNAME;
  979.   }
  980.   else {  /* row exists */
  981.     /* check if it is changeable */
  982.     if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  983.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamRowStatus : row is read onlyn"));
  984.       return SNMP_ERR_READONLY;
  985.     }
  986.     /* check if row is to be destroyed (note: it is ok to destroy notReady row!) */
  987.     else if (long_ret == SNMP_ROW_DESTROY)  {
  988.       if (temp_struct->storageType == SNMP_STORAGE_PERMANENT) {
  989. DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamRowStatus : unable to destroy permanent rown"));
  990. return SNMP_ERR_INCONSISTENTVALUE;
  991.       }
  992.       else  {
  993. onCommitDo = DESTROY;
  994.       }
  995.     }
  996.     /* check if row is new and can be changed from notready yet */
  997.     else if (temp_struct->rowStatus == SNMP_ROW_NOTREADY) {
  998.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargeParamRowStatus : unable to change from NOTREADYn"));
  999.       return SNMP_ERR_INCONSISTENTVALUE;
  1000.     }  
  1001.     /* we now know the row status can be set, check for two valid settings left*/
  1002.     else if ( (long_ret == SNMP_ROW_ACTIVE) || 
  1003.       (long_ret == SNMP_ROW_NOTINSERVICE) ) {
  1004.       onCommitDo = CHANGE;
  1005.     }
  1006.     /* not a valid setting */
  1007.     else  {
  1008.       DEBUGMSGTL(("snmpTargetParamsEntry","write to snmpTargetParamRowStatus : Bad value for setn"));
  1009.       return SNMP_ERR_INCONSISTENTVALUE;
  1010.     }
  1011.   } /* if row exist */
  1012.   
  1013.   /* if this is a commit, do expected action */
  1014.   if (action == COMMIT) {
  1015.     switch(onCommitDo) { 
  1016.       
  1017.     case CREATE :
  1018.       if (snmpTargetParams_createNewRow(name, name_len) == 0) {
  1019. DEBUGMSGTL(("snmpTargetParamsEntry", "write to snmpTargetParamsRowStatus : "));
  1020. DEBUGMSG(("snmpTargetParamsEntry","failed new row creation, bad OID/index value n"));
  1021. return SNMP_ERR_GENERR;
  1022.       }
  1023.       break;
  1024.       
  1025.     case DESTROY:
  1026.       snmpTargetParamTable_remFromList(temp_struct, &aPTable);
  1027.       break;
  1029.     case CHANGE:
  1030.   if ((temp_struct->rowStatus != SNMP_ROW_ACTIVE) && (long_ret == SNMP_ROW_ACTIVE))
  1031.   {
  1032.   temp_struct->rowStatus = long_ret;
  1033.   snmpTargetTryToAddTrap (temp_struct->paramName);
  1034.   }
  1035.   else if ((temp_struct->rowStatus == SNMP_ROW_ACTIVE) && (long_ret != SNMP_ROW_ACTIVE))
  1036.   {
  1037.   snmpTargetTryToDelTrap (temp_struct->paramName);
  1038.   }
  1040.       temp_struct->rowStatus = long_ret;
  1041.       break;
  1043.     case NOTHING:
  1044. default:
  1045.       break;
  1046.     }
  1047.   }
  1048.   
  1049.   return SNMP_ERR_NOERROR;
  1050. }  /* write_snmpTargetParamsRowStatus */
  1052. /**************************************************
  1053. *Called when delete an existing trap_sink
  1054. *IN: host_name -- ip address in string format
  1055. *IN: community -- community string of the trap_sink
  1056. * --sxf 2k-12-27
  1057. *******************************************************/
  1058. void snmp_delete_targetParam (char *host_name, char *community)
  1059. {
  1060. struct targetParamTable_struct *temp_struct, *temp_struct_next;
  1061. char  buf[256];
  1063. if (host_name == NULL || community == NULL)
  1064. {
  1065. snmp_trace("SNMP In add target entry: community or host_name not provided!n");
  1066. return;
  1067. }
  1069. if (strlen (community) + strlen (host_name) > 200)
  1070. {
  1071. snmp_trace("SNMP In add target entry: community or host_name length to long!n");
  1072. return;
  1073. }
  1075. sprintf (buf, "traphost.%s.%s",community,host_name);
  1076. for( temp_struct = aPTable; temp_struct != NULL; ) 
  1077. {
  1078. temp_struct_next = temp_struct->next;
  1079. if (strcmp (buf,temp_struct->paramName) == 0)
  1080. {
  1081. snmpTargetParamTable_remFromList(temp_struct, &aPTable);
  1082. }
  1083. temp_struct = temp_struct_next;
  1084.    }
  1085. }
  1086. /*********************************************************************
  1087. *Called when create a new host to send trap
  1088. *IN: host_name -- ip address in string format
  1089. *IN: community -- community of trapd application in manager entity
  1090. *IN: model -- for v1 model is 0
  1091. *IN: secModel -- the security model
  1092. *IN: secName -- for v1 it is the community string
  1093. *IN: secLevel -- noAuth authNoPriv or authPriv
  1094. *    --sxf 2k-12-27
  1095. *******************************************************************/
  1096. void snmp_add_targetParam (char *host_name, char *community, int model, 
  1097.    int secModel, char *secName, int secLevel)
  1098. {
  1099. struct targetParamTable_struct *newEntry;
  1100. char  buf[256];
  1102. if (host_name == NULL || community == NULL)
  1103. {
  1104. snmp_trace("SNMP In add param entry: community or host_name not provided!n");
  1105. return;
  1106. }
  1107. if (strlen (community) + strlen (host_name) > 200)
  1108. {
  1109. snmp_trace("SNMP In add param entry: community or host_name length to long!n");
  1110. return;
  1111. }
  1112. snmp_delete_targetParam (host_name, community);
  1113. newEntry = snmpTargetParamTable_create();
  1114. if (newEntry == NULL)
  1115. {
  1116. snmp_trace("SNMP In add param entry:Insufficient memoryn");
  1117. return;
  1118. }
  1119. sprintf (buf, "traphost.%s.%s",community,host_name);
  1120. newEntry->paramName = strdup (buf);
  1121. if (newEntry->paramName == NULL)
  1122. {
  1123. snmp_trace("SNMP In add target entry:Out of memoryn");
  1124. free (newEntry);
  1125. return;
  1126. }
  1127. newEntry->mpModel = model;
  1128. newEntry->secModel = secModel;
  1129. if (secName != NULL)
  1130. {
  1131. newEntry->secName = strdup (secName);
  1132. if (newEntry->secName == NULL)
  1133. {
  1134. snmp_trace("SNMP In add target entry:Out of memoryn");
  1135. free (newEntry);
  1136. free (newEntry->paramName);
  1137. return;
  1138. }
  1139. }
  1140. newEntry->secLevel = secLevel;
  1141. newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
  1142. newEntry->rowStatus = SNMP_ROW_ACTIVE;
  1144. snmpTargetParamTable_addToList(newEntry, &aPTable);
  1146. }
  1147. int snmpTargetGetCommFromIndex (char *name, char *buf)
  1148. {
  1149. struct targetParamTable_struct *temp_struct;
  1151. for( temp_struct = aPTable; temp_struct != NULL; temp_struct = temp_struct->next) 
  1152. {
  1153. if (strcmp (name,temp_struct->paramName) == 0 && temp_struct->rowStatus == SNMP_ROW_ACTIVE)
  1154. {
  1155. strncpy (buf, temp_struct->secName, 256);
  1156. return 1;
  1157. }
  1158. }
  1159. return 0;
  1160. }