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

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

SNMP编程

开发平台：

Unix_Linux

snmpNotifyTable.c：源码内容
  1. /*
  2.  * This file was generated by mib2c and is intended for use as
  3.  * a mib module for the ucd-snmp snmpd agent. 
  4.  */
  7. /*
  8.  * This should always be included first before anything else 
  9.  */
  10. #include <net-snmp/net-snmp-config.h>
  12. #include <sys/types.h>
  13. #if HAVE_WINSOCK_H
  14. #include <winsock.h>
  15. #endif
  16. #if HAVE_STDLIB_H
  17. #include <stdlib.h>
  18. #endif
  19. #if HAVE_STRING_H
  20. #include <string.h>
  21. #else
  22. #include <strings.h>
  23. #endif
  25. /*
  26.  * minimal include directives 
  27.  */
  28. #include <net-snmp/net-snmp-includes.h>
  29. #include <net-snmp/agent/net-snmp-agent-includes.h>
  31. #include "header_complex.h"
  32. #include "snmpNotifyTable.h"
  33. #include "target/snmpTargetParamsEntry.h"
  34. #include "target/snmpTargetAddrEntry.h"
  35. #include "target/target.h"
  36. #include <net-snmp/agent/agent_callbacks.h>
  37. #include <net-snmp/agent/agent_trap.h>
  39. SNMPCallback    store_snmpNotifyTable;
  41. /*
  42.  * snmpNotifyTable_variables_oid:
  43.  *   this is the top level oid that we want to register under.  This
  44.  *   is essentially a prefix, with the suffix appearing in the
  45.  *   variable below.
  46.  */
  49. oid             snmpNotifyTable_variables_oid[] =
  50.     { 1, 3, 6, 1, 6, 3, 13, 1, 1 };
  53. /*
  54.  * variable2 snmpNotifyTable_variables:
  55.  *   this variable defines function callbacks and type return information 
  56.  *   for the snmpNotifyTable mib section 
  57.  */
  60. struct variable2 snmpNotifyTable_variables[] = {
  61.     /*
  62.      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
  63.      */
  64. #define   SNMPNOTIFYTAG         4
  65.     {SNMPNOTIFYTAG, ASN_OCTET_STR, RWRITE, var_snmpNotifyTable, 2, {1, 2}},
  66. #define   SNMPNOTIFYTYPE        5
  67.     {SNMPNOTIFYTYPE, ASN_INTEGER, RWRITE, var_snmpNotifyTable, 2, {1, 3}},
  68. #define   SNMPNOTIFYSTORAGETYPE  6
  69.     {SNMPNOTIFYSTORAGETYPE, ASN_INTEGER, RWRITE, var_snmpNotifyTable, 2,
  70.      {1, 4}},
  71. #define   SNMPNOTIFYROWSTATUS   7
  72.     {SNMPNOTIFYROWSTATUS, ASN_INTEGER, RWRITE, var_snmpNotifyTable, 2,
  73.      {1, 5}},
  75. };
  76. /*
  77.  * (L = length of the oidsuffix) 
  78.  */
  81. /*
  82.  * global storage of our data, saved in and configured by header_complex() 
  83.  */
  84. static struct header_complex_index *snmpNotifyTableStorage = NULL;
  86. int
  87. send_notifications(int major, int minor, void *serverarg, void *clientarg)
  88. {
  89.     struct header_complex_index *hptr;
  90.     struct snmpNotifyTable_data *nptr;
  91.     netsnmp_session *sess, *sptr;
  92.     netsnmp_pdu    *template_pdu = (netsnmp_pdu *) serverarg;
  94.     DEBUGMSGTL(("send_notifications", "starting: pdu=%x, vars=%xn",
  95.                 template_pdu, template_pdu->variables));
  97.     for (hptr = snmpNotifyTableStorage; hptr; hptr = hptr->next) {
  98.         nptr = (struct snmpNotifyTable_data *) hptr->data;
  99.         if (nptr->snmpNotifyRowStatus != RS_ACTIVE)
  100.             continue;
  101.         if (!nptr->snmpNotifyTag)
  102.             continue;
  104.         sess = get_target_sessions(nptr->snmpNotifyTag, NULL, NULL);
  106.         /*
  107.          * XXX: filter appropriately 
  108.          */
  110.         for (sptr = sess; sptr; sptr = sptr->next) {
  111. #ifndef DISABLE_SNMPV1
  112.             if (sptr->version == SNMP_VERSION_1 &&
  113.                 minor == SNMPD_CALLBACK_SEND_TRAP1) {
  114.                 send_trap_to_sess(sptr, template_pdu);
  115.             } else
  116. #endif
  117.             if ((sptr->version == SNMP_VERSION_3
  118. #ifndef DISABLE_SNMPV2C
  119.                  || sptr->version == SNMP_VERSION_2c
  120. #endif
  121.                 ) && minor == SNMPD_CALLBACK_SEND_TRAP2) {
  122.                 if (nptr->snmpNotifyType == SNMPNOTIFYTYPE_INFORM) {
  123.                     template_pdu->command = SNMP_MSG_INFORM;
  124.                 } else {
  125.                     template_pdu->command = SNMP_MSG_TRAP2;
  126.                 }
  127.                 send_trap_to_sess(sptr, template_pdu);
  128.             }
  129.         }
  130.     }
  131.     return 0;
  132. }
  134. #define MAX_ENTRIES 1024
  136. int
  137. notifyTable_register_notifications(int major, int minor,
  138.                                    void *serverarg, void *clientarg)
  139. {
  140.     struct targetAddrTable_struct *ptr;
  141.     struct targetParamTable_struct *pptr;
  142.     struct snmpNotifyTable_data *nptr;
  143.     int             confirm, i;
  144.     char            buf[SNMP_MAXBUF_SMALL];
  145.     netsnmp_transport *t = NULL;
  146.     struct agent_add_trap_args *args =
  147.         (struct agent_add_trap_args *) serverarg;
  148.     netsnmp_session *ss;
  150.     if (!args || !(args->ss)) {
  151.         return (0);
  152.     }
  153.     confirm = args->confirm;
  154.     ss = args->ss;
  156.     /*
  157.      * XXX: START move target creation to target code 
  158.      */
  159.     for (i = 0; i < MAX_ENTRIES; i++) {
  160.         sprintf(buf, "internal%d", i);
  161.         if (get_addrForName(buf) == NULL && get_paramEntry(buf) == NULL)
  162.             break;
  163.     }
  164.     if (i == MAX_ENTRIES) {
  165.         snmp_log(LOG_ERR,
  166.                  "Can't register new trap destination: max limit reached: %d",
  167.                  MAX_ENTRIES);
  168.         snmp_sess_close(ss);
  169.         return (0);
  170.     }
  172.     /*
  173.      * address 
  174.      */
  175.     ptr = snmpTargetAddrTable_create();
  176.     ptr->name = strdup(buf);
  177.     t = snmp_sess_transport(snmp_sess_pointer(ss));
  178.     memcpy(ptr->tDomain, t->domain, t->domain_length * sizeof(oid));
  179.     ptr->tDomainLen = t->domain_length;
  180.     ptr->tAddressLen = t->remote_length;
  181.     ptr->tAddress = t->remote;
  183.     ptr->timeout = ss->timeout / 1000;
  184.     ptr->retryCount = ss->retries;
  185.     SNMP_FREE(ptr->tagList);
  186.     ptr->tagList = strdup(ptr->name);
  187.     ptr->params = strdup(ptr->name);
  188.     ptr->storageType = ST_READONLY;
  189.     ptr->rowStatus = RS_ACTIVE;
  190.     ptr->sess = ss;
  191.     DEBUGMSGTL(("trapsess", "adding to trap tablen"));
  192.     snmpTargetAddrTable_add(ptr);
  194.     /*
  195.      * param 
  196.      */
  197.     pptr = snmpTargetParamTable_create();
  198.     pptr->paramName = strdup(buf);
  199.     pptr->mpModel = ss->version;
  200.     if (ss->version == SNMP_VERSION_3) {
  201.         pptr->secModel = ss->securityModel;
  202.         pptr->secLevel = ss->securityLevel;
  203.         pptr->secName = (char *) malloc(ss->securityNameLen + 1);
  204.         memcpy((void *) pptr->secName, (void *) ss->securityName,
  205.                ss->securityNameLen);
  206.         pptr->secName[ss->securityNameLen] = 0;
  207.     }
  208. #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C)
  209.        else {
  210.         pptr->secModel = ss->version == SNMP_VERSION_1 ?
  211.             SNMP_SEC_MODEL_SNMPv1 : SNMP_SEC_MODEL_SNMPv2c;
  212.         pptr->secLevel = SNMP_SEC_LEVEL_NOAUTH;
  213.         pptr->secName = NULL;
  214.         if (ss->community && (ss->community_len > 0)) {
  215.             pptr->secName = (char *) malloc(ss->community_len + 1);
  216.             memcpy((void *) pptr->secName, (void *) ss->community,
  217.                    ss->community_len);
  218.             pptr->secName[ss->community_len] = 0;
  219.         }
  220.     }
  221. #endif
  222.     pptr->storageType = ST_READONLY;
  223.     pptr->rowStatus = RS_ACTIVE;
  224.     snmpTargetParamTable_add(pptr);
  225.     /*
  226.      * XXX: END move target creation to target code 
  227.      */
  229.     /*
  230.      * notify table 
  231.      */
  232.     nptr = SNMP_MALLOC_STRUCT(snmpNotifyTable_data);
  233.     nptr->snmpNotifyName = strdup(buf);
  234.     nptr->snmpNotifyNameLen = strlen(buf);
  235.     nptr->snmpNotifyTag = strdup(buf);
  236.     nptr->snmpNotifyTagLen = strlen(buf);
  237.     nptr->snmpNotifyType = confirm ?
  238.         SNMPNOTIFYTYPE_INFORM : SNMPNOTIFYTYPE_TRAP;
  239.     nptr->snmpNotifyStorageType = ST_READONLY;
  240.     nptr->snmpNotifyRowStatus = RS_ACTIVE;
  242.     snmpNotifyTable_add(nptr);
  243.     return 0;
  244. }
  247. /*
  248.  * XXX: this really needs to be done for the target mib entries too.
  249.  * But we can only trust that we've added stuff here and we don't want
  250.  * to destroy other valid entries in the target tables, so...  Don't
  251.  * do too many kill -HUPs to your agent as re reading the config file
  252.  * will be a slow memory leak in the target mib. 
  253.  */
  254. int
  255. notifyTable_unregister_notifications(int major, int minor,
  256.                                      void *serverarg, void *clientarg)
  257. {
  258.     struct header_complex_index *hptr, *nhptr;
  259.     struct snmpNotifyTable_data *nptr;
  261.     for (hptr = snmpNotifyTableStorage; hptr; hptr = nhptr) {
  262.         nptr = (struct snmpNotifyTable_data *) hptr->data;
  263.         nhptr = hptr->next;
  264.         if (nptr->snmpNotifyStorageType == ST_READONLY) {
  265.             header_complex_extract_entry(&snmpNotifyTableStorage, hptr);
  266.             SNMP_FREE(nptr->snmpNotifyName);
  267.             SNMP_FREE(nptr->snmpNotifyTag);
  268.             SNMP_FREE(nptr);
  269.         }
  270.     }
  271.     return (0);
  272. }
  274. /*
  275.  * init_snmpNotifyTable():
  276.  *   Initialization routine.  This is called when the agent starts up.
  277.  *   At a minimum, registration of your variables should take place here.
  278.  */
  279. void
  280. init_snmpNotifyTable(void)
  281. {
  282.     DEBUGMSGTL(("snmpNotifyTable", "initializing...  "));
  285.     /*
  286.      * register ourselves with the agent to handle our mib tree 
  287.      */
  288.     REGISTER_MIB("snmpNotifyTable", snmpNotifyTable_variables, variable2,
  289.                  snmpNotifyTable_variables_oid);
  292.     /*
  293.      * register our config handler(s) to deal with registrations 
  294.      */
  295.     snmpd_register_config_handler("snmpNotifyTable", parse_snmpNotifyTable,
  296.                                   NULL, NULL);
  299.     /*
  300.      * we need to be called back later to store our data 
  301.      */
  302.     snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  303.                            store_snmpNotifyTable, NULL);
  305.     snmp_register_callback(SNMP_CALLBACK_APPLICATION,
  306.                            SNMPD_CALLBACK_SEND_TRAP1, send_notifications,
  307.                            NULL);
  308.     snmp_register_callback(SNMP_CALLBACK_APPLICATION,
  309.                            SNMPD_CALLBACK_SEND_TRAP2, send_notifications,
  310.                            NULL);
  311.     snmp_register_callback(SNMP_CALLBACK_APPLICATION,
  312.                            SNMPD_CALLBACK_REGISTER_NOTIFICATIONS,
  313.                            notifyTable_register_notifications, NULL);
  314.     snmp_register_callback(SNMP_CALLBACK_APPLICATION,
  315.                            SNMPD_CALLBACK_PRE_UPDATE_CONFIG,
  316.                            notifyTable_unregister_notifications, NULL);
  318.     /*
  319.      * place any other initialization junk you need here 
  320.      */
  323.     DEBUGMSGTL(("snmpNotifyTable", "done.n"));
  324. }
  327. /*
  328.  * snmpNotifyTable_add(): adds a structure node to our data set 
  329.  */
  330. int
  331. snmpNotifyTable_add(struct snmpNotifyTable_data *thedata)
  332. {
  333.     netsnmp_variable_list *vars = NULL;
  336.     DEBUGMSGTL(("snmpNotifyTable", "adding data...  "));
  337.     /*
  338.      * add the index variables to the varbind list, which is 
  339.      * used by header_complex to index the data 
  340.      */
  343.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, (u_char *) thedata->snmpNotifyName, thedata->snmpNotifyNameLen);      /* snmpNotifyName */
  347.     header_complex_add_data(&snmpNotifyTableStorage, vars, thedata);
  348.     DEBUGMSGTL(("snmpNotifyTable", "registered an entryn"));
  351.     DEBUGMSGTL(("snmpNotifyTable", "done.n"));
  352.     return SNMPERR_SUCCESS;
  353. }
  356. /*
  357.  * parse_snmpNotifyTable():
  358.  *   parses .conf file entries needed to configure the mib.
  359.  */
  360. void
  361. parse_snmpNotifyTable(const char *token, char *line)
  362. {
  363.     size_t          tmpint;
  364.     struct snmpNotifyTable_data *StorageTmp =
  365.         SNMP_MALLOC_STRUCT(snmpNotifyTable_data);
  368.     DEBUGMSGTL(("snmpNotifyTable", "parsing config...  "));
  371.     if (StorageTmp == NULL) {
  372.         config_perror("malloc failure");
  373.         return;
  374.     }
  376.     line =
  377.         read_config_read_data(ASN_OCTET_STR, line,
  378.                               &StorageTmp->snmpNotifyName,
  379.                               &StorageTmp->snmpNotifyNameLen);
  380.     if (StorageTmp->snmpNotifyName == NULL) {
  381.         config_perror("invalid specification for snmpNotifyName");
  382.         return;
  383.     }
  385.     line =
  386.         read_config_read_data(ASN_OCTET_STR, line,
  387.                               &StorageTmp->snmpNotifyTag,
  388.                               &StorageTmp->snmpNotifyTagLen);
  389.     if (StorageTmp->snmpNotifyTag == NULL) {
  390.         config_perror("invalid specification for snmpNotifyTag");
  391.         return;
  392.     }
  394.     line =
  395.         read_config_read_data(ASN_INTEGER, line,
  396.                               &StorageTmp->snmpNotifyType, &tmpint);
  398.     line =
  399.         read_config_read_data(ASN_INTEGER, line,
  400.                               &StorageTmp->snmpNotifyStorageType, &tmpint);
  402.     line =
  403.         read_config_read_data(ASN_INTEGER, line,
  404.                               &StorageTmp->snmpNotifyRowStatus, &tmpint);
  409.     snmpNotifyTable_add(StorageTmp);
  412.     DEBUGMSGTL(("snmpNotifyTable", "done.n"));
  413. }
  418. /*
  419.  * store_snmpNotifyTable():
  420.  *   stores .conf file entries needed to configure the mib.
  421.  */
  422. int
  423. store_snmpNotifyTable(int majorID, int minorID, void *serverarg,
  424.                       void *clientarg)
  425. {
  426.     char            line[SNMP_MAXBUF];
  427.     char           *cptr;
  428.     size_t          tmpint;
  429.     struct snmpNotifyTable_data *StorageTmp;
  430.     struct header_complex_index *hcindex;
  433.     DEBUGMSGTL(("snmpNotifyTable", "storing data...  "));
  436.     for (hcindex = snmpNotifyTableStorage; hcindex != NULL;
  437.          hcindex = hcindex->next) {
  438.         StorageTmp = (struct snmpNotifyTable_data *) hcindex->data;
  440.         /*
  441.          * store permanent and nonvolatile rows.
  442.          * XXX should there be a qualification on RowStatus??
  443.          */
  444.         if ((StorageTmp->snmpNotifyStorageType == ST_NONVOLATILE) ||
  445.             (StorageTmp->snmpNotifyStorageType == ST_PERMANENT) ){
  447.             memset(line, 0, sizeof(line));
  448.             strcat(line, "snmpNotifyTable ");
  449.             cptr = line + strlen(line);
  451.             cptr =
  452.                 read_config_store_data(ASN_OCTET_STR, cptr,
  453.                                        &StorageTmp->snmpNotifyName,
  454.                                        &StorageTmp->snmpNotifyNameLen);
  455.             cptr =
  456.                 read_config_store_data(ASN_OCTET_STR, cptr,
  457.                                        &StorageTmp->snmpNotifyTag,
  458.                                        &StorageTmp->snmpNotifyTagLen);
  459.             cptr =
  460.                 read_config_store_data(ASN_INTEGER, cptr,
  461.                                        &StorageTmp->snmpNotifyType,
  462.                                        &tmpint);
  463.             cptr =
  464.                 read_config_store_data(ASN_INTEGER, cptr,
  465.                                        &StorageTmp->snmpNotifyStorageType,
  466.                                        &tmpint);
  467.             cptr =
  468.                 read_config_store_data(ASN_INTEGER, cptr,
  469.                                        &StorageTmp->snmpNotifyRowStatus,
  470.                                        &tmpint);
  472.             snmpd_store_config(line);
  473.         }
  474.     }
  475.     DEBUGMSGTL(("snmpNotifyTable", "done.n"));
  476.     return 0;
  477. }
  482. /*
  483.  * var_snmpNotifyTable():
  484.  *   Handle this table separately from the scalar value case.
  485.  *   The workings of this are basically the same as for var_snmpNotifyTable above.
  486.  */
  487. unsigned char  *
  488. var_snmpNotifyTable(struct variable *vp,
  489.                     oid * name,
  490.                     size_t * length,
  491.                     int exact,
  492.                     size_t * var_len, WriteMethod ** write_method)
  493. {
  494.     struct snmpNotifyTable_data *StorageTmp = NULL;
  495.     int             found = 1;
  497.     DEBUGMSGTL(("snmpNotifyTable",
  498.                 "var_snmpNotifyTable: Entering...  n"));
  499.     /*
  500.      * this assumes you have registered all your data properly
  501.      */
  502.     if ((StorageTmp = (struct snmpNotifyTable_data *)
  503.          header_complex((struct header_complex_index *)
  504.                         snmpNotifyTableStorage, vp, name, length, exact,
  505.                         var_len, write_method)) == NULL) {
  506.         found = 0;
  507.     }
  509.     switch (vp->magic) {
  510.     case SNMPNOTIFYTAG:
  511.         *write_method = write_snmpNotifyTag;
  512.         break;
  513.     case SNMPNOTIFYTYPE:
  514.         *write_method = write_snmpNotifyType;
  515.         break;
  516.     case SNMPNOTIFYSTORAGETYPE:
  517.         *write_method = write_snmpNotifyStorageType;
  518.         break;
  519.     case SNMPNOTIFYROWSTATUS:
  520.         *write_method = write_snmpNotifyRowStatus;
  521.         break;
  522.     default:
  523.         *write_method = NULL;
  524.     }
  526.     if (!found) {
  527.         return NULL;
  528.     }
  530.     switch (vp->magic) {
  531.     case SNMPNOTIFYTAG:
  532.         *var_len = StorageTmp->snmpNotifyTagLen;
  533.         return (u_char *) StorageTmp->snmpNotifyTag;
  535.     case SNMPNOTIFYTYPE:
  536.         *var_len = sizeof(StorageTmp->snmpNotifyType);
  537.         return (u_char *) & StorageTmp->snmpNotifyType;
  539.     case SNMPNOTIFYSTORAGETYPE:
  540.         *var_len = sizeof(StorageTmp->snmpNotifyStorageType);
  541.         return (u_char *) & StorageTmp->snmpNotifyStorageType;
  543.     case SNMPNOTIFYROWSTATUS:
  544.         *var_len = sizeof(StorageTmp->snmpNotifyRowStatus);
  545.         return (u_char *) & StorageTmp->snmpNotifyRowStatus;
  547.     default:
  548.         ERROR_MSG("");
  549.     }
  550.     return NULL;
  551. }
  553. static int
  554. is_delim(const char c)
  555. {
  556.     return (c == 0x020 || c == 0x09 || c == 0x0d || c == 0x0b);
  557. }
  559. int
  560. snmpTagValid(const char *tag, const size_t tagLen)
  561. {
  562.     size_t          i = 0;
  565.     for (i = 0; i < tagLen; i++) {
  566.         if (is_delim(tag[i])) {
  567.             /*
  568.              * Delimeters aren't allowed.  
  569.              */
  570.             return 0;
  571.         }
  572.     }
  573.     return 1;
  574. }
  576. static struct snmpNotifyTable_data *StorageNew;
  578. int
  579. write_snmpNotifyTag(int action,
  580.                     u_char * var_val,
  581.                     u_char var_val_type,
  582.                     size_t var_val_len,
  583.                     u_char * statP, oid * name, size_t name_len)
  584. {
  585.     static char    *tmpvar;
  586.     struct snmpNotifyTable_data *StorageTmp = NULL;
  587.     static size_t   tmplen;
  588.     size_t          newlen =
  589.         name_len - (sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
  590.                     3 - 1);
  593.     DEBUGMSGTL(("snmpNotifyTable",
  594.                 "write_snmpNotifyTag entering action=%d...  n", action));
  595.     if (action != RESERVE1 &&
  596.         (StorageTmp = (struct snmpNotifyTable_data *)
  597.          header_complex((struct header_complex_index *)
  598.                         snmpNotifyTableStorage, NULL,
  599.                         &name[sizeof(snmpNotifyTable_variables_oid) /
  600.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  601.                         NULL)) == NULL) {
  602.         if ((StorageTmp = StorageNew) == NULL)
  603.             return SNMP_ERR_NOSUCHNAME; /* remove if you support creation here */
  604.     }
  607.     switch (action) {
  608.     case RESERVE1:
  609.         if (var_val_type != ASN_OCTET_STR) {
  610.             return SNMP_ERR_WRONGTYPE;
  611.         }
  612.         if (var_val_len < 0 || var_val_len > 255) {
  613.             return SNMP_ERR_WRONGLENGTH;
  614.         }
  615.         if (!snmpTagValid(var_val, var_val_len)) {
  616.             return SNMP_ERR_WRONGVALUE;
  617.         }
  618.         break;
  621.     case RESERVE2:
  622.         /*
  623.          * memory reseveration, final preparation... 
  624.          */
  625.         tmpvar = StorageTmp->snmpNotifyTag;
  626.         tmplen = StorageTmp->snmpNotifyTagLen;
  627.         StorageTmp->snmpNotifyTag = calloc(1, var_val_len + 1);
  628.         if (NULL == StorageTmp->snmpNotifyTag)
  629.             return SNMP_ERR_RESOURCEUNAVAILABLE;
  630.         break;
  633.     case FREE:
  634.         /*
  635.          * Release any resources that have been allocated 
  636.          */
  637.         break;
  640.     case ACTION:
  641.         memcpy(StorageTmp->snmpNotifyTag, var_val, var_val_len);
  642.         StorageTmp->snmpNotifyTagLen = var_val_len;
  643.         break;
  646.     case UNDO:
  647.         /*
  648.          * Back out any changes made in the ACTION case 
  649.          */
  650.         SNMP_FREE(StorageTmp->snmpNotifyTag);
  651.         StorageTmp->snmpNotifyTag = tmpvar;
  652.         StorageTmp->snmpNotifyTagLen = tmplen;
  653.         tmpvar = NULL;
  654.         break;
  657.     case COMMIT:
  658.         /*
  659.          * Things are working well, so it's now safe to make the change
  660.          * permanently.  Make sure that anything done here can't fail! 
  661.          */
  662.         SNMP_FREE(tmpvar);
  663.         break;
  664.     }
  666.     return SNMP_ERR_NOERROR;
  667. }
  671. int
  672. write_snmpNotifyType(int action,
  673.                      u_char * var_val,
  674.                      u_char var_val_type,
  675.                      size_t var_val_len,
  676.                      u_char * statP, oid * name, size_t name_len)
  677. {
  678.     static int      tmpvar;
  679.     struct snmpNotifyTable_data *StorageTmp = NULL;
  680.     long            value = *((long *) var_val);
  681.     size_t          newlen =
  682.         name_len - (sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
  683.                     3 - 1);
  686.     DEBUGMSGTL(("snmpNotifyTable",
  687.                 "write_snmpNotifyType entering action=%d...  n", action));
  688.     if (action != RESERVE1 &&
  689.         (StorageTmp = (struct snmpNotifyTable_data *)
  690.          header_complex((struct header_complex_index *)
  691.                         snmpNotifyTableStorage, NULL,
  692.                         &name[sizeof(snmpNotifyTable_variables_oid) /
  693.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  694.                         NULL)) == NULL) {
  695.         if ((StorageTmp = StorageNew) == NULL)
  696.             return SNMP_ERR_NOSUCHNAME;
  697.     }
  699.     switch (action) {
  700.     case RESERVE1:
  701.         if (var_val_type != ASN_INTEGER) {
  702.             return SNMP_ERR_WRONGTYPE;
  703.         }
  704.         if (var_val_len != sizeof(long)) {
  705.             return SNMP_ERR_WRONGLENGTH;
  706.         }
  707.         if (value < 1 || value > 2) {
  708.             return SNMP_ERR_WRONGVALUE;
  709.         }
  710.         break;
  712.     case ACTION:
  713.         tmpvar = StorageTmp->snmpNotifyType;
  714.         StorageTmp->snmpNotifyType = value;
  715.         break;
  717.     case UNDO:
  718.         /*
  719.          * Back out any changes made in the ACTION case 
  720.          */
  721.         StorageTmp->snmpNotifyType = tmpvar;
  722.         break;
  723.     }
  725.     return SNMP_ERR_NOERROR;
  726. }
  730. int
  731. write_snmpNotifyStorageType(int action,
  732.                             u_char * var_val,
  733.                             u_char var_val_type,
  734.                             size_t var_val_len,
  735.                             u_char * statP, oid * name, size_t name_len)
  736. {
  737.     static int      tmpvar;
  738.     long            value = *((long *) var_val);
  739.     struct snmpNotifyTable_data *StorageTmp = NULL;
  740.     size_t          newlen =
  741.         name_len - (sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
  742.                     3 - 1);
  745.     DEBUGMSGTL(("snmpNotifyTable",
  746.                 "write_snmpNotifyStorageType entering action=%d...  n",
  747.                 action));
  748.     if (action != RESERVE1 &&
  749.         (StorageTmp = (struct snmpNotifyTable_data *)
  750.          header_complex((struct header_complex_index *)
  751.                         snmpNotifyTableStorage, NULL,
  752.                         &name[sizeof(snmpNotifyTable_variables_oid) /
  753.                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
  754.                         NULL)) == NULL) {
  755.         if ((StorageTmp = StorageNew) == NULL)
  756.             return SNMP_ERR_NOSUCHNAME;
  757.     }
  760.     switch (action) {
  761.     case RESERVE1:
  762.         if (var_val_type != ASN_INTEGER) {
  763.             return SNMP_ERR_WRONGTYPE;
  764.         }
  765.         if (var_val_len != sizeof(long)) {
  766.             return SNMP_ERR_WRONGLENGTH;
  767.         }
  768.         if (value != SNMP_STORAGE_OTHER && value != SNMP_STORAGE_VOLATILE
  769.             && value != SNMP_STORAGE_NONVOLATILE) {
  770.             return SNMP_ERR_WRONGVALUE;
  771.         }
  772.         break;
  774.     case ACTION:
  775.         tmpvar = StorageTmp->snmpNotifyStorageType;
  776.         StorageTmp->snmpNotifyStorageType = value;
  777.         break;
  779.     case UNDO:
  780.         StorageTmp->snmpNotifyStorageType = tmpvar;
  781.         break;
  782.     }
  783.     return SNMP_ERR_NOERROR;
  784. }
  788. int
  789. write_snmpNotifyRowStatus(int action,
  790.                           u_char * var_val,
  791.                           u_char var_val_type,
  792.                           size_t var_val_len,
  793.                           u_char * statP, oid * name, size_t name_len)
  794. {
  795.     struct snmpNotifyTable_data *StorageTmp = NULL;
  796.     static struct snmpNotifyTable_data *StorageDel;
  797.     size_t          newlen =
  798.         name_len - (sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
  799.                     3 - 1);
  800.     static int      old_value;
  801.     int             set_value = *((long *) var_val);
  802.     static netsnmp_variable_list *vars, *vp;
  803.     struct header_complex_index *hciptr;
  806.     DEBUGMSGTL(("snmpNotifyTable",
  807.                 "write_snmpNotifyRowStatus entering action=%d...  n",
  808.                 action));
  809.     StorageTmp = (struct snmpNotifyTable_data *)
  810.         header_complex((struct header_complex_index *)
  811.                        snmpNotifyTableStorage, NULL,
  812.                        &name[sizeof(snmpNotifyTable_variables_oid) /
  813.                              sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);
  815.     switch (action) {
  816.     case RESERVE1:
  817.         if (var_val_type != ASN_INTEGER || var_val == NULL) {
  818.             return SNMP_ERR_WRONGTYPE;
  819.         }
  820.         if (var_val_len != sizeof(long)) {
  821.             return SNMP_ERR_WRONGLENGTH;
  822.         }
  823.         if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY) {
  824.             return SNMP_ERR_WRONGVALUE;
  825.         }
  826.         if (StorageTmp == NULL) {
  827.             /*
  828.              * create the row now? 
  829.              */
  830.             /*
  831.              * ditch illegal values now 
  832.              */
  833.             if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
  834.                 return SNMP_ERR_INCONSISTENTVALUE;
  835.             }
  836.         } else {
  837.             /*
  838.              * row exists.  Check for a valid state change 
  839.              */
  840.             if (set_value == RS_CREATEANDGO
  841.                 || set_value == RS_CREATEANDWAIT) {
  842.                 /*
  843.                  * can't create a row that exists 
  844.                  */
  845.                 return SNMP_ERR_INCONSISTENTVALUE;
  846.             }
  847.             /*
  848.              * XXX: interaction with row storage type needed 
  849.              */
  850.         }
  852.         /*
  853.          * memory reseveration, final preparation... 
  854.          */
  855.         if (StorageTmp == NULL &&
  856.             (set_value == RS_CREATEANDGO
  857.              || set_value == RS_CREATEANDWAIT)) {
  858.             /*
  859.              * creation 
  860.              */
  861.             vars = NULL;
  863.             snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OCTET_STR, NULL, 0);     /* snmpNotifyName */
  865.             if (header_complex_parse_oid
  866.                 (&
  867.                  (name
  868.                   [sizeof(snmpNotifyTable_variables_oid) / sizeof(oid) +
  869.                    2]), newlen, vars) != SNMPERR_SUCCESS) {
  870.                 /*
  871.                  * XXX: free, zero vars 
  872.                  */
  873.                 snmp_free_var(vars);
  874.                 return SNMP_ERR_INCONSISTENTNAME;
  875.             }
  876.             vp = vars;
  879.             StorageNew = SNMP_MALLOC_STRUCT(snmpNotifyTable_data);
  880.             if (StorageNew == NULL) {
  881.                 return SNMP_ERR_RESOURCEUNAVAILABLE;
  882.             }
  883.             StorageNew->snmpNotifyName = calloc( 1, vp->val_len + 1 );
  884.             if (StorageNew->snmpNotifyName == NULL) {
  885.                 return SNMP_ERR_RESOURCEUNAVAILABLE;
  886.             }
  887.             memcpy(StorageNew->snmpNotifyName, vp->val.string, vp->val_len);
  888.             StorageNew->snmpNotifyNameLen = vp->val_len;
  889.             vp = vp->next_variable;
  891.             /*
  892.              * default values 
  893.              */
  894.             StorageNew->snmpNotifyStorageType = ST_NONVOLATILE;
  895.             StorageNew->snmpNotifyType = SNMPNOTIFYTYPE_TRAP;
  896.             StorageNew->snmpNotifyTagLen = 0;
  897.             StorageNew->snmpNotifyTag = (char *) calloc(sizeof(char), 1);
  898.             if (StorageNew->snmpNotifyTag == NULL) {
  899.                 return SNMP_ERR_RESOURCEUNAVAILABLE;
  900.             }
  902.             StorageNew->snmpNotifyRowStatus = set_value;
  903.             snmp_free_var(vars);
  904.         }
  905.         break;
  907.     case RESERVE2:
  908.         break;
  910.     case FREE:
  911.         if (StorageNew != NULL) {
  912.             SNMP_FREE(StorageNew->snmpNotifyTag);
  913.             SNMP_FREE(StorageNew->snmpNotifyName);
  914.             free(StorageNew);
  915.             StorageNew = NULL;
  916.         }
  917.         break;
  919.     case ACTION:
  920.         if (StorageTmp == NULL && (set_value == RS_CREATEANDGO ||
  921.                                    set_value == RS_CREATEANDWAIT)) {
  922.             /*
  923.              * row creation, so add it 
  924.              */
  925.             if (StorageNew != NULL) {
  926.                 snmpNotifyTable_add(StorageNew);
  927.             }
  928.         } else if (set_value != RS_DESTROY) {
  929.             /*
  930.              * set the flag? 
  931.              */
  932.             old_value = StorageTmp->snmpNotifyRowStatus;
  933.             StorageTmp->snmpNotifyRowStatus = *((long *) var_val);
  934.         } else {
  935.             /*
  936.              * destroy...  extract it for now 
  937.              */
  938.             if (StorageTmp) {
  939.                 hciptr = header_complex_find_entry(snmpNotifyTableStorage,
  940.                                                    StorageTmp);
  941.                 StorageDel = (struct snmpNotifyTable_data *)
  942.                     header_complex_extract_entry((struct
  943.                                                   header_complex_index **)
  944.                                                  &snmpNotifyTableStorage,
  945.                                                  hciptr);
  946.             }
  947.         }
  948.         break;
  950.     case UNDO:
  951.         /*
  952.          * Back out any changes made in the ACTION case 
  953.          */
  954.         if (StorageTmp == NULL && (set_value == RS_CREATEANDGO ||
  955.                                    set_value == RS_CREATEANDWAIT)) {
  956.             /*
  957.              * row creation, so remove it again 
  958.              */
  959.             hciptr = header_complex_find_entry(snmpNotifyTableStorage,
  960.                                                StorageNew);
  961.             StorageDel = (struct snmpNotifyTable_data *)
  962.                 header_complex_extract_entry((struct header_complex_index
  963.                                               **) &snmpNotifyTableStorage,
  964.                                              hciptr);
  965.             /*
  966.              * XXX: free it 
  967.              */
  968.         } else if (StorageDel != NULL) {
  969.             /*
  970.              * row deletion, so add it again 
  971.              */
  972.             snmpNotifyTable_add(StorageDel);
  973.         } else if (set_value != RS_DESTROY) {
  974.             StorageTmp->snmpNotifyRowStatus = old_value;
  975.         }
  976.         break;
  978.     case COMMIT:
  979.         if (StorageDel != NULL) {
  980.             SNMP_FREE(StorageDel->snmpNotifyTag);
  981.             SNMP_FREE(StorageDel->snmpNotifyName);
  982.             free(StorageDel);
  983.             StorageDel = NULL;
  984.         }
  985.         if (StorageTmp
  986.             && StorageTmp->snmpNotifyRowStatus == RS_CREATEANDGO) {
  987.             StorageTmp->snmpNotifyRowStatus = RS_ACTIVE;
  988.             StorageNew = NULL;
  989.         } else if (StorageTmp &&
  990.                    StorageTmp->snmpNotifyRowStatus == RS_CREATEANDWAIT) {
  991.             StorageTmp->snmpNotifyRowStatus = RS_NOTINSERVICE;
  992.             StorageNew = NULL;
  993.         }
  994.         break;
  995.     }
  996.     return SNMP_ERR_NOERROR;
  997. }