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

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

SNMP编程

开发平台：

Unix_Linux

extend.c：源码内容
  2. #include <net-snmp/net-snmp-config.h>
  3. #include <net-snmp/net-snmp-includes.h>
  4. #include <net-snmp/agent/net-snmp-agent-includes.h>
  5. #include <net-snmp/agent/watcher.h>
  7. #include "agent/extend.h"
  8. #include "utilities/execute.h"
  9. #include "struct.h"
  11. #ifndef USING_UCD_SNMP_EXTENSIBLE_MODULE
  12. #include "util_funcs.h"
  13. #include "mibdefs.h"
  14. #define SHELLCOMMAND 3
  15. #endif
  17. oid  ns_extend_oid[]    = { 1, 3, 6, 1, 4, 1, 8072, 1, 3, 2 };
  18. oid  extend_count_oid[] = { 1, 3, 6, 1, 4, 1, 8072, 1, 3, 2, 1 };
  19. oid  extend_config_oid[] = { 1, 3, 6, 1, 4, 1, 8072, 1, 3, 2, 2 };
  20. oid  extend_out1_oid[]  = { 1, 3, 6, 1, 4, 1, 8072, 1, 3, 2, 3 };
  21. oid  extend_out2_oid[]  = { 1, 3, 6, 1, 4, 1, 8072, 1, 3, 2, 4 };
  23. typedef struct extend_registration_block_s {
  24.     netsnmp_table_data *dinfo;
  25.     oid                *root_oid;
  26.     size_t              oid_len;
  27.     long                num_entries;
  28.     netsnmp_extend     *ehead;
  29.     struct extend_registration_block_s *next;
  30. } extend_registration_block;
  31. extend_registration_block *ereg_head = NULL;
  34. #ifndef USING_UCD_SNMP_EXTENSIBLE_MODULE
  35. typedef struct netsnmp_old_extend_s {
  36.     int idx;
  37.     netsnmp_extend *exec_entry;
  38.     netsnmp_extend *efix_entry;
  39. } netsnmp_old_extend;
  41. int             num_compatability_entries = 0;
  42. int             max_compatability_entries = 50;
  43. netsnmp_old_extend *compatability_entries;
  45. WriteMethod fixExec2Error;
  46. FindVarMethod var_extensible_old;
  47. oid  old_extensible_variables_oid[] = { UCDAVIS_MIB, SHELLMIBNUM, 1 };
  48. struct variable2 old_extensible_variables[] = {
  49.     {MIBINDEX,     ASN_INTEGER,   RONLY, var_extensible_old, 1, {MIBINDEX}},
  50.     {ERRORNAME,    ASN_OCTET_STR, RONLY, var_extensible_old, 1, {ERRORNAME}},
  51.     {SHELLCOMMAND, ASN_OCTET_STR, RONLY, var_extensible_old, 1, {SHELLCOMMAND}},
  52.     {ERRORFLAG,    ASN_INTEGER,   RONLY, var_extensible_old, 1, {ERRORFLAG}},
  53.     {ERRORMSG,     ASN_OCTET_STR, RONLY, var_extensible_old, 1, {ERRORMSG}},
  54.     {ERRORFIX,     ASN_INTEGER,  RWRITE, var_extensible_old, 1, {ERRORFIX}},
  55.     {ERRORFIXCMD,  ASN_OCTET_STR, RONLY, var_extensible_old, 1, {ERRORFIXCMD}}
  56. };
  57. #endif
  60.         /*************************
  61.          *
  62.          *  Main initialisation routine
  63.          *
  64.          *************************/
  66. extend_registration_block *
  67. _find_extension_block( oid *name, size_t name_len )
  68. {
  69.     extend_registration_block         *eptr;
  70.     size_t len;
  71.     for ( eptr=ereg_head; eptr; eptr=eptr->next ) {
  72.         len = SNMP_MIN(name_len, eptr->oid_len);
  73.         if (!snmp_oid_compare( name, len, eptr->root_oid, eptr->oid_len))
  74.             return eptr;
  75.     }
  76.     return NULL;
  77. }
  79. extend_registration_block *
  80. _register_extend( oid *base, size_t len )
  81. {
  82.     extend_registration_block         *eptr;
  83.     oid oid_buf[MAX_OID_LEN];
  85.     netsnmp_table_data                *dinfo;
  86.     netsnmp_table_registration_info   *tinfo;
  87.     netsnmp_watcher_info              *winfo;
  88.     netsnmp_handler_registration      *reg;
  90.     for ( eptr=ereg_head; eptr; eptr=eptr->next ) {
  91.         if (!snmp_oid_compare( base, len, eptr->root_oid, eptr->oid_len))
  92.             return eptr;
  93.     }
  94.     if (!eptr) {
  95.         eptr = SNMP_MALLOC_TYPEDEF( extend_registration_block );
  96.         eptr->root_oid = snmp_duplicate_objid( base, len );
  97.         eptr->oid_len  = len;
  98.         eptr->num_entries = 0;
  99.         eptr->ehead       = NULL;
  100.         eptr->dinfo       = netsnmp_create_table_data( "nsExtendTable" );
  101.         eptr->next        = ereg_head;
  102.         ereg_head         = eptr;
  103.     }
  105.     dinfo = eptr->dinfo;
  106.     memcpy( oid_buf, base, len*sizeof(oid) );
  108.         /*
  109.          * Register the configuration table
  110.          */
  111.     tinfo = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info );
  112.     netsnmp_table_helper_add_indexes( tinfo, ASN_OCTET_STR, 0 );
  113.     tinfo->min_column = COLUMN_EXTCFG_FIRST_COLUMN;
  114.     tinfo->max_column = COLUMN_EXTCFG_LAST_COLUMN;
  115.     oid_buf[len] = 2;
  116.     reg   = netsnmp_create_handler_registration(
  117.                 "nsExtendConfigTable", handle_nsExtendConfigTable, 
  118.                 oid_buf, len+1, HANDLER_CAN_RWRITE);
  119.     netsnmp_register_table_data( reg, dinfo, tinfo );
  121.         /*
  122.          * Register the main output table
  123.          *   using the same table_data handle.
  124.          * This is sufficient to link the two tables,
  125.          *   and implement the AUGMENTS behaviour
  126.          */
  127.     tinfo = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info );
  128.     netsnmp_table_helper_add_indexes( tinfo, ASN_OCTET_STR, 0 );
  129.     tinfo->min_column = COLUMN_EXTOUT1_FIRST_COLUMN;
  130.     tinfo->max_column = COLUMN_EXTOUT1_LAST_COLUMN;
  131.     oid_buf[len] = 3;
  132.     reg   = netsnmp_create_handler_registration(
  133.                 "nsExtendOut1Table", handle_nsExtendOutput1Table, 
  134.                 oid_buf, len+1, HANDLER_CAN_RONLY);
  135.     netsnmp_register_table_data( reg, dinfo, tinfo );
  137.         /*
  138.          * Register the multi-line output table
  139.          *   using a simple table helper.
  140.          * This handles extracting the indexes from
  141.          *   the request OID, but leaves most of
  142.          *   the work to our handler routine.
  143.          * Still, it was nice while it lasted...
  144.          */
  145.     tinfo = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info );
  146.     netsnmp_table_helper_add_indexes( tinfo, ASN_OCTET_STR, ASN_INTEGER, 0 );
  147.     tinfo->min_column = COLUMN_EXTOUT2_FIRST_COLUMN;
  148.     tinfo->max_column = COLUMN_EXTOUT2_LAST_COLUMN;
  149.     oid_buf[len] = 4;
  150.     reg   = netsnmp_create_handler_registration(
  151.                 "nsExtendOut2Table", handle_nsExtendOutput2Table, 
  152.                 oid_buf, len+1, HANDLER_CAN_RONLY);
  153.     netsnmp_register_table( reg, tinfo );
  155.         /*
  156.          * Register a watched scalar to keep track of the number of entries
  157.          */
  158.     oid_buf[len] = 1;
  159.     reg   = netsnmp_create_handler_registration(
  160.                 "nsExtendNumEntries", NULL, 
  161.                 oid_buf, len+1, HANDLER_CAN_RONLY);
  162.     winfo = netsnmp_create_watcher_info(
  163.                 &(eptr->num_entries), sizeof(eptr->num_entries),
  164.                 ASN_INTEGER, WATCHER_FIXED_SIZE);
  165.     netsnmp_register_watched_scalar( reg, winfo );
  167.     return eptr;
  168. }
  170. void init_extend( void )
  171. {
  172.     snmpd_register_config_handler("extend",    extend_parse_config, NULL, NULL);
  173.     snmpd_register_config_handler("extend-sh", extend_parse_config, NULL, NULL);
  174.     snmpd_register_config_handler("extendfix", extend_parse_config, NULL, NULL);
  175.     snmpd_register_config_handler("exec2", extend_parse_config, NULL, NULL);
  176.     snmpd_register_config_handler("sh2",   extend_parse_config, NULL, NULL);
  177.     snmpd_register_config_handler("execFix2", extend_parse_config, NULL, NULL);
  178.     (void)_register_extend( ns_extend_oid, OID_LENGTH(ns_extend_oid));
  180. #ifndef USING_UCD_SNMP_EXTENSIBLE_MODULE
  181.     snmpd_register_config_handler("exec", extend_parse_config, NULL, NULL);
  182.     snmpd_register_config_handler("sh",   extend_parse_config, NULL, NULL);
  183.     snmpd_register_config_handler("execFix", extend_parse_config, NULL, NULL);
  184.     compatability_entries = calloc( max_compatability_entries,
  185.                                     sizeof(netsnmp_old_extend));
  186.     REGISTER_MIB("ucd-extensible", old_extensible_variables,
  187.                  variable2, old_extensible_variables_oid);
  188. #endif
  189. }
  191.         /*************************
  192.          *
  193.          *  Cached-data hooks
  194.          *  see 'cache_handler' helper
  195.          *
  196.          *************************/
  198. int
  199. extend_load_cache(netsnmp_cache *cache, void *magic)
  200. {
  201.     int  out_len = 1024*100;
  202.     char out_buf[ 1024*100 ];
  203.     int  cmd_len = 255*2 + 2; /* 2 * DisplayStrings */
  204.     char cmd_buf[ 255*2 + 2 ];
  205.     int  ret;
  206.     char *cp;
  207.     char *line_buf[ 1024 ];
  208.     netsnmp_extend *extension = (netsnmp_extend *)magic;
  210.     if (!magic)
  211.         return -1;
  212.     DEBUGMSGTL(( "nsExtendTable:cache", "load %s", extension->token ));
  213.     if ( extension->args )
  214.         snprintf( cmd_buf, cmd_len, "%s %s", extension->command, extension->args );
  215.     else 
  216.         snprintf( cmd_buf, cmd_len, "%s", extension->command );
  217.     if ( extension->flags & NS_EXTEND_FLAGS_SHELL )
  218.         ret = run_shell_command( cmd_buf, extension->input, out_buf, &out_len);
  219.     else
  220.         ret = run_exec_command(  cmd_buf, extension->input, out_buf, &out_len);
  221.     DEBUGMSG(( "nsExtendTable:cache", ": %s : %dn", cmd_buf, ret));
  222.     if (ret >= 0) {
  223.         if (out_buf[   out_len-1 ] == 'n')
  224.             out_buf[ --out_len   ] =  ''; /* Stomp on trailing newline */
  225.         extension->output   = strdup( out_buf );
  226.         extension->out_len  = out_len;
  227.         /*
  228.          * Now we need to pick the output apart into separate lines.
  229.          * Start by counting how many lines we've got, and keeping
  230.          * track of where each line starts in a static buffer
  231.          */
  232.         extension->numlines = 1;
  233.         line_buf[ 0 ] = extension->output;
  234.         for (cp=extension->output; *cp; cp++) {
  235.             if (*cp == 'n') {
  236.                 line_buf[ extension->numlines++ ] = cp+1;
  237.             }
  238.         }
  239.         if ( extension->numlines > 1 ) {
  240.             extension->lines = calloc( sizeof(char *), extension->numlines );
  241.             memcpy( extension->lines, line_buf,
  242.                                        sizeof(char *) * extension->numlines );
  243.         }
  244.     }
  245.     extension->result = ret;
  246.     return ret;
  247. }
  249. void
  250. extend_free_cache(netsnmp_cache *cache, void *magic)
  251. {
  252.     netsnmp_extend *extension = (netsnmp_extend *)magic;
  253.     if (!magic)
  254.         return;
  256.     DEBUGMSGTL(( "nsExtendTable:cache", "free %sn", extension->token ));
  257.     if (extension->output) {
  258.         SNMP_FREE(extension->output);
  259.         extension->output = NULL;
  260.     }
  261.     if (extension->lines) {
  262.         SNMP_FREE(extension->lines);
  263.         extension->lines  = NULL;
  264.     }
  265.     extension->out_len  = 0;
  266.     extension->numlines = 0;
  267. }
  270.         /*************************
  271.          *
  272.          *  Utility routines for setting up a new entry
  273.          *  (either via SET requests, or the config file)
  274.          *
  275.          *************************/
  277. void
  278. _free_extension( netsnmp_extend *extension, extend_registration_block *ereg )
  279. {
  280.     netsnmp_extend *eptr  = NULL;
  281.     netsnmp_extend *eprev = NULL;
  283.     if (!extension)
  284.         return;
  286.     if (ereg) {
  287.         /* Unlink from 'ehead' list */
  288.         for (eptr=ereg->ehead; eptr; eptr=eptr->next) {
  289.             if (eptr == extension)
  290.                 break;
  291.             eprev = eptr;
  292.         }
  293.         if (eprev)
  294.             eprev->next = eptr->next;
  295.         else
  296.             ereg->ehead = eptr->next;
  297.     }
  299.     netsnmp_table_data_remove_and_delete_row( ereg->dinfo, extension->row);
  300.     SNMP_FREE( extension->token );
  301.     SNMP_FREE( extension->cache );
  302.     SNMP_FREE( extension->command );
  303.     SNMP_FREE( extension->args  );
  304.     SNMP_FREE( extension->input );
  305.     SNMP_FREE( extension );
  306.     return;
  307. }
  309. netsnmp_extend *
  310. _new_extension( char *exec_name, int exec_flags, extend_registration_block *ereg )
  311. {
  312.     netsnmp_extend     *extension;
  313.     netsnmp_table_row  *row;
  314.     netsnmp_extend     *eptr1, *eptr2; 
  315.     netsnmp_table_data *dinfo = ereg->dinfo;
  317.     if (!exec_name)
  318.         return NULL;
  319.     extension = SNMP_MALLOC_TYPEDEF( netsnmp_extend );
  320.     if (!extension)
  321.         return NULL;
  322.     extension->token    = strdup( exec_name );
  323.     extension->flags    = exec_flags;
  324.     extension->cache    = netsnmp_cache_create( 0, extend_load_cache,
  325.                                                    extend_free_cache, NULL, 0 );
  326.     if (extension->cache)
  327.         extension->cache->magic = extension;
  329.     row = netsnmp_create_table_data_row();
  330.     if (!row || !extension->cache) {
  331.         _free_extension( extension, ereg );
  332.         SNMP_FREE( row );
  333.         return NULL;
  334.     }
  335.     row->data = (void *)extension;
  336.     extension->row = row;
  337.     netsnmp_table_row_add_index( row, ASN_OCTET_STR,
  338.                                  exec_name, strlen(exec_name));
  339.     netsnmp_table_data_add_row( dinfo, row);
  341.     ereg->num_entries++;
  342.         /*
  343.          *  Now add this structure to a private linked list.
  344.          *  We don't need this for the main tables - the
  345.          *   'table_data' helper will take care of those.
  346.          *  But it's probably easier to handle the multi-line
  347.          *  output table ourselves, for which we need access
  348.          *  to the underlying data.
  349.          *   So we'll keep a list internally as well.
  350.          */
  351.     for ( eptr1 = ereg->ehead, eptr2 = NULL;
  352.           eptr1;
  353.           eptr2 = eptr1, eptr1 = eptr1->next ) {
  355.         if (strlen( eptr1->token )  > strlen( exec_name ))
  356.             break;
  357.         if (strlen( eptr1->token ) == strlen( exec_name ) &&
  358.             strcmp( eptr1->token, exec_name ) > 0 )
  359.             break;
  360.     }
  361.     if ( eptr2 )
  362.         eptr2->next = extension;
  363.     else
  364.         ereg->ehead = extension;
  365.     extension->next = eptr1;
  366.     return extension;
  367. }
  369. void
  370. extend_parse_config(const char *token, char *cptr)
  371. {
  372.     netsnmp_extend *extension;
  373.     char exec_name[STRMAX];
  374.     char exec_command[STRMAX];
  375.     oid  oid_buf[MAX_OID_LEN];
  376.     size_t oid_len;
  377.     extend_registration_block *eptr;
  378.     int  flags;
  380.     cptr = copy_nword(cptr, exec_name,    sizeof(exec_name));
  381.     if ( *exec_name == '.' ) {
  382.         oid_len = MAX_OID_LEN;
  383.         read_objid( exec_name, oid_buf, &oid_len );
  384.         cptr = copy_nword(cptr, exec_name,    sizeof(exec_name));
  385.     } else {
  386.         memcpy( oid_buf, ns_extend_oid, sizeof(ns_extend_oid));
  387.         oid_len = OID_LENGTH(ns_extend_oid);
  388.     }
  389.     cptr = copy_nword(cptr, exec_command, sizeof(exec_command));
  390.     /* XXX - check 'exec_command' exists & is executable */
  391.     flags = (NS_EXTEND_FLAGS_ACTIVE | NS_EXTEND_FLAGS_CONFIG);
  392.     if (!strcmp( token, "sh"        ) ||
  393.         !strcmp( token, "extend-sh" ) ||
  394.         !strcmp( token, "sh2" ))
  395.         flags |= NS_EXTEND_FLAGS_SHELL;
  396.     if (!strcmp( token, "execFix"   ) ||
  397.         !strcmp( token, "extendfix" ) ||
  398.         !strcmp( token, "execFix2" )) {
  399.         strcat( exec_name, "Fix" );
  400.         flags |= NS_EXTEND_FLAGS_WRITEABLE;
  401.         /* XXX - Check for shell... */
  402.     }
  404.     eptr      = _register_extend( oid_buf, oid_len );
  405.     extension = _new_extension( exec_name, flags, eptr );
  406.     if (extension) {
  407.         extension->command  = strdup( exec_command );
  408.         if (cptr)
  409.             extension->args = strdup( cptr );
  410.     }
  412. #ifndef USING_UCD_SNMP_EXTENSIBLE_MODULE
  413.     /*
  414.      *  Compatability with the UCD extTable
  415.      */
  416.     if (!strcmp( token, "execFix"  )) {
  417.         int  i;
  418.         for ( i=0; i < num_compatability_entries; i++ ) {
  419.             if (!strcmp( exec_name,
  420.                     compatability_entries[i].exec_entry->token))
  421.                 break;
  422.         }
  423.         if ( i == num_compatability_entries )
  424.             config_perror("No matching exec entry" );
  425.         else
  426.             compatability_entries[ i ].efix_entry = extension;
  427.             
  428.     } else if (!strcmp( token, "sh"   ) ||
  429.                !strcmp( token, "exec" )) {
  430.         if ( num_compatability_entries == max_compatability_entries )
  431.             /* XXX - should really use dynamic allocation */
  432.             config_perror("No further UCD-compatible entries" );
  433.         else
  434.             compatability_entries[
  435.                 num_compatability_entries++ ].exec_entry = extension;
  436.     }
  437. #endif
  438. }
  440.         /*************************
  441.          *
  442.          *  Main table handlers
  443.          *  Most of the work is handled
  444.          *   by the 'table_data' helper.
  445.          *
  446.          *************************/
  448. int
  449. handle_nsExtendConfigTable(netsnmp_mib_handler          *handler,
  450.                      netsnmp_handler_registration *reginfo,
  451.                      netsnmp_agent_request_info   *reqinfo,
  452.                      netsnmp_request_info         *requests)
  453. {
  454.     netsnmp_request_info       *request;
  455.     netsnmp_table_request_info *table_info;
  456.     netsnmp_extend             *extension;
  457.     extend_registration_block  *eptr;
  458.     int  i;
  459.     int  need_to_validate = 0;
  461.     for ( request=requests; request; request=request->next ) {
  462.         if (request->processed)
  463.             continue;
  464.         table_info = netsnmp_extract_table_info( request );
  465.         extension  = (netsnmp_extend*)netsnmp_extract_table_row_data( request );
  467.         DEBUGMSGTL(( "nsExtendTable:config", "varbind: "));
  468.         DEBUGMSGOID(("nsExtendTable:config", request->requestvb->name,
  469.                                              request->requestvb->name_length));
  470.         DEBUGMSG((   "nsExtendTable:config", " (%s)n",
  471.                       se_find_label_in_slist("agent_mode", reqinfo->mode)));
  473.         switch (reqinfo->mode) {
  474.         case MODE_GET:
  475.             switch (table_info->colnum) {
  476.             case COLUMN_EXTCFG_COMMAND:
  477.                 snmp_set_var_typed_value(
  478.                      request->requestvb, ASN_OCTET_STR,
  479.                      extension->command,
  480.                     (extension->command)?strlen(extension->command):0);
  481.                 break;
  482.             case COLUMN_EXTCFG_ARGS:
  483.                 snmp_set_var_typed_value(
  484.                      request->requestvb, ASN_OCTET_STR,
  485.                      extension->args,
  486.                     (extension->args)?strlen(extension->args):0);
  487.                 break;
  488.             case COLUMN_EXTCFG_INPUT:
  489.                 snmp_set_var_typed_value(
  490.                      request->requestvb, ASN_OCTET_STR,
  491.                      extension->input,
  492.                     (extension->input)?strlen(extension->input):0);
  493.                 break;
  494.             case COLUMN_EXTCFG_CACHETIME:
  495.                 snmp_set_var_typed_value(
  496.                      request->requestvb, ASN_INTEGER,
  497.                     (u_char*)&extension->cache->timeout, sizeof(int));
  498.                 break;
  499.             case COLUMN_EXTCFG_EXECTYPE:
  500.                 i = ((extension->flags & NS_EXTEND_FLAGS_SHELL) ?
  501.                                          NS_EXTEND_ETYPE_SHELL :
  502.                                          NS_EXTEND_ETYPE_EXEC);
  503.                 snmp_set_var_typed_value(
  504.                      request->requestvb, ASN_INTEGER,
  505.                     (u_char*)&i, sizeof(i));
  506.                 break;
  507.             case COLUMN_EXTCFG_RUNTYPE:
  508.                 i = ((extension->flags & NS_EXTEND_FLAGS_WRITEABLE) ?
  509.                                          NS_EXTEND_RTYPE_RWRITE :
  510.                                          NS_EXTEND_RTYPE_RONLY);
  511.                 snmp_set_var_typed_value(
  512.                      request->requestvb, ASN_INTEGER,
  513.                     (u_char*)&i, sizeof(i));
  514.                 break;
  516.             case COLUMN_EXTCFG_STORAGE:
  517.                 i = ((extension->flags & NS_EXTEND_FLAGS_CONFIG) ?
  518.                                          ST_PERMANENT : ST_VOLATILE);
  519.                 snmp_set_var_typed_value(
  520.                      request->requestvb, ASN_INTEGER,
  521.                     (u_char*)&i, sizeof(i));
  522.                 break;
  523.             case COLUMN_EXTCFG_STATUS:
  524.                 i = ((extension->flags & NS_EXTEND_FLAGS_ACTIVE) ?
  525.                                          RS_ACTIVE :
  526.                                          RS_NOTINSERVICE);
  527.                 snmp_set_var_typed_value(
  528.                      request->requestvb, ASN_INTEGER,
  529.                     (u_char*)&i, sizeof(i));
  530.                 break;
  532.             default:
  533.                 netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  534.                 continue;
  535.             }
  536.             break;
  538.         /**********
  539.          *
  540.          * Start of SET handling
  541.          *
  542.          *   All config objects are potentially writable except
  543.          *     nsExtendStorage which is fixed as either 'permanent'
  544.          *     (if read from a config file) or 'volatile' (if set via SNMP)
  545.          *   The string-based settings of a 'permanent' entry cannot 
  546.          *     be changed - neither can the execution or run type.
  547.          *   Such entries can be (temporarily) marked as inactive,
  548.          *     and the cache timeout adjusted, but these changes are
  549.          *     not persistent.
  550.          *
  551.          **********/
  553.         case MODE_SET_RESERVE1:
  554.             /*
  555.              * Validate the new assignments
  556.              */
  557.             switch (table_info->colnum) {
  558.             case COLUMN_EXTCFG_COMMAND:
  559.                 if (request->requestvb->type != ASN_OCTET_STR) {
  560.                     netsnmp_set_request_error(reqinfo, request,
  561.                                               SNMP_ERR_WRONGTYPE);
  562.                     return SNMP_ERR_WRONGTYPE;
  563.                 }
  564.                 /*
  565.                  * Must have a full path to the command
  566.                  * XXX - Assumes Unix-style paths
  567.                  */
  568.                 if (request->requestvb->val_len == 0 ||
  569.                     request->requestvb->val.string[0] != '/') {
  570.                     netsnmp_set_request_error(reqinfo, request,
  571.                                               SNMP_ERR_WRONGVALUE);
  572.                     return SNMP_ERR_WRONGVALUE;
  573.                 }
  574.                 /*
  575.                  * XXX - need to check this file exists
  576.                  *       (and is executable)
  577.                  */
  579.                 if (extension && extension->flags & NS_EXTEND_FLAGS_CONFIG) {
  580.                     /*
  581.                      * config entries are "permanent" so can't be changed
  582.                      */
  583.                     netsnmp_set_request_error(reqinfo, request,
  584.                                               SNMP_ERR_NOTWRITABLE);
  585.                     return SNMP_ERR_NOTWRITABLE;
  586.                 }
  587.                 break;
  589.             case COLUMN_EXTCFG_ARGS:
  590.             case COLUMN_EXTCFG_INPUT:
  591.                 if (request->requestvb->type != ASN_OCTET_STR) {
  592.                     netsnmp_set_request_error(reqinfo, request,
  593.                                               SNMP_ERR_WRONGTYPE);
  594.                     return SNMP_ERR_WRONGTYPE;
  595.                 }
  597.                 if (extension && extension->flags & NS_EXTEND_FLAGS_CONFIG) {
  598.                     /*
  599.                      * config entries are "permanent" so can't be changed
  600.                      */
  601.                     netsnmp_set_request_error(reqinfo, request,
  602.                                               SNMP_ERR_NOTWRITABLE);
  603.                     return SNMP_ERR_NOTWRITABLE;
  604.                 }
  605.                 break;
  607.             case COLUMN_EXTCFG_CACHETIME:
  608.                 if (request->requestvb->type != ASN_INTEGER) {
  609.                     netsnmp_set_request_error(reqinfo, request,
  610.                                               SNMP_ERR_WRONGTYPE);
  611.                     return SNMP_ERR_WRONGTYPE;
  612.                 }
  613.                 i = *request->requestvb->val.integer;
  614.                 /*
  615.                  * -1 is a special value indicating "don't cache"
  616.                  *    [[ XXX - should this be 0 ?? ]]
  617.                  * Otherwise, cache times must be non-negative
  618.                  */
  619.                 if (i < -1 ) {
  620.                     netsnmp_set_request_error(reqinfo, request,
  621.                                               SNMP_ERR_WRONGVALUE);
  622.                     return SNMP_ERR_WRONGVALUE;
  623.                 }
  624.                 break;
  626.             case COLUMN_EXTCFG_EXECTYPE:
  627.                 if (request->requestvb->type != ASN_INTEGER) {
  628.                     netsnmp_set_request_error(reqinfo, request,
  629.                                               SNMP_ERR_WRONGTYPE);
  630.                     return SNMP_ERR_WRONGTYPE;
  631.                 }
  632.                 i = *request->requestvb->val.integer;
  633.                 if (i<1 || i>2) {  /* 'exec(1)' or 'shell(2)' only */
  634.                     netsnmp_set_request_error(reqinfo, request,
  635.                                               SNMP_ERR_WRONGVALUE);
  636.                     return SNMP_ERR_WRONGVALUE;
  637.                 }
  638.                 if (extension && extension->flags & NS_EXTEND_FLAGS_CONFIG) {
  639.                     /*
  640.                      * config entries are "permanent" so can't be changed
  641.                      */
  642.                     netsnmp_set_request_error(reqinfo, request,
  643.                                               SNMP_ERR_NOTWRITABLE);
  644.                     return SNMP_ERR_NOTWRITABLE;
  645.                 }
  646.                 break;
  648.             case COLUMN_EXTCFG_RUNTYPE:
  649.                 if (request->requestvb->type != ASN_INTEGER) {
  650.                     netsnmp_set_request_error(reqinfo, request,
  651.                                               SNMP_ERR_WRONGTYPE);
  652.                     return SNMP_ERR_WRONGTYPE;
  653.                 }
  654.                 /*
  655.                  * 'run-on-read(1)', 'run-on-set(2)'
  656.                  *  or 'run-command(3)' only
  657.                  */
  658.                 i = *request->requestvb->val.integer;
  659.                 if (i<1 || i>3) {
  660.                     netsnmp_set_request_error(reqinfo, request,
  661.                                               SNMP_ERR_WRONGVALUE);
  662.                     return SNMP_ERR_WRONGVALUE;
  663.                 }
  664.                 /*
  665.                  * 'run-command(3)' can only be used with
  666.                  *  a pre-existing 'run-on-set(2)' entry.
  667.                  */
  668.                 if (i==3 && !(extension && (extension->flags & NS_EXTEND_FLAGS_WRITEABLE))) {
  669.                     netsnmp_set_request_error(reqinfo, request,
  670.                                               SNMP_ERR_INCONSISTENTVALUE);
  671.                     return SNMP_ERR_INCONSISTENTVALUE;
  672.                 }
  673.                 /*
  674.                  * 'run-command(3)' is the only valid assignment
  675.                  *  for permanent (i.e. config) entries
  676.                  */
  677.                 if ((extension && extension->flags & NS_EXTEND_FLAGS_CONFIG)
  678.                     && i!=3 ) {
  679.                     netsnmp_set_request_error(reqinfo, request,
  680.                                               SNMP_ERR_INCONSISTENTVALUE);
  681.                     return SNMP_ERR_INCONSISTENTVALUE;
  682.                 }
  683.                 break;
  685.             case COLUMN_EXTCFG_STATUS:
  686.                 if (request->requestvb->type != ASN_INTEGER) {
  687.                     netsnmp_set_request_error(reqinfo, request,
  688.                                               SNMP_ERR_WRONGTYPE);
  689.                     return SNMP_ERR_WRONGTYPE;
  690.                 }
  691.                 i = *request->requestvb->val.integer;
  692.                 switch (i) {
  693.                 case RS_ACTIVE:
  694.                 case RS_NOTINSERVICE:
  695.                     if (!extension) {
  696.                         /* Must be used with existing rows */
  697.                         netsnmp_set_request_error(reqinfo, request,
  698.                                                   SNMP_ERR_INCONSISTENTVALUE);
  699.                         return SNMP_ERR_INCONSISTENTVALUE;
  700.                     }
  701.                     break;    /* OK */
  702.                 case RS_CREATEANDGO:
  703.                 case RS_CREATEANDWAIT:
  704.                     if (extension) {
  705.                         /* Can only be used to create new rows */
  706.                         netsnmp_set_request_error(reqinfo, request,
  707.                                                   SNMP_ERR_INCONSISTENTVALUE);
  708.                         return SNMP_ERR_INCONSISTENTVALUE;
  709.                     }
  710.                     break;
  711.                 case RS_DESTROY:
  712.                     break;
  713.                 default:
  714.                     netsnmp_set_request_error(reqinfo, request,
  715.                                               SNMP_ERR_WRONGVALUE);
  716.                     return SNMP_ERR_WRONGVALUE;
  717.                 }
  718.                 break;
  720.             default:
  721.                 netsnmp_set_request_error(reqinfo, request,
  722.                                           SNMP_ERR_NOTWRITABLE);
  723.                 return SNMP_ERR_NOTWRITABLE;
  724.             }
  725.             break;
  727.         case MODE_SET_RESERVE2:
  728.             switch (table_info->colnum) {
  729.             case COLUMN_EXTCFG_STATUS:
  730.                 i = *request->requestvb->val.integer;
  731.                 switch (i) {
  732.                 case RS_CREATEANDGO:
  733.                 case RS_CREATEANDWAIT:
  734.                     eptr = _find_extension_block( request->requestvb->name,
  735.                                                   request->requestvb->name_length );
  736.                     extension = _new_extension( table_info->indexes->val.string,
  737.                                                 0, eptr );
  738.                     if (!extension) {  /* failed */
  739.                         netsnmp_set_request_error(reqinfo, request,
  740.                                                   SNMP_ERR_RESOURCEUNAVAILABLE);
  741.                         return SNMP_ERR_RESOURCEUNAVAILABLE;
  742.                     }
  743.                     netsnmp_insert_table_row( request, extension->row );
  744.                 }
  745.             }
  746.             break;
  748.         case MODE_SET_FREE:
  749.             switch (table_info->colnum) {
  750.             case COLUMN_EXTCFG_STATUS:
  751.                 i = *request->requestvb->val.integer;
  752.                 switch (i) {
  753.                 case RS_CREATEANDGO:
  754.                 case RS_CREATEANDWAIT:
  755.                     eptr = _find_extension_block( request->requestvb->name,
  756.                                                   request->requestvb->name_length );
  757.                     _free_extension( extension, eptr );
  758.                 }
  759.             }
  760.             break;
  762.         case MODE_SET_ACTION:
  763.             switch (table_info->colnum) {
  764.             case COLUMN_EXTCFG_COMMAND:
  765.                 extension->old_command = extension->command;
  766.                 extension->command = netsnmp_strdup_and_null(
  767.                     request->requestvb->val.string,
  768.                     request->requestvb->val_len);
  769.                 break;
  770.             case COLUMN_EXTCFG_ARGS:
  771.                 extension->old_args = extension->args;
  772.                 extension->args = netsnmp_strdup_and_null(
  773.                     request->requestvb->val.string,
  774.                     request->requestvb->val_len);
  775.                 break;
  776.             case COLUMN_EXTCFG_INPUT:
  777.                 extension->old_input = extension->input;
  778.                 extension->input = netsnmp_strdup_and_null(
  779.                     request->requestvb->val.string,
  780.                     request->requestvb->val_len);
  781.                 break;
  782.             case COLUMN_EXTCFG_STATUS:
  783.                 i = *request->requestvb->val.integer;
  784.                 switch (i) {
  785.                 case RS_ACTIVE:
  786.                 case RS_CREATEANDGO:
  787.                     need_to_validate = 1;
  788.                 }
  789.                 break;
  790.             }
  791.             break;
  793.         case MODE_SET_UNDO:
  794.             switch (table_info->colnum) {
  795.             case COLUMN_EXTCFG_COMMAND:
  796.                 if ( extension && extension->old_command ) {
  797.                     SNMP_FREE(extension->command);
  798.                     extension->command     = extension->old_command;
  799.                     extension->old_command = NULL;
  800.                 }
  801.                 break;
  802.             case COLUMN_EXTCFG_ARGS:
  803.                 if ( extension && extension->old_args ) {
  804.                     SNMP_FREE(extension->args);
  805.                     extension->args     = extension->old_args;
  806.                     extension->old_args = NULL;
  807.                 }
  808.                 break;
  809.             case COLUMN_EXTCFG_INPUT:
  810.                 if ( extension && extension->old_input ) {
  811.                     SNMP_FREE(extension->input);
  812.                     extension->input     = extension->old_input;
  813.                     extension->old_input = NULL;
  814.                 }
  815.                 break;
  816.             case COLUMN_EXTCFG_STATUS:
  817.                 i = *request->requestvb->val.integer;
  818.                 switch (i) {
  819.                 case RS_CREATEANDGO:
  820.                 case RS_CREATEANDWAIT:
  821.                     eptr = _find_extension_block( request->requestvb->name,
  822.                                                   request->requestvb->name_length );
  823.                     _free_extension( extension, eptr );
  824.                 }
  825.                 break;
  826.             }
  827.             break;
  829.         case MODE_SET_COMMIT:
  830.             switch (table_info->colnum) {
  831.             case COLUMN_EXTCFG_CACHETIME:
  832.                 i = *request->requestvb->val.integer;
  833.                 extension->cache->timeout = i;
  834.                 break;
  836.             case COLUMN_EXTCFG_RUNTYPE:
  837.                 i = *request->requestvb->val.integer;
  838.                 switch (i) {
  839.                 case 1:
  840.                     extension->flags &= ~NS_EXTEND_FLAGS_WRITEABLE;
  841.                     break;
  842.                 case 2:
  843.                     extension->flags |=  NS_EXTEND_FLAGS_WRITEABLE;
  844.                     break;
  845.                 case 3:
  846.                     (void)netsnmp_cache_check_and_reload( extension->cache );
  847.                     break;
  848.                 }
  849.                 break;
  851.             case COLUMN_EXTCFG_EXECTYPE:
  852.                 i = *request->requestvb->val.integer;
  853.                 if ( i == NS_EXTEND_ETYPE_SHELL )
  854.                     extension->flags |=  NS_EXTEND_FLAGS_SHELL;
  855.                 else
  856.                     extension->flags &= ~NS_EXTEND_FLAGS_SHELL;
  857.                 break;
  859.             case COLUMN_EXTCFG_STATUS:
  860.                 i = *request->requestvb->val.integer;
  861.                 switch (i) {
  862.                 case RS_ACTIVE:
  863.                 case RS_CREATEANDGO:
  864.                     extension->flags |= NS_EXTEND_FLAGS_ACTIVE;
  865.                     break;
  866.                 case RS_NOTINSERVICE:
  867.                 case RS_CREATEANDWAIT:
  868.                     extension->flags &= ~NS_EXTEND_FLAGS_ACTIVE;
  869.                     break;
  870.                 case RS_DESTROY:
  871.                     eptr = _find_extension_block( request->requestvb->name,
  872.                                                   request->requestvb->name_length );
  873.                     _free_extension( extension, eptr );
  874.                     break;
  875.                 }
  876.             }
  877.             break;
  879.         default:
  880.             netsnmp_set_request_error(reqinfo, request, SNMP_ERR_GENERR);
  881.             return SNMP_ERR_GENERR;
  882.         }
  883.     }
  885.     /*
  886.      * If we're marking a given row as active,
  887.      *  then we need to check that it's ready.
  888.      */
  889.     if (need_to_validate) {
  890.         for ( request=requests; request; request=request->next ) {
  891.             if (request->processed)
  892.                 continue;
  893.             table_info = netsnmp_extract_table_info( request );
  894.             extension  = (netsnmp_extend*)netsnmp_extract_table_row_data( request );
  895.             switch (table_info->colnum) {
  896.             case COLUMN_EXTCFG_STATUS:
  897.                 i = *request->requestvb->val.integer;
  898.                 if (( i == RS_ACTIVE || i == RS_CREATEANDGO ) &&
  899.                     !(extension && extension->command &&
  900.                       extension->command[0] == '/' /* &&
  901.                       is_executable(extension->command) */)) {
  902.                     netsnmp_set_request_error(reqinfo, request,
  903.                                               SNMP_ERR_INCONSISTENTVALUE);
  904.                     return SNMP_ERR_INCONSISTENTVALUE;
  905.                 }
  906.             }
  907.         }
  908.     }
  910.     return SNMP_ERR_NOERROR;
  911. }
  914. int
  915. handle_nsExtendOutput1Table(netsnmp_mib_handler          *handler,
  916.                      netsnmp_handler_registration *reginfo,
  917.                      netsnmp_agent_request_info   *reqinfo,
  918.                      netsnmp_request_info         *requests)
  919. {
  920.     netsnmp_request_info       *request;
  921.     netsnmp_table_request_info *table_info;
  922.     netsnmp_extend             *extension;
  923.     int len;
  925.     for ( request=requests; request; request=request->next ) {
  926.         if (request->processed)
  927.             continue;
  928.         table_info = netsnmp_extract_table_info( request );
  929.         extension  = (netsnmp_extend*)netsnmp_extract_table_row_data( request );
  931.         DEBUGMSGTL(( "nsExtendTable:output1", "varbind: "));
  932.         DEBUGMSGOID(("nsExtendTable:output1", request->requestvb->name,
  933.                                               request->requestvb->name_length));
  934.         DEBUGMSG((   "nsExtendTable:output1", "n"));
  936.         switch (reqinfo->mode) {
  937.         case MODE_GET:
  938.             if (!extension || !(extension->flags & NS_EXTEND_FLAGS_ACTIVE)) {
  939.                 /*
  940.                  * If this row is inactive, then skip it.
  941.                  */
  942.                 netsnmp_set_request_error(reqinfo, request,
  943.                                           SNMP_NOSUCHINSTANCE);
  944.                 continue;
  945.             }
  946.             if (!(extension->flags & NS_EXTEND_FLAGS_WRITEABLE) &&
  947.                 (netsnmp_cache_check_and_reload( extension->cache ) < 0 )) {
  948.                 /*
  949.                  * If reloading the output cache of a 'run-on-read'
  950.                  * entry fails, then skip it.
  951.                  */
  952.                 netsnmp_set_request_error(reqinfo, request,
  953.                                           SNMP_NOSUCHINSTANCE);
  954.                 continue;
  955.             }
  956.             if ((extension->flags & NS_EXTEND_FLAGS_WRITEABLE) &&
  957.                 (netsnmp_cache_check_expired( extension->cache ) == 1 )) {
  958.                 /*
  959.                  * If the output cache of a 'run-on-write'
  960.                  * entry has expired, then skip it.
  961.                  */
  962.                 netsnmp_set_request_error(reqinfo, request,
  963.                                           SNMP_NOSUCHINSTANCE);
  964.                 continue;
  965.             }
  967.             switch (table_info->colnum) {
  968.             case COLUMN_EXTOUT1_OUTLEN:
  969.                 snmp_set_var_typed_value(
  970.                      request->requestvb, ASN_INTEGER,
  971.                     (u_char*)&extension->out_len, sizeof(int));
  972.                 break;
  973.             case COLUMN_EXTOUT1_OUTPUT1:
  974.                 /* 
  975.                  * If we've got more than one line,
  976.                  * find the length of the first one.
  977.                  * Otherwise find the length of the whole string.
  978.                  */
  979.                 if (extension->lines) {
  980.                     len = (extension->lines[1])-(extension->output) -1;
  981.                 } else if (extension->output) {
  982.                     len = strlen(extension->output);
  983.                 } else {
  984.                     len = 0;
  985.                 }
  986.                 snmp_set_var_typed_value(
  987.                      request->requestvb, ASN_OCTET_STR,
  988.                      extension->output, len);
  989.                 break;
  990.             case COLUMN_EXTOUT1_OUTPUT2:
  991.                 snmp_set_var_typed_value(
  992.                      request->requestvb, ASN_OCTET_STR,
  993.                      extension->output,
  994.                     (extension->output)?strlen(extension->output):0);
  995.                 break;
  996.             case COLUMN_EXTOUT1_NUMLINES:
  997.                 snmp_set_var_typed_value(
  998.                      request->requestvb, ASN_INTEGER,
  999.                     (u_char*)&extension->numlines, sizeof(int));
  1000.                 break;
  1001.             case COLUMN_EXTOUT1_RESULT:
  1002.                 snmp_set_var_typed_value(
  1003.                      request->requestvb, ASN_INTEGER,
  1004.                     (u_char*)&extension->result, sizeof(int));
  1005.                 break;
  1006.             default:
  1007.                 netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  1008.                 continue;
  1009.             }
  1010.             break;
  1011.         default:
  1012.             netsnmp_set_request_error(reqinfo, request, SNMP_ERR_GENERR);
  1013.             return SNMP_ERR_GENERR;
  1014.         }
  1015.     }
  1016.     return SNMP_ERR_NOERROR;
  1017. }
  1020.         /*************************
  1021.          *
  1022.          *  Multi-line output table handler
  1023.          *  Most of the work is handled here.
  1024.          *
  1025.          *************************/
  1028. /*
  1029.  *  Locate the appropriate entry for a given request
  1030.  */
  1031. netsnmp_extend *
  1032. _extend_find_entry( netsnmp_request_info       *request,
  1033.                     netsnmp_table_request_info *table_info,
  1034.                     int mode  )
  1035. {
  1036.     netsnmp_extend            *eptr;
  1037.     extend_registration_block *ereg;
  1038.     int line_idx;
  1039.     oid oid_buf[MAX_OID_LEN];
  1040.     int oid_len;
  1041.     int i;
  1042.     char *token;
  1044.     if (!request || !table_info || !table_info->indexes
  1045.                  || !table_info->indexes->next_variable) {
  1046.         DEBUGMSGTL(( "nsExtendTable:output2", "invalid invocationn"));
  1047.         return NULL;
  1048.     }
  1050.     ereg = _find_extension_block( request->requestvb->name,
  1051.                                   request->requestvb->name_length );
  1053.     /***
  1054.      *  GET handling - find the exact entry being requested
  1055.      ***/
  1056.     if ( mode == MODE_GET ) {
  1057.         DEBUGMSGTL(( "nsExtendTable:output2", "GET: %s / %dn ",
  1058.                       table_info->indexes->val.string,
  1059.                      *table_info->indexes->next_variable->val.integer));
  1060.         for ( eptr = ereg->ehead; eptr; eptr = eptr->next ) {
  1061.             if ( !strcmp( eptr->token, table_info->indexes->val.string ))
  1062.                 break;
  1063.         }
  1065.         if ( eptr ) {
  1066.             /*
  1067.              * Ensure the output is available...
  1068.              */
  1069.             if (!(eptr->flags & NS_EXTEND_FLAGS_ACTIVE) ||
  1070.                (netsnmp_cache_check_and_reload( eptr->cache ) < 0 ))
  1071.                 return NULL;
  1073.             /*
  1074.              * ...and check the line requested is valid
  1075.              */
  1076.             line_idx = *table_info->indexes->next_variable->val.integer;
  1077.             if (eptr->numlines < line_idx)
  1078.                 return NULL;
  1079.         }
  1080.         return eptr;
  1081.     }
  1083.         /***
  1084.          *  GETNEXT handling - find the first suitable entry
  1085.          ***/
  1086.     else {
  1087.         if (!table_info->indexes->val_len ) {
  1088.             DEBUGMSGTL(( "nsExtendTable:output2", "GETNEXT: first entryn"));
  1089.             /*
  1090.              * Beginning of the table - find the first active
  1091.              *  (and successful) entry, and use the first line of it
  1092.              */
  1093.             for (eptr = ereg->ehead; eptr; eptr = eptr->next ) {
  1094.                 if ((eptr->flags & NS_EXTEND_FLAGS_ACTIVE) &&
  1095.                     (netsnmp_cache_check_and_reload( eptr->cache ) >= 0 )) {
  1096.                     line_idx = 1;
  1097.                     break;
  1098.                 }
  1099.             }
  1100.         } else {
  1101.             token    =  table_info->indexes->val.string,
  1102.             line_idx = *table_info->indexes->next_variable->val.integer;
  1103.             DEBUGMSGTL(( "nsExtendTable:output2", "GETNEXT: %s / %dn ",
  1104.                           token, line_idx ));
  1105.             /*
  1106.              * Otherwise, find the first entry not earlier
  1107.              * than the requested token...
  1108.              */
  1109.             for (eptr = ereg->ehead; eptr; eptr = eptr->next ) {
  1110.                 if ( strlen(eptr->token) > strlen( token ))
  1111.                     break;
  1112.                 if ( strlen(eptr->token) == strlen( token ) &&
  1113.                      strcmp(eptr->token, token) >= 0 )
  1114.                     break;
  1115.             }
  1116.             if (!eptr)
  1117.                 return NULL;    /* (assuming there is one) */
  1119.             /*
  1120.              * ... and make sure it's active & the output is available
  1121.              * (or use the first following entry that is)
  1122.              */
  1123.             for (    ; eptr; eptr = eptr->next ) {
  1124.                 if ((eptr->flags & NS_EXTEND_FLAGS_ACTIVE) &&
  1125.                     (netsnmp_cache_check_and_reload( eptr->cache ) >= 0 )) {
  1126.                     break;
  1127.                 }
  1128.                 line_idx = 1;
  1129.             }
  1131.             /*
  1132.              *  If we're working with the same entry that was requested,
  1133.              *  see whether we've reached the end of the output...
  1134.              */
  1135.             if (!strcmp( eptr->token, token )) {
  1136.                 if ( eptr->numlines <= line_idx ) {
  1137.                     /*
  1138.                      * ... and if so, move on to the first line
  1139.                      * of the next (active and successful) entry.
  1140.                      */
  1141.                     line_idx = 1;
  1142.                     for (eptr = eptr->next ; eptr; eptr = eptr->next ) {
  1143.                         if ((eptr->flags & NS_EXTEND_FLAGS_ACTIVE) &&
  1144.                             (netsnmp_cache_check_and_reload( eptr->cache ) >= 0 )) {
  1145.                             break;
  1146.                         }
  1147.                     }
  1148.                 } else {
  1149.                     /*
  1150.                      * Otherwise just use the next line of this entry.
  1151.                      */
  1152.                     line_idx++;
  1153.                 }
  1154.             }
  1155.         }
  1156.         if (eptr) {
  1157.             DEBUGMSGTL(( "nsExtendTable:output2", "GETNEXT -> %s / %dn ",
  1158.                           eptr->token, line_idx));
  1159.             /*
  1160.              * Since we're processing a GETNEXT request,
  1161.              * now we've found the appropriate entry (and line),
  1162.              * we need to update the varbind OID ...
  1163.              */
  1164.             memcpy( oid_buf, extend_out2_oid, sizeof(extend_out2_oid));
  1165.             oid_len = OID_LENGTH(extend_out2_oid);
  1166.             oid_buf[ oid_len++ ] = 1;    /* nsExtendOutput2Entry */
  1167.             oid_buf[ oid_len++ ] = COLUMN_EXTOUT2_OUTLINE;
  1168.                                          /* string token index */
  1169.             oid_buf[ oid_len++ ] = strlen(eptr->token);
  1170.             for ( i=0; i < (int)strlen(eptr->token); i++ )
  1171.                 oid_buf[ oid_len+i ] = eptr->token[i];
  1172.             oid_len += strlen( eptr->token );
  1173.                                          /* plus line number */
  1174.             oid_buf[ oid_len++ ] = line_idx;
  1175.             snmp_set_var_objid( request->requestvb, oid_buf, oid_len );
  1176.             /*
  1177.              * ... and index values to match.
  1178.              */
  1179.             snmp_set_var_value( table_info->indexes,
  1180.                                 eptr->token, strlen(eptr->token));
  1181.             *table_info->indexes->next_variable->val.integer = line_idx;
  1182.         }
  1183.         return eptr;  /* Finally, signal success */
  1184.     }
  1185.     return NULL;
  1186. }
  1188. /*
  1189.  *  Multi-line output handler
  1190.  *  Locate the appropriate entry (using _extend_find_entry)
  1191.  *  and return the appropriate output line
  1192.  */
  1193. int
  1194. handle_nsExtendOutput2Table(netsnmp_mib_handler          *handler,
  1195.                      netsnmp_handler_registration *reginfo,
  1196.                      netsnmp_agent_request_info   *reqinfo,
  1197.                      netsnmp_request_info         *requests)
  1198. {
  1199.     netsnmp_request_info       *request;
  1200.     netsnmp_table_request_info *table_info;
  1201.     netsnmp_extend             *extension;
  1202.     char *cp;
  1203.     int line_idx;
  1204.     int len;
  1206.     for ( request=requests; request; request=request->next ) {
  1207.         if (request->processed)
  1208.             continue;
  1210.         table_info = netsnmp_extract_table_info( request );
  1211.         extension  = _extend_find_entry( request, table_info, reqinfo->mode );
  1213.         DEBUGMSGTL(( "nsExtendTable:output2", "varbind: "));
  1214.         DEBUGMSGOID(("nsExtendTable:output2", request->requestvb->name,
  1215.                                               request->requestvb->name_length));
  1216.         DEBUGMSG((   "nsExtendTable:output2", " (%s)n",
  1217.                                     (extension) ? extension->token : "[none]"));
  1219.         if (!extension) {
  1220.             if (reqinfo->mode == MODE_GET)
  1221.                 netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE);
  1222.             else
  1223.                 netsnmp_set_request_error(reqinfo, request, SNMP_ENDOFMIBVIEW);
  1224.             continue;
  1225.         }
  1227.         switch (reqinfo->mode) {
  1228.         case MODE_GET:
  1229.         case MODE_GETNEXT:
  1230.             switch (table_info->colnum) {
  1231.             case COLUMN_EXTOUT2_OUTLINE:
  1232.                 /* 
  1233.                  * Determine which line we've been asked for....
  1234.                  */
  1235.                 line_idx = *table_info->indexes->next_variable->val.integer;
  1236.                 if (extension->lines)
  1237.                     cp  = extension->lines[line_idx-1];
  1238.                 else
  1239.                     cp  = extension->output;
  1241.                 /* 
  1242.                  * ... and how long it is.
  1243.                  */
  1244.                 if ( extension->numlines > line_idx )
  1245.                     len = (extension->lines[line_idx])-cp -1;
  1246.                 else if (cp)
  1247.                     len = strlen(cp);
  1248.                 else
  1249.                     len = 0;
  1251.                 snmp_set_var_typed_value( request->requestvb,
  1252.                                           ASN_OCTET_STR, cp, len );
  1253.                 break;
  1254.             default:
  1255.                 netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
  1256.                 continue;
  1257.             }
  1258.             break;
  1259.         default:
  1260.             netsnmp_set_request_error(reqinfo, request, SNMP_ERR_GENERR);
  1261.             return SNMP_ERR_GENERR;
  1262.         }
  1263.     }
  1264.     return SNMP_ERR_NOERROR;
  1265. }
  1267. #ifndef USING_UCD_SNMP_EXTENSIBLE_MODULE
  1268.         /*************************
  1269.          *
  1270.          *  Compatability with the UCD extTable
  1271.          *
  1272.          *************************/
  1274. u_char *
  1275. var_extensible_old(struct variable * vp,
  1276.                      oid * name,
  1277.                      size_t * length,
  1278.                      int exact,
  1279.                      size_t * var_len, WriteMethod ** write_method)
  1280. {
  1281.     netsnmp_old_extend *exten = NULL;
  1282.     static long     long_ret;
  1283.     int idx;
  1285.     if (header_simple_table
  1286.         (vp, name, length, exact, var_len, write_method, num_compatability_entries))
  1287.         return (NULL);
  1289.     idx = name[*length-1] -1;
  1290.     exten = &compatability_entries[ idx ];
  1291.     if (exten) {
  1292.         switch (vp->magic) {
  1293.         case MIBINDEX:
  1294.             long_ret = name[*length - 1];
  1295.             return ((u_char *) (&long_ret));
  1296.         case ERRORNAME:        /* name defined in config file */
  1297.             *var_len = strlen(exten->exec_entry->token);
  1298.             return ((u_char *) (exten->exec_entry->token));
  1299.         case SHELLCOMMAND:
  1300.             *var_len = strlen(exten->exec_entry->command);
  1301.             return ((u_char *) (exten->exec_entry->command));
  1302.         case ERRORFLAG:        /* return code from the process */
  1303.             netsnmp_cache_check_and_reload( exten->exec_entry->cache );
  1304.             long_ret = exten->exec_entry->result;
  1305.             return ((u_char *) (&long_ret));
  1306.         case ERRORMSG:         /* first line of text returned from the process */
  1307.             netsnmp_cache_check_and_reload( exten->exec_entry->cache );
  1308.             if (exten->exec_entry->lines) {
  1309.                 *var_len = (exten->exec_entry->lines[1])-
  1310.                            (exten->exec_entry->output) -1;
  1311.             } else if (exten->exec_entry->output) {
  1312.                 *var_len = strlen(exten->exec_entry->output);
  1313.             } else {
  1314.                 *var_len = 0;
  1315.             }
  1316.             return ((u_char *) (exten->exec_entry->output));
  1317.         case ERRORFIX:
  1318.             *write_method = fixExec2Error;
  1319.             long_return = 0;
  1320.             return ((u_char *) &long_return);
  1322.         case ERRORFIXCMD:
  1323.             if (exten->efix_entry) {
  1324.                 *var_len = strlen(exten->efix_entry->command);
  1325.                 return ((u_char *) exten->efix_entry->command);
  1326.             } else {
  1327.                 *var_len = 0;
  1328.                 return ((u_char *) &long_return);  /* Just needs to be non-null! */
  1329.             }
  1330.         }
  1331.         return NULL;
  1332.     }
  1333.     return NULL;
  1334. }
  1337. int
  1338. fixExec2Error(int action,
  1339.              u_char * var_val,
  1340.              u_char var_val_type,
  1341.              size_t var_val_len,
  1342.              u_char * statP, oid * name, size_t name_len)
  1343. {
  1344.     netsnmp_old_extend *exten = NULL;
  1345.     int idx;
  1347.     idx = name[name_len-1] -1;
  1348.     exten = &compatability_entries[ idx ];
  1350.     switch (action) {
  1351.     case MODE_SET_RESERVE1:
  1352.         if (var_val_type != ASN_INTEGER) {
  1353.             snmp_log(LOG_ERR, "Wrong type != intn");
  1354.             return SNMP_ERR_WRONGTYPE;
  1355.         }
  1356.         idx = *((long *) var_val);
  1357.         if (idx != 1) {
  1358.             snmp_log(LOG_ERR, "Wrong value != 1n");
  1359.             return SNMP_ERR_WRONGVALUE;
  1360.         }
  1361.         if (!exten || !exten->efix_entry) {
  1362.             snmp_log(LOG_ERR, "No command to runn");
  1363.             return SNMP_ERR_GENERR;
  1364.         }
  1365.         return SNMP_ERR_NOERROR;
  1367.     case MODE_SET_COMMIT:
  1368.         netsnmp_cache_check_and_reload( exten->efix_entry->cache );
  1369.     }
  1370.     return SNMP_ERR_NOERROR;
  1371. }
  1372. #endif