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

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

SNMP编程

开发平台：

Unix_Linux

snmptable.c：源码内容
  1. /*
  2.  * snmptable.c - walk a table and print it nicely
  3.  *
  4.  * Update: 1999-10-26 <rs-snmp@revelstone.com>
  5.  * Added ability to use MIB to query tables with non-sequential column OIDs
  6.  * Added code to handle sparse tables
  7.  *
  8.  * Update: 1998-07-17 <jhy@gsu.edu>
  9.  * Added text <special options> to usage().
  10.  */
  11. /**********************************************************************
  12. Copyright 1997 Niels Baggesen
  14.                       All Rights Reserved
  16. Permission to use, copy, modify, and distribute this software and its 
  17. documentation for any purpose and without fee is hereby granted, 
  18. provided that the above copyright notice appear in all copies.
  20. I DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  21. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  22. I BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  23. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  25. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  26. SOFTWARE.
  27. ******************************************************************/
  28. #include <net-snmp/net-snmp-config.h>
  30. #if HAVE_STDLIB_H
  31. #include <stdlib.h>
  32. #endif
  33. #if HAVE_UNISTD_H
  34. #include <unistd.h>
  35. #endif
  36. #if HAVE_STRING_H
  37. #include <string.h>
  38. #else
  39. #include <strings.h>
  40. #endif
  41. #include <sys/types.h>
  42. #if HAVE_NETINET_IN_H
  43. # include <netinet/in.h>
  44. #endif
  45. #if TIME_WITH_SYS_TIME
  46. # ifdef WIN32
  47. #  include <sys/timeb.h>
  48. # else
  49. #  include <sys/time.h>
  50. # endif
  51. # include <time.h>
  52. #else
  53. # if HAVE_SYS_TIME_H
  54. #  include <sys/time.h>
  55. # else
  56. #  include <time.h>
  57. # endif
  58. #endif
  59. #if HAVE_SYS_SELECT_H
  60. #include <sys/select.h>
  61. #endif
  62. #include <stdio.h>
  63. #if HAVE_WINSOCK_H
  64. #include <winsock.h>
  65. #endif
  66. #if HAVE_NETDB_H
  67. #include <netdb.h>
  68. #endif
  69. #if HAVE_ARPA_INET_H
  70. #include <arpa/inet.h>
  71. #endif
  73. #include <net-snmp/net-snmp-includes.h>
  75. struct column {
  76.     int             width;
  77.     oid             subid;
  78.     char           *label;
  79.     char           *fmt;
  80. }              *column = NULL;
  82. static char   **data = NULL;
  83. static char   **indices = NULL;
  84. static int      index_width = sizeof("index ") - 1;
  85. static int      fields;
  86. static int      entries;
  87. static int      allocated;
  88. static int      end_of_table = 1;
  89. static int      headers_only = 0;
  90. static int      no_headers = 0;
  91. static int      max_width = 0;
  92. static int      column_width = 0;
  93. static int      brief = 0;
  94. static int      show_index = 0;
  95. static const char    *left_justify_flag = "";
  96. static char    *field_separator = NULL;
  97. static char    *table_name;
  98. static oid      name[MAX_OID_LEN];
  99. static size_t   name_length;
  100. static oid      root[MAX_OID_LEN];
  101. static size_t   rootlen;
  102. static int      localdebug;
  103. static int      exitval = 0;
  104. static int      use_getbulk = 1;
  105. static int      max_getbulk = 10;
  107. void            usage(void);
  108. void            get_field_names(void);
  109. void            get_table_entries(netsnmp_session * ss);
  110. void            getbulk_table_entries(netsnmp_session * ss);
  111. void            print_table(void);
  113. static void
  114. optProc(int argc, char *const *argv, int opt)
  115. {
  116.     switch (opt) {
  117.     case 'C':
  118.         /*
  119.          * Handle new '-C' command-specific meta-options 
  120.          */
  121.         while (*optarg) {
  122.             switch (*optarg++) {
  123.             case 'w':
  124. if (optind < argc) {
  125.     if (argv[optind]) {
  126. max_width = atoi(argv[optind]);
  127. if (max_width == 0) {
  128.     usage();
  129.     fprintf(stderr, "Bad -Cw option: %sn", 
  130.     argv[optind]);
  131.     exit(1);
  132. }
  133.     }
  134. } else {
  135.     usage();
  136.                     fprintf(stderr, "Bad -Cw option: no argument givenn");
  137.     exit(1);
  138. }
  139. optind++;
  140.                 break;
  141.             case 'c':
  142. if (optind < argc) {
  143.     if (argv[optind]) {
  144. column_width = atoi(argv[optind]);
  145. if (column_width <= 2) {
  146.     usage();
  147.     fprintf(stderr, "Bad -Cc option: %sn", 
  148.     argv[optind]);
  149.     exit(1);
  150. }
  151.                         /* Reduce by one for space at end of column */
  152.                         column_width -= 1;
  153.     }
  154. } else {
  155.     usage();
  156.                     fprintf(stderr, "Bad -Cc option: no argument givenn");
  157.     exit(1);
  158. }
  159. optind++;
  160.                 break;
  161.             case 'l':
  162.                 left_justify_flag = "-";
  163.                 break;
  164.             case 'f':
  165. if (optind < argc) {
  166.     field_separator = argv[optind];
  167. } else {
  168.                     usage();
  169.     fprintf(stderr, "Bad -Cf option: no argument givenn");
  170.     exit(1);
  171. }
  172. optind++;
  173.                 break;
  174.             case 'h':
  175.                 headers_only = 1;
  176.                 break;
  177.             case 'H':
  178.                 no_headers = 1;
  179.                 break;
  180.             case 'B':
  181.                 use_getbulk = 0;
  182.                 break;
  183.             case 'b':
  184.                 brief = 1;
  185.                 break;
  186.             case 'i':
  187.                 show_index = 1;
  188.                 break;
  189.             case 'r':
  190. if (optind < argc) {
  191.     if (argv[optind]) {
  192. max_getbulk = atoi(argv[optind]);
  193. if (max_getbulk == 0) {
  194.     usage();
  195.     fprintf(stderr, "Bad -Cr option: %sn", 
  196.     argv[optind]);
  197.     exit(1);
  198. }
  199.     }
  200. } else {
  201.     usage();
  202.                     fprintf(stderr, "Bad -Cr option: no argument givenn");
  203.     exit(1);
  204. }
  205. optind++;
  206.                 break;
  207.             default:
  208.                 fprintf(stderr, "Bad option after -C: %cn", optarg[-1]);
  209.                 usage();
  210.             }
  211.         }
  212.         break;
  213.     }
  214. }
  216. void
  217. usage(void)
  218. {
  219.     fprintf(stderr, "USAGE: snmptable ");
  220.     snmp_parse_args_usage(stderr);
  221.     fprintf(stderr, " TABLE-OIDnn");
  222.     snmp_parse_args_descriptions(stderr);
  223.     fprintf(stderr,
  224.     "  -C APPOPTSttSet various application specific behaviours:n");
  225.     fprintf(stderr, "ttt  b:       brief field namesn");
  226.     fprintf(stderr, "ttt  B:       do not use GETBULK requestsn");
  227.     fprintf(stderr, "ttt  c<NUM>:  print table in columns of <NUM> chars widthn");
  228.     fprintf(stderr, "ttt  f<STR>:  print table delimitied with <STR>n");
  229.     fprintf(stderr, "ttt  h:       print only the column headersn");
  230.     fprintf(stderr, "ttt  H:       print no column headersn");
  231.     fprintf(stderr, "ttt  i:       print index valuesn");
  232.     fprintf(stderr, "ttt  l:       left justify outputn");
  233.     fprintf(stderr, "ttt  r<NUM>:  for GETBULK: set max-repeaters to <NUM>n");
  234.     fprintf(stderr, "ttt           for GETNEXT: retrieve <NUM> entries at a timen");
  235.     fprintf(stderr, "ttt  w<NUM>:  print table in parts of <NUM> chars widthn");
  236. }
  238. void
  239. reverse_fields(void)
  240. {
  241.     struct column   tmp;
  242.     int             i;
  244.     for (i = 0; i < fields / 2; i++) {
  245.         memcpy(&tmp, &(column[i]), sizeof(struct column));
  246.         memcpy(&(column[i]), &(column[fields - 1 - i]),
  247.                sizeof(struct column));
  248.         memcpy(&(column[fields - 1 - i]), &tmp, sizeof(struct column));
  249.     }
  250. }
  252. int
  253. main(int argc, char *argv[])
  254. {
  255.     netsnmp_session session, *ss;
  256.     int            total_entries = 0;
  258.     setvbuf(stdout, NULL, _IOLBF, 1024);
  259.     netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, 
  260.                            NETSNMP_DS_LIB_QUICK_PRINT, 1);
  262.     /*
  263.      * get the common command line arguments 
  264.      */
  265.     switch (snmp_parse_args(argc, argv, &session, "C:", optProc)) {
  266.     case -2:
  267.         exit(0);
  268.     case -1:
  269.         usage();
  270.         exit(1);
  271.     default:
  272.         break;
  273.     }
  275.     /*
  276.      * get the initial object and subtree 
  277.      */
  278.     /*
  279.      * specified on the command line 
  280.      */
  281.     if (optind + 1 != argc) {
  282.         fprintf(stderr, "Must have exactly one table namen");
  283.         usage();
  284.         exit(1);
  285.     }
  287.     rootlen = MAX_OID_LEN;
  288.     if (!snmp_parse_oid(argv[optind], root, &rootlen)) {
  289.         snmp_perror(argv[optind]);
  290.         exit(1);
  291.     }
  292.     localdebug = netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, 
  293.                                         NETSNMP_DS_LIB_DUMP_PACKET);
  295.     get_field_names();
  296.     reverse_fields();
  298.     /*
  299.      * open an SNMP session 
  300.      */
  301.     SOCK_STARTUP;
  302.     ss = snmp_open(&session);
  303.     if (ss == NULL) {
  304.         /*
  305.          * diagnose snmp_open errors with the input netsnmp_session pointer 
  306.          */
  307.         snmp_sess_perror("snmptable", &session);
  308.         SOCK_CLEANUP;
  309.         exit(1);
  310.     }
  312. #ifndef DISABLE_SNMPV1
  313.     if (ss->version == SNMP_VERSION_1)
  314.         use_getbulk = 0;
  315. #endif
  317.     do {
  318.         entries = 0;
  319.         allocated = 0;
  320.         if (!headers_only) {
  321.             if (use_getbulk)
  322.                 getbulk_table_entries(ss);
  323.             else
  324.                 get_table_entries(ss);
  325.         }
  327.         if (exitval) {
  328.             snmp_close(ss);
  329.             SOCK_CLEANUP;
  330.             return exitval;
  331.         }
  333.         if (entries || headers_only)
  334.             print_table();
  336.         if (data) {
  337.             free (data);
  338.             data = NULL;
  339.         }
  341.         if (indices) {
  342.             free (indices);
  343.             indices = NULL;
  344.         }
  346.         total_entries += entries;
  348.     } while (!end_of_table);
  350.     snmp_close(ss);
  351.     SOCK_CLEANUP;
  353.     if (total_entries == 0)
  354.         printf("%s: No entriesn", table_name);
  356.     return 0;
  357. }
  359. void
  360. print_table(void)
  361. {
  362.     int             entry, field, first_field, last_field = 0, width, part = 0;
  363.     char          **dp;
  364.     char            string_buf[SPRINT_MAX_LEN];
  365.     char           *index_fmt = NULL;
  366.     static int      first_pass = 1;
  368.     if (!no_headers && !headers_only && first_pass)
  369.         printf("SNMP table: %snn", table_name);
  371.     for (field = 0; field < fields; field++) {
  372.         if (column_width != 0)
  373.             sprintf(string_buf, "%%%s%d.%ds", left_justify_flag,
  374.                     column_width + 1, column_width );
  375.         else if (field_separator == NULL)
  376.             sprintf(string_buf, "%%%s%ds", left_justify_flag,
  377.                     column[field].width + 1);
  378.         else if (field == 0 && !show_index)
  379.             sprintf(string_buf, "%%s");
  380.         else
  381.             sprintf(string_buf, "%s%%s", field_separator);
  382.         column[field].fmt = strdup(string_buf);
  383.     }
  384.     if (show_index) {
  385.         if (column_width)
  386.             sprintf(string_buf, "nindex: %%sn");
  387.         else if (field_separator == NULL)
  388.             sprintf(string_buf, "%%%s%ds", left_justify_flag, index_width);
  389.         else
  390.             sprintf(string_buf, "%%s");
  391.         index_fmt = strdup(string_buf);
  392.     }
  394.     while (last_field != fields) {
  395.         part++;
  396.         if (part != 1 && !no_headers)
  397.             printf("nSNMP table %s, part %dnn", table_name, part);
  398.         first_field = last_field;
  399.         dp = data;
  400.         if (show_index && !no_headers && !column_width) {
  401.             width = index_width;
  402.             printf(index_fmt, "index");
  403.         } else
  404.             width = 0;
  405.         for (field = first_field; field < fields; field++) {
  406.             if (max_width)
  407.             {
  408.                 if (column_width) {
  409.                     if (!no_headers && first_pass) {
  410.                         width += column_width + 1;
  411.                         if (field != first_field && width > max_width) {
  412.                             printf("n");
  413.                             width = column_width + 1;
  414.                         }
  415.                     }
  416.                 }
  417.                 else {
  418.                     width += column[field].width + 1;
  419.                     if (field != first_field && width > max_width)
  420.                         break;
  421.                 }
  422.             }
  423.             if (!no_headers && first_pass)
  424.                 printf(column[field].fmt, column[field].label);
  425.         }
  426.         last_field = field;
  427.         if (!no_headers && first_pass)
  428.             printf("n");
  429.         for (entry = 0; entry < entries; entry++) {
  430.             width = 0;
  431.             if (show_index)
  432.             {
  433.                 if (!column_width)
  434.                     width = index_width;
  435.                 printf(index_fmt, indices[entry]);
  436.             }
  437.             for (field = first_field; field < last_field; field++) {
  438.                 if (column_width && max_width) {
  439.                     width += column_width + 1;
  440.                     if (field != first_field && width > max_width) {
  441.                         printf("n");
  442.                         width = column_width + 1;
  443.                     }
  444.                 }
  445.                 printf(column[field].fmt, dp[field] ? dp[field] : "?");
  446.             }
  447.             dp += fields;
  448.             printf("n");
  449.         }
  450.     }
  452.     first_pass = 0;
  453. }
  455. void
  456. get_field_names(void)
  457. {
  458.     u_char         *buf = NULL, *name_p = NULL;
  459.     size_t          buf_len = 0, out_len = 0;
  460. #ifndef DISABLE_MIB_LOADING
  461.     struct tree    *tbl = NULL;
  462. #endif /* DISABLE_MIB_LOADING */
  463.     int             going = 1;
  465. #ifndef DISABLE_MIB_LOADING
  466.     tbl = get_tree(root, rootlen, get_tree_head());
  467.     if (tbl) {
  468.         tbl = tbl->child_list;
  469.         if (tbl) {
  470.             root[rootlen++] = tbl->subid;
  471.             tbl = tbl->child_list;
  472.         } else {
  473.             root[rootlen++] = 1;
  474.             going = 0;
  475.         }
  476.     }
  477. #endif /* DISABLE_MIB_LOADING */
  479.     if (sprint_realloc_objid
  480.         (&buf, &buf_len, &out_len, 1, root, rootlen - 1)) {
  481.         table_name = buf;
  482.         buf = NULL;
  483.         buf_len = out_len = 0;
  484.     } else {
  485.         table_name = strdup("[TRUNCATED]");
  486.         out_len = 0;
  487.     }
  489.     fields = 0;
  490.     while (going) {
  491.         fields++;
  492. #ifndef DISABLE_MIB_LOADING
  493.         if (tbl) {
  494.             if (tbl->access == MIB_ACCESS_NOACCESS) {
  495.                 fields--;
  496.                 tbl = tbl->next_peer;
  497.                 if (!tbl) {
  498.                     going = 0;
  499.                 }
  500.                 continue;
  501.             }
  502.             root[rootlen] = tbl->subid;
  503.             tbl = tbl->next_peer;
  504.             if (!tbl)
  505.                 going = 0;
  506.         } else {
  507. #endif /* DISABLE_MIB_LOADING */
  508.             root[rootlen] = fields;
  509. #ifndef DISABLE_MIB_LOADING
  510.         }
  511. #endif /* DISABLE_MIB_LOADING */
  512.         out_len = 0;
  513.         if (sprint_realloc_objid
  514.             (&buf, &buf_len, &out_len, 1, root, rootlen + 1)) {
  515.             name_p = strrchr(buf, '.');
  516.             if (name_p == NULL) {
  517.                 name_p = strrchr(buf, ':');
  518.             }
  519.             if (name_p == NULL) {
  520.                 name_p = buf;
  521.             } else {
  522.                 name_p++;
  523.             }
  524.         } else {
  525.             break;
  526.         }
  527.         if (localdebug) {
  528.             printf("%s %cn", buf, name_p[0]);
  529.         }
  530.         if ('0' <= name_p[0] && name_p[0] <= '9') {
  531.             fields--;
  532.             break;
  533.         }
  534.         if (fields == 1) {
  535.             column = (struct column *) malloc(sizeof(*column));
  536.         } else {
  537.             column =
  538.                 (struct column *) realloc(column,
  539.                                           fields * sizeof(*column));
  540.         }
  541.         column[fields - 1].label = strdup(name_p);
  542.         column[fields - 1].width = strlen(name_p);
  543.         column[fields - 1].subid = root[rootlen];
  544.     }
  545.     if (fields == 0) {
  546.         fprintf(stderr, "Was that a table? %sn", table_name);
  547.         exit(1);
  548.     }
  549.     *name_p = 0;
  550.     memmove(name, root, rootlen * sizeof(oid));
  551.     name_length = rootlen + 1;
  552.     name_p = strrchr(buf, '.');
  553.     if (name_p == NULL) {
  554.         name_p = strrchr(buf, ':');
  555.     }
  556.     if (name_p != NULL) {
  557.         *name_p = 0;
  558.     }
  559.     if (brief && fields > 1) {
  560.         char           *f1, *f2;
  561.         int             common = strlen(column[0].label);
  562.         int             field, len;
  563.         for (field = 1; field < fields; field++) {
  564.             f1 = column[field - 1].label;
  565.             f2 = column[field].label;
  566.             while (*f1 && *f1++ == *f2++);
  567.             len = f2 - column[field].label - 1;
  568.             if (len < common)
  569.                 common = len;
  570.         }
  571.         if (common) {
  572.             for (field = 0; field < fields; field++) {
  573.                 column[field].label += common;
  574.                 column[field].width -= common;
  575.             }
  576.         }
  577.     }
  578.     if (buf != NULL) {
  579.         free(buf);
  580.     }
  581. }
  583. void
  584. get_table_entries(netsnmp_session * ss)
  585. {
  586.     int             running = 1;
  587.     netsnmp_pdu    *pdu, *response;
  588.     netsnmp_variable_list *vars;
  589.     int             count;
  590.     int             status;
  591.     int             i;
  592.     int             col;
  593.     u_char         *buf = NULL;
  594.     size_t          out_len = 0, buf_len = 0;
  595.     char           *cp;
  596.     char           *name_p = NULL;
  597.     char          **dp;
  598.     int             have_current_index;
  600.     /*
  601.      * TODO:
  602.      *   1) Deal with multiple index fields
  603.      *   2) Deal with variable length index fields
  604.      *   3) optimize to remove a sparse column from get-requests
  605.      */
  607.     while (running &&
  608.            ((max_width && !column_width) || (entries < max_getbulk))) {
  609.         /*
  610.          * create PDU for GETNEXT request and add object name to request 
  611.          */
  612.         pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
  613.         for (i = 1; i <= fields; i++) {
  614.             name[rootlen] = column[i - 1].subid;
  615.             snmp_add_null_var(pdu, name, name_length);
  616.         }
  618.         /*
  619.          * do the request 
  620.          */
  621.         status = snmp_synch_response(ss, pdu, &response);
  622.         if (status == STAT_SUCCESS) {
  623.             if (response->errstat == SNMP_ERR_NOERROR) {
  624.                 /*
  625.                  * check resulting variables 
  626.                  */
  627.                 vars = response->variables;
  628.                 entries++;
  629.                 if (entries >= allocated) {
  630.                     if (allocated == 0) {
  631.                         allocated = 10;
  632.                         data =
  633.                             (char **) malloc(allocated * fields *
  634.                                              sizeof(char *));
  635.                         memset(data, 0,
  636.                                allocated * fields * sizeof(char *));
  637.                         if (show_index)
  638.                             indices =
  639.                                 (char **) malloc(allocated *
  640.                                                  sizeof(char *));
  641.                     } else {
  642.                         allocated += 10;
  643.                         data =
  644.                             (char **) realloc(data,
  645.                                               allocated * fields *
  646.                                               sizeof(char *));
  647.                         memset(data + entries * fields, 0,
  648.                                (allocated -
  649.                                 entries) * fields * sizeof(char *));
  650.                         if (show_index)
  651.                             indices =
  652.                                 (char **) realloc(indices,
  653.                                                   allocated *
  654.                                                   sizeof(char *));
  655.                     }
  656.                 }
  657.                 dp = data + (entries - 1) * fields;
  658.                 col = -1;
  659.                 end_of_table = 1;       /* assume end of table */
  660.                 have_current_index = 0;
  661.                 name_length = rootlen + 1;
  662.                 for (vars = response->variables; vars;
  663.                      vars = vars->next_variable) {
  664.                     col++;
  665.                     name[rootlen] = column[col].subid;
  666.                     if ((vars->name_length < name_length) ||
  667.                         ((int) vars->name[rootlen] != column[col].subid) ||
  668.                         memcmp(name, vars->name,
  669.                                name_length * sizeof(oid)) != 0
  670.                         || vars->type == SNMP_ENDOFMIBVIEW) {
  671.                         /*
  672.                          * not part of this subtree 
  673.                          */
  674.                         if (localdebug) {
  675.                             fprint_variable(stderr, vars->name,
  676.                                             vars->name_length, vars);
  677.                             fprintf(stderr, " => ignoredn");
  678.                         }
  679.                         continue;
  680.                     }
  682.                     /*
  683.                      * save index off 
  684.                      */
  685.                     if (!have_current_index) {
  686.                         end_of_table = 0;
  687.                         have_current_index = 1;
  688.                         name_length = vars->name_length;
  689.                         memcpy(name, vars->name,
  690.                                name_length * sizeof(oid));
  691.                         out_len = 0;
  692.                         if (!sprint_realloc_objid
  693.                             (&buf, &buf_len, &out_len, 1, vars->name,
  694.                              vars->name_length)) {
  695.                             break;
  696.                         }
  697.                         i = vars->name_length - rootlen + 1;
  698.                         if (localdebug || show_index) {
  699.                             if (netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, 
  700.                                               NETSNMP_DS_LIB_EXTENDED_INDEX)) {
  701.                                 name_p = strchr(buf, '[');
  702.                             } else {
  703.                                 switch (netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,
  704.                                                           NETSNMP_DS_LIB_OID_OUTPUT_FORMAT)) {
  705.                                 case NETSNMP_OID_OUTPUT_MODULE:
  706. case 0:
  707.                                     name_p = strrchr(buf, ':');
  708.                                     break;
  709.                                 case NETSNMP_OID_OUTPUT_SUFFIX:
  710.                                     name_p = buf;
  711.                                     break;
  712.                                 case NETSNMP_OID_OUTPUT_FULL:
  713.                                 case NETSNMP_OID_OUTPUT_NUMERIC:
  714.                                 case NETSNMP_OID_OUTPUT_UCD:
  715.                                     name_p = buf + strlen(table_name)+1;
  716.                                     name_p = strchr(name_p, '.')+1;
  717.                                     break;
  718. default:
  719.     fprintf(stderr, "Unrecognized -O option: %dn",
  720.     netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,
  721.       NETSNMP_DS_LIB_OID_OUTPUT_FORMAT));
  722.     exit(1);
  723.                                 }
  724.                                 name_p = strchr(name_p, '.') + 1;
  725.                             }
  726.                         }
  727.                         if (localdebug) {
  728.                             printf("Name: %s Index: %sn", buf, name_p);
  729.                         }
  730.                         if (show_index) {
  731.                             indices[entries - 1] = strdup(name_p);
  732.                             i = strlen(name_p);
  733.                             if (i > index_width)
  734.                                 index_width = i;
  735.                         }
  736.                     }
  738.                     if (localdebug && buf) {
  739.                         printf("%s => takenn", buf);
  740.                     }
  741.                     out_len = 0;
  742.                     sprint_realloc_value(&buf, &buf_len, &out_len, 1,
  743.                                          vars->name, vars->name_length,
  744.                                          vars);
  745.                     for (cp = buf; *cp; cp++) {
  746.                         if (*cp == 'n') {
  747.                             *cp = ' ';
  748.                         }
  749.                     }
  750.                     dp[col] = buf;
  751.                     i = out_len;
  752.                     buf = NULL;
  753.                     buf_len = 0;
  754.                     if (i > column[col].width) {
  755.                         column[col].width = i;
  756.                     }
  757.                 }
  759.                 if (end_of_table) {
  760.                     --entries;
  761.                     /*
  762.                      * not part of this subtree 
  763.                      */
  764.                     if (localdebug) {
  765.                         printf("End of table: %sn",
  766.                                buf ? (char *) buf : "[NIL]");
  767.                     }
  768.                     running = 0;
  769.                     continue;
  770.                 }
  771.             } else {
  772.                 /*
  773.                  * error in response, print it 
  774.                  */
  775.                 running = 0;
  776.                 if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  777.                     printf("End of MIBn");
  778.                     end_of_table = 1;
  779.                 } else {
  780.                     fprintf(stderr, "Error in packet.nReason: %sn",
  781.                             snmp_errstring(response->errstat));
  782.                     if (response->errindex != 0) {
  783.                         fprintf(stderr, "Failed object: ");
  784.                         for (count = 1, vars = response->variables;
  785.                              vars && count != response->errindex;
  786.                              vars = vars->next_variable, count++)
  787.                             /*EMPTY*/;
  788.                         if (vars) {
  789.                             fprint_objid(stderr, vars->name,
  790.                                          vars->name_length);
  791.                         }
  792.                         fprintf(stderr, "n");
  793.                     }
  794.                     exitval = 2;
  795.                 }
  796.             }
  797.         } else if (status == STAT_TIMEOUT) {
  798.             fprintf(stderr, "Timeout: No Response from %sn",
  799.                     ss->peername);
  800.             running = 0;
  801.             exitval = 1;
  802.         } else {                /* status == STAT_ERROR */
  803.             snmp_sess_perror("snmptable", ss);
  804.             running = 0;
  805.             exitval = 1;
  806.         }
  807.         if (response)
  808.             snmp_free_pdu(response);
  809.     }
  810. }
  812. void
  813. getbulk_table_entries(netsnmp_session * ss)
  814. {
  815.     int             running = 1;
  816.     netsnmp_pdu    *pdu, *response;
  817.     netsnmp_variable_list *vars, *last_var;
  818.     int             count;
  819.     int             status;
  820.     int             i;
  821.     int             row, col;
  822.     u_char         *buf = NULL;
  823.     size_t          buf_len = 0, out_len = 0;
  824.     char           *cp;
  825.     char           *name_p = NULL;
  826.     char          **dp;
  828.     while (running) {
  829.         /*
  830.          * create PDU for GETBULK request and add object name to request 
  831.          */
  832.         pdu = snmp_pdu_create(SNMP_MSG_GETBULK);
  833.         pdu->non_repeaters = 0;
  834.         pdu->max_repetitions = max_getbulk;
  835.         snmp_add_null_var(pdu, name, name_length);
  837.         /*
  838.          * do the request 
  839.          */
  840.         status = snmp_synch_response(ss, pdu, &response);
  841.         if (status == STAT_SUCCESS) {
  842.             if (response->errstat == SNMP_ERR_NOERROR) {
  843.                 /*
  844.                  * check resulting variables 
  845.                  */
  846.                 vars = response->variables;
  847.                 last_var = NULL;
  848.                 while (vars) {
  849.                     out_len = 0;
  850.                     sprint_realloc_objid(&buf, &buf_len, &out_len, 1,
  851.                                          vars->name, vars->name_length);
  852.                     if (vars->type == SNMP_ENDOFMIBVIEW ||
  853.                         memcmp(vars->name, name,
  854.                                rootlen * sizeof(oid)) != 0) {
  855.                         if (localdebug) {
  856.                             printf("%s => end of tablen",
  857.                                    buf ? (char *) buf : "[NIL]");
  858.                         }
  859.                         running = 0;
  860.                         break;
  861.                     }
  862.                     if (localdebug) {
  863.                         printf("%s => takenn",
  864.                                buf ? (char *) buf : "[NIL]");
  865.                     }
  866.                     if (netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, 
  867.                                               NETSNMP_DS_LIB_EXTENDED_INDEX)) {
  868.                         name_p = strchr(buf, '[');
  869.                     } else {
  870.                         switch (netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,
  871.                                                   NETSNMP_DS_LIB_OID_OUTPUT_FORMAT)) {
  872.                         case NETSNMP_OID_OUTPUT_MODULE:
  873. case 0:
  874.                             name_p = strrchr(buf, ':');
  875.                             break;
  876.                         case NETSNMP_OID_OUTPUT_SUFFIX:
  877.                             name_p = buf;
  878.                             break;
  879.                         case NETSNMP_OID_OUTPUT_FULL:
  880.                         case NETSNMP_OID_OUTPUT_NUMERIC:
  881.                         case NETSNMP_OID_OUTPUT_UCD:
  882.                             name_p = buf + strlen(table_name)+1;
  883.                             name_p = strchr(name_p, '.')+1;
  884.                             break;
  885. default:
  886.     fprintf(stderr, "Unrecognized -O option: %dn",
  887.     netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,
  888.               NETSNMP_DS_LIB_OID_OUTPUT_FORMAT));
  889.     exit(1);
  890.                         }
  891.                         name_p = strchr(name_p, '.') + 1;
  892.                     }
  893.                     for (row = 0; row < entries; row++)
  894.                         if (strcmp(name_p, indices[row]) == 0)
  895.                             break;
  896.                     if (row == entries) {
  897.                         entries++;
  898.                         if (entries >= allocated) {
  899.                             if (allocated == 0) {
  900.                                 allocated = 10;
  901.                                 data =
  902.                                     (char **) malloc(allocated * fields *
  903.                                                      sizeof(char *));
  904.                                 memset(data, 0,
  905.                                        allocated * fields *
  906.                                        sizeof(char *));
  907.                                 indices =
  908.                                     (char **) malloc(allocated *
  909.                                                      sizeof(char *));
  910.                             } else {
  911.                                 allocated += 10;
  912.                                 data =
  913.                                     (char **) realloc(data,
  914.                                                       allocated * fields *
  915.                                                       sizeof(char *));
  916.                                 memset(data + entries * fields, 0,
  917.                                        (allocated -
  918.                                         entries) * fields *
  919.                                        sizeof(char *));
  920.                                 indices =
  921.                                     (char **) realloc(indices,
  922.                                                       allocated *
  923.                                                       sizeof(char *));
  924.                             }
  925.                         }
  926.                         indices[row] = strdup(name_p);
  927.                         i = strlen(name_p);
  928.                         if (i > index_width)
  929.                             index_width = i;
  930.                     }
  931.                     dp = data + row * fields;
  932.                     out_len = 0;
  933.                     sprint_realloc_value(&buf, &buf_len, &out_len, 1,
  934.                                          vars->name, vars->name_length,
  935.                                          vars);
  936.                     for (cp = buf; *cp; cp++)
  937.                         if (*cp == 'n')
  938.                             *cp = ' ';
  939.                     for (col = 0; col < fields; col++)
  940.                         if (column[col].subid == vars->name[rootlen])
  941.                             break;
  942.                     dp[col] = buf;
  943.                     i = out_len;
  944.                     buf = NULL;
  945.                     buf_len = 0;
  946.                     if (i > column[col].width)
  947.                         column[col].width = i;
  948.                     last_var = vars;
  949.                     vars = vars->next_variable;
  950.                 }
  951.                 if (last_var) {
  952.                     name_length = last_var->name_length;
  953.                     memcpy(name, last_var->name,
  954.                            name_length * sizeof(oid));
  955.                 }
  956.             } else {
  957.                 /*
  958.                  * error in response, print it 
  959.                  */
  960.                 running = 0;
  961.                 if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  962.                     printf("End of MIBn");
  963.                 } else {
  964.                     fprintf(stderr, "Error in packet.nReason: %sn",
  965.                             snmp_errstring(response->errstat));
  966.                     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  967.                         fprintf(stderr,
  968.                                 "The request for this object identifier failed: ");
  969.                         for (count = 1, vars = response->variables;
  970.                              vars && count != response->errindex;
  971.                              vars = vars->next_variable, count++)
  972.                             /*EMPTY*/;
  973.                         if (vars) {
  974.                             fprint_objid(stderr, vars->name,
  975.                                          vars->name_length);
  976.                         }
  977.                         fprintf(stderr, "n");
  978.                     }
  979.                     exitval = 2;
  980.                 }
  981.             }
  982.         } else if (status == STAT_TIMEOUT) {
  983.             fprintf(stderr, "Timeout: No Response from %sn",
  984.                     ss->peername);
  985.             running = 0;
  986.             exitval = 1;
  987.         } else {                /* status == STAT_ERROR */
  988.             snmp_sess_perror("snmptable", ss);
  989.             running = 0;
  990.             exitval = 1;
  991.         }
  992.         if (response)
  993.             snmp_free_pdu(response);
  994.     }
  995. }