snmp_debug.c
上传用户:wxp200602
上传日期:2007-10-30
资源大小:4028k
文件大小:12k
源码类别:

SNMP编程

开发平台:

Unix_Linux

  1. #include <net-snmp/net-snmp-config.h>
  2. #include <stdio.h>
  3. #if HAVE_STDLIB_H
  4. #include <stdlib.h>
  5. #endif
  6. #if HAVE_STRING_H
  7. #include <string.h>
  8. #else
  9. #include <strings.h>
  10. #endif
  11. #include <sys/types.h>
  12. #if HAVE_NETINET_IN_H
  13. #include <netinet/in.h>
  14. #endif
  15. #if HAVE_STDARG_H
  16. #include <stdarg.h>
  17. #else
  18. #include <varargs.h>
  19. #endif
  20. #if HAVE_WINSOCK_H
  21. #include <winsock.h>
  22. #endif
  23. #if HAVE_DMALLOC_H
  24. #include <dmalloc.h>
  25. #endif
  26. #include <net-snmp/types.h>
  27. #include <net-snmp/output_api.h>
  28. #include <net-snmp/library/snmp_debug.h>        /* For this file's "internal" definitions */
  29. #include <net-snmp/config_api.h>
  30. #include <net-snmp/utilities.h>
  31. #include <net-snmp/library/mib.h>
  32. #include <net-snmp/library/snmp_api.h>
  33. static int      dodebug = SNMP_ALWAYS_DEBUG;
  34. int             debug_num_tokens = 0;
  35. static int      debug_print_everything = 0;
  36. netsnmp_token_descr dbg_tokens[MAX_DEBUG_TOKENS];
  37. /*
  38.  * indent debugging:  provide a space padded section to return an indent for 
  39.  */
  40. static int      debugindent = 0;
  41. #define INDENTMAX 80
  42. static char     debugindentchars[] =
  43.     "                                                                                ";
  44. /*
  45.  * Prototype definitions 
  46.  */
  47. void            debug_config_register_tokens(const char *configtoken,
  48.                                              char *tokens);
  49. void            debug_config_turn_on_debugging(const char *configtoken,
  50.                                                char *line);
  51. char           *
  52. debug_indent(void)
  53. {
  54.     return debugindentchars;
  55. }
  56. void
  57. debug_indent_add(int amount)
  58. {
  59.     if (debugindent + amount >= 0 && debugindent + amount < 80) {
  60.         debugindentchars[debugindent] = ' ';
  61.         debugindent += amount;
  62.         debugindentchars[debugindent] = '';
  63.     }
  64. }
  65. void
  66. debug_config_register_tokens(const char *configtoken, char *tokens)
  67. {
  68.     debug_register_tokens(tokens);
  69. }
  70. void
  71. debug_config_turn_on_debugging(const char *configtoken, char *line)
  72. {
  73.     snmp_set_do_debugging(atoi(line));
  74. }
  75. void
  76. snmp_debug_init(void)
  77. {
  78.     debugindentchars[0] = ''; /* zero out the debugging indent array. */
  79.     /*
  80.      * Hmmm....
  81.      *   this "init" routine seems to be called *after* processing
  82.      *   the command line options.   So we can't clear the debug
  83.      *   token array here, and will just have to rely on it being
  84.      *   initialised to 0 automatically.
  85.      * So much for trying to program responsibly :-)
  86.      */
  87. /*  memset(dbg_tokens, 0, MAX_DEBUG_TOKENS*sizeof(struct token_dscr));  */
  88.     register_prenetsnmp_mib_handler("snmp", "doDebugging",
  89.                                     debug_config_turn_on_debugging, NULL,
  90.                                     "(1|0)");
  91.     register_prenetsnmp_mib_handler("snmp", "debugTokens",
  92.                                     debug_config_register_tokens, NULL,
  93.                                     "token[,token...]");
  94. }
  95. void
  96. debug_register_tokens(char *tokens)
  97. {
  98.     char           *newp, *cp;
  99.     char           *st;
  100.     if (tokens == 0 || *tokens == 0)
  101.         return;
  102.     newp = strdup(tokens);      /* strtok_r messes it up */
  103.     cp = strtok_r(newp, DEBUG_TOKEN_DELIMITER, &st);
  104.     while (cp) {
  105.         if (strlen(cp) < MAX_DEBUG_TOKEN_LEN) {
  106.             if (strcasecmp(cp, DEBUG_ALWAYS_TOKEN) == 0) {
  107.                 debug_print_everything = 1;
  108.             } else if (debug_num_tokens < MAX_DEBUG_TOKENS) {
  109.                 dbg_tokens[debug_num_tokens].token_name = strdup(cp);
  110.                 dbg_tokens[debug_num_tokens++].enabled  = 1;
  111.             } else {
  112.                 snmp_log(LOG_NOTICE, "Unable to register debug token %s", cp);
  113.             }
  114.         } else {
  115.             snmp_log(LOG_NOTICE, "Debug token %s over length", cp);
  116.         }
  117.         cp = strtok_r(NULL, DEBUG_TOKEN_DELIMITER, &st);
  118.     }
  119.     free(newp);
  120. }
  121. /* 
  122.  * Print all registered tokens along with their current status
  123.  */
  124. void 
  125. debug_print_registered_tokens(void) {
  126.     int i;
  127.     snmp_log(LOG_INFO, "%d tokens registered :n", debug_num_tokens);
  128.     for (i=0; i<debug_num_tokens; i++) {
  129.         snmp_log( LOG_INFO, "%d) %s : %dn", 
  130.                  i, dbg_tokens [i].token_name, dbg_tokens [i].enabled);
  131.     }
  132. }
  133. /*
  134.  * Enable logs on a given token
  135.  */
  136. int
  137. debug_enable_token_logs (const char *token) {
  138.     int i;
  139.     /* debugging flag is on or off */
  140.     if (!dodebug)
  141.         return SNMPERR_GENERR;
  142.     if (debug_num_tokens == 0 || debug_print_everything) {
  143.         /* no tokens specified, print everything */
  144.         return SNMPERR_SUCCESS;
  145.     } else {
  146.         for(i=0; i < debug_num_tokens; i++) {
  147.             if (dbg_tokens[i].token_name &&
  148.                 strncmp(dbg_tokens[i].token_name, token, 
  149.                         strlen(dbg_tokens[i].token_name)) == 0) {
  150.                 dbg_tokens[i].enabled = 1;
  151.                 return SNMPERR_SUCCESS;
  152.             }
  153.         }
  154.     }
  155.     return SNMPERR_GENERR;
  156. }
  157. /*
  158.  * Diable logs on a given token
  159.  */
  160. int
  161. debug_disable_token_logs (const char *token) {
  162.     int i;
  163.     /* debugging flag is on or off */
  164.     if (!dodebug)
  165.         return SNMPERR_GENERR;
  166.     if (debug_num_tokens == 0 || debug_print_everything) {
  167.         /* no tokens specified, print everything */
  168.         return SNMPERR_SUCCESS;
  169.     } else {
  170.         for(i=0; i < debug_num_tokens; i++) {
  171.             if (strncmp(dbg_tokens[i].token_name, token, 
  172.                   strlen(dbg_tokens[i].token_name)) == 0) {
  173.                 dbg_tokens[i].enabled = 0;
  174.                 return SNMPERR_SUCCESS;
  175.             }
  176.         }
  177.     }
  178.     return SNMPERR_GENERR;
  179. }
  180. /*
  181.  * debug_is_token_registered(char *TOKEN):
  182.  * 
  183.  * returns SNMPERR_SUCCESS
  184.  * or SNMPERR_GENERR
  185.  * 
  186.  * if TOKEN has been registered and debugging support is turned on.
  187.  */
  188. int
  189. debug_is_token_registered(const char *token)
  190. {
  191.     int             i;
  192.     /*
  193.      * debugging flag is on or off 
  194.      */
  195.     if (!dodebug)
  196.         return SNMPERR_GENERR;
  197.     if (debug_num_tokens == 0 || debug_print_everything) {
  198.         /*
  199.          * no tokens specified, print everything 
  200.          */
  201.         return SNMPERR_SUCCESS;
  202.     } else {
  203.         for (i = 0; i < debug_num_tokens; i++) {
  204.             if (dbg_tokens[i].token_name &&
  205.                 strncmp(dbg_tokens[i].token_name, token,
  206.                         strlen(dbg_tokens[i].token_name)) == 0) {
  207.                 if (dbg_tokens[i].enabled)
  208.                     return SNMPERR_SUCCESS;
  209.                 else
  210.                     return SNMPERR_GENERR;
  211.             }
  212.         }
  213.     }
  214.     return SNMPERR_GENERR;
  215. }
  216. void
  217. #if HAVE_STDARG_H
  218. debugmsg(const char *token, const char *format, ...)
  219. #else
  220. debugmsg(va_alist)
  221.      va_dcl
  222. #endif
  223. {
  224.     va_list         debugargs;
  225. #if HAVE_STDARG_H
  226.     va_start(debugargs, format);
  227. #else
  228.     const char     *format;
  229.     const char     *token;
  230.     va_start(debugargs);
  231.     token = va_arg(debugargs, const char *);
  232.     format = va_arg(debugargs, const char *);   /* ??? */
  233. #endif
  234.     if (debug_is_token_registered(token) == SNMPERR_SUCCESS) {
  235.         snmp_vlog(LOG_DEBUG, format, debugargs);
  236.     }
  237.     va_end(debugargs);
  238. }
  239. void
  240. debugmsg_oid(const char *token, const oid * theoid, size_t len)
  241. {
  242.     u_char         *buf = NULL;
  243.     size_t          buf_len = 0, out_len = 0;
  244.     if (sprint_realloc_objid(&buf, &buf_len, &out_len, 1, theoid, len)) {
  245.         if (buf != NULL) {
  246.             debugmsg(token, "%s", buf);
  247.         }
  248.     } else {
  249.         if (buf != NULL) {
  250.             debugmsg(token, "%s [TRUNCATED]", buf);
  251.         }
  252.     }
  253.     if (buf != NULL) {
  254.         free(buf);
  255.     }
  256. }
  257. void
  258. debugmsg_suboid(const char *token, const oid * theoid, size_t len)
  259. {
  260.     u_char         *buf = NULL;
  261.     size_t          buf_len = 0, out_len = 0;
  262.     int             buf_overflow = 0;
  263.     netsnmp_sprint_realloc_objid(&buf, &buf_len, &out_len, 1,
  264.                                  &buf_overflow, theoid, len);
  265.     if(buf_overflow) {
  266.         if (buf != NULL) {
  267.             debugmsg(token, "%s [TRUNCATED]", buf);
  268.         }
  269.     } else {
  270.         if (buf != NULL) {
  271.             debugmsg(token, "%s", buf);
  272.         }
  273.     }
  274.     if (buf != NULL) {
  275.         free(buf);
  276.     }
  277. }
  278. void
  279. debugmsg_var(const char *token, netsnmp_variable_list * var)
  280. {
  281.     u_char         *buf = NULL;
  282.     size_t          buf_len = 0, out_len = 0;
  283.     if (var == NULL || token == NULL) {
  284.         return;
  285.     }
  286.     if (sprint_realloc_variable(&buf, &buf_len, &out_len, 1,
  287.                                 var->name, var->name_length, var)) {
  288.         if (buf != NULL) {
  289.             debugmsg(token, "%s", buf);
  290.         }
  291.     } else {
  292.         if (buf != NULL) {
  293.             debugmsg(token, "%s [TRUNCATED]", buf);
  294.         }
  295.     }
  296.     if (buf != NULL) {
  297.         free(buf);
  298.     }
  299. }
  300. void
  301. debugmsg_oidrange(const char *token, const oid * theoid, size_t len,
  302.                   size_t var_subid, oid range_ubound)
  303. {
  304.     u_char         *buf = NULL;
  305.     size_t          buf_len = 0, out_len = 0, i = 0;
  306.     int             rc = 0;
  307.     if (var_subid == 0) {
  308.         rc = sprint_realloc_objid(&buf, &buf_len, &out_len, 1, theoid,
  309.                                   len);
  310.     } else {
  311.         char            tmpbuf[128];
  312.         /* XXX - ? check for 0 == var_subid -1 ? */
  313.         rc = sprint_realloc_objid(&buf, &buf_len, &out_len, 1, theoid,
  314.                                   var_subid-1);  /* Adjust for C's 0-based array indexing */
  315.         if (rc) {
  316.             sprintf(tmpbuf, ".%lu--%lu", theoid[var_subid - 1],
  317.                     range_ubound);
  318.             rc = snmp_strcat(&buf, &buf_len, &out_len, 1, tmpbuf);
  319.             if (rc) {
  320.                 for (i = var_subid; i < len; i++) {
  321.                     sprintf(tmpbuf, ".%lu", theoid[i]);
  322.                     if (!snmp_strcat(&buf, &buf_len, &out_len, 1, tmpbuf)) {
  323.                         break;
  324.                     }
  325.                 }
  326.             }
  327.         }
  328.     }
  329.     if (buf != NULL) {
  330.         debugmsg(token, "%s%s", buf, rc ? "" : " [TRUNCATED]");
  331.         free(buf);
  332.     }
  333. }
  334. void
  335. debugmsg_hex(const char *token, u_char * thedata, size_t len)
  336. {
  337.     u_char         *buf = NULL;
  338.     size_t          buf_len = 0, out_len = 0;
  339.     if (sprint_realloc_hexstring
  340.         (&buf, &buf_len, &out_len, 1, thedata, len)) {
  341.         if (buf != NULL) {
  342.             debugmsg(token, "%s", buf);
  343.         }
  344.     } else {
  345.         if (buf != NULL) {
  346.             debugmsg(token, "%s [TRUNCATED]", buf);
  347.         }
  348.     }
  349.     if (buf != NULL) {
  350.         free(buf);
  351.     }
  352. }
  353. void
  354. debugmsg_hextli(const char *token, u_char * thedata, size_t len)
  355. {
  356.     char            buf[SPRINT_MAX_LEN], token2[SPRINT_MAX_LEN];
  357.     u_char         *b3 = NULL;
  358.     size_t          b3_len = 0, o3_len = 0;
  359.     int             incr;
  360.     sprintf(token2, "dumpx_%s", token);
  361.     /*
  362.      * XX tracing lines removed from this function DEBUGTRACE; 
  363.      */
  364.     DEBUGIF(token2) {
  365.         for (incr = 16; len > 0; len -= incr, thedata += incr) {
  366.             if ((int) len < incr) {
  367.                 incr = len;
  368.             }
  369.             /*
  370.              * XXnext two lines were DEBUGPRINTINDENT(token);
  371.              */
  372.             sprintf(buf, "dumpx%s", token);
  373.             debugmsg(buf, "%s: %s", token2, debug_indent());
  374.             if (sprint_realloc_hexstring
  375.                 (&b3, &b3_len, &o3_len, 1, thedata, incr)) {
  376.                 if (b3 != NULL) {
  377.                     debugmsg(token2, "%s", b3);
  378.                 }
  379.             } else {
  380.                 if (b3 != NULL) {
  381.                     debugmsg(token2, "%s [TRUNCATED]", b3);
  382.                 }
  383.             }
  384.             o3_len = 0;
  385.         }
  386.     }
  387.     if (b3 != NULL) {
  388.         free(b3);
  389.     }
  390. }
  391. void
  392. #if HAVE_STDARG_H
  393. debugmsgtoken(const char *token, const char *format, ...)
  394. #else
  395. debugmsgtoken(va_alist)
  396.      va_dcl
  397. #endif
  398. {
  399.     va_list         debugargs;
  400. #if HAVE_STDARG_H
  401.     va_start(debugargs, format);
  402. #else
  403.     const char     *token;
  404.     va_start(debugargs);
  405.     token = va_arg(debugargs, const char *);
  406. #endif
  407.     debugmsg(token, "%s: ", token);
  408.     va_end(debugargs);
  409. }
  410. void
  411. #if HAVE_STDARG_H
  412. debug_combo_nc(const char *token, const char *format, ...)
  413. #else
  414. debugmsgtoken(va_alist)
  415.      va_dcl
  416. #endif
  417. {
  418.     va_list         debugargs;
  419. #if HAVE_STDARG_H
  420.     va_start(debugargs, format);
  421. #else
  422.     const char     *format;
  423.     const char     *token;
  424.     va_start(debugargs);
  425.     token = va_arg(debugargs, const char *);
  426.     format = va_arg(debugargs, const char *);   /* ??? */
  427. #endif
  428.     snmp_log(LOG_DEBUG, "%s: ", token);
  429.     snmp_vlog(LOG_DEBUG, format, debugargs);
  430.     va_end(debugargs);
  431. }
  432. /*
  433.  * for speed, these shouldn't be in default_storage space 
  434.  */
  435. void
  436. snmp_set_do_debugging(int val)
  437. {
  438.     dodebug = val;
  439. }
  440. int
  441. snmp_get_do_debugging(void)
  442. {
  443.     return dodebug;
  444. }