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

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

SNMP编程

开发平台：

C/C++

snmpTargetAddrEntry.c：源码内容
  1. /* snmpTargetAddrEntry MIB
  2.    
  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 "snmpTargetAddrEntry.h"
  23. #include "read_config.h"
  24. #include "callback.h"
  25. #include "util_funcs.h"
  27. #define snmpTargetAddrOIDLen 11 /*This is base+column, 
  28.   i.e. everything but index*/
  30. oid snmpTargetAddrOID[snmpTargetAddrOIDLen] = {1,3,6,1,6,3,12,1,2,1,0};
  32. static struct targetAddrTable_struct *aAddrTable=0;
  33. static unsigned int snmpTargetSpinLock = 420420;
  35. /* Utility routines */
  36. extern char *snmp_ntoa (long );
  37. extern char *strdup (const char*);
  38. /* TargetAddrTable_create creates and returns a pointer
  39.    to a targetAddrTable_struct with default values set */
  40. /* Convert Internet address in ascii dotted-decimal format (44.0.0.1) to
  41.  * binary IP address
  42.  */
  43. int32
  44. aton(char *s)
  45. {
  46.     int32 n;
  47.   
  48.     register int i;
  49.   
  50.     n = 0;
  51.     if(s == NULLCHAR)
  52.         return 0;
  53.     for(i=24;i>=0;i -= 8){
  54.         /* Skip any leading stuff (e.g., spaces, '[') */
  55.         while(*s != '' && !isdigit(*s))
  56.             s++;
  57.         if(*s == '')
  58.             break;
  59.         n |= (int32)atoi(s) << i;
  60.         if((s = strchr(s,'.')) == NULLCHAR)
  61.             break;
  62.         s++;
  63.     }
  64.     return n;
  65. }
  66.   
  67. struct targetAddrTable_struct 
  68. *snmpTargetAddrTable_create(void)
  69. {
  70.   struct targetAddrTable_struct *newEntry;
  72.   newEntry = (struct targetAddrTable_struct *)
  73.     malloc(sizeof(struct targetAddrTable_struct));
  75.   if (newEntry) {
  76.   newEntry->name        = 0;
  78.   newEntry->tDomainLen  = 0;
  79.   newEntry->tAddress    = 0;
  80.  
  81.   newEntry->timeout     = 1500;
  82.   newEntry->retryCount  = 3;
  84.   newEntry->tagList     = strdup("");
  85.   if (newEntry->tagList == NULL)
  86.   {
  87.   free (newEntry);
  88.   return NULL;
  89.   }
  90.   newEntry->params      = 0;
  91.   newEntry->spinLock    = 0;
  93.   newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
  94.   newEntry->rowStatus   = SNMP_ROW_NONEXISTENT;
  95.   newEntry->next        = 0;
  96.   }
  98.   return newEntry;
  99. }  /* snmpTargetAddrTable_create */
  102. /* TargetAddrTable_dispose frees the space allocated to a
  103.    targetAddrTable_struct */
  104. void snmpTargetAddrTable_dispose(struct targetAddrTable_struct *reaped)
  105. {
  106.   free(reaped->name);
  107.   free(reaped->tAddress);
  108.   free(reaped->tagList);
  109.   free(reaped->params);
  110.   
  111.   free(reaped);
  112. }  /* snmpTargetAddrTable_dispose  */
  115. /* snmpTargetAddrTable_addToList adds a targetAddrTable_struct 
  116.    to a list passed in. The list is assumed to be in a sorted order,
  117.    low to high and this procedure inserts a new struct in the proper 
  118.    location. Sorting uses OID values based on name. A new equal value 
  119.    overwrites a current one. */
  120. void snmpTargetAddrTable_addToList(
  121.      struct targetAddrTable_struct *newEntry,
  122.      struct targetAddrTable_struct **listPtr)
  123. {
  124.   static struct targetAddrTable_struct *curr_struct, *prev_struct;
  125.   int    i;
  126.   int newOIDLen, currOIDLen;
  127.   oid    newOID[128], currOID[128];
  128.   
  129.   /* if the list is empty, add the new entry to the top */
  130.   if ( (prev_struct = curr_struct = *listPtr) == 0 ) {
  131.     *listPtr = newEntry;
  132.     return;
  133.   }
  134.   else {
  135.     /* get the 'OID' value of the new entry */
  136.     newOIDLen = strlen(newEntry->name);
  137.     for(i=0; i < (int)newOIDLen ;i++) {
  138.       newOID[i] = newEntry->name[i];
  139.     }
  141.     /* search through the list for an equal or greater OID value */
  142.     while (curr_struct != 0) {
  143.       currOIDLen = strlen(curr_struct->name);
  144.       for(i=0; i < (int)currOIDLen ;i++) {
  145. currOID[i] = curr_struct->name[i];
  146.       }
  148.       i=snmp_oid_compare(newOID, newOIDLen, currOID, currOIDLen);
  149.       if (i==0) {  /* Exact match, overwrite with new struct */
  150. newEntry->next = curr_struct->next;
  151. /* if curr_struct is the top of the list */
  152. if (*listPtr == curr_struct)  *listPtr = newEntry;
  153. else prev_struct->next = newEntry;
  154. snmpTargetAddrTable_dispose(curr_struct);
  155. return;
  156.       }
  157.       else if (i < 0) { /* Found a greater OID, insert struct in front of it.*/
  158. newEntry->next = curr_struct;
  159. /* if curr_struct is the top of the list */
  160. if (*listPtr == curr_struct) *listPtr = newEntry;
  161. else prev_struct->next = newEntry;
  162. return;
  163.       }
  164.       prev_struct = curr_struct;
  165.       curr_struct = curr_struct->next;
  166.     }
  167.   }
  168.   /* if we're here, no larger OID was ever found, insert on end of list */
  169.   prev_struct->next = newEntry;
  170. }  /* snmpTargeAddrTable_addToList  */
  173. /* snmpTargetAddrTable_remFromList removes a targetAddrTable_struct 
  174.    from the list passed in */
  175. void snmpTargetAddrTable_remFromList(
  176.      struct targetAddrTable_struct *oldEntry,
  177.      struct targetAddrTable_struct **listPtr)
  178. {
  179.   struct targetAddrTable_struct *tptr;
  181.   if ( (tptr = *listPtr) == 0 ) return;
  182.   else if (tptr == oldEntry) {
  183.     *listPtr = (*listPtr)->next;
  184.     snmpTargetAddrTable_dispose(tptr);
  185.     return;
  186.   }
  187.   else  {
  188.     while (tptr->next != 0) {
  189.       if (tptr->next == oldEntry) {
  190. tptr->next = tptr->next->next;
  191. snmpTargetAddrTable_dispose(oldEntry);
  192. return;
  193.       }
  194.       tptr = tptr->next;
  195.     }
  196.   }
  197. }  /* snmpTargetAddrTable_remFromList  */
  200. /* lookup OID in the link list of Addr Table Entries */
  201. struct targetAddrTable_struct *
  202. search_snmpTargetAddrTable(
  203.      oid    *baseName,
  204.      int  baseNameLen,
  205.      oid    *name,
  206.      int *length,
  207.      int    exact)
  208. {
  209.    static struct targetAddrTable_struct *temp_struct;
  210.    int    i;
  211.    int myOIDLen;
  212.    oid    newNum[128];
  214.    /* lookup entry in addrTable linked list, Get Current MIB ID */
  215.    memcpy(newNum, baseName, baseNameLen*sizeof(oid));
  216.   
  217.    for( temp_struct = aAddrTable; temp_struct != 0; temp_struct = temp_struct->next) {
  218.      for(i=0; i < (int)strlen(temp_struct->name) ;i++) {
  219.        newNum[baseNameLen+i] = temp_struct->name[i];
  220.      }
  221.      myOIDLen = baseNameLen+strlen(temp_struct->name);
  222.      i=snmp_oid_compare(name, *length, newNum, myOIDLen);
  223.      /* Assumes that the linked list sorted by OID, low to high */
  224.      if ( (i==0 && exact!=0) || (i<0 && exact==0) ) {
  225.        if (exact == 0) {
  226.  memcpy(name, newNum, myOIDLen*sizeof(oid));
  227.  *length = myOIDLen;
  228.        }
  229.        return temp_struct;
  230.      }
  231.    }
  232.    return(0);
  233. }  /* search_snmpTargetAddrTable  */
  236. /* snmpTargetAddr_rowStatusCheck is boolean funciton that  checks 
  237.    the status of a row's values in order to determine whether
  238.    the row should be notReady or notInService  */
  239. int snmpTargetAddr_rowStatusCheck(struct targetAddrTable_struct *entry)
  240. {
  241.   if ( (entry->tDomainLen == 0) || (entry->tAddress == 0) ||
  242.        (entry->params == 0)  )
  243.     return 0;
  244.   else
  245.     return 1;
  246. }  /* snmtpTargetAddrTable_rowStatusCheck */
  249. /* Init routines */
  251. /* this variable defines function callbacks and type return information 
  252.    for the snmpTargetAddrEntry mib */
  254. struct variable2 snmpTargetAddrEntry_variables[] = {
  255.   { SNMPTARGETADDRTDOMAIN,     ASN_OBJECT_ID , RWRITE, 
  256.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRTDOMAINCOLUMN } },
  257.   { SNMPTARGETADDRTADDRESS,    ASN_OCTET_STR , RWRITE, 
  258.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRTADDRESSCOLUMN } },
  259.   { SNMPTARGETADDRTIMEOUT,     ASN_INTEGER   , RWRITE, 
  260.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRTIMEOUTCOLUMN } },
  261.   { SNMPTARGETADDRRETRYCOUNT,  ASN_INTEGER   , RWRITE, 
  262.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRRETRYCOUNTCOLUMN } },
  263.   { SNMPTARGETADDRTAGLIST,     ASN_OCTET_STR , RWRITE, 
  264.     var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTAGLISTCOLUMN } },
  265.   { SNMPTARGETADDRPARAMS,      ASN_OCTET_STR , RWRITE, 
  266.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRPARAMSCOLUMN } },
  267.   { SNMPTARGETADDRSTORAGETYPE, ASN_INTEGER   , RWRITE, 
  268.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRSTORAGETYPECOLUMN } },
  269.   { SNMPTARGETADDRROWSTATUS,   ASN_INTEGER   , RWRITE, 
  270.     var_snmpTargetAddrEntry, 1, { SNMPTARGETADDRROWSTATUSCOLUMN } },
  272. };
  274. struct variable2 snmpTargetSpinLock_variables[] = {
  275. {SNMPTARGETSPINLOCK, ASN_INTEGER, RWRITE, var_snmpTargetSpinLock, 1, {1}},
  276. };
  277. /*
  278. struct variable2 snmpTargetContexts_variables[] = {
  279. {SNMPUNAVAILABLECONTEXTS , ASN_INTEGER, RWRITE, var_snmpTargetContexts, 1, {4}},
  280. {SNMPUNKNOWNCONTEXTS , ASN_INTEGER, RWRITE, var_snmpTargetContexts, 1, {5}},
  281. };
  282. */
  284. /* now load this mib into the agents mib table */
  285. oid snmpTargetAddrEntry_variables_oid[] = { 1,3,6,1,6,3,12,1,2,1 };
  286. oid snmpTargetSpinLock_variables_oid[] = {1,3,6,1,6,3,12,1};
  287. static oid snmpTargetAddrEntry_TDomain_oid[] = {1,3,6,1,6,1,1};
  288. static int snmpTargetAddrEntry_TDomain_oid_len = 7;
  290. void init_snmpTargetAddrEntry(void) {
  291.   aAddrTable = 0;
  292.   DEBUGMSGTL(("snmpTargetAddrEntry","initn"));
  293.   REGISTER_MIB("target/snmpTargetAddrEntry", snmpTargetAddrEntry_variables,
  294. variable2, snmpTargetAddrEntry_variables_oid);
  295.   REGISTER_MIB("target/snmpTargetSpinLock", snmpTargetSpinLock_variables, 
  296. variable2, snmpTargetSpinLock_variables_oid);
  298.   snmpd_register_config_handler("targetAddr", snmpd_parse_config_targetAddr,
  299. 0, "");
  301.   /* we need to be called back later */
  302.   snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  303.                          store_snmpTargetAddrEntry, NULL);
  305. }  /* init_snmpTargetAddrEntry */
  308. int snmpTargetAddr_addName(
  309.      struct targetAddrTable_struct *entry,
  310.      char   *cptr)
  311. {
  312.   int len;
  313.   if (cptr == 0) {
  314.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no name in config stringn"));
  315.     return(0);
  316.   }
  317.   else {
  318.     len = strlen(cptr);    
  319.     /* spec check for string 1-32 */
  320.     if (len < 1 || len > 32)  {
  321.       DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: name out of range in config stringn"));
  322.       return(0);
  323.     }
  324.     entry->name = (char *)malloc(len + 1);
  325. if (entry->name == NULL)
  326. return 0;
  327.     strncpy(entry->name, cptr, len);
  328.     entry->name[len] = '';
  329.   }
  330.   return(1);
  331. } /* addName */
  332.   
  334. int snmpTargetAddr_addTDomain(
  335.      struct targetAddrTable_struct *entry,
  336.      char   *cptr)
  337. {
  338.   int len=128;
  339.   
  340.   if (cptr == 0) {
  341.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no tDomain in config stringn"));
  342.     return(0);
  343.   }
  345.   if ( !read_objid(cptr, entry->tDomain, (size_t *)&len) ) {
  346.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: tDomain unreadable in config stringn"));
  347.     return(0);
  348.   }
  350.   /* spec check for oid 1-128 */
  351.   if (len < 1 || len > 128)  {
  352.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: tDomain out of range in config stringn"));
  353.     return(0);
  354.   }
  355.   
  356.   entry->tDomainLen = len;
  357.   return(1);
  358. } /* snmpTargetAddr_addTDomain */
  361. int snmpTargetAddr_addTAddress(
  362.      struct targetAddrTable_struct *entry,
  363.      char   *cptr)
  364. {
  365.   int len;
  366.   if (cptr == 0) {
  367.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no tAddress in config stringn"));
  368.     return(0);
  369.   }
  370.   else {
  371.     len = strlen(cptr);    
  372.     /* spec check for string 1-32 */
  373.     /*    if (len < 1 || len > 32)  {
  374.   DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: name out of range in config stringn"));
  375.   return(0);
  376.       } */
  377.     free(entry->tAddress);
  378.     entry->tAddress = (char *)malloc(len + 1);
  379. if (entry->tAddress == NULL)
  380. return 0;
  381.     strncpy(entry->tAddress, cptr, len);
  382.     entry->tAddress[len] = '';
  383.   }
  384.   return(1);
  385. } /* snmpTargetAddr_addTAddress */
  386.   
  387.   
  388. int snmpTargetAddr_addTimeout(
  389.      struct targetAddrTable_struct *entry,
  390.      char   *cptr)
  391. {
  392.   if (cptr == 0) {
  393.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetParamsEntry: no Timeout in config stringn"));
  394.     return(0);
  395.   }
  396.   else if (!(isdigit(*cptr))) {
  397.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargeParamsEntry: Timeout is not a digit in config stringn"));
  398.     return(0);
  399.   }
  400.   /* check Timeout >= 0 */
  401.   else if ( (entry->timeout = (int)strtol(cptr, (char **)NULL, 0)) < 0) {
  402.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargeParamsEntry: Timeout out of range in config stringn"));
  403.     return(0);
  404.   }
  405.   return(1);
  406. }  /* snmpTargetAddr_addTimeout  */
  407.   
  408.   
  409. int snmpTargetAddr_addRetryCount(
  410.      struct targetAddrTable_struct *entry,
  411.      char   *cptr)
  412. {
  413.   if (cptr == 0) {
  414.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetParamsEntry: no Retry Count in config stringn"));
  415.     return(0);
  416.   }
  417.   else if (!(isdigit(*cptr))) {
  418.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargeParamsEntry: Retry Count is not a digit in config stringn"));
  419.     return(0);
  420.   }
  421.   /* spec check 0..255 */
  422.   else {
  423.     entry->retryCount = (int)strtol(cptr, (char **)NULL, 0);
  424.     if ( (entry->retryCount < 0) ||
  425.  (entry->retryCount > 255) )  {
  426.       DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargeParamsEntry: Retry Count is out of range in config stringn"));
  427.       return(0);
  428.     }
  429.   }
  430.   return(1);
  431. }  /* snmpTargetAddr_addRetryCount  */
  433.  
  434. int snmpTargetAddr_addTagList(
  435.      struct targetAddrTable_struct *entry,
  436.      char   *cptr)
  437. {
  438.   int len;
  439.   if (cptr == 0) {
  440.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no tag list in config stringn"));
  441.     return(0);
  442.   }
  443.   else {
  444.     len = strlen(cptr);    
  445.     /* spec check for string 0-255 */
  446.     if (len < 0 || len > 255)  {
  447.       DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: tag list out of range in config stringn"));
  448.       return(0);
  449.     } 
  450.     free(entry->tagList);
  451.     entry->tagList = (char *)malloc(len + 1);
  452. if (entry->tagList == NULL)
  453. return 0;
  454.     strncpy(entry->tagList, cptr, len);
  455.     entry->tagList[len] = '';
  456.   }
  457.   return(1);
  458. } /* snmpTargetAddr_addTagList */
  459.   
  460.  
  461. int snmpTargetAddr_addParams(
  462.      struct targetAddrTable_struct *entry,
  463.      char   *cptr)
  464. {
  465.   int len;
  466.   if (cptr == 0) {
  467.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no params in config stringn"));
  468.     return(0);
  469.   }
  470.   else {
  471.     len = strlen(cptr);    
  472.     /* spec check for string 1-32 */
  473.     if (len < 1 || len > 32)  {
  474.       DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: params out of range in config stringn"));
  475.       return(0);
  476.     } 
  477.     entry->params = (char *)malloc(len + 1);
  478. if (entry->params == NULL)
  479. return 0;
  480.     strncpy(entry->params, cptr, len);
  481.     entry->params[len] = '';
  482.   }
  483.   return(1);
  484. } /* snmpTargetAddr_addParams */
  486.   
  487. int snmpTargetAddr_addStorageType(
  488.      struct targetAddrTable_struct *entry,
  489.      char   *cptr)
  490. {
  491.   char   buff[1024];
  493.   if (cptr == 0) {
  494.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no storage type in config stringn"));
  495.     return(0);
  496.   }
  497.   else if (!(isdigit(*cptr))) {
  498.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: storage type is not a digit in config stringn"));
  499.     return(0);
  500.   }
  501.   /* check that storage type is a possible value */
  502.   else if ( ((entry->storageType = (int)strtol(cptr, (char **)NULL, 0)) 
  503.      != SNMP_STORAGE_OTHER) &&
  504.     (entry->storageType != SNMP_STORAGE_VOLATILE) && 
  505.     (entry->storageType != SNMP_STORAGE_NONVOLATILE)  &&
  506.     (entry->storageType != SNMP_STORAGE_PERMANENT) && 
  507.     (entry->storageType != SNMP_STORAGE_READONLY) )  {
  508.     sprintf(buff,"ERROR snmpTargetAddrEntry: storage type not a valid value of other(%d), volatile(%d), nonvolatile(%d), permanent(%d), or readonly(%d) in config string.n", SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE, SNMP_STORAGE_NONVOLATILE, SNMP_STORAGE_PERMANENT, SNMP_STORAGE_READONLY);
  509.     DEBUGMSGTL(("snmpTargetAddrEntry", buff));
  511.     return(0);
  512.   }
  513.   return(1);
  514. }  /* snmpTargetAddr_addStorageType */
  515.   
  516.   
  517. int snmpTargetAddr_addRowStatus(
  518.      struct targetAddrTable_struct *entry,
  519.      char   *cptr)
  520. {
  521.   char buff[1024];
  523.   if (cptr == 0) {
  524.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: no Row Status in config stringn"));
  525.     return(0);
  526.   }
  527.   else if (!(isdigit(*cptr))) {
  528.     DEBUGMSGTL(("snmpTargetAddrEntry","ERROR snmpTargetAddrEntry: Row Status is not a digit in config stringn"));
  529.     return(0);
  530.   }
  531.   /* check that row status is a valid value */
  532.   else if ( ((entry->rowStatus = (int)strtol(cptr, (char **)NULL, 0)) 
  533.      != SNMP_ROW_ACTIVE) &&
  534.     (entry->rowStatus != SNMP_ROW_NOTINSERVICE) &&
  535.     (entry->rowStatus != SNMP_ROW_NOTREADY) ) {
  536.     sprintf(buff, "ERROR snmpTargetAddrEntry: Row Status is not a valid value of active(%d), notinservice(%d), or notready(%d) in config string.n", SNMP_ROW_ACTIVE, SNMP_ROW_NOTINSERVICE, SNMP_ROW_NOTREADY);
  537.     DEBUGMSGTL(("snmpTargetAddrEntry", buff));
  538.     
  539.     return(0);
  540.   }
  541.   return(1);
  542. }  /* snmpTargetAddr_addRowStatus  */
  544. /**************************************************
  545. *Delete a target address entry
  546. *IN: host_name -- ip address in string format
  547. *IN: community -- community string
  548. * --sxf 2k-12-26
  549. *******************************************************/
  550. void snmp_delete_targetAddr (char *host_name, char *community)
  551. {
  552. struct targetAddrTable_struct *temp_struct, *temp_struct_next;
  553. char  buf[256];
  555. if (host_name == NULL || community == NULL)
  556. {
  557. snmp_trace("SNMP In add target entry: community or host_name not provided!n");
  558. return;
  559. }
  561. if (strlen (community) + strlen (host_name) > 200)
  562. {
  563. snmp_trace("SNMP In add target entry: community or host_name length to long!n");
  564. return;
  565. }
  567. sprintf (buf, "traphost.%s.%s",community,host_name);
  568.    for( temp_struct = aAddrTable; temp_struct != NULL; ) 
  569.    {
  570.     temp_struct_next = temp_struct->next;
  571.     if (strcmp (buf,temp_struct->name) == 0)
  572.     {
  573.     snmpTargetAddrTable_remFromList(temp_struct, &aAddrTable);
  574.     }
  575.     temp_struct = temp_struct_next;
  576.    }
  577. }
  578. /*
  579. *Create target address entry. Called when create a new host to send trap.
  580. *IN: host_name -- ip address in string format
  581. *IN: community -- community of trapd application in manager entity
  582. *IN: timeout -- default value is 1500 (defined in target mib) 
  583. *IN: retry -- default value is 3 (defined in target mib)
  584. *    --sxf 2k-12-26
  585. */
  586. void snmp_add_targetAddr (char *host_name, char *community, int timeout, int retry)
  587. {
  588. struct targetAddrTable_struct *newEntry;
  589. char  buf[256];
  590. long ipAddr;
  592. if (host_name == NULL || community == NULL)
  593. {
  594. snmp_trace("SNMP In add target entry: community or host_name not provided!n");
  595. return;
  596. }
  598. if (strlen (community) + strlen (host_name) > 200)
  599. {
  600. snmp_trace("SNMP In add target entry: community or host_name length to long!n");
  601. return;
  602. }
  603. snmp_delete_targetAddr (host_name, community);
  604. newEntry = snmpTargetAddrTable_create();
  605. if (newEntry == NULL)
  606. return;
  607. sprintf (buf, "traphost.%s.%s",community,host_name);
  608. newEntry->name = strdup (buf);
  609. memcpy (newEntry->tDomain, snmpTargetAddrEntry_TDomain_oid,snmpTargetAddrEntry_TDomain_oid_len*sizeof(oid));
  610. newEntry->tDomainLen = snmpTargetAddrEntry_TDomain_oid_len;
  611. newEntry->tAddress = (char *)malloc (7*sizeof(char));
  612. /*ip addr*/
  613. ipAddr = aton(host_name);
  614. if (newEntry->tAddress != NULL)
  615. {
  616. memcpy (newEntry->tAddress, &ipAddr, 4);
  617. /*udp port*/
  618. (newEntry->tAddress)[4] = 0;
  619. (newEntry->tAddress)[5] = 0xA2;
  620. (newEntry->tAddress)[6] = '';
  621. }
  623. newEntry->timeout = timeout;
  624. newEntry->retryCount = retry;
  625. newEntry->tagList = strdup ("trap");
  626. newEntry->params = strdup (buf);
  627. newEntry->storageType = SNMP_STORAGE_NONVOLATILE;
  628. newEntry->rowStatus = SNMP_ROW_ACTIVE;
  630. if (newEntry->name == NULL||newEntry->tAddress == NULL
  631. ||newEntry->tagList == NULL||newEntry->params == NULL)
  632. {
  633. snmp_trace("SNMP In add target entry:Insufficient memoryn");
  634. if (newEntry->name)
  635. free(newEntry->name);
  636. if (newEntry->tAddress)
  637. free (newEntry->tAddress);
  638. if (newEntry->tagList)
  639. free (newEntry->tagList);
  640. if (newEntry->params)
  641. free (newEntry->params);
  642. free (newEntry);
  643. return;
  644. }
  645. snmpTargetAddrTable_addToList(newEntry, &aAddrTable);
  647. }
  650. void snmpd_parse_config_targetAddr(const char *token, char *char_ptr)
  651. {
  652.   char  *cptr = char_ptr, buff[1024];
  653.   struct targetAddrTable_struct *newEntry;
  654.   int                            i;
  656.   newEntry = snmpTargetAddrTable_create();
  657.   if (newEntry == NULL)
  658.   return;
  659.   cptr = copy_word(cptr, buff);
  660.   if (snmpTargetAddr_addName(newEntry, buff) == 0) {
  661.     snmpTargetAddrTable_dispose(newEntry);
  662.     return;
  663.   }
  664.   cptr = copy_word(cptr, buff);
  665.   if (snmpTargetAddr_addTDomain(newEntry, buff) == 0) {
  666.     snmpTargetAddrTable_dispose(newEntry);
  667.     return;
  668.   }
  669.   cptr = copy_word(cptr, buff);
  670.   if (snmpTargetAddr_addTAddress(newEntry, buff) == 0) {
  671.     snmpTargetAddrTable_dispose(newEntry);
  672.     return;
  673.   }
  674.   cptr = copy_word(cptr, buff);
  675.   if (snmpTargetAddr_addTimeout(newEntry, buff) == 0) {
  676.     snmpTargetAddrTable_dispose(newEntry);
  677.     return;
  678.   }
  679.   cptr = copy_word(cptr, buff);
  680.   if (snmpTargetAddr_addRetryCount(newEntry, buff) == 0) {
  681.     snmpTargetAddrTable_dispose(newEntry);
  682.     return;
  683.   }
  684.   cptr = copy_word(cptr, buff);
  685.   if (snmpTargetAddr_addTagList(newEntry, buff) == 0) {
  686.     snmpTargetAddrTable_dispose(newEntry);
  687.     return;
  688.   }
  689.   cptr = copy_word(cptr, buff);
  690.   if (snmpTargetAddr_addParams(newEntry, buff) == 0) {
  691.     snmpTargetAddrTable_dispose(newEntry);
  692.     return;
  693.   }
  694.   cptr = copy_word(cptr, buff);
  695.   if (snmpTargetAddr_addStorageType(newEntry, buff) == 0) {
  696.     snmpTargetAddrTable_dispose(newEntry);
  697.     return;
  698.   }
  699.   cptr = copy_word(cptr, buff);
  700.   if (snmpTargetAddr_addRowStatus(newEntry, buff) == 0) {
  701.     snmpTargetAddrTable_dispose(newEntry);
  702.     return;
  703.   }
  704.   sprintf(buff, "snmp_parse_config_targetAddr, read: %sn",
  705.    newEntry->name);
  706.   for(i=0;i<newEntry->tDomainLen;i++) {
  707.     sprintf(&buff[strlen(buff)], ".%d", (int)newEntry->tDomain[i]);
  708.   }
  709.   sprintf(&buff[strlen(buff)], " %s %d %d %s %s %d %dn",
  710.   snmp_ntoa(*((long*)(newEntry->tAddress))), newEntry->timeout, newEntry->retryCount,
  711.   newEntry->tagList,  newEntry->params,  newEntry->storageType, 
  712.   newEntry->rowStatus);
  713.   DEBUGMSGTL(("snmpTargetAddrEntry", buff));
  715.   snmpTargetAddrTable_addToList(newEntry, &aAddrTable);
  716. } /* snmpd_parse_config_target */
  719. /* Shutdown routines */
  722. /* store_snmpTargetAddrEntry handles the persistent storage proccess 
  723.    for this MIB table. It writes out all the non-volatile rows 
  724.    to permanent storage on a shutdown  */
  725. int 
  726. store_snmpTargetAddrEntry(int majorID, int minorID, void *serverarg,
  727.                           void *clientarg)
  728. {
  729.   struct targetAddrTable_struct *curr_struct;
  730.   char line[1024];
  731.   int  i;
  733.   if ( (curr_struct = aAddrTable) != 0) {
  734.     while (curr_struct != 0) {
  735.       if ( (curr_struct->storageType == SNMP_STORAGE_NONVOLATILE || 
  736.     curr_struct->storageType == SNMP_STORAGE_PERMANENT) 
  737.    &&
  738.    (curr_struct->rowStatus == SNMP_ROW_ACTIVE ||
  739.     curr_struct->rowStatus == SNMP_ROW_NOTINSERVICE) ) {
  740. sprintf(line, "targetAddr %s ", curr_struct->name);
  741. for(i=0; i < curr_struct->tDomainLen; i++) {
  742.   sprintf(&line[strlen(line)], ".%i", (int)curr_struct->tDomain[i]);
  743. }
  744. sprintf(&line[strlen(line)], " %s %i %i "%s" %s %i %i", 
  745.  snmp_ntoa(*((long*)(curr_struct->tAddress))),    curr_struct->timeout, 
  746.  curr_struct->retryCount,  curr_struct->tagList,
  747.  curr_struct->params,      curr_struct->storageType, 
  748.  curr_struct->rowStatus);
  750. /* store to file */
  751. snmpd_store_config(line);
  752.       }
  753.       curr_struct = curr_struct->next;
  754.     }
  755.   }
  756.   return SNMPERR_SUCCESS;
  758. }  /*  store_snmpTargetAddrEntry  */
  761. /*MIB table access routines */
  764. u_char *
  765. var_snmpTargetAddrEntry(
  766.     struct variable *vp,
  767.     oid     *name,
  768.     int *length,
  769.     int     exact,
  770.     int  *var_len,
  771.     WriteMethod **write_method)
  772. {
  774.   /* variables we may use later */
  775.   static long                    long_ret;
  776.   static char                    string[1500];
  777.   static oid                     objid[128];
  778.   struct targetAddrTable_struct *temp_struct;
  779.   int                            i;
  781.   *write_method = 0;           /* assume it isnt writable for the time being */
  782.   *var_len = sizeof(long_ret); /* assume an integer and change later if not */
  784.   /* look for OID in current table */
  785.   if ( (temp_struct = search_snmpTargetAddrTable(vp->name, vp->namelen, 
  786.       name, length, exact)) == 0 ) {
  787.     /* for creation of new rows */
  788.     if (vp->magic == SNMPTARGETADDRROWSTATUS)  {
  789.       *write_method = write_snmpTargetAddrRowStatus;
  790.     }
  791.     return(0);
  792.   }
  793.   
  794.   /* We found what we were looking for, either the next OID or the exact OID */
  795.   /* this is where we do the value assignments for the mib results. */
  796.   switch(vp->magic) {
  798.   case SNMPTARGETADDRTDOMAIN:
  799.     *write_method = write_snmpTargetAddrTDomain;
  800.     if (temp_struct->tDomainLen <= 0) {
  801.       return(0);
  802.     }
  803.     else {
  804.       for (i=0;i<temp_struct->tDomainLen;i++) {
  805. objid[i] = temp_struct->tDomain[i];
  806.       }
  807.       *var_len = temp_struct->tDomainLen * sizeof(oid);
  808.     }
  809.     return (unsigned char *) objid;
  810.     
  811.   case SNMPTARGETADDRTADDRESS:
  812.     *write_method = write_snmpTargetAddrTAddress;
  813.     if (temp_struct->tAddress == 0)  return(0);
  814.     memcpy(string, temp_struct->tAddress, 7);
  815.     *var_len = 6;
  816.     return (unsigned char *) string;
  817.     
  818.   case SNMPTARGETADDRTIMEOUT:
  819.     *write_method = write_snmpTargetAddrTimeout;
  820.     long_ret = temp_struct->timeout;
  821.     return (unsigned char *) &long_ret;
  823.   case SNMPTARGETADDRRETRYCOUNT:
  824.     *write_method = write_snmpTargetAddrRetryCount;
  825.     long_ret = temp_struct->retryCount;
  826.     return (unsigned char *) &long_ret;
  828.   case SNMPTARGETADDRTAGLIST:
  829.     *write_method = write_snmpTargetAddrTagList;
  830.     strcpy(string, temp_struct->tagList);
  831.     *var_len = strlen(string);
  832.     return (unsigned char *) string;
  834.   case SNMPTARGETADDRPARAMS:
  835.     *write_method = write_snmpTargetAddrParams;
  836.     if (temp_struct->params == 0) return(0);
  837.     strcpy(string, temp_struct->params);
  838.     *var_len = strlen(string);
  839.     return (unsigned char *) string;
  840.     
  841.   case SNMPTARGETADDRSTORAGETYPE:
  842.     *write_method = write_snmpTargetAddrStorageType;
  843.     long_ret = temp_struct->storageType;
  844.     return (unsigned char *) &long_ret;
  846.   case SNMPTARGETADDRROWSTATUS:
  847.     *write_method = write_snmpTargetAddrRowStatus;
  848.     long_ret = temp_struct->rowStatus;
  849.     return (unsigned char *) &long_ret;
  850.     
  851.   default:
  852.     DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_snmpTargetAddrEntryn", vp->magic));
  853.   }
  854.   return 0;
  855. }  /* var_snmpTargetAddrEntry */
  858. int
  859. write_snmpTargetAddrTDomain(
  860.    int      action,
  861.    u_char   *var_val,
  862.    u_char   var_val_type,
  863.    int     var_val_len,
  864.    u_char   *statP,
  865.    oid      *name,
  866.    int      name_len)
  867. {
  868.   int                            objSize;
  869.   int                            i;
  870.   struct targetAddrTable_struct *temp_struct;
  871.   static oid                    objid[MAX_OID_LEN];
  873.   if (var_val_type != ASN_OBJECT_ID) {
  874.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTDomain not ASN_OBJECT_IDn"));
  875.     return SNMP_ERR_WRONGTYPE;
  876.   }
  877.   if (var_val_len > 128) {
  878.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTDomain: bad lengthn"));
  879.     return SNMP_ERR_WRONGLENGTH;
  880.   }
  882.   /* spec check, ??? */
  883.   objSize = var_val_len/sizeof(oid);
  884.   memcpy(objid, var_val, var_val_len);
  885.   
  886.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTDOMAINCOLUMN;
  887.   if ( (temp_struct = search_snmpTargetAddrTable(snmpTargetAddrOID, 
  888.  snmpTargetAddrOIDLen,
  889.  name, &name_len, 1)) == 0) {
  890.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTDomain : BAD OID!n"));
  891.     return SNMP_ERR_NOSUCHNAME;
  892.   }
  893.   /* row exists, check if it is changeable */
  894.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  895.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTDomain : row is read onlyn"));
  896.     return SNMP_ERR_READONLY;
  897.   }
  898.   /* check if row active */
  899.   if (temp_struct->rowStatus == SNMP_ROW_ACTIVE) {
  900.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTDomains : This change not allowed in active row.n"));
  901.     return SNMP_ERR_INCONSISTENTVALUE;
  902.   }
  904.   /* Finally, we're golden, check if we should save value */
  905.   if (action == COMMIT)  {    
  906.     for (i=0;i < (int)objSize; i++) 
  907.       temp_struct->tDomain[i] = objid[i];
  908.     temp_struct->tDomainLen = objSize;
  910.     /* If row is new, check if its status can be updated */
  911.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  912.  (snmpTargetAddr_rowStatusCheck(temp_struct) != 0) )
  913.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  914.   }
  916.   return SNMP_ERR_NOERROR;
  917. }  /* write_snmpTargetAddrTDomain */
  920. int
  921. write_snmpTargetAddrTAddress(
  922.    int action,
  923.    u_char   *var_val,
  924.    u_char   var_val_type,
  925.    int   var_val_len,
  926.    u_char   *statP,
  927.    oid      *name,
  928.    int   name_len)
  929. {
  930.   static unsigned char           string[1500];
  931.   int  size;
  932.   struct targetAddrTable_struct *temp_struct;
  934.   if (var_val_type != ASN_OCTET_STR) {
  935.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTAddress not ASN_OCTET_STRn"));
  936.       return SNMP_ERR_WRONGTYPE;
  937.   }
  938.   if (var_val_len > (sizeof(string))) {
  939.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTAddress: bad lengthn"));
  940.       return SNMP_ERR_WRONGLENGTH;
  941.   }
  943.   /* spec check, ??? */
  944.   size = var_val_len;
  945.   memcpy(string, var_val, var_val_len);
  946.   
  947.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTADDRESSCOLUMN;
  948.   if ( (temp_struct = search_snmpTargetAddrTable(snmpTargetAddrOID, 
  949.  snmpTargetAddrOIDLen,
  950.  name, &name_len, 1)) == 0) {
  951.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTAddress : BAD OID!n"));
  952.     return SNMP_ERR_NOSUCHNAME;
  953.   }
  954.   /* row exists, check if it is changeable */
  955.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  956.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTAddress : row is read onlyn"));
  957.     return SNMP_ERR_READONLY;
  958.   }
  959.   /* check if row active */
  960.   if (temp_struct->rowStatus == SNMP_ROW_ACTIVE) {
  961.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTAddress : This change not allowed in active row.n"));
  962.     return SNMP_ERR_INCONSISTENTVALUE;
  963.   }
  964.   
  965.   /* Finally, we're golden, check if we should save value */
  966.   if (action == COMMIT)  {    
  967.     free(temp_struct->tAddress);
  968.     temp_struct->tAddress = (char *)malloc(size + 1);
  969. if (temp_struct->tAddress == NULL)
  970. return SNMP_ERR_COMMITFAILED;
  971.     memcpy(temp_struct->tAddress, string, size);
  972.     temp_struct->tAddress[size] = '';
  973.     
  974.     /* If row is new, check if its status can be updated */
  975.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  976.  (snmpTargetAddr_rowStatusCheck(temp_struct) != 0) )
  977.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  978.   }
  979.   return SNMP_ERR_NOERROR;
  980. }  /* write_snmpTargetAddrTAddress */
  983. int
  984. write_snmpTargetAddrTimeout(
  985.    int      action,
  986.    u_char   *var_val,
  987.    u_char   var_val_type,
  988.    int   var_val_len,
  989.    u_char   *statP,
  990.    oid      *name,
  991.    int   name_len)
  992. {
  993.   /* variables we may use later */
  994.   static long                    long_ret;
  995.  /* int                         size;*/
  996.   struct targetAddrTable_struct *temp_struct;
  998.   if (var_val_type != ASN_INTEGER) {
  999.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout not ASN_INTEGERn"));
  1000.       return SNMP_ERR_WRONGTYPE;
  1001.   }
  1002.   if (var_val_len > (sizeof(long_ret))) {
  1003.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout: bad lengthn"));
  1004.       return SNMP_ERR_WRONGLENGTH;
  1005.   }
  1006.   long_ret = *((long *) var_val);
  1007.   
  1008.   /* spec check range, no spec check */
  1009.   
  1010.   /* Find row in linked list and check pertinent status... */
  1011.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTIMEOUTCOLUMN;
  1012.   if ((temp_struct = search_snmpTargetAddrTable
  1013.        (snmpTargetAddrOID, snmpTargetAddrOIDLen, 
  1014. name, &name_len, 1)) == 0 ) {
  1015.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout : BAD OIDn"));
  1016.     return SNMP_ERR_NOSUCHNAME;
  1017.   }
  1018.   /* row exists, check if it is changeable */
  1019.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  1020.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout : row is read onlyn"));
  1021.     return SNMP_ERR_READONLY;
  1022.   }
  1024.   /* Finally, we're golden, should we save value? */
  1025.   if (action == COMMIT)  {
  1026.     temp_struct->timeout = long_ret;
  1027.   }
  1029.   return SNMP_ERR_NOERROR;
  1030. }  /* write_snmpTargetAddrTimeout */
  1033. int
  1034. write_snmpTargetAddrRetryCount(
  1035.    int      action,
  1036.    u_char   *var_val,
  1037.    u_char   var_val_type,
  1038.    int   var_val_len,
  1039.    u_char   *statP,
  1040.    oid      *name,
  1041.    int   name_len)
  1042. {
  1043.   /* variables we may use later */
  1044.   static long                    long_ret;
  1045.   struct targetAddrTable_struct *temp_struct;
  1047.   if (var_val_type != ASN_INTEGER) {
  1048.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRetryCount not ASN_INTEGERn"));
  1049.     return SNMP_ERR_WRONGTYPE;
  1050.   }
  1051.   if (var_val_len > (sizeof(long_ret))) {
  1052.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRetryCount: bad lengthn"));
  1053.     return SNMP_ERR_WRONGLENGTH;
  1054.   }
  1055.   long_ret = *((long *) var_val);
  1056.   
  1057.   /* spec check range, no spec check */
  1058.   
  1059.   /* Find row in linked list and check pertinent status... */
  1060.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRRETRYCOUNTCOLUMN;
  1061.   if ((temp_struct = search_snmpTargetAddrTable
  1062.        (snmpTargetAddrOID, snmpTargetAddrOIDLen, 
  1063. name, &name_len, 1)) == 0 ) {
  1064.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTimeout : BAD OIDn"));
  1065.     return SNMP_ERR_NOSUCHNAME;
  1066.   }
  1068.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  1069.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRetryCount : row is read onlyn"));
  1070.     return SNMP_ERR_READONLY;
  1071.   }
  1073.   /* Finally, we're golden, should we save value? */
  1074.   if (action == COMMIT)  {
  1075.     temp_struct->retryCount = long_ret;
  1076.   }
  1078.   return SNMP_ERR_NOERROR;
  1079. }  /* write_snmpTargetAddrRetryCount */
  1082. int
  1083. write_snmpTargetAddrTagList(
  1084.    int      action,
  1085.    u_char   *var_val,
  1086.    u_char   var_val_type,
  1087.    int   var_val_len,
  1088.    u_char   *statP,
  1089.    oid      *name,
  1090.    int   name_len)
  1091. {
  1092.   /* variables we may use later */
  1093.   static unsigned char           string[1500];
  1094.   int                         size;
  1095.   struct targetAddrTable_struct *temp_struct;
  1097.   if (var_val_type != ASN_OCTET_STR) {
  1098.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTagList not ASN_OCTET_STRn"));
  1099.     return SNMP_ERR_WRONGTYPE;
  1100.   }
  1101.   if (var_val_len > (sizeof(string))) {
  1102.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTagList: bad lengthn"));
  1103.     return SNMP_ERR_WRONGLENGTH;
  1104.   }
  1105.   
  1106.   /* spec check, ??? */
  1107.   size = var_val_len;
  1108.   memcpy(string, var_val, var_val_len);
  1109.   
  1110.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRTAGLISTCOLUMN;
  1111.   if ( (temp_struct = search_snmpTargetAddrTable(snmpTargetAddrOID, 
  1112.  snmpTargetAddrOIDLen,
  1113.  name, &name_len, 1)) == 0) {
  1114.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTagList : BAD OID!n"));
  1115.     return SNMP_ERR_NOSUCHNAME;
  1116.   }
  1117.   /* row exists, check if it is changeable */
  1118.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  1119.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrTagList : row is read onlyn"));
  1120.     return SNMP_ERR_READONLY;
  1121.   }
  1122.   
  1123.   /* Finally, we're golden, check if we should save value */
  1124.   if (action == COMMIT)  {    
  1125.     free(temp_struct->tagList);
  1126.     temp_struct->tagList = (char *)malloc(size + 1);
  1127. if (temp_struct->tagList == NULL)
  1128. return SNMP_ERR_COMMITFAILED;
  1129.     memcpy(temp_struct->tagList, string, size);
  1130.     temp_struct->tagList[size] = '';
  1131.   }
  1133.   return SNMP_ERR_NOERROR;
  1134. }  /* write_snmpTargetAddrTagList */
  1137. int
  1138. write_snmpTargetAddrParams(
  1139.    int      action,
  1140.    u_char   *var_val,
  1141.    u_char   var_val_type,
  1142.    int   var_val_len,
  1143.    u_char   *statP,
  1144.    oid      *name,
  1145.    int   name_len)
  1146. {
  1147.   static unsigned char           string[1500];
  1148.   int                         size;
  1149.   struct targetAddrTable_struct *temp_struct;
  1151.   if (var_val_type != ASN_OCTET_STR) {
  1152.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrParams not ASN_OCTET_STRn"));
  1153.     return SNMP_ERR_WRONGTYPE;
  1154.   }
  1155.   if (var_val_len > (sizeof(string))) {
  1156.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrParams: bad lengthn"));
  1157.     return SNMP_ERR_WRONGLENGTH;
  1158.   }
  1160.   /* spec check, ??? */
  1161.   size = var_val_len;
  1162.   memcpy(string, var_val, var_val_len);
  1163.   
  1164.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRPARAMSCOLUMN;
  1165.   if ( (temp_struct = search_snmpTargetAddrTable(snmpTargetAddrOID, 
  1166.  snmpTargetAddrOIDLen,
  1167.  name, &name_len, 1)) == 0) {
  1168.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrParams : BAD OID!n"));
  1169.     return SNMP_ERR_NOSUCHNAME;
  1170.   }
  1171.   /* row exists, check if it is changeable */
  1172.   if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  1173.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrParams : row is read onlyn"));
  1174.     return SNMP_ERR_READONLY;
  1175.   }
  1176.   
  1177.   /* Finally, we're golden, check if we should save value */
  1178.   if (action == COMMIT)  {    
  1179.     free(temp_struct->params);
  1180.     temp_struct->params = (char *)malloc(size + 1);
  1181. if (temp_struct->params == NULL)
  1182. return SNMP_ERR_COMMITFAILED;
  1183.     memcpy(temp_struct->params, string, size);
  1184.     temp_struct->params[size] = '';
  1185.     
  1186.     /* If row is new, check if its status can be updated */
  1187.     if ( (temp_struct->rowStatus == SNMP_ROW_NOTREADY) &&
  1188.  (snmpTargetAddr_rowStatusCheck(temp_struct) != 0) )
  1189.       temp_struct->rowStatus = SNMP_ROW_NOTINSERVICE;
  1190.   }
  1192.   return SNMP_ERR_NOERROR;
  1193. }  /* write_snmpTargetAddrParams */
  1196. int
  1197. write_snmpTargetAddrStorageType(
  1198.    int      action,
  1199.    u_char   *var_val,
  1200.    u_char   var_val_type,
  1201.    int   var_val_len,
  1202.    u_char   *statP,
  1203.    oid      *name,
  1204.    int   name_len)
  1205. {
  1206.   static long                    long_ret;
  1207.   struct targetAddrTable_struct *temp_struct;
  1209.   if (var_val_type != ASN_INTEGER) {
  1210.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrStorageType not ASN_INTEGERn"));
  1211.       return SNMP_ERR_WRONGTYPE;
  1212.   }
  1213.   if (var_val_len > (sizeof(long_ret))) {
  1214.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrStorageType: bad lengthn"));
  1215.       return SNMP_ERR_WRONGLENGTH;
  1216.   }
  1218.   long_ret = *((long *) var_val);
  1219.   
  1220.   if ( (long_ret != SNMP_STORAGE_OTHER) && (long_ret != SNMP_STORAGE_VOLATILE) &&
  1221.        (long_ret != SNMP_STORAGE_NONVOLATILE) )  {
  1222.     DEBUGMSGTL(("snmpTargetAddrEntry", "write to snmpTargetAddrStorageType : attempted storage type not a valid"));
  1223.     DEBUGMSG(("snmpTargetAddrEntry", "  value of other(%d), volatile(%d), or nonvolatile(%d)n", 
  1224.    SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE, SNMP_STORAGE_NONVOLATILE));
  1225.     return SNMP_ERR_INCONSISTENTVALUE;
  1226.   }
  1228.   /* Find the struct in the linked list and check status */
  1229.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRSTORAGETYPECOLUMN;
  1230.   if ((temp_struct = search_snmpTargetAddrTable(snmpTargetAddrOID, 
  1231. snmpTargetAddrOIDLen, 
  1232. name, &name_len, 1)) == 0 ) {
  1233.     DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrStorageType : BAD OIDn"));
  1234.     return SNMP_ERR_NOSUCHNAME;
  1235.   }
  1236.   if ( (temp_struct->storageType == SNMP_STORAGE_PERMANENT) || 
  1237.        (temp_struct->storageType == SNMP_STORAGE_READONLY) )  {
  1238.     DEBUGMSGTL(("snmpTargetAddrEntry", "write to snmpTargetAddrStorageType : row has unchangeable storage status: %dn",
  1239.    temp_struct->storageType));
  1240.     return SNMP_ERR_INCONSISTENTVALUE;
  1241.   }
  1243.   /* Finally, we're golden, check if we should save new value */
  1244.   if (action == COMMIT) {      
  1245.     temp_struct->storageType = long_ret;
  1246.   }
  1248.   return SNMP_ERR_NOERROR;
  1249. }  /* write_snmpTargetAddrStorageType */
  1252. /* snmpTargeAddr_createNewRow is called from write_snmpTargetAddrRowStatus
  1253.    when a new row is required. It creates a new row with 
  1254.    the index of the passed in 'name' (i.e. full index OID) and
  1255.    adds it to the linked list. 'name' should be the full OID of the new index. 
  1256.    It passes back 0 if unsuccessfull.*/
  1257. int snmpTargetAddr_createNewRow(
  1258.      oid   *name,
  1259.      int name_len)
  1260. {
  1261.   int newNameLen;
  1262.   int i;
  1263.   struct targetAddrTable_struct *temp_struct;
  1265.   /* setup a new snmpTargetAddrTable structure and add it to the list */
  1266.   newNameLen = name_len - snmpTargetAddrOIDLen;
  1267.   if (newNameLen > 0) {
  1268.     temp_struct       = snmpTargetAddrTable_create();
  1269. if (temp_struct == NULL)
  1270. return 0;
  1271.     temp_struct->name = (char *)malloc(newNameLen + 1);
  1272.     if (temp_struct->name == NULL) {
  1273. free(temp_struct);
  1274. return 0;
  1275.     }
  1277.     for (i = 0; i < (int)newNameLen; i++) {
  1278.       temp_struct->name[i] = (char)name[i+snmpTargetAddrOIDLen];
  1279.     }
  1281.     temp_struct->name[newNameLen]  = '';
  1282.     temp_struct->rowStatus         = SNMP_ROW_NOTREADY;
  1283.     
  1284.     snmpTargetAddrTable_addToList(temp_struct, &aAddrTable);
  1286.     return 1;
  1287.   }
  1289.   return 0;
  1290. }  /* snmpTargetAddr_createNewRow */
  1293. /* Assign a value to the Row Status variable */
  1294. int
  1295. write_snmpTargetAddrRowStatus(
  1296.    int      action,
  1297.    u_char   *var_val,
  1298.    u_char   var_val_type,
  1299.    int   var_val_len,
  1300.    u_char   *statP,
  1301.    oid      *name,
  1302.    int   name_len)
  1303. {
  1304.   enum commit_action_enum        {NOTHING, DESTROY, CREATE, CHANGE};
  1305.   enum commit_action_enum        onCommitDo; 
  1306.   static long                    long_ret;
  1307.   struct targetAddrTable_struct *temp_struct;
  1309.   if (var_val_type != ASN_INTEGER) {
  1310.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRowStatus not ASN_INTEGERn"));
  1311.       return SNMP_ERR_WRONGTYPE;
  1312.   }
  1313.   if (var_val_len > (sizeof(long_ret))) {
  1314.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRowStatus: bad lengthn"));
  1315.       return SNMP_ERR_WRONGLENGTH;
  1316.   }
  1317.   long_ret = *((long *) var_val);
  1319.   /* search for struct in linked list */
  1320.   snmpTargetAddrOID[snmpTargetAddrOIDLen-1] = SNMPTARGETADDRROWSTATUSCOLUMN;
  1321.   if ((temp_struct = search_snmpTargetAddrTable(snmpTargetAddrOID, 
  1322. snmpTargetAddrOIDLen, 
  1323. name, &name_len, 1)) == 0) {
  1324.     /* row doesn't exist, check valid possibilities */
  1325.     if (long_ret == SNMP_ROW_DESTROY)  
  1326.       /* re: RFC 1903, destroying a non-existent row is noError, whatever */
  1327.       onCommitDo = NOTHING;
  1328.     /* check if this is for a new row creation */
  1329.     else if (long_ret == SNMP_ROW_CREATEANDGO || long_ret == SNMP_ROW_CREATEANDWAIT) 
  1330.       onCommitDo = CREATE;
  1331.     else /* no valid sets for no row being found so... */
  1332.       return SNMP_ERR_NOSUCHNAME;
  1333.   }
  1334.   else {  /* row exists */
  1336.     /* check if it is changeable */
  1337.     if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
  1338.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRowStatus : row is read onlyn"));
  1339.       return SNMP_ERR_READONLY;
  1340.     }    
  1341.     /* check if row is to be destroyed (note: it is ok to destroy notReady row!) */
  1342.     else if (long_ret == SNMP_ROW_DESTROY)  {
  1343.       if (temp_struct->storageType == SNMP_STORAGE_PERMANENT) {
  1344. DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRowStatus : unable to destroy permanent rown"));
  1345. return SNMP_ERR_INCONSISTENTVALUE;
  1346.       }
  1347.       else  {
  1348. onCommitDo = DESTROY;
  1349.       }
  1350.     }
  1351.     /* check if row is new and can be changed from notready yet */
  1352.     else if (temp_struct->rowStatus == SNMP_ROW_NOTREADY) {
  1353.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargeAddrRowStatus : unable to change from NOTREADYn"));
  1354.       return SNMP_ERR_INCONSISTENTVALUE;
  1355.     }  
  1356.     /* we now know the row status can be set, check for the two valid settings left*/
  1357.     else if ( (long_ret == SNMP_ROW_ACTIVE) || 
  1358.       (long_ret == SNMP_ROW_NOTINSERVICE) ) {
  1359.       onCommitDo = CHANGE;
  1360.     }
  1361.     /* not a valid setting */
  1362.     else  {
  1363.       DEBUGMSGTL(("snmpTargetAddrEntry","write to snmpTargetAddrRowStatus : Bad value for setn"));
  1364.       return SNMP_ERR_INCONSISTENTVALUE;
  1365.     }
  1366.   } /* if row exist */
  1367.   
  1369.   /* if this is a commit, do expected action */
  1370.   if (action == COMMIT) {
  1371.     switch(onCommitDo) { 
  1372.       
  1373.     case CREATE :
  1374.       if (snmpTargetAddr_createNewRow(name, name_len) == 0) {
  1375. DEBUGMSGTL(("snmpTargetAddrEntry", "write to snmpTargetAddrRowStatus : "));
  1376. DEBUGMSG(("snmpTargetAddrEntry","failed new row creation, bad OID/index value n"));
  1377. return SNMP_ERR_GENERR;
  1378.       }
  1379.       break;
  1380.       
  1381.     case DESTROY:
  1382.       snmpTargetAddrTable_remFromList(temp_struct, &aAddrTable);
  1383.       break;
  1385.     case CHANGE:
  1386.   if ((temp_struct->rowStatus != SNMP_ROW_ACTIVE) && (long_ret == SNMP_ROW_ACTIVE))
  1387.   {
  1388.   temp_struct->rowStatus = long_ret;
  1389.   snmpTargetTryToAddTrap (temp_struct->name);
  1390.   }
  1391.   else if ((temp_struct->rowStatus == SNMP_ROW_ACTIVE) && (long_ret != SNMP_ROW_ACTIVE))
  1392.   {
  1393.   snmpTargetTryToDelTrap (temp_struct->name);
  1394.   }
  1395.       temp_struct->rowStatus = long_ret;
  1396.       break;
  1398.     case NOTHING:
  1399. default:
  1400.       break;
  1401.     }
  1402.   }
  1403.   
  1404.   return SNMP_ERR_NOERROR;
  1405. }  /* write_snmpTargetAddrRowStatus */
  1408. u_char *
  1409. var_snmpTargetSpinLock(
  1410.     struct variable *vp,
  1411.     oid     *name,
  1412.     int  *length,
  1413.     int     exact,
  1414.     int  *var_len,
  1415.     WriteMethod **write_method)
  1416. {
  1417. static long long_ret;
  1419. *write_method = NULL;
  1420. if (header_generic(vp,name,length,exact,var_len,write_method) == MATCH_FAILED)
  1421. return NULL;
  1422. switch(vp->magic) {
  1423.     case SNMPTARGETSPINLOCK:
  1424.       *write_method = write_snmpTargetSpinLock;
  1425.       long_ret = snmpTargetSpinLock;
  1426.   *var_len = sizeof (long);
  1427.       return (unsigned char *) &long_ret;
  1428. default:
  1429. snmp_trace ("SNMP in var_snmpTargetSpinLock: unknown suboidn");
  1430. }
  1431. return NULL;
  1432. }
  1433.  
  1434. int write_snmpTargetSpinLock(
  1435.    int      action,
  1436.    u_char   *var_val,
  1437.    u_char   var_val_type,
  1438.    int   var_val_len,
  1439.    u_char   *statP,
  1440.    oid      *name,
  1441.    int   name_len)
  1442. {
  1443.   /* variables we may use later */
  1444.   static long long_ret;
  1446.   if (var_val_type != ASN_INTEGER){
  1447.       DEBUGMSGTL(("usmUser","write to usmUserSpinLock not ASN_INTEGERn"));
  1448.       return SNMP_ERR_WRONGTYPE;
  1449.   }
  1450.   if (var_val_len > sizeof(long_ret)){
  1451.       DEBUGMSGTL(("usmUser","write to usmUserSpinLock: bad lengthn"));
  1452.       return SNMP_ERR_WRONGLENGTH;
  1453.   }
  1454.   long_ret = *((long *) var_val);
  1455.   if (long_ret != (long)snmpTargetSpinLock)
  1456.     return SNMP_ERR_INCONSISTENTVALUE;
  1457.   if (action == COMMIT) {
  1458.     if (snmpTargetSpinLock == 2147483647)
  1459.       snmpTargetSpinLock = 0;
  1460.     else
  1461.       snmpTargetSpinLock++;
  1462.   }
  1463.   return SNMP_ERR_NOERROR;
  1464. }  /* end write_usmUserSpinLock() */
  1466. int snmpTargetGetAddrFromIndex(char *name, char *buf, int *pRetry)
  1467. {
  1468. struct targetAddrTable_struct *temp_struct;
  1469. long ipAddr;
  1471. for( temp_struct = aAddrTable; temp_struct != NULL; temp_struct = temp_struct->next) 
  1472. {
  1473.     if (strcmp (name,temp_struct->name) == 0 && temp_struct->rowStatus == SNMP_ROW_ACTIVE)
  1474. {
  1475. ipAddr = *((long *)(temp_struct->tAddress));
  1476. strncpy (buf, snmp_ntoa(ipAddr), 256);
  1477. *pRetry = temp_struct->retryCount;
  1478. return 1;
  1479. }
  1480. }
  1481. return 0;
  1482. }
  1483. /************************************************
  1484. *When rowStatus set to active, add to trap sink.
  1485. *--sxf 2k-12-27
  1486. ************************************************/
  1487. extern int deleteTrapSessionNoRem (char *peer, char *community, int version, int pdutype);
  1488. extern int createTrapSessionNoAdd (char *sink,char * com,int timeout,int queuelen,unsigned short trapflags, int version, int pdutype);
  1489. extern int snmpTargetGetCommFromIndex (char*, char*);
  1491. void  snmpTargetTryToAddTrap (char *name)
  1492. {
  1493. char host_name[256];
  1494. char community[256];
  1495. int  retry;
  1497. if (snmpTargetGetAddrFromIndex (name, host_name, &retry))
  1498. {
  1499. if (snmpTargetGetCommFromIndex(name, community))
  1500. {
  1501. createTrapSessionNoAdd (host_name, community, 30, retry, 0xffff, SNMP_VERSION_1, SNMP_MSG_TRAP);
  1502. }
  1503. }
  1504. }
  1505. /***************************************************
  1506. *When rowStatus set from active, del from trap sink
  1507. *--sxf 2k-12-27
  1508. ***************************************************/
  1509. void  snmpTargetTryToDelTrap (char *name)
  1510. {
  1511. char host_name[256];
  1512. char community[256];
  1513. int  retry;
  1515. if (snmpTargetGetAddrFromIndex (name, host_name, &retry))
  1516. {
  1517. if (snmpTargetGetCommFromIndex(name, community))
  1518. {
  1519. deleteTrapSessionNoRem (host_name, community, SNMP_VERSION_1, SNMP_MSG_TRAP);
  1520. }
  1521. }
  1523. }
  1525. u_char *
  1526. var_snmpTargetContexts(
  1527.     struct variable *vp,
  1528.     oid     *name,
  1529.     int  *length,
  1530.     int     exact,
  1531.     int  *var_len,
  1532.     WriteMethod **write_method)
  1533. {
  1534. static long long_ret;
  1536. *write_method = NULL;
  1537. if (header_generic(vp,name,length,exact,var_len,write_method) == MATCH_FAILED)
  1538. return NULL;
  1539. switch(vp->magic) {
  1540.     case SNMPUNAVAILABLECONTEXTS:
  1541. case SNMPUNKNOWNCONTEXTS:
  1542.       long_ret = 0;
  1543.      *var_len = sizeof (long);
  1544.       return (unsigned char *) &long_ret;
  1545. default:
  1546. snmp_trace ("SNMP in var_snmpTargetSpinLock: unknown suboidn");
  1547. }
  1548. return NULL;
  1549. }