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

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

SNMP编程

开发平台：

Unix_Linux

extensible.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  3. #if HAVE_STDLIB_H
  4. #include <stdlib.h>
  5. #endif
  6. #if HAVE_UNISTD_H
  7. #include <unistd.h>
  8. #endif
  9. #if HAVE_FCNTL_H
  10. #include <fcntl.h>
  11. #endif
  12. #if TIME_WITH_SYS_TIME
  13. # ifdef WIN32
  14. #  include <sys/timeb.h>
  15. # else
  16. #  include <sys/time.h>
  17. # endif
  18. # include <time.h>
  19. #else
  20. # if HAVE_SYS_TIME_H
  21. #  include <sys/time.h>
  22. # else
  23. #  include <time.h>
  24. # endif
  25. #endif
  26. #include <signal.h>
  27. #if HAVE_MACHINE_PARAM_H
  28. #include <machine/param.h>
  29. #endif
  30. #if HAVE_SYS_PARAM_H
  31. #include <sys/param.h>
  32. #endif
  33. #if HAVE_SYS_VMMETER_H
  34. #if !(defined(bsdi2) || defined(netbsd1))
  35. #include <sys/vmmeter.h>
  36. #endif
  37. #endif
  38. #if HAVE_SYS_CONF_H
  39. #include <sys/conf.h>
  40. #endif
  41. #if HAVE_ASM_PAGE_H
  42. #include <asm/page.h>
  43. #endif
  44. #if HAVE_SYS_SWAP_H
  45. #include <sys/swap.h>
  46. #endif
  47. #if HAVE_SYS_FS_H
  48. #include <sys/fs.h>
  49. #else
  50. #if HAVE_UFS_FS_H
  51. #include <ufs/fs.h>
  52. #else
  53. #if HAVE_UFS_UFS_DINODE_H
  54. #include <ufs/ufs/dinode.h>
  55. #endif
  56. #if HAVE_UFS_FFS_FS_H
  57. #include <ufs/ffs/fs.h>
  58. #endif
  59. #endif
  60. #endif
  61. #if HAVE_MTAB_H
  62. #include <mtab.h>
  63. #endif
  64. #include <sys/stat.h>
  65. #include <errno.h>
  66. #if HAVE_FSTAB_H
  67. #include <fstab.h>
  68. #endif
  69. #if HAVE_SYS_STATFS_H
  70. #include <sys/statfs.h>
  71. #endif
  72. #if HAVE_SYS_STATVFS_H
  73. #include <sys/statvfs.h>
  74. #endif
  75. #if HAVE_SYS_VFS_H
  76. #include <sys/vfs.h>
  77. #endif
  78. #if (!defined(HAVE_STATVFS)) && defined(HAVE_STATFS)
  79. #if HAVE_SYS_MOUNT_H
  80. #include <sys/mount.h>
  81. #endif
  82. #if HAVE_SYS_SYSCTL_H
  83. #include <sys/sysctl.h>
  84. #endif
  85. #define statvfs statfs
  86. #endif
  87. #if HAVE_VM_VM_H
  88. #include <vm/vm.h>
  89. #endif
  90. #if HAVE_VM_SWAP_PAGER_H
  91. #include <vm/swap_pager.h>
  92. #endif
  93. #if HAVE_SYS_FIXPOINT_H
  94. #include <sys/fixpoint.h>
  95. #endif
  96. #if HAVE_MALLOC_H
  97. #include <malloc.h>
  98. #endif
  99. #if HAVE_STRING_H
  100. #include <string.h>
  101. #endif
  102. #include <ctype.h>
  103. #if HAVE_WINSOCK_H
  104. #include <winsock.h>
  105. #endif
  106. #ifndef HAVE_STRNCASECMP
  107. int             strncasecmp(const char *s1, const char *s2, size_t n);
  108. #endif
  110. #if HAVE_DMALLOC_H
  111. #include <dmalloc.h>
  112. #endif
  114. #include <net-snmp/net-snmp-includes.h>
  115. #include <net-snmp/agent/net-snmp-agent-includes.h>
  116. #include <net-snmp/agent/auto_nlist.h>
  117. #include <net-snmp/agent/agent_callbacks.h>
  119. #include "struct.h"
  120. #include "extensible.h"
  121. #include "utilities/execute.h"
  122. #include "util_funcs.h"
  124. extern struct myproc *procwatch;        /* moved to proc.c */
  125. extern int      numprocs;       /* ditto */
  126. extern struct extensible *extens;       /* In exec.c */
  127. extern struct extensible *relocs;       /* In exec.c */
  128. extern int      numextens;      /* ditto */
  129. extern int      numrelocs;      /* ditto */
  130. extern struct extensible *passthrus;    /* In pass.c */
  131. extern int      numpassthrus;   /* ditto */
  132. extern char     sysName[];
  133. extern netsnmp_subtree *subtrees;
  134. extern struct variable2 extensible_relocatable_variables[];
  135. extern struct variable2 extensible_passthru_variables[];
  137. /*
  138.  * the relocatable extensible commands variables 
  139.  */
  140. struct variable2 extensible_relocatable_variables[] = {
  141.     {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_relocatable, 1,
  142.      {MIBINDEX}},
  143.     {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_relocatable, 1,
  144.      {ERRORNAME}},
  145.     {SHELLCOMMAND, ASN_OCTET_STR, RONLY, var_extensible_relocatable, 1,
  146.      {SHELLCOMMAND}},
  147.     {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_relocatable, 1,
  148.      {ERRORFLAG}},
  149.     {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_relocatable, 1,
  150.      {ERRORMSG}},
  151.     {ERRORFIX, ASN_INTEGER, RWRITE, var_extensible_relocatable, 1,
  152.      {ERRORFIX}},
  153.     {ERRORFIXCMD, ASN_OCTET_STR, RONLY, var_extensible_relocatable, 1,
  154.      {ERRORFIXCMD}}
  155. };
  158. void
  159. init_extensible(void)
  160. {
  162.     struct variable2 extensible_extensible_variables[] = {
  163.         {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_shell, 1,
  164.          {MIBINDEX}},
  165.         {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_shell, 1,
  166.          {ERRORNAME}},
  167.         {SHELLCOMMAND, ASN_OCTET_STR, RONLY, var_extensible_shell, 1,
  168.          {SHELLCOMMAND}},
  169.         {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_shell, 1,
  170.          {ERRORFLAG}},
  171.         {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_shell, 1,
  172.          {ERRORMSG}},
  173.         {ERRORFIX, ASN_INTEGER, RWRITE, var_extensible_shell, 1,
  174.          {ERRORFIX}},
  175.         {ERRORFIXCMD, ASN_OCTET_STR, RONLY, var_extensible_shell, 1,
  176.          {ERRORFIXCMD}}
  177.     };
  179.     /*
  180.      * Define the OID pointer to the top of the mib tree that we're
  181.      * registering underneath 
  182.      */
  183.     oid             extensible_variables_oid[] =
  184.         { UCDAVIS_MIB, SHELLMIBNUM, 1 };
  186.     /*
  187.      * register ourselves with the agent to handle our mib tree 
  188.      */
  189.     REGISTER_MIB("ucd-snmp/extensible", extensible_extensible_variables,
  190.                  variable2, extensible_variables_oid);
  192.     snmpd_register_config_handler("exec", extensible_parse_config,
  193.                                   extensible_free_config,
  194.                                   "[miboid] name program arguments");
  195.     snmpd_register_config_handler("sh", extensible_parse_config,
  196.                                   extensible_free_config,
  197.                                   "[miboid] name program-or-script arguments");
  198.     snmpd_register_config_handler("execfix", execfix_parse_config, NULL,
  199.                                   "exec-or-sh-name program [arguments...]");
  200.     snmp_register_callback(SNMP_CALLBACK_APPLICATION,
  201.                            SNMPD_CALLBACK_PRE_UPDATE_CONFIG,
  202.                            extensible_unregister, NULL);
  203. }
  205. extern int pass_compare(const void *a, const void *b);
  207. void
  208. extensible_parse_config(const char *token, char *cptr)
  209. {
  210.     struct extensible *ptmp, **pp;
  211.     char           *tcptr;
  212.     int            scount;
  214.     /*
  215.      * allocate and clear memory structure 
  216.      */
  217.     ptmp = (struct extensible *) calloc(1, sizeof(struct extensible));
  218.     if (ptmp == NULL)
  219.         return;                 /* XXX memory alloc error */
  221.     if (*cptr == '.')
  222.         cptr++;
  223.     if (isdigit(*cptr)) {
  224.         /*
  225.          * its a relocatable extensible mib 
  226.          */
  227.         config_perror("Warning: relocatable 'exec' format will change in a future release - See 'NET-SNMP-EXTEND-MIB' for an alternative" );
  228.         for (pp = &relocs, numrelocs++; *pp; pp = &((*pp)->next));
  229.         (*pp) = ptmp;
  230.         pp = &relocs; scount = numrelocs;
  232.     } else {
  233.         /*
  234.          * it goes in with the general extensible table 
  235.          */
  236.         for (pp = &extens, numextens++; *pp; pp = &((*pp)->next));
  237.         (*pp) = ptmp;
  238.         pp = &extens; scount = numextens;
  239.     }
  241.     /*
  242.      * the rest is pretty much handled the same 
  243.      */
  244.     if (!strncasecmp(token, "sh", 2))
  245.         ptmp->type = SHPROC;
  246.     else
  247.         ptmp->type = EXECPROC;
  248.     if (isdigit(*cptr)) {
  249.         ptmp->miblen = parse_miboid(cptr, ptmp->miboid);
  250.         while (isdigit(*cptr) || *cptr == '.')
  251.             cptr++;
  252.     }
  254.     /*
  255.      * name 
  256.      */
  257.     cptr = skip_white(cptr);
  258.     copy_nword(cptr, ptmp->name, sizeof(ptmp->name));
  259.     cptr = skip_not_white(cptr);
  260.     cptr = skip_white(cptr);
  261.     /*
  262.      * command 
  263.      */
  264.     if (cptr == NULL) {
  265.         config_perror("No command specified on line");
  266.     } else {
  267.         /*
  268.          * Support multi-element commands in shell configuration
  269.          *   lines, but truncate after the first command for 'exec'
  270.          */
  271.         for (tcptr = cptr; *tcptr != 0 && *tcptr != '#'; tcptr++)
  272.             if (*tcptr == ';' && ptmp->type == EXECPROC)
  273.                 break;
  274.         strncpy(ptmp->command, cptr, tcptr - cptr);
  275.         ptmp->command[tcptr - cptr] = 0;
  276.     }
  277. #ifdef EXECFIXCMD
  278.     sprintf(ptmp->fixcmd, EXECFIXCMD, ptmp->name);
  279. #endif
  280.     if (ptmp->miblen > 0) {
  281.         register_mib(token,
  282.                      (struct variable *) extensible_relocatable_variables,
  283.                      sizeof(struct variable2), 
  284.                      sizeof(extensible_relocatable_variables) /
  285.                      sizeof(*extensible_relocatable_variables),
  286.                      ptmp->miboid, ptmp->miblen);
  287.     }
  289.     if (scount > 1) {
  290.         int i;
  291.         struct extensible **etmp = (struct extensible **)
  292.             malloc(((sizeof(struct extensible *)) * scount));
  293.         if (etmp == NULL)
  294.             return;                 /* XXX memory alloc error */
  295.         for (i = 0, ptmp = *pp;
  296.              i < scount && ptmp != 0; i++, ptmp = ptmp->next)
  297.             etmp[i] = ptmp;
  298.         qsort(etmp, scount, sizeof(struct extensible *),
  299.               pass_compare);
  300.         *pp = (struct extensible *) etmp[0];
  301.         ptmp = (struct extensible *) etmp[0];
  303.         for (i = 0; i < scount - 1; i++) {
  304.             ptmp->next = etmp[i + 1];
  305.             ptmp = ptmp->next;
  306.         }
  307.         ptmp->next = NULL;
  308.         free(etmp);
  309.     }
  310. }
  312. int
  313. extensible_unregister(int major, int minor,
  314.                       void *serverarg, void *clientarg)
  315. {
  316.     extensible_free_config();
  317.     return 0;
  318. }
  320. void
  321. extensible_free_config(void)
  322. {
  323.     struct extensible *etmp, *etmp2;
  324.     oid    tname[MAX_OID_LEN];
  325.     int    i;
  327.     for (etmp = extens; etmp != NULL;) {
  328.         etmp2 = etmp;
  329.         etmp = etmp->next;
  330.         free(etmp2);
  331.     }
  333.     for (etmp = relocs; etmp != NULL;) {
  334.         etmp2 = etmp;
  335.         etmp = etmp->next;
  337.         /*
  338.          * The new modular API results in the column
  339.          *  objects being registered individually, so
  340.          *  they need to be unregistered individually too!
  341.          */
  342.         memset(tname, 0, MAX_OID_LEN*sizeof(oid));
  343.         memcpy(tname,  etmp2->miboid, etmp2->miblen*sizeof(oid));
  344.         for (i=1; i<4; i++) {
  345.             tname[etmp2->miblen] = i;
  346.             unregister_mib(tname, etmp2->miblen+1);
  347.         }
  348.         for (i=100; i<=103; i++) {
  349.             tname[etmp2->miblen] = i;
  350.             unregister_mib(tname, etmp2->miblen+1);
  351.         }
  352.         free(etmp2);
  353.     }
  355.     relocs = NULL;
  356.     extens = NULL;
  357.     numextens = 0;
  358.     numrelocs = 0;
  359. }
  362. #define MAXMSGLINES 1000
  364. struct extensible *extens = NULL;       /* In exec.c */
  365. struct extensible *relocs = NULL;       /* In exec.c */
  366. int             numextens = 0, numrelocs = 0;   /* ditto */
  369. /*
  370.  * var_extensible_shell(...
  371.  * Arguments:
  372.  * vp     IN      - pointer to variable entry that points here
  373.  * name    IN/OUT  - IN/name requested, OUT/name found
  374.  * length  IN/OUT  - length of IN/OUT oid's 
  375.  * exact   IN      - TRUE if an exact match was requested
  376.  * var_len OUT     - length of variable or 0 if function returned
  377.  * write_method
  378.  * 
  379.  */
  381. /*
  382.  * find a give entry in the linked list associated with a proc name 
  383.  */
  384. struct extensible *
  385. get_exec_by_name(char *name)
  386. {
  387.     struct extensible *etmp;
  389.     if (name == NULL)
  390.         return NULL;
  392.     for (etmp = extens; etmp != NULL && strcmp(etmp->name, name) != 0;
  393.          etmp = etmp->next);
  395.     if(NULL == etmp)
  396.         for (etmp = relocs; etmp != NULL && strcmp(etmp->name, name) != 0;
  397.          etmp = etmp->next);
  399.     return etmp;
  400. }
  402. void
  403. execfix_parse_config(const char *token, char *cptr)
  404. {
  405.     char            tmpname[STRMAX];
  406.     struct extensible *execp;
  408.     /*
  409.      * don't allow two entries with the same name 
  410.      */
  411.     cptr = copy_nword(cptr, tmpname, sizeof(tmpname));
  412.     if ((execp = get_exec_by_name(tmpname)) == NULL) {
  413.         config_perror("No exec entry registered for this exec name yet.");
  414.         return;
  415.     }
  417.     if (strlen(cptr) > sizeof(execp->fixcmd)) {
  418.         config_perror("fix command too long.");
  419.         return;
  420.     }
  422.     strncpy(execp->fixcmd, cptr, sizeof(execp->fixcmd));
  423.     execp->fixcmd[ sizeof(execp->fixcmd)-1 ] = 0;
  424. }
  426. u_char         *
  427. var_extensible_shell(struct variable * vp,
  428.                      oid * name,
  429.                      size_t * length,
  430.                      int exact,
  431.                      size_t * var_len, WriteMethod ** write_method)
  432. {
  434.     static struct extensible *exten = 0;
  435.     static long     long_ret;
  436.     int len;
  438.     if (header_simple_table
  439.         (vp, name, length, exact, var_len, write_method, numextens))
  440.         return (NULL);
  442.     if ((exten = get_exten_instance(extens, name[*length - 1]))) {
  443.         switch (vp->magic) {
  444.         case MIBINDEX:
  445.             long_ret = name[*length - 1];
  446.             return ((u_char *) (&long_ret));
  447.         case ERRORNAME:        /* name defined in config file */
  448.             *var_len = strlen(exten->name);
  449.             return ((u_char *) (exten->name));
  450.         case SHELLCOMMAND:
  451.             *var_len = strlen(exten->command);
  452.             return ((u_char *) (exten->command));
  453.         case ERRORFLAG:        /* return code from the process */
  454.             len = sizeof(exten->output);
  455.             if (exten->type == EXECPROC) {
  456.                 exten->result = run_exec_command( exten->command, NULL,
  457.                                                   exten->output, &len);
  458.     } else {
  459.                 exten->result = run_shell_command(exten->command, NULL,
  460.                                                   exten->output, &len);
  461.     }
  462.             long_ret = exten->result;
  463.             return ((u_char *) (&long_ret));
  464.         case ERRORMSG:         /* first line of text returned from the process */
  465.             len = sizeof(exten->output);
  466.             if (exten->type == EXECPROC) {
  467.                 exten->result = run_exec_command( exten->command, NULL,
  468.                                                   exten->output, &len);
  469.     } else {
  470.                 exten->result = run_shell_command(exten->command, NULL,
  471.                                                   exten->output, &len);
  472.     }
  473.             *var_len = strlen(exten->output);
  474.             if (exten->output[*var_len - 1] == 'n')
  475.                 exten->output[--(*var_len)] = '';
  476.             return ((u_char *) (exten->output));
  477.         case ERRORFIX:
  478.             *write_method = fixExecError;
  479.             long_return = 0;
  480.             return ((u_char *) & long_return);
  482.         case ERRORFIXCMD:
  483.             *var_len = strlen(exten->fixcmd);
  484.             return ((u_char *) exten->fixcmd);
  485.         }
  486.         return NULL;
  487.     }
  488.     return NULL;
  489. }
  491. int
  492. fixExecError(int action,
  493.              u_char * var_val,
  494.              u_char var_val_type,
  495.              size_t var_val_len,
  496.              u_char * statP, oid * name, size_t name_len)
  497. {
  499.     struct extensible *exten;
  500.     long            tmp = 0;
  501.     int             fd;
  502.     static struct extensible ex;
  503.     FILE           *file;
  505.     if ((exten = get_exten_instance(extens, name[10]))) {
  506.         if (var_val_type != ASN_INTEGER) {
  507.             snmp_log(LOG_ERR, "Wrong type != intn");
  508.             return SNMP_ERR_WRONGTYPE;
  509.         }
  510.         tmp = *((long *) var_val);
  511.         if ((tmp == 1) && (action == COMMIT) && (exten->fixcmd[0] != 0)) {
  512.             sprintf(ex.command, exten->fixcmd);
  513.             if ((fd = get_exec_output(&ex)) != -1) {
  514.                 file = fdopen(fd, "r");
  515.                 while (fgets(ex.output, sizeof(ex.output), file) != NULL);
  516.                 fclose(file);
  517.                 wait_on_exec(&ex);
  518.             }
  519.         }
  520.         return SNMP_ERR_NOERROR;
  521.     }
  522.     return SNMP_ERR_WRONGTYPE;
  523. }
  525. u_char         *
  526. var_extensible_relocatable(struct variable *vp,
  527.                            oid * name,
  528.                            size_t * length,
  529.                            int exact,
  530.                            size_t * var_len, WriteMethod ** write_method)
  531. {
  533.     int             i;
  534.     int             len;
  535.     struct extensible *exten = 0;
  536.     static long     long_ret;
  537.     static char     errmsg[STRMAX];
  538.     char            *cp, *cp1;
  539.     struct variable myvp;
  540.     oid             tname[MAX_OID_LEN];
  542.     memcpy(&myvp, vp, sizeof(struct variable));
  544.     long_ret = *length;
  545.     for (i = 1; i <= (int) numrelocs; i++) {
  546.         exten = get_exten_instance(relocs, i);
  547.         if ((int) exten->miblen == (int) vp->namelen - 1) {
  548.             memcpy(myvp.name, exten->miboid, exten->miblen * sizeof(oid));
  549.             myvp.namelen = exten->miblen;
  550.             *length = vp->namelen;
  551.             memcpy(tname, vp->name, vp->namelen * sizeof(oid));
  552.             if (!header_simple_table
  553.                 (&myvp, tname, length, -1, var_len, write_method, -1))
  554.                 break;
  555.             else
  556.                 exten = NULL;
  557.         }
  558.     }
  559.     if (i > (int) numrelocs || exten == NULL) {
  560.         *length = long_ret;
  561.         *var_len = 0;
  562.         *write_method = NULL;
  563.         return (NULL);
  564.     }
  566.     *length = long_ret;
  567.     if (header_simple_table(vp, name, length, exact, var_len, write_method,
  568.                             ((vp->magic == ERRORMSG) ? MAXMSGLINES : 1)))
  569.         return (NULL);
  571.     switch (vp->magic) {
  572.     case MIBINDEX:
  573.         long_ret = name[*length - 1];
  574.         return ((u_char *) (&long_ret));
  575.     case ERRORNAME:            /* name defined in config file */
  576.         *var_len = strlen(exten->name);
  577.         return ((u_char *) (exten->name));
  578.     case SHELLCOMMAND:
  579.         *var_len = strlen(exten->command);
  580.         return ((u_char *) (exten->command));
  581.     case ERRORFLAG:            /* return code from the process */
  582.         len = sizeof(exten->output);
  583.         if (exten->type == EXECPROC)
  584.             exten->result = run_exec_command( exten->command, NULL,
  585.                                               exten->output, &len);
  586. else
  587.             exten->result = run_shell_command(exten->command, NULL,
  588.                                               exten->output, &len);
  589.         long_ret = exten->result;
  590.         return ((u_char *) (&long_ret));
  591.     case ERRORMSG:             /* first line of text returned from the process */
  592.         len = sizeof(exten->output);
  593.         if (exten->type == EXECPROC)
  594.             exten->result = run_exec_command( exten->command, NULL,
  595.                                               exten->output, &len);
  596. else
  597.             exten->result = run_shell_command(exten->command, NULL,
  598.                                               exten->output, &len);
  600.         /*
  601.          *  Pick the output string apart into individual lines,
  602.          *  and extract the one being asked for....
  603.          */
  604.         cp1 = exten->output;
  605.         for (i = 1; i != (int) name[*length - 1]; i++) {
  606.             cp = strchr(cp1, 'n');
  607.             if (!cp) {
  608.         *var_len = 0;
  609.         /* wait_on_exec(exten); ??? */
  610.         return NULL;
  611.     }
  612.     cp1 = ++cp;
  613. }
  614.         /*
  615.          *  ... and quit if we've run off the end of the output
  616.          */
  617.         if (!*cp1) {
  618.             *var_len = 0;
  619.     return NULL;
  620. }
  621.         cp = strchr(cp1, 'n');
  622.         if (cp)
  623.             *cp = 0;
  624.         strncpy(errmsg, cp1, sizeof(errmsg));
  625.         errmsg[ sizeof(errmsg)-1 ] = 0;
  626.         *var_len = strlen(errmsg);
  627.         if (errmsg[*var_len - 1] == 'n')
  628.             errmsg[--(*var_len)] = '';
  629.         return ((u_char *) (errmsg));
  630.     case ERRORFIX:
  631.         *write_method = fixExecError;
  632.         long_return = 0;
  633.         return ((u_char *) & long_return);
  635.     case ERRORFIXCMD:
  636.         *var_len = strlen(exten->fixcmd);
  637.         return ((u_char *) exten->fixcmd);
  638.     }
  639.     return NULL;
  640. }
  642. netsnmp_subtree *
  643. find_extensible(netsnmp_subtree *tp, oid *tname, size_t tnamelen, int exact)
  644. {
  645.     size_t          tmp;
  646.     int             i;
  647.     struct extensible *exten = 0;
  648.     struct variable myvp;
  649.     oid             name[MAX_OID_LEN];
  650.     static netsnmp_subtree mysubtree[2] =
  651. { { NULL, 0, NULL, 0, NULL, 0, NULL, 0, 0, NULL, NULL, 0, 0, 0,
  652.     NULL, NULL, NULL, 0, 0, NULL, 0, 0 },
  653.   { NULL, 0, NULL, 0, NULL, 0, NULL, 0, 0, NULL, NULL, 0, 0, 0,
  654.     NULL, NULL, NULL, 0, 0, NULL, 0, 0 } };
  656.     for (i = 1; i <= (int) numrelocs; i++) {
  657.         exten = get_exten_instance(relocs, i);
  658.         if (exten->miblen != 0) {
  659.             memcpy(myvp.name, exten->miboid, exten->miblen * sizeof(oid));
  660.             memcpy(name, tname, tnamelen * sizeof(oid));
  661.             myvp.name[exten->miblen] = name[exten->miblen];
  662.             myvp.namelen = exten->miblen + 1;
  663.             tmp = exten->miblen + 1;
  664.             if (!header_simple_table(&myvp, name, &tmp, -1, 
  665.      NULL, NULL, numrelocs)) {
  666.                 break;
  667.     }
  668.         }
  669.     }
  670.     if (i > (int)numrelocs || exten == NULL) {
  671.         return (tp);
  672.     }
  674.     if (mysubtree[0].name_a != NULL) {
  675. free(mysubtree[0].name_a);
  676. mysubtree[0].name_a = NULL;
  677.     }
  678.     mysubtree[0].name_a  = snmp_duplicate_objid(exten->miboid, exten->miblen);
  679.     mysubtree[0].namelen = exten->miblen;
  680.     mysubtree[0].variables = (struct variable *)extensible_relocatable_variables;
  681.     mysubtree[0].variables_len = sizeof(extensible_relocatable_variables) /
  682.         sizeof(*extensible_relocatable_variables);
  683.     mysubtree[0].variables_width = sizeof(*extensible_relocatable_variables);
  684.     mysubtree[1].namelen = 0;
  685.     return (mysubtree);
  686. }