userapps/opensource/net-snmp/agent/mibgroup/disman/mteTriggerExistenceTable.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  */
   5
   6
   7 /*
   8  * This should always be included first before anything else
   9  */
  10 #include <net-snmp/net-snmp-config.h>
  11 #if HAVE_STDLIB_H
  12 #include <stdlib.h>
  13 #endif
  14 #if HAVE_STRING_H
  15 #include <string.h>
  16 #else
  17 #include <strings.h>
  18 #endif
  19
  20
  21 /*
  22  * minimal include directives
  23  */
  24 #include <net-snmp/net-snmp-includes.h>
  25 #include <net-snmp/agent/net-snmp-agent-includes.h>
  26
  27 #include "header_complex.h"
  28 #include "mteTriggerExistenceTable.h"
  29 #include "mteTriggerTable.h"
  30
  31
  32 /*
  33  * mteTriggerExistenceTable_variables_oid:
  34  *   this is the top level oid that we want to register under.  This
  35  *   is essentially a prefix, with the suffix appearing in the
  36  *   variable below.
  37  */
  38
  39
  40 oid             mteTriggerExistenceTable_variables_oid[] =
  41     { 1, 3, 6, 1, 2, 1, 88, 1, 2, 4 };
  42
  43
  44 /*
  45  * variable2 mteTriggerExistenceTable_variables:
  46  *   this variable defines function callbacks and type return information
  47  *   for the mteTriggerExistenceTable mib section
  48  */
  49
  50
  51 struct variable2 mteTriggerExistenceTable_variables[] = {
  52     /*
  53      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix
  54      */
  55 #define   MTETRIGGEREXISTENCETEST  3
  56     {MTETRIGGEREXISTENCETEST, ASN_BIT_STR, RWRITE,
  57      var_mteTriggerExistenceTable, 2, {1, 1}},
  58 #define   MTETRIGGEREXISTENCESTARTUP  4
  59     {MTETRIGGEREXISTENCESTARTUP, ASN_BIT_STR, RWRITE,
  60      var_mteTriggerExistenceTable, 2, {1, 2}},
  61 #define   MTETRIGGEREXISTENCEOBJECTSOWNER  5
  62     {MTETRIGGEREXISTENCEOBJECTSOWNER, ASN_OCTET_STR, RWRITE,
  63      var_mteTriggerExistenceTable, 2, {1, 3}},
  64 #define   MTETRIGGEREXISTENCEOBJECTS  6
  65     {MTETRIGGEREXISTENCEOBJECTS, ASN_OCTET_STR, RWRITE,
  66      var_mteTriggerExistenceTable, 2, {1, 4}},
  67 #define   MTETRIGGEREXISTENCEEVENTOWNER  7
  68     {MTETRIGGEREXISTENCEEVENTOWNER, ASN_OCTET_STR, RWRITE,
  69      var_mteTriggerExistenceTable, 2, {1, 5}},
  70 #define   MTETRIGGEREXISTENCEEVENT  8
  71     {MTETRIGGEREXISTENCEEVENT, ASN_OCTET_STR, RWRITE,
  72      var_mteTriggerExistenceTable, 2, {1, 6}},
  73
  74 };
  75 /*
  76  * (L = length of the oidsuffix)
  77  */
  78
  79
  80 /*
  81  * global storage of our data, saved in and configured by header_complex()
  82  */
  83 extern struct header_complex_index *mteTriggerTableStorage;
  84
  85
  86
  87
  88 /*
  89  * init_mteTriggerExistenceTable():
  90  *   Initialization routine.  This is called when the agent starts up.
  91  *   At a minimum, registration of your variables should take place here.
  92  */
  93 void
  94 init_mteTriggerExistenceTable(void)
  95 {
  96     DEBUGMSGTL(("mteTriggerExistenceTable", "initializing...  "));
  97
  98
  99     /*
 100      * register ourselves with the agent to handle our mib tree
 101      */
 102     REGISTER_MIB("mteTriggerExistenceTable",
 103                  mteTriggerExistenceTable_variables, variable2,
 104                  mteTriggerExistenceTable_variables_oid);
 105
 106
 107     /*
 108      * place any other initialization junk you need here
 109      */
 110
 111
 112     DEBUGMSGTL(("mteTriggerExistenceTable", "done.\n"));
 113 }
 114
 115 /*
 116  * var_mteTriggerExistenceTable():
 117  *   Handle this table separately from the scalar value case.
 118  *   The workings of this are basically the same as for var_mteTriggerExistenceTable above.
 119  */
 120 unsigned char  *
 121 var_mteTriggerExistenceTable(struct variable *vp,
 122                              oid * name,
 123                              size_t * length,
 124                              int exact,
 125                              size_t * var_len, WriteMethod ** write_method)
 126 {
 127
 128
 129     struct mteTriggerTable_data *StorageTmp = NULL;
 130
 131
 132     DEBUGMSGTL(("mteTriggerExistenceTable",
 133                 "var_mteTriggerExistenceTable: Entering...  \n"));
 134     /*
 135      * this assumes you have registered all your data properly
 136      */
 137     if ((StorageTmp =
 138          header_complex(mteTriggerTableStorage, vp, name, length, exact,
 139                         var_len, write_method)) == NULL)
 140         return NULL;
 141
 142     if (!(StorageTmp->mteTriggerTest[0] & MTETRIGGERTEST_EXISTENCE))
 143         return NULL;
 144
 145     /*
 146      * this is where we do the value assignments for the mib results.
 147      */
 148     switch (vp->magic) {
 149
 150
 151     case MTETRIGGEREXISTENCETEST:
 152         *write_method = write_mteTriggerExistenceTest;
 153         *var_len = StorageTmp->mteTriggerExistenceTestLen;
 154         return (u_char *) StorageTmp->mteTriggerExistenceTest;
 155
 156     case MTETRIGGEREXISTENCESTARTUP:
 157         *write_method = write_mteTriggerExistenceStartup;
 158         *var_len = StorageTmp->mteTriggerExistenceStartupLen;
 159         return (u_char *) StorageTmp->mteTriggerExistenceStartup;
 160
 161     case MTETRIGGEREXISTENCEOBJECTSOWNER:
 162         *write_method = write_mteTriggerExistenceObjectsOwner;
 163         *var_len = StorageTmp->mteTriggerExistenceObjectsOwnerLen;
 164         return (u_char *) StorageTmp->mteTriggerExistenceObjectsOwner;
 165
 166     case MTETRIGGEREXISTENCEOBJECTS:
 167         *write_method = write_mteTriggerExistenceObjects;
 168         *var_len = StorageTmp->mteTriggerExistenceObjectsLen;
 169         return (u_char *) StorageTmp->mteTriggerExistenceObjects;
 170
 171     case MTETRIGGEREXISTENCEEVENTOWNER:
 172         *write_method = write_mteTriggerExistenceEventOwner;
 173         *var_len = StorageTmp->mteTriggerExistenceEventOwnerLen;
 174         return (u_char *) StorageTmp->mteTriggerExistenceEventOwner;
 175
 176     case MTETRIGGEREXISTENCEEVENT:
 177         *write_method = write_mteTriggerExistenceEvent;
 178         *var_len = StorageTmp->mteTriggerExistenceEventLen;
 179         return (u_char *) StorageTmp->mteTriggerExistenceEvent;
 180
 181
 182     default:
 183         ERROR_MSG("");
 184     }
 185     return NULL;
 186 }
 187
 188
 189
 190
 191 int
 192 write_mteTriggerExistenceTest(int action,
 193                               u_char * var_val,
 194                               u_char var_val_type,
 195                               size_t var_val_len,
 196                               u_char * statP, oid * name, size_t name_len)
 197 {
 198     static char    *tmpvar;
 199     struct mteTriggerTable_data *StorageTmp = NULL;
 200     static size_t   tmplen;
 201     size_t          newlen =
 202         name_len -
 203         (sizeof(mteTriggerExistenceTable_variables_oid) / sizeof(oid) + 3 -
 204          1);
 205
 206
 207     DEBUGMSGTL(("mteTriggerExistenceTable",
 208                 "write_mteTriggerExistenceTest entering action=%d...  \n",
 209                 action));
 210     if ((StorageTmp =
 211          header_complex(mteTriggerTableStorage, NULL,
 212                         &name[sizeof
 213                               (mteTriggerExistenceTable_variables_oid) /
 214                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 215                         NULL)) == NULL)
 216         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 217
 218
 219     switch (action) {
 220     case RESERVE1:
 221         if (var_val_type != ASN_OCTET_STR) {
 222             fprintf(stderr,
 223                     "write to mteTriggerExistenceTest not ASN_OCTET_STR\n");
 224             return SNMP_ERR_WRONGTYPE;
 225         }
 226         if (StorageTmp->storageType != ST_NONVOLATILE)
 227             return SNMP_ERR_NOTWRITABLE;
 228         break;
 229
 230
 231     case RESERVE2:
 232         /*
 233          * memory reseveration, final preparation...
 234          */
 235         break;
 236
 237
 238     case FREE:
 239         /*
 240          * Release any resources that have been allocated
 241          */
 242         break;
 243
 244
 245     case ACTION:
 246         /*
 247          * The variable has been stored in string for
 248          * you to use, and you have just been asked to do something with
 249          * it.  Note that anything done here must be reversable in the UNDO case
 250          */
 251         tmpvar = StorageTmp->mteTriggerExistenceTest;
 252         tmplen = StorageTmp->mteTriggerExistenceTestLen;
 253         memdup((u_char **) & StorageTmp->mteTriggerExistenceTest, var_val,
 254                var_val_len);
 255         StorageTmp->mteTriggerExistenceTestLen = var_val_len;
 256         break;
 257
 258
 259     case UNDO:
 260         /*
 261          * Back out any changes made in the ACTION case
 262          */
 263         SNMP_FREE(StorageTmp->mteTriggerExistenceTest);
 264         StorageTmp->mteTriggerExistenceTest = tmpvar;
 265         StorageTmp->mteTriggerExistenceTestLen = tmplen;
 266         break;
 267
 268
 269     case COMMIT:
 270         /*
 271          * Things are working well, so it's now safe to make the change
 272          * permanently.  Make sure that anything done here can't fail!
 273          */
 274         SNMP_FREE(tmpvar);
 275         break;
 276     }
 277     return SNMP_ERR_NOERROR;
 278 }
 279
 280
 281
 282 int
 283 write_mteTriggerExistenceStartup(int action,
 284                                  u_char * var_val,
 285                                  u_char var_val_type,
 286                                  size_t var_val_len,
 287                                  u_char * statP,
 288                                  oid * name, size_t name_len)
 289 {
 290     static char    *tmpvar;
 291     struct mteTriggerTable_data *StorageTmp = NULL;
 292     static size_t   tmplen;
 293     size_t          newlen =
 294         name_len -
 295         (sizeof(mteTriggerExistenceTable_variables_oid) / sizeof(oid) + 3 -
 296          1);
 297
 298
 299     DEBUGMSGTL(("mteTriggerExistenceTable",
 300                 "write_mteTriggerExistenceStartup entering action=%d...  \n",
 301                 action));
 302     if ((StorageTmp =
 303          header_complex(mteTriggerTableStorage, NULL,
 304                         &name[sizeof
 305                               (mteTriggerExistenceTable_variables_oid) /
 306                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 307                         NULL)) == NULL)
 308         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 309
 310
 311     switch (action) {
 312     case RESERVE1:
 313         if (var_val_type != ASN_OCTET_STR) {
 314             fprintf(stderr,
 315                     "write to mteTriggerExistenceStartup not ASN_OCTET_STR\n");
 316             return SNMP_ERR_WRONGTYPE;
 317         }
 318         if (StorageTmp->storageType != ST_NONVOLATILE)
 319             return SNMP_ERR_NOTWRITABLE;
 320         break;
 321
 322
 323     case RESERVE2:
 324         /*
 325          * memory reseveration, final preparation...
 326          */
 327         break;
 328
 329
 330     case FREE:
 331         /*
 332          * Release any resources that have been allocated
 333          */
 334         break;
 335
 336
 337     case ACTION:
 338         /*
 339          * The variable has been stored in string for
 340          * you to use, and you have just been asked to do something with
 341          * it.  Note that anything done here must be reversable in the UNDO case
 342          */
 343         tmpvar = StorageTmp->mteTriggerExistenceStartup;
 344         tmplen = StorageTmp->mteTriggerExistenceStartupLen;
 345         memdup((u_char **) & StorageTmp->mteTriggerExistenceStartup,
 346                var_val, var_val_len);
 347         StorageTmp->mteTriggerExistenceStartupLen = var_val_len;
 348         break;
 349
 350
 351     case UNDO:
 352         /*
 353          * Back out any changes made in the ACTION case
 354          */
 355         SNMP_FREE(StorageTmp->mteTriggerExistenceStartup);
 356         StorageTmp->mteTriggerExistenceStartup = tmpvar;
 357         StorageTmp->mteTriggerExistenceStartupLen = tmplen;
 358         break;
 359
 360
 361     case COMMIT:
 362         /*
 363          * Things are working well, so it's now safe to make the change
 364          * permanently.  Make sure that anything done here can't fail!
 365          */
 366         SNMP_FREE(tmpvar);
 367         break;
 368     }
 369     return SNMP_ERR_NOERROR;
 370 }
 371
 372
 373
 374 int
 375 write_mteTriggerExistenceObjectsOwner(int action,
 376                                       u_char * var_val,
 377                                       u_char var_val_type,
 378                                       size_t var_val_len,
 379                                       u_char * statP,
 380                                       oid * name, size_t name_len)
 381 {
 382     static char    *tmpvar;
 383     struct mteTriggerTable_data *StorageTmp = NULL;
 384     static size_t   tmplen;
 385     size_t          newlen =
 386         name_len -
 387         (sizeof(mteTriggerExistenceTable_variables_oid) / sizeof(oid) + 3 -
 388          1);
 389
 390
 391     DEBUGMSGTL(("mteTriggerExistenceTable",
 392                 "write_mteTriggerExistenceObjectsOwner entering action=%d...  \n",
 393                 action));
 394     if ((StorageTmp =
 395          header_complex(mteTriggerTableStorage, NULL,
 396                         &name[sizeof
 397                               (mteTriggerExistenceTable_variables_oid) /
 398                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 399                         NULL)) == NULL)
 400         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 401
 402
 403     switch (action) {
 404     case RESERVE1:
 405         if (var_val_type != ASN_OCTET_STR) {
 406             fprintf(stderr,
 407                     "write to mteTriggerExistenceObjectsOwner not ASN_OCTET_STR\n");
 408             return SNMP_ERR_WRONGTYPE;
 409         }
 410         if (StorageTmp->storageType != ST_NONVOLATILE)
 411             return SNMP_ERR_NOTWRITABLE;
 412         break;
 413
 414
 415     case RESERVE2:
 416         /*
 417          * memory reseveration, final preparation...
 418          */
 419         break;
 420
 421
 422     case FREE:
 423         /*
 424          * Release any resources that have been allocated
 425          */
 426         break;
 427
 428
 429     case ACTION:
 430         /*
 431          * The variable has been stored in string for
 432          * you to use, and you have just been asked to do something with
 433          * it.  Note that anything done here must be reversable in the UNDO case
 434          */
 435         tmpvar = StorageTmp->mteTriggerExistenceObjectsOwner;
 436         tmplen = StorageTmp->mteTriggerExistenceObjectsOwnerLen;
 437         memdup((u_char **) & StorageTmp->mteTriggerExistenceObjectsOwner,
 438                var_val, var_val_len);
 439         StorageTmp->mteTriggerExistenceObjectsOwnerLen = var_val_len;
 440         break;
 441
 442
 443     case UNDO:
 444         /*
 445          * Back out any changes made in the ACTION case
 446          */
 447         SNMP_FREE(StorageTmp->mteTriggerExistenceObjectsOwner);
 448         StorageTmp->mteTriggerExistenceObjectsOwner = tmpvar;
 449         StorageTmp->mteTriggerExistenceObjectsOwnerLen = tmplen;
 450         break;
 451
 452
 453     case COMMIT:
 454         /*
 455          * Things are working well, so it's now safe to make the change
 456          * permanently.  Make sure that anything done here can't fail!
 457          */
 458         SNMP_FREE(tmpvar);
 459         break;
 460     }
 461     return SNMP_ERR_NOERROR;
 462 }
 463
 464
 465
 466 int
 467 write_mteTriggerExistenceObjects(int action,
 468                                  u_char * var_val,
 469                                  u_char var_val_type,
 470                                  size_t var_val_len,
 471                                  u_char * statP,
 472                                  oid * name, size_t name_len)
 473 {
 474     static char    *tmpvar;
 475     struct mteTriggerTable_data *StorageTmp = NULL;
 476     static size_t   tmplen;
 477     size_t          newlen =
 478         name_len -
 479         (sizeof(mteTriggerExistenceTable_variables_oid) / sizeof(oid) + 3 -
 480          1);
 481
 482
 483     DEBUGMSGTL(("mteTriggerExistenceTable",
 484                 "write_mteTriggerExistenceObjects entering action=%d...  \n",
 485                 action));
 486     if ((StorageTmp =
 487          header_complex(mteTriggerTableStorage, NULL,
 488                         &name[sizeof
 489                               (mteTriggerExistenceTable_variables_oid) /
 490                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 491                         NULL)) == NULL)
 492         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 493
 494
 495     switch (action) {
 496     case RESERVE1:
 497         if (var_val_type != ASN_OCTET_STR) {
 498             fprintf(stderr,
 499                     "write to mteTriggerExistenceObjects not ASN_OCTET_STR\n");
 500             return SNMP_ERR_WRONGTYPE;
 501         }
 502         if (StorageTmp->storageType != ST_NONVOLATILE)
 503             return SNMP_ERR_NOTWRITABLE;
 504         break;
 505
 506
 507     case RESERVE2:
 508         /*
 509          * memory reseveration, final preparation...
 510          */
 511         break;
 512
 513
 514     case FREE:
 515         /*
 516          * Release any resources that have been allocated
 517          */
 518         break;
 519
 520
 521     case ACTION:
 522         /*
 523          * The variable has been stored in string for
 524          * you to use, and you have just been asked to do something with
 525          * it.  Note that anything done here must be reversable in the UNDO case
 526          */
 527         tmpvar = StorageTmp->mteTriggerExistenceObjects;
 528         tmplen = StorageTmp->mteTriggerExistenceObjectsLen;
 529         memdup((u_char **) & StorageTmp->mteTriggerExistenceObjects,
 530                var_val, var_val_len);
 531         StorageTmp->mteTriggerExistenceObjectsLen = var_val_len;
 532         break;
 533
 534
 535     case UNDO:
 536         /*
 537          * Back out any changes made in the ACTION case
 538          */
 539         SNMP_FREE(StorageTmp->mteTriggerExistenceObjects);
 540         StorageTmp->mteTriggerExistenceObjects = tmpvar;
 541         StorageTmp->mteTriggerExistenceObjectsLen = tmplen;
 542         break;
 543
 544
 545     case COMMIT:
 546         /*
 547          * Things are working well, so it's now safe to make the change
 548          * permanently.  Make sure that anything done here can't fail!
 549          */
 550         SNMP_FREE(tmpvar);
 551         break;
 552     }
 553     return SNMP_ERR_NOERROR;
 554 }
 555
 556
 557
 558 int
 559 write_mteTriggerExistenceEventOwner(int action,
 560                                     u_char * var_val,
 561                                     u_char var_val_type,
 562                                     size_t var_val_len,
 563                                     u_char * statP,
 564                                     oid * name, size_t name_len)
 565 {
 566     static char    *tmpvar;
 567     struct mteTriggerTable_data *StorageTmp = NULL;
 568     static size_t   tmplen;
 569     size_t          newlen =
 570         name_len -
 571         (sizeof(mteTriggerExistenceTable_variables_oid) / sizeof(oid) + 3 -
 572          1);
 573
 574
 575     DEBUGMSGTL(("mteTriggerExistenceTable",
 576                 "write_mteTriggerExistenceEventOwner entering action=%d...  \n",
 577                 action));
 578     if ((StorageTmp =
 579          header_complex(mteTriggerTableStorage, NULL,
 580                         &name[sizeof
 581                               (mteTriggerExistenceTable_variables_oid) /
 582                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 583                         NULL)) == NULL)
 584         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 585
 586
 587     switch (action) {
 588     case RESERVE1:
 589         if (var_val_type != ASN_OCTET_STR) {
 590             fprintf(stderr,
 591                     "write to mteTriggerExistenceEventOwner not ASN_OCTET_STR\n");
 592             return SNMP_ERR_WRONGTYPE;
 593         }
 594         if (StorageTmp->storageType != ST_NONVOLATILE)
 595             return SNMP_ERR_NOTWRITABLE;
 596         break;
 597
 598
 599     case RESERVE2:
 600         /*
 601          * memory reseveration, final preparation...
 602          */
 603         break;
 604
 605
 606     case FREE:
 607         /*
 608          * Release any resources that have been allocated
 609          */
 610         break;
 611
 612
 613     case ACTION:
 614         /*
 615          * The variable has been stored in string for
 616          * you to use, and you have just been asked to do something with
 617          * it.  Note that anything done here must be reversable in the UNDO case
 618          */
 619         tmpvar = StorageTmp->mteTriggerExistenceEventOwner;
 620         tmplen = StorageTmp->mteTriggerExistenceEventOwnerLen;
 621         memdup((u_char **) & StorageTmp->mteTriggerExistenceEventOwner,
 622                var_val, var_val_len);
 623         StorageTmp->mteTriggerExistenceEventOwnerLen = var_val_len;
 624         break;
 625
 626
 627     case UNDO:
 628         /*
 629          * Back out any changes made in the ACTION case
 630          */
 631         SNMP_FREE(StorageTmp->mteTriggerExistenceEventOwner);
 632         StorageTmp->mteTriggerExistenceEventOwner = tmpvar;
 633         StorageTmp->mteTriggerExistenceEventOwnerLen = tmplen;
 634         break;
 635
 636
 637     case COMMIT:
 638         /*
 639          * Things are working well, so it's now safe to make the change
 640          * permanently.  Make sure that anything done here can't fail!
 641          */
 642         SNMP_FREE(tmpvar);
 643         break;
 644     }
 645     return SNMP_ERR_NOERROR;
 646 }
 647
 648
 649
 650 int
 651 write_mteTriggerExistenceEvent(int action,
 652                                u_char * var_val,
 653                                u_char var_val_type,
 654                                size_t var_val_len,
 655                                u_char * statP, oid * name, size_t name_len)
 656 {
 657     static char    *tmpvar;
 658     struct mteTriggerTable_data *StorageTmp = NULL;
 659     static size_t   tmplen;
 660     size_t          newlen =
 661         name_len -
 662         (sizeof(mteTriggerExistenceTable_variables_oid) / sizeof(oid) + 3 -
 663          1);
 664
 665
 666     DEBUGMSGTL(("mteTriggerExistenceTable",
 667                 "write_mteTriggerExistenceEvent entering action=%d...  \n",
 668                 action));
 669     if ((StorageTmp =
 670          header_complex(mteTriggerTableStorage, NULL,
 671                         &name[sizeof
 672                               (mteTriggerExistenceTable_variables_oid) /
 673                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 674                         NULL)) == NULL)
 675         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 676
 677
 678     switch (action) {
 679     case RESERVE1:
 680         if (var_val_type != ASN_OCTET_STR) {
 681             fprintf(stderr,
 682                     "write to mteTriggerExistenceEvent not ASN_OCTET_STR\n");
 683             return SNMP_ERR_WRONGTYPE;
 684         }
 685         if (StorageTmp->storageType != ST_NONVOLATILE)
 686             return SNMP_ERR_NOTWRITABLE;
 687         break;
 688
 689
 690     case RESERVE2:
 691         /*
 692          * memory reseveration, final preparation...
 693          */
 694         break;
 695
 696
 697     case FREE:
 698         /*
 699          * Release any resources that have been allocated
 700          */
 701         break;
 702
 703
 704     case ACTION:
 705         /*
 706          * The variable has been stored in string for
 707          * you to use, and you have just been asked to do something with
 708          * it.  Note that anything done here must be reversable in the UNDO case
 709          */
 710         tmpvar = StorageTmp->mteTriggerExistenceEvent;
 711         tmplen = StorageTmp->mteTriggerExistenceEventLen;
 712         memdup((u_char **) & StorageTmp->mteTriggerExistenceEvent, var_val,
 713                var_val_len);
 714         StorageTmp->mteTriggerExistenceEventLen = var_val_len;
 715         break;
 716
 717
 718     case UNDO:
 719         /*
 720          * Back out any changes made in the ACTION case
 721          */
 722         SNMP_FREE(StorageTmp->mteTriggerExistenceEvent);
 723         StorageTmp->mteTriggerExistenceEvent = tmpvar;
 724         StorageTmp->mteTriggerExistenceEventLen = tmplen;
 725         break;
 726
 727
 728     case COMMIT:
 729         /*
 730          * Things are working well, so it's now safe to make the change
 731          * permanently.  Make sure that anything done here can't fail!
 732          */
 733         SNMP_FREE(tmpvar);
 734         break;
 735     }
 736     return SNMP_ERR_NOERROR;
 737 }