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