userapps/opensource/net-snmp/agent/mibgroup/disman/mteTriggerDeltaTable.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 "mteTriggerDeltaTable.h"
  29 #include "mteTriggerTable.h"
  30
  31
  32 /*
  33  * mteTriggerDeltaTable_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             mteTriggerDeltaTable_variables_oid[] =
  41     { 1, 3, 6, 1, 2, 1, 88, 1, 2, 3 };
  42
  43
  44 /*
  45  * variable2 mteTriggerDeltaTable_variables:
  46  *   this variable defines function callbacks and type return information
  47  *   for the mteTriggerDeltaTable mib section
  48  */
  49
  50
  51 struct variable2 mteTriggerDeltaTable_variables[] = {
  52     /*
  53      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix
  54      */
  55 #define   MTETRIGGERDELTADISCONTINUITYID  3
  56     {MTETRIGGERDELTADISCONTINUITYID, ASN_OBJECT_ID, RWRITE,
  57      var_mteTriggerDeltaTable, 2, {1, 1}},
  58 #define   MTETRIGGERDELTADISCONTINUITYIDWILDCARD  4
  59     {MTETRIGGERDELTADISCONTINUITYIDWILDCARD, ASN_INTEGER, RWRITE,
  60      var_mteTriggerDeltaTable, 2, {1, 2}},
  61 #define   MTETRIGGERDELTADISCONTINUITYIDTYPE  5
  62     {MTETRIGGERDELTADISCONTINUITYIDTYPE, ASN_INTEGER, RWRITE,
  63      var_mteTriggerDeltaTable, 2, {1, 3}},
  64
  65 };
  66 /*
  67  * (L = length of the oidsuffix)
  68  */
  69
  70
  71 /*
  72  * global storage of our data, saved in and configured by header_complex()
  73  */
  74 extern struct header_complex_index *mteTriggerTableStorage;
  75
  76
  77
  78 /*
  79  * init_mteTriggerDeltaTable():
  80  *   Initialization routine.  This is called when the agent starts up.
  81  *   At a minimum, registration of your variables should take place here.
  82  */
  83 void
  84 init_mteTriggerDeltaTable(void)
  85 {
  86     DEBUGMSGTL(("mteTriggerDeltaTable", "initializing...  "));
  87
  88
  89     /*
  90      * register ourselves with the agent to handle our mib tree
  91      */
  92     REGISTER_MIB("mteTriggerDeltaTable", mteTriggerDeltaTable_variables,
  93                  variable2, mteTriggerDeltaTable_variables_oid);
  94
  95     DEBUGMSGTL(("mteTriggerDeltaTable", "done.\n"));
  96 }
  97
  98 /*
  99  * var_mteTriggerDeltaTable():
 100  *   Handle this table separately from the scalar value case.
 101  *   The workings of this are basically the same as for var_mteTriggerDeltaTable above.
 102  */
 103 unsigned char  *
 104 var_mteTriggerDeltaTable(struct variable *vp,
 105                          oid * name,
 106                          size_t * length,
 107                          int exact,
 108                          size_t * var_len, WriteMethod ** write_method)
 109 {
 110
 111
 112     struct mteTriggerTable_data *StorageTmp = NULL;
 113
 114
 115     DEBUGMSGTL(("mteTriggerDeltaTable",
 116                 "var_mteTriggerDeltaTable: Entering...  \n"));
 117     /*
 118      * this assumes you have registered all your data properly
 119      */
 120     if ((StorageTmp =
 121          header_complex(mteTriggerTableStorage, vp, name, length, exact,
 122                         var_len, write_method)) == NULL)
 123         return NULL;
 124
 125     /*
 126      * this is where we do the value assignments for the mib results.
 127      */
 128     switch (vp->magic) {
 129
 130
 131     case MTETRIGGERDELTADISCONTINUITYID:
 132         *write_method = write_mteTriggerDeltaDiscontinuityID;
 133         *var_len =
 134             StorageTmp->mteTriggerDeltaDiscontinuityIDLen * sizeof(oid);
 135         return (u_char *) StorageTmp->mteTriggerDeltaDiscontinuityID;
 136
 137     case MTETRIGGERDELTADISCONTINUITYIDWILDCARD:
 138         *write_method = write_mteTriggerDeltaDiscontinuityIDWildcard;
 139         *var_len =
 140             sizeof(StorageTmp->mteTriggerDeltaDiscontinuityIDWildcard);
 141         return (u_char *) & StorageTmp->
 142             mteTriggerDeltaDiscontinuityIDWildcard;
 143
 144     case MTETRIGGERDELTADISCONTINUITYIDTYPE:
 145         *write_method = write_mteTriggerDeltaDiscontinuityIDType;
 146         *var_len = sizeof(StorageTmp->mteTriggerDeltaDiscontinuityIDType);
 147         return (u_char *) & StorageTmp->mteTriggerDeltaDiscontinuityIDType;
 148
 149
 150     default:
 151         ERROR_MSG("");
 152     }
 153     return NULL;
 154 }
 155
 156
 157
 158
 159 int
 160 write_mteTriggerDeltaDiscontinuityID(int action,
 161                                      u_char * var_val,
 162                                      u_char var_val_type,
 163                                      size_t var_val_len,
 164                                      u_char * statP,
 165                                      oid * name, size_t name_len)
 166 {
 167     static oid     *tmpvar;
 168     struct mteTriggerTable_data *StorageTmp = NULL;
 169     static size_t   tmplen;
 170     size_t          newlen =
 171         name_len -
 172         (sizeof(mteTriggerDeltaTable_variables_oid) / sizeof(oid) + 3 - 1);
 173
 174
 175     DEBUGMSGTL(("mteTriggerDeltaTable",
 176                 "write_mteTriggerDeltaDiscontinuityID entering action=%d...  \n",
 177                 action));
 178     if ((StorageTmp =
 179          header_complex(mteTriggerTableStorage, NULL,
 180                         &name[sizeof(mteTriggerDeltaTable_variables_oid) /
 181                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 182                         NULL)) == NULL)
 183         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 184
 185
 186     switch (action) {
 187     case RESERVE1:
 188         if (var_val_type != ASN_OBJECT_ID) {
 189             fprintf(stderr,
 190                     "write to mteTriggerDeltaDiscontinuityID not ASN_OBJECT_ID\n");
 191             return SNMP_ERR_WRONGTYPE;
 192         }
 193         if (StorageTmp->storageType != ST_NONVOLATILE)
 194             return SNMP_ERR_NOTWRITABLE;
 195         break;
 196
 197
 198     case RESERVE2:
 199         /*
 200          * memory reseveration, final preparation...
 201          */
 202         break;
 203
 204
 205     case FREE:
 206         /*
 207          * Release any resources that have been allocated
 208          */
 209         break;
 210
 211
 212     case ACTION:
 213         /*
 214          * The variable has been stored in objid for
 215          * you to use, and you have just been asked to do something with
 216          * it.  Note that anything done here must be reversable in the UNDO case
 217          */
 218         tmpvar = StorageTmp->mteTriggerDeltaDiscontinuityID;
 219         tmplen = StorageTmp->mteTriggerDeltaDiscontinuityIDLen;
 220         memdup((u_char **) & StorageTmp->mteTriggerDeltaDiscontinuityID,
 221                var_val, var_val_len);
 222         StorageTmp->mteTriggerDeltaDiscontinuityIDLen =
 223             var_val_len / sizeof(oid);
 224         break;
 225
 226
 227     case UNDO:
 228         /*
 229          * Back out any changes made in the ACTION case
 230          */
 231         SNMP_FREE(StorageTmp->mteTriggerDeltaDiscontinuityID);
 232         StorageTmp->mteTriggerDeltaDiscontinuityID = tmpvar;
 233         StorageTmp->mteTriggerDeltaDiscontinuityIDLen = tmplen;
 234         break;
 235
 236
 237     case COMMIT:
 238         /*
 239          * Things are working well, so it's now safe to make the change
 240          * permanently.  Make sure that anything done here can't fail!
 241          */
 242         SNMP_FREE(tmpvar);
 243         break;
 244     }
 245     return SNMP_ERR_NOERROR;
 246 }
 247
 248
 249
 250 int
 251 write_mteTriggerDeltaDiscontinuityIDWildcard(int action,
 252                                              u_char * var_val,
 253                                              u_char var_val_type,
 254                                              size_t var_val_len,
 255                                              u_char * statP,
 256                                              oid * name, size_t name_len)
 257 {
 258     static int      tmpvar;
 259     struct mteTriggerTable_data *StorageTmp = NULL;
 260     size_t          newlen =
 261         name_len -
 262         (sizeof(mteTriggerDeltaTable_variables_oid) / sizeof(oid) + 3 - 1);
 263
 264
 265     DEBUGMSGTL(("mteTriggerDeltaTable",
 266                 "write_mteTriggerDeltaDiscontinuityIDWildcard entering action=%d...  \n",
 267                 action));
 268     if ((StorageTmp =
 269          header_complex(mteTriggerTableStorage, NULL,
 270                         &name[sizeof(mteTriggerDeltaTable_variables_oid) /
 271                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 272                         NULL)) == NULL)
 273         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 274
 275
 276     switch (action) {
 277     case RESERVE1:
 278         if (var_val_type != ASN_INTEGER) {
 279             fprintf(stderr,
 280                     "write to mteTriggerDeltaDiscontinuityIDWildcard not ASN_INTEGER\n");
 281             return SNMP_ERR_WRONGTYPE;
 282         }
 283         if (StorageTmp->storageType != ST_NONVOLATILE)
 284             return SNMP_ERR_NOTWRITABLE;
 285         break;
 286
 287
 288     case RESERVE2:
 289         /*
 290          * memory reseveration, final preparation...
 291          */
 292         break;
 293
 294
 295     case FREE:
 296         /*
 297          * Release any resources that have been allocated
 298          */
 299         break;
 300
 301
 302     case ACTION:
 303         /*
 304          * The variable has been stored in long_ret for
 305          * you to use, and you have just been asked to do something with
 306          * it.  Note that anything done here must be reversable in the UNDO case
 307          */
 308         tmpvar = StorageTmp->mteTriggerDeltaDiscontinuityIDWildcard;
 309         StorageTmp->mteTriggerDeltaDiscontinuityIDWildcard =
 310             *((long *) var_val);
 311         break;
 312
 313
 314     case UNDO:
 315         /*
 316          * Back out any changes made in the ACTION case
 317          */
 318         StorageTmp->mteTriggerDeltaDiscontinuityIDWildcard = tmpvar;
 319         break;
 320
 321
 322     case COMMIT:
 323         /*
 324          * Things are working well, so it's now safe to make the change
 325          * permanently.  Make sure that anything done here can't fail!
 326          */
 327
 328         break;
 329     }
 330     return SNMP_ERR_NOERROR;
 331 }
 332
 333
 334
 335 int
 336 write_mteTriggerDeltaDiscontinuityIDType(int action,
 337                                          u_char * var_val,
 338                                          u_char var_val_type,
 339                                          size_t var_val_len,
 340                                          u_char * statP,
 341                                          oid * name, size_t name_len)
 342 {
 343     static int      tmpvar;
 344     struct mteTriggerTable_data *StorageTmp = NULL;
 345     size_t          newlen =
 346         name_len -
 347         (sizeof(mteTriggerDeltaTable_variables_oid) / sizeof(oid) + 3 - 1);
 348
 349
 350     DEBUGMSGTL(("mteTriggerDeltaTable",
 351                 "write_mteTriggerDeltaDiscontinuityIDType entering action=%d...  \n",
 352                 action));
 353     if ((StorageTmp =
 354          header_complex(mteTriggerTableStorage, NULL,
 355                         &name[sizeof(mteTriggerDeltaTable_variables_oid) /
 356                               sizeof(oid) + 3 - 1], &newlen, 1, NULL,
 357                         NULL)) == NULL)
 358         return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */
 359
 360
 361     switch (action) {
 362     case RESERVE1:
 363         if (var_val_type != ASN_INTEGER) {
 364             fprintf(stderr,
 365                     "write to mteTriggerDeltaDiscontinuityIDType not ASN_INTEGER\n");
 366             return SNMP_ERR_WRONGTYPE;
 367         }
 368         if (StorageTmp->storageType != ST_NONVOLATILE)
 369             return SNMP_ERR_NOTWRITABLE;
 370         break;
 371
 372
 373     case RESERVE2:
 374         /*
 375          * memory reseveration, final preparation...
 376          */
 377         break;
 378
 379
 380     case FREE:
 381         /*
 382          * Release any resources that have been allocated
 383          */
 384         break;
 385
 386
 387     case ACTION:
 388         /*
 389          * The variable has been stored in long_ret for
 390          * you to use, and you have just been asked to do something with
 391          * it.  Note that anything done here must be reversable in the UNDO case
 392          */
 393         tmpvar = StorageTmp->mteTriggerDeltaDiscontinuityIDType;
 394         StorageTmp->mteTriggerDeltaDiscontinuityIDType =
 395             *((long *) var_val);
 396         break;
 397
 398
 399     case UNDO:
 400         /*
 401          * Back out any changes made in the ACTION case
 402          */
 403         StorageTmp->mteTriggerDeltaDiscontinuityIDType = tmpvar;
 404         break;
 405
 406
 407     case COMMIT:
 408         /*
 409          * Things are working well, so it's now safe to make the change
 410          * permanently.  Make sure that anything done here can't fail!
 411          */
 412
 413         break;
 414     }
 415     return SNMP_ERR_NOERROR;
 416 }