instance.c

00001 /* Portions of this file are subject to the following copyright(s).  See
00002  * the Net-SNMP's COPYING file for more details and other copyrights
00003  * that may apply:
00004  */
00005 /*
00006  * Portions of this file are copyrighted by:
00007  * Copyright © 2003 Sun Microsystems, Inc. All rights reserved.
00008  * Use is subject to license terms specified in the COPYING file
00009  * distributed with the Net-SNMP package.
00010  */
00011 #include <net-snmp/net-snmp-config.h>
00012 
00013 #include <net-snmp/net-snmp-includes.h>
00014 #include <net-snmp/agent/net-snmp-agent-includes.h>
00015 
00016 #include <net-snmp/agent/instance.h>
00017 
00018 #include <stdlib.h>
00019 #if HAVE_STRING_H
00020 #include <string.h>
00021 #else
00022 #include <strings.h>
00023 #endif
00024 
00025 #include <net-snmp/agent/serialize.h>
00026 #include <net-snmp/agent/read_only.h>
00027 
00028 typedef struct netsnmp_num_file_instance_s {
00029     char *file_name;
00030     FILE *filep;
00031     int   type;
00032     int   flags;
00033 } netsnmp_num_file_instance;
00034 
00048 netsnmp_mib_handler *
00049 netsnmp_get_instance_handler(void)
00050 {
00051     return netsnmp_create_handler("instance",
00052                                   netsnmp_instance_helper_handler);
00053 }
00054 
00073 int
00074 netsnmp_register_instance(netsnmp_handler_registration *reginfo)
00075 {
00076     netsnmp_mib_handler *handler = netsnmp_get_instance_handler();
00077     handler->flags |= MIB_HANDLER_INSTANCE;
00078     netsnmp_inject_handler(reginfo, handler);
00079     return netsnmp_register_serialize(reginfo);
00080 }
00081 
00100 int
00101 netsnmp_register_read_only_instance(netsnmp_handler_registration *reginfo)
00102 {
00103     netsnmp_inject_handler(reginfo, netsnmp_get_instance_handler());
00104     netsnmp_inject_handler(reginfo, netsnmp_get_read_only_handler());
00105     return netsnmp_register_serialize(reginfo);
00106 }
00107 
00108 static
00109 netsnmp_handler_registration *
00110 get_reg(const char *name,
00111         const char *ourname,
00112         const oid * reg_oid, size_t reg_oid_len,
00113         void *it,
00114         int modes,
00115         Netsnmp_Node_Handler * scalarh, Netsnmp_Node_Handler * subhandler,
00116         const char *contextName)
00117 {
00118     netsnmp_handler_registration *myreg;
00119     netsnmp_mib_handler *myhandler;
00120 
00121     if (subhandler) {
00122         myreg =
00123             netsnmp_create_handler_registration(name,
00124                                                 subhandler,
00125                                                 reg_oid, reg_oid_len,
00126                                                 modes);
00127         myhandler = netsnmp_create_handler(ourname, scalarh);
00128         myhandler->myvoid = (void *) it;
00129         netsnmp_inject_handler(myreg, myhandler);
00130     } else {
00131         myreg =
00132             netsnmp_create_handler_registration(name,
00133                                                 scalarh,
00134                                                 reg_oid, reg_oid_len,
00135                                                 modes);
00136         myreg->handler->myvoid = (void *) it;
00137     }
00138     if (contextName)
00139         myreg->contextName = strdup(contextName);
00140     return myreg;
00141 }
00142 
00143 int
00144 netsnmp_register_read_only_ulong_instance(const char *name,
00145                                           const oid * reg_oid,
00146                                           size_t reg_oid_len, u_long * it,
00147                                           Netsnmp_Node_Handler *
00148                                           subhandler)
00149 {
00150     return netsnmp_register_watched_instance(
00151                netsnmp_create_handler_registration(
00152                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY),
00153                netsnmp_create_watcher_info(
00154                    (void *)it, sizeof(u_long),
00155                    ASN_UNSIGNED, WATCHER_FIXED_SIZE));
00156 }
00157 
00158 int
00159 netsnmp_register_ulong_instance(const char *name,
00160                                 const oid * reg_oid, size_t reg_oid_len,
00161                                 u_long * it,
00162                                 Netsnmp_Node_Handler * subhandler)
00163 {
00164     return netsnmp_register_watched_instance(
00165                netsnmp_create_handler_registration(
00166                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE),
00167                netsnmp_create_watcher_info(
00168                    (void *)it, sizeof(u_long),
00169                    ASN_UNSIGNED, WATCHER_FIXED_SIZE));
00170 }
00171 
00172 int
00173 netsnmp_register_read_only_counter32_instance(const char *name,
00174                                               const oid * reg_oid,
00175                                               size_t reg_oid_len,
00176                                               u_long * it,
00177                                               Netsnmp_Node_Handler *
00178                                               subhandler)
00179 {
00180     return netsnmp_register_watched_instance(
00181                netsnmp_create_handler_registration(
00182                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY),
00183                netsnmp_create_watcher_info(
00184                    (void *)it, sizeof(u_long),
00185                    ASN_COUNTER, WATCHER_FIXED_SIZE));
00186 }
00187 
00188 int
00189 netsnmp_register_read_only_long_instance(const char *name,
00190                                          const oid * reg_oid,
00191                                          size_t reg_oid_len,
00192                                          long *it,
00193                                          Netsnmp_Node_Handler * subhandler)
00194 {
00195     return netsnmp_register_watched_instance(
00196                netsnmp_create_handler_registration(
00197                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY),
00198                netsnmp_create_watcher_info(
00199                    (void *)it, sizeof(long), ASN_INTEGER, WATCHER_FIXED_SIZE));
00200 }
00201 
00202 int
00203 netsnmp_register_long_instance(const char *name,
00204                                const oid * reg_oid, size_t reg_oid_len,
00205                                long *it, Netsnmp_Node_Handler * subhandler)
00206 {
00207     return netsnmp_register_watched_instance(
00208                netsnmp_create_handler_registration(
00209                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE),
00210                netsnmp_create_watcher_info(
00211                    (void *)it, sizeof(long), ASN_INTEGER, WATCHER_FIXED_SIZE));
00212 }
00213 
00214 
00215 int
00216 netsnmp_register_read_only_uint_instance(const char *name,
00217                                          const oid * reg_oid,
00218                                          size_t reg_oid_len,
00219                                          unsigned int *it,
00220                                          Netsnmp_Node_Handler * subhandler)
00221 {
00222     return netsnmp_register_watched_instance(
00223                netsnmp_create_handler_registration(
00224                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY),
00225                netsnmp_create_watcher_info(
00226                    (void *)it, sizeof(unsigned int),
00227                    ASN_UNSIGNED, WATCHER_FIXED_SIZE));
00228 }
00229 
00230 int
00231 netsnmp_register_uint_instance(const char *name,
00232                                const oid * reg_oid, size_t reg_oid_len,
00233                                unsigned int *it, Netsnmp_Node_Handler * subhandler)
00234 {
00235     return netsnmp_register_watched_instance(
00236                netsnmp_create_handler_registration(
00237                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE),
00238                netsnmp_create_watcher_info(
00239                    (void *)it, sizeof(unsigned int),
00240                    ASN_UNSIGNED, WATCHER_FIXED_SIZE));
00241 }
00242 
00243 int
00244 netsnmp_register_read_only_int_instance(const char *name,
00245                                 const oid * reg_oid, size_t reg_oid_len,
00246                                 int *it, Netsnmp_Node_Handler * subhandler)
00247 {
00248     return netsnmp_register_watched_instance(
00249                netsnmp_create_handler_registration(
00250                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY),
00251                netsnmp_create_watcher_info(
00252                    (void *)it, sizeof(int), ASN_INTEGER, WATCHER_FIXED_SIZE));
00253 }
00254 
00255   /*
00256    * Compatibility with earlier (inconsistently named) routine
00257    */
00258 int
00259 register_read_only_int_instance(const char *name,
00260                                 const oid * reg_oid, size_t reg_oid_len,
00261                                 int *it, Netsnmp_Node_Handler * subhandler)
00262 {
00263   return netsnmp_register_read_only_int_instance(name,
00264                                 reg_oid, reg_oid_len,
00265                                 it, subhandler);
00266 }
00267 
00268 /*
00269  * Context registrations
00270  */
00271 
00272 int
00273 netsnmp_register_read_only_ulong_instance_context(const char *name,
00274                                                   const oid * reg_oid,
00275                                                   size_t reg_oid_len,
00276                                                   u_long * it,
00277                                                   Netsnmp_Node_Handler *
00278                                                   subhandler,
00279                                                   const char *contextName)
00280 {
00281     netsnmp_handler_registration *myreg =
00282       netsnmp_create_handler_registration(
00283           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY);
00284     if (myreg && contextName)
00285       myreg->contextName = strdup(contextName);
00286     return netsnmp_register_watched_instance(
00287         myreg, netsnmp_create_watcher_info(
00288             (void *)it, sizeof(u_long), ASN_UNSIGNED, WATCHER_FIXED_SIZE));
00289 }
00290 
00291 int
00292 netsnmp_register_ulong_instance_context(const char *name,
00293                                         const oid * reg_oid, size_t reg_oid_len,
00294                                         u_long * it,
00295                                         Netsnmp_Node_Handler * subhandler,
00296                                         const char *contextName)
00297 {
00298     netsnmp_handler_registration *myreg =
00299       netsnmp_create_handler_registration(
00300           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE);
00301     if (myreg && contextName)
00302       myreg->contextName = strdup(contextName);
00303     return netsnmp_register_watched_instance(
00304         myreg, netsnmp_create_watcher_info(
00305             (void *)it, sizeof(u_long), ASN_UNSIGNED, WATCHER_FIXED_SIZE));
00306 }
00307 
00308 int
00309 netsnmp_register_read_only_counter32_instance_context(const char *name,
00310                                                       const oid * reg_oid,
00311                                                       size_t reg_oid_len,
00312                                                       u_long * it,
00313                                                       Netsnmp_Node_Handler *
00314                                                       subhandler,
00315                                                       const char *contextName)
00316 {
00317     netsnmp_handler_registration *myreg =
00318       netsnmp_create_handler_registration(
00319           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY);
00320     if (myreg && contextName)
00321       myreg->contextName = strdup(contextName);
00322     return netsnmp_register_watched_instance(
00323         myreg, netsnmp_create_watcher_info(
00324             (void *)it, sizeof(u_long), ASN_COUNTER, WATCHER_FIXED_SIZE));
00325 }
00326 
00327 int
00328 netsnmp_register_read_only_long_instance_context(const char *name,
00329                                                  const oid * reg_oid,
00330                                                  size_t reg_oid_len,
00331                                                  long *it,
00332                                                  Netsnmp_Node_Handler
00333                                                  *subhandler,
00334                                                  const char *contextName)
00335 {
00336     netsnmp_handler_registration *myreg =
00337       netsnmp_create_handler_registration(
00338           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY);
00339     if (myreg && contextName)
00340       myreg->contextName = strdup(contextName);
00341     return netsnmp_register_watched_instance(
00342         myreg, netsnmp_create_watcher_info(
00343             (void *)it, sizeof(long), ASN_INTEGER, WATCHER_FIXED_SIZE));
00344 }
00345 
00346 int
00347 netsnmp_register_long_instance_context(const char *name,
00348                                        const oid * reg_oid, size_t reg_oid_len,
00349                                        long *it,
00350                                        Netsnmp_Node_Handler * subhandler,
00351                                        const char *contextName)
00352 {
00353     netsnmp_handler_registration *myreg =
00354       netsnmp_create_handler_registration(
00355           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE);
00356     if (myreg && contextName)
00357       myreg->contextName = strdup(contextName);
00358     return netsnmp_register_watched_instance(
00359         myreg, netsnmp_create_watcher_info(
00360             (void *)it, sizeof(long), ASN_INTEGER, WATCHER_FIXED_SIZE));
00361 }
00362 
00363 int
00364 netsnmp_register_int_instance_context(const char *name,
00365                                       const oid * reg_oid,
00366                                       size_t reg_oid_len,
00367                                       int *it,
00368                                       Netsnmp_Node_Handler * subhandler,
00369                                       const char *contextName)
00370 {
00371     netsnmp_handler_registration *myreg =
00372       netsnmp_create_handler_registration(
00373           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE);
00374     if (myreg && contextName)
00375       myreg->contextName = strdup(contextName);
00376     return netsnmp_register_watched_instance(
00377         myreg, netsnmp_create_watcher_info(
00378             (void *)it, sizeof(int), ASN_INTEGER, WATCHER_FIXED_SIZE));
00379 }
00380 
00381 int
00382 netsnmp_register_read_only_int_instance_context(const char *name,
00383                                                 const oid * reg_oid,
00384                                                 size_t reg_oid_len,
00385                                                 int *it,
00386                                                 Netsnmp_Node_Handler * subhandler,
00387                                                 const char *contextName)
00388 {
00389     netsnmp_handler_registration *myreg =
00390       netsnmp_create_handler_registration(
00391           name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RONLY);
00392     if (myreg && contextName)
00393       myreg->contextName = strdup(contextName);
00394     return netsnmp_register_watched_instance(
00395         myreg, netsnmp_create_watcher_info(
00396             (void *)it, sizeof(int), ASN_INTEGER, WATCHER_FIXED_SIZE));
00397 }
00398 
00399 /*
00400  * Compatibility with earlier (inconsistently named) routine
00401  */
00402 int
00403 register_read_only_int_instance_context(const char *name,
00404                                         const oid * reg_oid, size_t reg_oid_len,
00405                                         int *it,
00406                                         Netsnmp_Node_Handler * subhandler,
00407                                         const char *contextName)
00408 {
00409     return netsnmp_register_read_only_int_instance_context(name,
00410                                                            reg_oid, reg_oid_len,
00411                                                            it, subhandler,
00412                                                            contextName);
00413 }
00414 
00415 int
00416 netsnmp_register_num_file_instance(const char *name,
00417                                    const oid * reg_oid, size_t reg_oid_len,
00418                                    const char *file_name, int asn_type, int mode,
00419                                    Netsnmp_Node_Handler * subhandler,
00420                                    const char *contextName)
00421 {
00422     netsnmp_handler_registration *myreg;
00423     netsnmp_num_file_instance *nfi;
00424 
00425     if ((NULL == name) || (NULL == reg_oid) || (NULL == file_name)) {
00426         snmp_log(LOG_ERR, "bad parameter to netsnmp_register_num_file_instance\n");
00427         return MIB_REGISTRATION_FAILED;
00428     }
00429 
00430     nfi = SNMP_MALLOC_TYPEDEF(netsnmp_num_file_instance);
00431     if ((NULL == nfi) ||
00432         (NULL == (nfi->file_name = strdup(file_name)))) {
00433         snmp_log(LOG_ERR, "could not not allocate memory\n");
00434         if (NULL != nfi)
00435             free(nfi); /* SNMP_FREE overkill on local var */
00436         return MIB_REGISTRATION_FAILED;
00437     }
00438 
00439     myreg = get_reg(name, "file_num_handler", reg_oid, reg_oid_len, nfi,
00440                     mode, netsnmp_instance_num_file_handler,
00441                     subhandler, contextName);
00442     if (NULL == myreg) {
00443         free(nfi); /* SNMP_FREE overkill on local var */
00444         return MIB_REGISTRATION_FAILED;
00445     }
00446 
00447     nfi->type = asn_type;
00448 
00449     if (HANDLER_CAN_RONLY == mode)
00450         return netsnmp_register_read_only_instance(myreg);
00451 
00452     return netsnmp_register_instance(myreg);
00453 }
00454 
00473 int
00474 netsnmp_register_int_instance(const char *name,
00475                               const oid * reg_oid, size_t reg_oid_len,
00476                               int *it, Netsnmp_Node_Handler * subhandler)
00477 {
00478     return netsnmp_register_watched_instance(
00479                netsnmp_create_handler_registration(
00480                    name, subhandler, reg_oid, reg_oid_len, HANDLER_CAN_RWRITE),
00481                netsnmp_create_watcher_info(
00482                    (void *)it, sizeof(int), ASN_INTEGER, WATCHER_FIXED_SIZE));
00483 }
00484 
00485 #ifndef NETSNMP_NO_DEPRECATED_FUNCTIONS
00486 
00490 int
00491 netsnmp_instance_ulong_handler(netsnmp_mib_handler *handler,
00492                                netsnmp_handler_registration *reginfo,
00493                                netsnmp_agent_request_info *reqinfo,
00494                                netsnmp_request_info *requests)
00495 {
00496 
00497     u_long         *it = (u_long *) handler->myvoid;
00498     u_long         *it_save;
00499 
00500     DEBUGMSGTL(("netsnmp_instance_ulong_handler", "Got request:  %d\n",
00501                 reqinfo->mode));
00502 
00503     switch (reqinfo->mode) {
00504         /*
00505          * data requests 
00506          */
00507     case MODE_GET:
00508         snmp_set_var_typed_value(requests->requestvb, ASN_UNSIGNED,
00509                                  (u_char *) it, sizeof(*it));
00510         break;
00511 
00512         /*
00513          * SET requests.  Should only get here if registered RWRITE 
00514          */
00515     case MODE_SET_RESERVE1:
00516         if (requests->requestvb->type != ASN_UNSIGNED)
00517             netsnmp_set_request_error(reqinfo, requests,
00518                                       SNMP_ERR_WRONGTYPE);
00519         break;
00520 
00521     case MODE_SET_RESERVE2:
00522         /*
00523          * store old info for undo later 
00524          */
00525         memdup((u_char **) & it_save, (u_char *) it, sizeof(u_long));
00526         if (it_save == NULL) {
00527             netsnmp_set_request_error(reqinfo, requests,
00528                                       SNMP_ERR_RESOURCEUNAVAILABLE);
00529             return SNMP_ERR_NOERROR;
00530         }
00531         netsnmp_request_add_list_data(requests,
00532                                       netsnmp_create_data_list
00533                                       (INSTANCE_HANDLER_NAME, it_save,
00534                                        free));
00535         break;
00536 
00537     case MODE_SET_ACTION:
00538         /*
00539          * update current 
00540          */
00541         DEBUGMSGTL(("testhandler", "updated u_long %lu -> %lu\n", *it,
00542                     *(requests->requestvb->val.integer)));
00543         *it = *(requests->requestvb->val.integer);
00544         break;
00545 
00546     case MODE_SET_UNDO:
00547         *it =
00548             *((u_long *) netsnmp_request_get_list_data(requests,
00549                                                        INSTANCE_HANDLER_NAME));
00550         break;
00551 
00552     case MODE_SET_COMMIT:
00553     case MODE_SET_FREE:
00554         /*
00555          * nothing to do 
00556          */
00557         break;
00558     }
00559 
00560     if (handler->next && handler->next->access_method)
00561         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00562                                          requests);
00563 
00564     return SNMP_ERR_NOERROR;
00565 }
00566 
00570 int
00571 netsnmp_instance_counter32_handler(netsnmp_mib_handler *handler,
00572                                    netsnmp_handler_registration *reginfo,
00573                                    netsnmp_agent_request_info *reqinfo,
00574                                    netsnmp_request_info *requests)
00575 {
00576 
00577     u_long         *it = (u_long *) handler->myvoid;
00578 
00579     DEBUGMSGTL(("netsnmp_instance_counter32_handler",
00580                 "Got request:  %d\n", reqinfo->mode));
00581 
00582     switch (reqinfo->mode) {
00583         /*
00584          * data requests 
00585          */
00586     case MODE_GET:
00587         snmp_set_var_typed_value(requests->requestvb, ASN_COUNTER,
00588                                  (u_char *) it, sizeof(*it));
00589         break;
00590 
00591         /*
00592          * SET requests.  Should only get here if registered RWRITE 
00593          */
00594     default:
00595         snmp_log(LOG_ERR,
00596                  "netsnmp_instance_counter32_handler: illegal mode\n");
00597         netsnmp_set_request_error(reqinfo, requests, SNMP_ERR_GENERR);
00598         return SNMP_ERR_NOERROR;
00599     }
00600     if (handler->next && handler->next->access_method)
00601         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00602                                          requests);
00603     return SNMP_ERR_NOERROR;
00604 }
00605 
00609 int
00610 netsnmp_instance_long_handler(netsnmp_mib_handler *handler,
00611                               netsnmp_handler_registration *reginfo,
00612                               netsnmp_agent_request_info *reqinfo,
00613                               netsnmp_request_info *requests)
00614 {
00615 
00616     long           *it = (long *) handler->myvoid;
00617     long           *it_save;
00618 
00619     DEBUGMSGTL(("netsnmp_instance_long_handler", "Got request:  %d\n",
00620                 reqinfo->mode));
00621 
00622     switch (reqinfo->mode) {
00623         /*
00624          * data requests 
00625          */
00626     case MODE_GET:
00627         snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
00628                                  (u_char *) it, sizeof(*it));
00629         break;
00630 
00631         /*
00632          * SET requests.  Should only get here if registered RWRITE 
00633          */
00634     case MODE_SET_RESERVE1:
00635         if (requests->requestvb->type != ASN_INTEGER)
00636             netsnmp_set_request_error(reqinfo, requests,
00637                                       SNMP_ERR_WRONGTYPE);
00638         break;
00639 
00640     case MODE_SET_RESERVE2:
00641         /*
00642          * store old info for undo later 
00643          */
00644         memdup((u_char **) & it_save, (u_char *) it, sizeof(long));
00645         if (it_save == NULL) {
00646             netsnmp_set_request_error(reqinfo, requests,
00647                                       SNMP_ERR_RESOURCEUNAVAILABLE);
00648             return SNMP_ERR_NOERROR;
00649         }
00650         netsnmp_request_add_list_data(requests,
00651                                       netsnmp_create_data_list
00652                                       (INSTANCE_HANDLER_NAME, it_save,
00653                                        free));
00654         break;
00655 
00656     case MODE_SET_ACTION:
00657         /*
00658          * update current 
00659          */
00660         DEBUGMSGTL(("testhandler", "updated u_long %lu -> %lu\n", *it,
00661                     *(requests->requestvb->val.integer)));
00662         *it = *(requests->requestvb->val.integer);
00663         break;
00664 
00665     case MODE_SET_UNDO:
00666         *it =
00667             *((u_long *) netsnmp_request_get_list_data(requests,
00668                                                        INSTANCE_HANDLER_NAME));
00669         break;
00670 
00671     case MODE_SET_COMMIT:
00672     case MODE_SET_FREE:
00673         /*
00674          * nothing to do 
00675          */
00676         break;
00677     }
00678     if (handler->next && handler->next->access_method)
00679         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00680                                          requests);
00681     return SNMP_ERR_NOERROR;
00682 }
00683 
00687 int
00688 netsnmp_instance_int_handler(netsnmp_mib_handler *handler,
00689                              netsnmp_handler_registration *reginfo,
00690                              netsnmp_agent_request_info *reqinfo,
00691                              netsnmp_request_info *requests)
00692 {
00693 
00694     int *it = (int *) handler->myvoid;
00695     int *it_save;
00696     long tmp_it;
00697     
00698     DEBUGMSGTL(("netsnmp_instance_int_handler", "Got request:  %d\n",
00699                 reqinfo->mode));
00700 
00701     switch (reqinfo->mode) {
00702         /*
00703          * data requests 
00704          */
00705     case MODE_GET:
00706         /*
00707          * Use a long here, otherwise on 64 bit use of an int would fail
00708          */
00709         tmp_it = *it;
00710         snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
00711                                  (u_char *) &tmp_it, sizeof(tmp_it));
00712         break;
00713 
00714         /*
00715          * SET requests.  Should only get here if registered RWRITE 
00716          */
00717     case MODE_SET_RESERVE1:
00718         if (requests->requestvb->type != ASN_INTEGER)
00719             netsnmp_set_request_error(reqinfo, requests,
00720                                       SNMP_ERR_WRONGTYPE);
00721         break;
00722 
00723     case MODE_SET_RESERVE2:
00724         /*
00725          * store old info for undo later 
00726          */
00727         memdup((u_char **) & it_save, (u_char *) it, sizeof(int));
00728         if (it_save == NULL) {
00729             netsnmp_set_request_error(reqinfo, requests,
00730                                       SNMP_ERR_RESOURCEUNAVAILABLE);
00731             return SNMP_ERR_NOERROR;
00732         }
00733         netsnmp_request_add_list_data(requests,
00734                                       netsnmp_create_data_list
00735                                       (INSTANCE_HANDLER_NAME, it_save,
00736                                        free));
00737         break;
00738 
00739     case MODE_SET_ACTION:
00740         /*
00741          * update current 
00742          */
00743         DEBUGMSGTL(("testhandler", "updated int %d -> %ld\n", *it,
00744                     *(requests->requestvb->val.integer)));
00745         *it = (int) *(requests->requestvb->val.integer);
00746         break;
00747 
00748     case MODE_SET_UNDO:
00749         *it =
00750             *((u_int *) netsnmp_request_get_list_data(requests,
00751                                                       INSTANCE_HANDLER_NAME));
00752         break;
00753 
00754     case MODE_SET_COMMIT:
00755     case MODE_SET_FREE:
00756         /*
00757          * nothing to do 
00758          */
00759         break;
00760     }
00761     if (handler->next && handler->next->access_method)
00762         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00763                                          requests);
00764     return SNMP_ERR_NOERROR;
00765 }
00766 
00767 #endif /* NETSNMP_NO_DEPRECATED_FUNCTIONS */
00768 
00769 int
00770 netsnmp_instance_num_file_handler(netsnmp_mib_handler *handler,
00771                                   netsnmp_handler_registration *reginfo,
00772                                   netsnmp_agent_request_info *reqinfo,
00773                                   netsnmp_request_info *requests)
00774 {
00775     netsnmp_num_file_instance *nfi;
00776     u_long it, *it_save;
00777     int rc;
00778 
00779     netsnmp_assert(NULL != handler);
00780     nfi = (netsnmp_num_file_instance *)handler->myvoid;
00781     netsnmp_assert(NULL != nfi);
00782     netsnmp_assert(NULL != nfi->file_name);
00783 
00784     DEBUGMSGTL(("netsnmp_instance_int_handler", "Got request:  %d\n",
00785                 reqinfo->mode));
00786 
00787     switch (reqinfo->mode) {
00788         /*
00789          * data requests 
00790          */
00791     case MODE_GET:
00792         /*
00793          * Use a long here, otherwise on 64 bit use of an int would fail
00794          */
00795         netsnmp_assert(NULL == nfi->filep);
00796         nfi->filep = fopen(nfi->file_name, "r");
00797         if (NULL == nfi->filep) {
00798             netsnmp_set_request_error(reqinfo, requests,
00799                                       SNMP_NOSUCHINSTANCE);
00800             return SNMP_ERR_NOERROR;
00801         }
00802         rc = fscanf(nfi->filep, (nfi->type == ASN_INTEGER) ? "%ld" : "%lu",
00803                     &it);
00804         fclose(nfi->filep);
00805         nfi->filep = NULL;
00806         if (rc != 1) {
00807             netsnmp_set_request_error(reqinfo, requests,
00808                                       SNMP_NOSUCHINSTANCE);
00809             return SNMP_ERR_NOERROR;
00810         }
00811         snmp_set_var_typed_value(requests->requestvb, nfi->type,
00812                                  (u_char *) &it, sizeof(it));
00813         break;
00814 
00815         /*
00816          * SET requests.  Should only get here if registered RWRITE 
00817          */
00818     case MODE_SET_RESERVE1:
00819         netsnmp_assert(NULL == nfi->filep);
00820         if (requests->requestvb->type != nfi->type)
00821             netsnmp_set_request_error(reqinfo, requests,
00822                                       SNMP_ERR_WRONGTYPE);
00823         break;
00824 
00825     case MODE_SET_RESERVE2:
00826         netsnmp_assert(NULL == nfi->filep);
00827         nfi->filep = fopen(nfi->file_name, "w+");
00828         if (NULL == nfi->filep) {
00829             netsnmp_set_request_error(reqinfo, requests,
00830                                       SNMP_ERR_NOTWRITABLE);
00831             return SNMP_ERR_NOERROR;
00832         }
00833         /*
00834          * store old info for undo later 
00835          */
00836         if (fscanf(nfi->filep, (nfi->type == ASN_INTEGER) ? "%ld" : "%lu",
00837                    &it) != 1) {
00838             netsnmp_set_request_error(reqinfo, requests,
00839                                       SNMP_ERR_RESOURCEUNAVAILABLE);
00840             return SNMP_ERR_NOERROR;
00841         }
00842 
00843         memdup((u_char **) & it_save, (u_char *)&it, sizeof(u_long));
00844         if (it_save == NULL) {
00845             netsnmp_set_request_error(reqinfo, requests,
00846                                       SNMP_ERR_RESOURCEUNAVAILABLE);
00847             return SNMP_ERR_NOERROR;
00848         }
00849         netsnmp_request_add_list_data(requests,
00850                                       netsnmp_create_data_list
00851                                       (INSTANCE_HANDLER_NAME, it_save,
00852                                        free));
00853         break;
00854 
00855     case MODE_SET_ACTION:
00856         /*
00857          * update current 
00858          */
00859         DEBUGMSGTL(("helper:instance", "updated %s -> %ld\n", nfi->file_name,
00860                     *(requests->requestvb->val.integer)));
00861         it = *(requests->requestvb->val.integer);
00862         rewind(nfi->filep); /* rewind to make sure we are at the beginning */
00863         rc = fprintf(nfi->filep, (nfi->type == ASN_INTEGER) ? "%ld" : "%lu",
00864                      it);
00865         if (rc < 0) {
00866             netsnmp_set_request_error(reqinfo, requests,
00867                                       SNMP_ERR_GENERR);
00868             return SNMP_ERR_NOERROR;
00869         }
00870         break;
00871 
00872     case MODE_SET_UNDO:
00873         it =
00874             *((u_int *) netsnmp_request_get_list_data(requests,
00875                                                       INSTANCE_HANDLER_NAME));
00876         rc = fprintf(nfi->filep, (nfi->type == ASN_INTEGER) ? "%ld" : "%lu",
00877                      it);
00878         if (rc < 0)
00879             netsnmp_set_request_error(reqinfo, requests,
00880                                       SNMP_ERR_UNDOFAILED);
00883     case MODE_SET_COMMIT:
00884     case MODE_SET_FREE:
00885         if (NULL != nfi->filep) {
00886             fclose(nfi->filep);
00887             nfi->filep = NULL;
00888         }
00889         break;
00890     }
00891 
00892     if (handler->next && handler->next->access_method)
00893         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00894                                          requests);
00895     return SNMP_ERR_NOERROR;
00896 }
00897 
00898 #ifndef NETSNMP_NO_DEPRECATED_FUNCTIONS
00899 
00903 int
00904 netsnmp_instance_uint_handler(netsnmp_mib_handler *handler,
00905                               netsnmp_handler_registration *reginfo,
00906                               netsnmp_agent_request_info *reqinfo,
00907                               netsnmp_request_info *requests)
00908 {
00909 
00910     unsigned int *it = (unsigned int *) handler->myvoid;
00911     unsigned int *it_save;
00912     unsigned long tmp_it;
00913     
00914     DEBUGMSGTL(("netsnmp_instance_uint_handler", "Got request:  %d\n",
00915                 reqinfo->mode));
00916 
00917     switch (reqinfo->mode) {
00918         /*
00919          * data requests 
00920          */
00921     case MODE_GET:
00922         /*
00923          * Use a long here, otherwise on 64 bit use of an int would fail
00924          */
00925         tmp_it = *it;
00926         snmp_set_var_typed_value(requests->requestvb, ASN_UNSIGNED,
00927                                  (u_char *) &tmp_it, sizeof(unsigned long));
00928         break;
00929 
00930         /*
00931          * SET requests.  Should only get here if registered RWRITE 
00932          */
00933     case MODE_SET_RESERVE1:
00934         if (requests->requestvb->type != ASN_UNSIGNED)
00935             netsnmp_set_request_error(reqinfo, requests,
00936                                       SNMP_ERR_WRONGTYPE);
00937         break;
00938 
00939     case MODE_SET_RESERVE2:
00940         /*
00941          * store old info for undo later 
00942          */
00943         memdup((u_char **) & it_save, (u_char *) it, sizeof(u_int));
00944         if (it_save == NULL) {
00945             netsnmp_set_request_error(reqinfo, requests,
00946                                       SNMP_ERR_RESOURCEUNAVAILABLE);
00947             return SNMP_ERR_NOERROR;
00948         }
00949         netsnmp_request_add_list_data(requests,
00950                                       netsnmp_create_data_list
00951                                       (INSTANCE_HANDLER_NAME, it_save,
00952                                        free));
00953         break;
00954 
00955     case MODE_SET_ACTION:
00956         /*
00957          * update current 
00958          */
00959         DEBUGMSGTL(("testhandler", "updated uint %d -> %ld\n", *it,
00960                     *(requests->requestvb->val.integer)));
00961         *it = (unsigned int) *(requests->requestvb->val.integer);
00962         break;
00963 
00964     case MODE_SET_UNDO:
00965         *it =
00966             *((u_int *) netsnmp_request_get_list_data(requests,
00967                                                       INSTANCE_HANDLER_NAME));
00968         break;
00969 
00970     case MODE_SET_COMMIT:
00971     case MODE_SET_FREE:
00972         /*
00973          * nothing to do 
00974          */
00975         break;
00976     }
00977     if (handler->next && handler->next->access_method)
00978         return netsnmp_call_next_handler(handler, reginfo, reqinfo,
00979                                          requests);
00980     return SNMP_ERR_NOERROR;
00981 }
00982 
00983 #endif /* NETSNMP_NO_DEPRECATED_FUNCTIONS */
00984 
00985 int
00986 netsnmp_instance_helper_handler(netsnmp_mib_handler *handler,
00987                                 netsnmp_handler_registration *reginfo,
00988                                 netsnmp_agent_request_info *reqinfo,
00989                                 netsnmp_request_info *requests)
00990 {
00991 
00992     netsnmp_variable_list *var = requests->requestvb;
00993 
00994     int             ret, cmp;
00995 
00996     DEBUGMSGTL(("helper:instance", "Got request:\n"));
00997     cmp = snmp_oid_compare(requests->requestvb->name,
00998                            requests->requestvb->name_length,
00999                            reginfo->rootoid, reginfo->rootoid_len);
01000 
01001     DEBUGMSGTL(("helper:instance", "  oid:"));
01002     DEBUGMSGOID(("helper:instance", var->name, var->name_length));
01003     DEBUGMSG(("helper:instance", "\n"));
01004 
01005     switch (reqinfo->mode) {
01006     case MODE_GET:
01007         if (cmp != 0) {
01008             netsnmp_set_request_error(reqinfo, requests,
01009                                       SNMP_NOSUCHINSTANCE);
01010             return SNMP_ERR_NOERROR;
01011         } else {
01012             return netsnmp_call_next_handler(handler, reginfo, reqinfo,
01013                                              requests);
01014         }
01015         break;
01016 
01017     case MODE_SET_RESERVE1:
01018     case MODE_SET_RESERVE2:
01019     case MODE_SET_ACTION:
01020     case MODE_SET_COMMIT:
01021     case MODE_SET_UNDO:
01022     case MODE_SET_FREE:
01023         if (cmp != 0) {
01024             netsnmp_set_request_error(reqinfo, requests,
01025                                       SNMP_ERR_NOCREATION);
01026             return SNMP_ERR_NOERROR;
01027         } else {
01028             return netsnmp_call_next_handler(handler, reginfo, reqinfo,
01029                                              requests);
01030         }
01031         break;
01032 
01033     case MODE_GETNEXT:
01034         if (cmp < 0 || (cmp == 0 && requests->inclusive)) {
01035             reqinfo->mode = MODE_GET;
01036             snmp_set_var_objid(requests->requestvb, reginfo->rootoid,
01037                                reginfo->rootoid_len);
01038             ret =
01039                 netsnmp_call_next_handler(handler, reginfo, reqinfo,
01040                                           requests);
01041             reqinfo->mode = MODE_GETNEXT;
01042             /*
01043              * if the instance doesn't have data, set type to ASN_NULL
01044              * to move to the next sub-tree. Ignore delegated requests; they
01045              * might have data later on.
01046              */
01047             if (!requests->delegated &&
01048                 (requests->requestvb->type == SNMP_NOSUCHINSTANCE ||
01049                  requests->requestvb->type == SNMP_NOSUCHOBJECT)) {
01050                 requests->requestvb->type = ASN_NULL;
01051             }
01052             return ret;
01053         } else {
01054             return SNMP_ERR_NOERROR;
01055         }
01056         break;
01057     }
01058     /*
01059      * got here only if illegal mode found 
01060      */
01061     return SNMP_ERR_GENERR;
01062 }
01063