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

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

SNMP编程

开发平台：

Unix_Linux

tools.c：源码内容
  1. /*
  2.  * tools.c
  3.  */
  5. #define NETSNMP_TOOLS_C 1 /* dont re-define malloc wrappers here */
  7. #include <net-snmp/net-snmp-config.h>
  9. #include <ctype.h>
  10. #include <stdio.h>
  11. #include <sys/types.h>
  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. #ifdef HAVE_SYS_SOCKET_H
  27. #include <sys/socket.h>
  28. #endif
  29. #if HAVE_WINSOCK_H
  30. #include <winsock.h>
  31. #endif
  32. #ifdef HAVE_STDLIB_H
  33. #include <stdlib.h>
  34. #endif
  35. #if HAVE_STRING_H
  36. #include <string.h>
  37. #else
  38. #include <strings.h>
  39. #endif
  40. #ifdef HAVE_NETINET_IN_H
  41. #include <netinet/in.h>
  42. #endif
  43. #ifdef HAVE_ARPA_INET_H
  44. #include <arpa/inet.h>
  45. #endif
  46. #ifdef cygwin
  47. #include <windows.h>
  48. #endif
  50. #if HAVE_DMALLOC_H
  51. #include <dmalloc.h>
  52. #endif
  54. #include <net-snmp/types.h>
  55. #include <net-snmp/output_api.h>
  56. #include <net-snmp/utilities.h>
  57. #include <net-snmp/library/tools.h>     /* for "internal" definitions */
  59. #include <net-snmp/library/snmp_api.h>
  60. #include <net-snmp/library/mib.h>
  61. #include <net-snmp/library/scapi.h>
  63. #ifdef WIN32
  64. /**
  65.  * This function is a wrapper for the strdup function.
  66.  */
  67. char * netsnmp_strdup( const char * ptr)
  68. {
  69.     return strdup(ptr);
  70. }
  71. /**
  72.  * This function is a wrapper for the calloc function.
  73.  */
  74. void * netsnmp_calloc(size_t nmemb, size_t size)
  75. {
  76.     return calloc(nmemb, size);
  77. }
  79. /**
  80.  * This function is a wrapper for the malloc function.
  81.  */
  82. void * netsnmp_malloc(size_t size)
  83. {
  84.     return malloc(size);
  85. }
  87. /**
  88.  * This function is a wrapper for the realloc function.
  89.  */
  90. void * netsnmp_realloc( void * ptr, size_t size)
  91. {
  92.     return realloc(ptr, size);
  93. }
  95. /**
  96.  * This function is a wrapper for the free function.
  97.  * It calls free only if the calling parameter has a non-zero value.
  98.  */
  99. void netsnmp_free( void * ptr)
  100. {
  101.     if (ptr)
  102.         free(ptr);
  103. }
  104. #endif /* WIN32 */
  106. /**
  107.  * This function increase the size of the buffer pointed at by *buf, which is
  108.  * initially of size *buf_len.  Contents are preserved **AT THE BOTTOM END OF
  109.  * THE BUFFER**.  If memory can be (re-)allocated then it returns 1, else it
  110.  * returns 0.
  111.  * 
  112.  * @param buf  pointer to a buffer pointer
  113.  * @param buf_len      pointer to current size of buffer in bytes
  114.  * 
  115.  * @note
  116.  * The current re-allocation algorithm is to increase the buffer size by
  117.  * whichever is the greater of 256 bytes or the current buffer size, up to
  118.  * a maximum increase of 8192 bytes.  
  119.  */
  120. int
  121. snmp_realloc(u_char ** buf, size_t * buf_len)
  122. {
  123.     u_char         *new_buf = NULL;
  124.     size_t          new_buf_len = 0;
  126.     if (buf == NULL) {
  127.         return 0;
  128.     }
  130.     if (*buf_len <= 255) {
  131.         new_buf_len = *buf_len + 256;
  132.     } else if (*buf_len > 255 && *buf_len <= 8191) {
  133.         new_buf_len = *buf_len * 2;
  134.     } else if (*buf_len > 8191) {
  135.         new_buf_len = *buf_len + 8192;
  136.     }
  138.     if (*buf == NULL) {
  139.         new_buf = (u_char *) malloc(new_buf_len);
  140.     } else {
  141.         new_buf = (u_char *) realloc(*buf, new_buf_len);
  142.     }
  144.     if (new_buf != NULL) {
  145.         *buf = new_buf;
  146.         *buf_len = new_buf_len;
  147.         return 1;
  148.     } else {
  149.         return 0;
  150.     }
  151. }
  153. int
  154. snmp_strcat(u_char ** buf, size_t * buf_len, size_t * out_len,
  155.             int allow_realloc, const u_char * s)
  156. {
  157.     if (buf == NULL || buf_len == NULL || out_len == NULL) {
  158.         return 0;
  159.     }
  161.     if (s == NULL) {
  162.         /*
  163.          * Appending a NULL string always succeeds since it is a NOP.  
  164.          */
  165.         return 1;
  166.     }
  168.     while ((*out_len + strlen((const char *) s) + 1) >= *buf_len) {
  169.         if (!(allow_realloc && snmp_realloc(buf, buf_len))) {
  170.             return 0;
  171.         }
  172.     }
  174.     strcpy((char *) (*buf + *out_len), (const char *) s);
  175.     *out_len += strlen((char *) (*buf + *out_len));
  176.     return 1;
  177. }
  179. /** zeros memory before freeing it.
  180.  *
  181.  * @param *buf Pointer at bytes to free.
  182.  * @param size Number of bytes in buf.
  183.  */
  184. void
  185. free_zero(void *buf, size_t size)
  186. {
  187.     if (buf) {
  188.         memset(buf, 0, size);
  189.         free(buf);
  190.     }
  192. }                               /* end free_zero() */
  194. /**
  195.  * Returns pointer to allocaed & set buffer on success, size contains
  196.  * number of random bytes filled.  buf is NULL and *size set to KMT
  197.  * error value upon failure.
  198.  *
  199.  * @param size Number of bytes to malloc() and fill with random bytes.
  200.  *
  201.  * @return a malloced buffer
  202.  *
  203.  */
  204. u_char         *
  205. malloc_random(size_t * size)
  206. {
  207.     int             rval = SNMPERR_SUCCESS;
  208.     u_char         *buf = (u_char *) calloc(1, *size);
  210.     if (buf) {
  211.         rval = sc_random(buf, size);
  213.         if (rval < 0) {
  214.             free_zero(buf, *size);
  215.             buf = NULL;
  216.         } else {
  217.             *size = rval;
  218.         }
  219.     }
  221.     return buf;
  223. }                               /* end malloc_random() */
  225. /** Duplicates a memory block.
  226.  *  Copies a existing memory location from a pointer to another, newly
  227.     malloced, pointer.
  229.  * @param to       Pointer to allocate and copy memory to.
  230.  *      @param from     Pointer to copy memory from.
  231.  *      @param size     Size of the data to be copied.
  232.  *      
  233.  * @return SNMPERR_SUCCESS on success, SNMPERR_GENERR on failure.
  234.  */
  235. int
  236. memdup(u_char ** to, const u_char * from, size_t size)
  237. {
  238.     if (to == NULL)
  239.         return SNMPERR_GENERR;
  240.     if (from == NULL) {
  241.         *to = NULL;
  242.         return SNMPERR_SUCCESS;
  243.     }
  244.     if ((*to = (u_char *) malloc(size)) == NULL)
  245.         return SNMPERR_GENERR;
  246.     memcpy(*to, from, size);
  247.     return SNMPERR_SUCCESS;
  249. }                               /* end memdup() */
  251. /** copies a (possible) unterminated string of a given length into a
  252.  *  new buffer and null terminates it as well (new buffer MAY be one
  253.  *  byte longer to account for this */
  254. char           *
  255. netsnmp_strdup_and_null(const u_char * from, size_t from_len)
  256. {
  257.     u_char         *ret;
  259.     if (from_len == 0 || from[from_len - 1] != '') {
  260.         ret = malloc(from_len + 1);
  261.         if (!ret)
  262.             return NULL;
  263.         ret[from_len] = '';
  264.     } else {
  265.         ret = malloc(from_len);
  266.         if (!ret)
  267.             return NULL;
  268.         ret[from_len - 1] = '';
  269.     }
  270.     memcpy(ret, from, from_len);
  271.     return ret;
  272. }
  274. /** converts binary to hexidecimal
  275.  *
  276.  * @param *input Binary data.
  277.  * @param len Length of binary data.
  278.  * @param **output NULL terminated string equivalent in hex.
  279.  *      
  280.  * @return olen Length of output string not including NULL terminator.
  281.  *
  282.  * FIX Is there already one of these in the UCD SNMP codebase?
  283.  * The old one should be used, or this one should be moved to
  284.  * snmplib/snmp_api.c.
  285.  */
  286. u_int
  287. binary_to_hex(const u_char * input, size_t len, char **output)
  288. {
  289.     u_int           olen = (len * 2) + 1;
  290.     char           *s = (char *) calloc(1, olen), *op = s;
  291.     const u_char   *ip = input;
  294.     while (ip - input < (int) len) {
  295.         *op++ = VAL2HEX((*ip >> 4) & 0xf);
  296.         *op++ = VAL2HEX(*ip & 0xf);
  297.         ip++;
  298.     }
  299.     *op = '';
  301.     *output = s;
  302.     return olen;
  304. }                               /* end binary_to_hex() */
  309. /**
  310.  * hex_to_binary2
  311.  * @param *input Printable data in base16.
  312.  * @param len Length in bytes of data.
  313.  * @param **output Binary data equivalent to input.
  314.  *      
  315.  * @return SNMPERR_GENERR on failure, otherwise length of allocated string.
  316.  *
  317.  * Input of an odd length is right aligned.
  318.  *
  319.  * FIX Another version of "hex-to-binary" which takes odd length input
  320.  * strings.  It also allocates the memory to hold the binary data.
  321.  * Should be integrated with the official hex_to_binary() function.
  322.  */
  323. int
  324. hex_to_binary2(const u_char * input, size_t len, char **output)
  325. {
  326.     u_int           olen = (len / 2) + (len % 2);
  327.     char           *s = (char *) calloc(1, (olen) ? olen : 1), *op = s;
  328.     const u_char   *ip = input;
  331.     *output = NULL;
  332.     *op = 0;
  333.     if (len % 2) {
  334.         if (!isxdigit(*ip))
  335.             goto hex_to_binary2_quit;
  336.         *op++ = HEX2VAL(*ip);
  337.         ip++;
  338.     }
  340.     while (ip - input < (int) len) {
  341.         if (!isxdigit(*ip))
  342.             goto hex_to_binary2_quit;
  343.         *op = HEX2VAL(*ip) << 4;
  344.         ip++;
  346.         if (!isxdigit(*ip))
  347.             goto hex_to_binary2_quit;
  348.         *op++ += HEX2VAL(*ip);
  349.         ip++;
  350.     }
  352.     *output = s;
  353.     return olen;
  355.   hex_to_binary2_quit:
  356.     free_zero(s, olen);
  357.     return -1;
  359. }                               /* end hex_to_binary2() */
  361. int
  362. snmp_decimal_to_binary(u_char ** buf, size_t * buf_len, size_t * out_len,
  363.                        int allow_realloc, const char *decimal)
  364. {
  365.     int             subid = 0;
  366.     const char     *cp = decimal;
  368.     if (buf == NULL || buf_len == NULL || out_len == NULL
  369.         || decimal == NULL) {
  370.         return 0;
  371.     }
  373.     while (*cp != '') {
  374.         if (isspace((int) *cp) || *cp == '.') {
  375.             cp++;
  376.             continue;
  377.         }
  378.         if (!isdigit((int) *cp)) {
  379.             return 0;
  380.         }
  381.         if ((subid = atoi(cp)) > 255) {
  382.             return 0;
  383.         }
  384.         if ((*out_len >= *buf_len) &&
  385.             !(allow_realloc && snmp_realloc(buf, buf_len))) {
  386.             return 0;
  387.         }
  388.         *(*buf + *out_len) = (u_char) subid;
  389.         (*out_len)++;
  390.         while (isdigit((int) *cp)) {
  391.             cp++;
  392.         }
  393.     }
  394.     return 1;
  395. }
  397. /**
  398.  * convert an ASCII hex string (with specified delimiters) to binary
  399.  *
  400.  * @param buf     address of a pointer (pointer to pointer) for the output buffer.
  401.  *                If allow_realloc is set, the buffer may be grown via snmp_realloc
  402.  *                to accomodate the data.
  403.  *
  404.  * @param buf_len pointer to a size_t containing the initial size of buf.
  405.  *
  406.  * @param out_len On input, a pointer to a size_t indicating an offset into buf.
  407.  *                The  binary data will be stored at this offset.
  408.  *                On output, this pointer will have updated the offset to be
  409.  *                the first byte after the converted data.
  410.  *
  411.  * @param allow_realloc If true, the buffer can be reallocated. If false, and
  412.  *                      the buffer is not large enough to contain the string,
  413.  *                      an error will be returned.
  414.  *
  415.  * @param hex     pointer to hex string to be converted. May be prefixed by
  416.  *                "0x" or "0X".
  417.  *
  418.  * @param delim   point to a string of allowed delimiters between bytes.
  419.  *                If not specified, any non-hex characters will be an error.
  420.  *
  421.  * @retval 1  success
  422.  * @retval 0  error
  423.  */
  424. int
  425. netsnmp_hex_to_binary(u_char ** buf, size_t * buf_len, size_t * out_len,
  426.                       int allow_realloc, const char *hex, const char *delim)
  427. {
  428.     int             subid = 0;
  429.     const char     *cp = hex;
  431.     if (buf == NULL || buf_len == NULL || out_len == NULL || hex == NULL) {
  432.         return 0;
  433.     }
  435.     if ((*cp == '0') && ((*(cp + 1) == 'x') || (*(cp + 1) == 'X'))) {
  436.         cp += 2;
  437.     }
  439.     while (*cp != '') {
  440.         if (!isxdigit((int) *cp)) {
  441.             if ((NULL != delim) && (NULL != strchr(delim, *cp))) {
  442.                 cp++;
  443.                 continue;
  444.             }
  445.             return 0;
  446.         }
  447.         if (sscanf(cp, "%2x", &subid) == 0) {
  448.             return 0;
  449.         }
  450.         /*
  451.          * if we dont' have enough space, realloc.
  452.          * (snmp_realloc will adjust buf_len to new size)
  453.          */
  454.         if ((*out_len >= *buf_len) &&
  455.             !(allow_realloc && snmp_realloc(buf, buf_len))) {
  456.             return 0;
  457.         }
  458.         *(*buf + *out_len) = (u_char) subid;
  459.         (*out_len)++;
  460.         if (*++cp == '') {
  461.             /*
  462.              * Odd number of hex digits is an error.  
  463.              */
  464.             return 0;
  465.         } else {
  466.             cp++;
  467.         }
  468.     }
  469.     return 1;
  470. }
  472. /**
  473.  * convert an ASCII hex string to binary
  474.  *
  475.  * @note This is a wrapper which calls netsnmp_hex_to_binary with a
  476.  * delimiter string of " ".
  477.  *
  478.  * See netsnmp_hex_to_binary for parameter descriptions.
  479.  *
  480.  * @retval 1  success
  481.  * @retval 0  error
  482.  */
  483. int
  484. snmp_hex_to_binary(u_char ** buf, size_t * buf_len, size_t * out_len,
  485.                    int allow_realloc, const char *hex)
  486. {
  487.     return netsnmp_hex_to_binary(buf, buf_len, out_len, allow_realloc, hex, " ");
  488. }
  490. /*******************************************************************-o-******
  491.  * dump_chunk
  492.  *
  493.  * Parameters:
  494.  * *title (May be NULL.)
  495.  * *buf
  496.  *  size
  497.  */
  498. void
  499. dump_chunk(const char *debugtoken, const char *title, const u_char * buf,
  500.            int size)
  501. {
  502.     u_int           printunit = 64;     /* XXX  Make global. */
  503.     char            chunk[SNMP_MAXBUF], *s, *sp;
  505.     if (title && (*title != '')) {
  506.         DEBUGMSGTL((debugtoken, "%sn", title));
  507.     }
  510.     memset(chunk, 0, SNMP_MAXBUF);
  511.     size = binary_to_hex(buf, size, &s);
  512.     sp = s;
  514.     while (size > 0) {
  515.         if (size > (int) printunit) {
  516.             strncpy(chunk, sp, printunit);
  517.             chunk[printunit] = '';
  518.             DEBUGMSGTL((debugtoken, "t%sn", chunk));
  519.         } else {
  520.             DEBUGMSGTL((debugtoken, "t%sn", sp));
  521.         }
  523.         sp += printunit;
  524.         size -= printunit;
  525.     }
  528.     SNMP_FREE(s);
  530. }                               /* end dump_chunk() */
  535. /*******************************************************************-o-******
  536.  * dump_snmpEngineID
  537.  *
  538.  * Parameters:
  539.  * *estring
  540.  * *estring_len
  541.  *      
  542.  * Returns:
  543.  * Allocated memory pointing to a string of buflen char representing
  544.  * a printf'able form of the snmpEngineID.
  545.  *
  546.  * -OR- NULL on error.
  547.  *
  548.  *
  549.  * Translates the snmpEngineID TC into a printable string.  From RFC 2271,
  550.  * Section 5 (pp. 36-37):
  551.  *
  552.  * First bit: 0 Bit string structured by means non-SNMPv3.
  553.  *   1 Structure described by SNMPv3 SnmpEngineID TC.
  554.  *  
  555.  * Bytes 1-4: Enterprise ID.  (High bit of first byte is ignored.)
  556.  *  
  557.  * Byte 5: 0 (RESERVED by IANA.)
  558.  *   1 IPv4 address. (   4 octets)
  559.  *   2 IPv6 address. (  16 octets)
  560.  *   3 MAC address. (   6 octets)
  561.  *   4 Locally defined text. (0-27 octets)
  562.  *   5 Locally defined octets. (0-27 octets)
  563.  *   6-127 (RESERVED for enterprise.)
  564.  *  
  565.  * Bytes 6-32: (Determined by byte 5.)
  566.  *  
  567.  *
  568.  * Non-printable characters are given in hex.  Text is given in quotes.
  569.  * IP and MAC addresses are given in standard (UN*X) conventions.  Sections
  570.  * are comma separated.
  571.  *
  572.  * esp, remaining_len and s trace the state of the constructed buffer.
  573.  * s will be defined if there is something to return, and it will point
  574.  * to the end of the constructed buffer.
  575.  *
  576.  *
  577.  * ASSUME  "Text" means printable characters.
  578.  *
  579.  * XXX Must the snmpEngineID always have a minimum length of 12?
  580.  * (Cf. part 2 of the TC definition.)
  581.  * XXX Does not enforce upper-bound of 32 bytes.
  582.  * XXX Need a switch to decide whether to use DNS name instead of a simple
  583.  * IP address.
  584.  *
  585.  * FIX Use something other than snprint_hexstring which doesn't add 
  586.  * trailing spaces and (sometimes embedded) newlines...
  587.  */
  588. #ifdef SNMP_TESTING_CODE
  589. char           *
  590. dump_snmpEngineID(const u_char * estring, size_t * estring_len)
  591. {
  592. #define eb(b) ( *(esp+b) & 0xff )
  594.     int             rval = SNMPERR_SUCCESS, gotviolation = 0, slen = 0;
  595.     u_int           remaining_len;
  597.     char            buf[SNMP_MAXBUF], *s = NULL, *t;
  598.     const u_char   *esp = estring;
  600.     struct in_addr  iaddr;
  604.     /*
  605.      * Sanity check.
  606.      */
  607.     if (!estring || (*estring_len <= 0)) {
  608.         QUITFUN(SNMPERR_GENERR, dump_snmpEngineID_quit);
  609.     }
  610.     remaining_len = *estring_len;
  611.     memset(buf, 0, SNMP_MAXBUF);
  615.     /*
  616.      * Test first bit.  Return immediately with a hex string, or
  617.      * begin by formatting the enterprise ID.
  618.      */
  619.     if (!(*esp & 0x80)) {
  620.         snprint_hexstring(buf, SNMP_MAXBUF, esp, remaining_len);
  621.         s = strchr(buf, '');
  622.         s -= 1;
  623.         goto dump_snmpEngineID_quit;
  624.     }
  626.     s = buf;
  627.     s += sprintf(s, "enterprise %d, ", ((*(esp + 0) & 0x7f) << 24) |
  628.                  ((*(esp + 1) & 0xff) << 16) |
  629.                  ((*(esp + 2) & 0xff) << 8) | ((*(esp + 3) & 0xff)));
  630.     /*
  631.      * XXX  Ick. 
  632.      */
  634.     if (remaining_len < 5) {    /* XXX  Violating string. */
  635.         goto dump_snmpEngineID_quit;
  636.     }
  638.     esp += 4;                   /* Incremented one more in the switch below. */
  639.     remaining_len -= 5;
  643.     /*
  644.      * Act on the fifth byte.
  645.      */
  646.     switch ((int) *esp++) {
  647.     case 1:                    /* IPv4 address. */
  649.         if (remaining_len < 4)
  650.             goto dump_snmpEngineID_violation;
  651.         memcpy(&iaddr.s_addr, esp, 4);
  653.         if (!(t = inet_ntoa(iaddr)))
  654.             goto dump_snmpEngineID_violation;
  655.         s += sprintf(s, "%s", t);
  657.         esp += 4;
  658.         remaining_len -= 4;
  659.         break;
  661.     case 2:                    /* IPv6 address. */
  663.         if (remaining_len < 16)
  664.             goto dump_snmpEngineID_violation;
  666.         s += sprintf(s,
  667.                      "%02X%02X %02X%02X %02X%02X %02X%02X::"
  668.                      "%02X%02X %02X%02X %02X%02X %02X%02X",
  669.                      eb(0), eb(1), eb(2), eb(3),
  670.                      eb(4), eb(5), eb(6), eb(7),
  671.                      eb(8), eb(9), eb(10), eb(11),
  672.                      eb(12), eb(13), eb(14), eb(15));
  674.         esp += 16;
  675.         remaining_len -= 16;
  676.         break;
  678.     case 3:                    /* MAC address. */
  680.         if (remaining_len < 6)
  681.             goto dump_snmpEngineID_violation;
  683.         s += sprintf(s, "%02X:%02X:%02X:%02X:%02X:%02X",
  684.                      eb(0), eb(1), eb(2), eb(3), eb(4), eb(5));
  686.         esp += 6;
  687.         remaining_len -= 6;
  688.         break;
  690.     case 4:                    /* Text. */
  692.         /*
  693.          * Doesn't exist on all (many) architectures 
  694.          */
  695.         /*
  696.          * s += snprintf(s, remaining_len+3, ""%s"", esp); 
  697.          */
  698.         s += sprintf(s, ""%s"", esp);
  699.         goto dump_snmpEngineID_quit;
  700.         break;
  701.      /*NOTREACHED*/ case 5:    /* Octets. */
  703.         snprint_hexstring(s, (SNMP_MAXBUF - (s-buf)),
  704.                           esp, remaining_len);
  705.         s = strchr(buf, '');
  706.         s -= 1;
  707.         goto dump_snmpEngineID_quit;
  708.         break;
  709.        /*NOTREACHED*/ dump_snmpEngineID_violation:
  710.     case 0:                    /* Violation of RESERVED, 
  711.                                  * *   -OR- of expected length.
  712.                                  */
  713.         gotviolation = 1;
  714.         s += sprintf(s, "!!! ");
  716.     default:                   /* Unknown encoding. */
  718.         if (!gotviolation) {
  719.             s += sprintf(s, "??? ");
  720.         }
  721.         snprint_hexstring(s, (SNMP_MAXBUF - (s-buf)),
  722.                           esp, remaining_len);
  723.         s = strchr(buf, '');
  724.         s -= 1;
  726.         goto dump_snmpEngineID_quit;
  728.     }                           /* endswitch */
  732.     /*
  733.      * Cases 1-3 (IP and MAC addresses) should not have trailing
  734.      * octets, but perhaps they do.  Throw them in too.  XXX
  735.      */
  736.     if (remaining_len > 0) {
  737.         s += sprintf(s, " (??? ");
  739.         snprint_hexstring(s, (SNMP_MAXBUF - (s-buf)),
  740.                           esp, remaining_len);
  741.         s = strchr(buf, '');
  742.         s -= 1;
  744.         s += sprintf(s, ")");
  745.     }
  749.   dump_snmpEngineID_quit:
  750.     if (s) {
  751.         slen = s - buf + 1;
  752.         s = calloc(1, slen);
  753.         memcpy(s, buf, (slen) - 1);
  754.     }
  756.     memset(buf, 0, SNMP_MAXBUF);        /* XXX -- Overkill? XXX: Yes! */
  758.     return s;
  760. #undef eb
  761. }                               /* end dump_snmpEngineID() */
  762. #endif                          /* SNMP_TESTING_CODE */
  765. /**
  766.  * create a new time marker.
  767.  * NOTE: Caller must free time marker when no longer needed.
  768.  */
  769. marker_t
  770. atime_newMarker(void)
  771. {
  772.     marker_t        pm = (marker_t) calloc(1, sizeof(struct timeval));
  773.     gettimeofday((struct timeval *) pm, 0);
  774.     return pm;
  775. }
  777. /**
  778.  * set a time marker.
  779.  */
  780. void
  781. atime_setMarker(marker_t pm)
  782. {
  783.     if (!pm)
  784.         return;
  786.     gettimeofday((struct timeval *) pm, 0);
  787. }
  790. /**
  791.  * Returns the difference (in msec) between the two markers
  792.  */
  793. long
  794. atime_diff(marker_t first, marker_t second)
  795. {
  796.     struct timeval *tv1, *tv2, diff;
  798.     tv1 = (struct timeval *) first;
  799.     tv2 = (struct timeval *) second;
  801.     diff.tv_sec = tv2->tv_sec - tv1->tv_sec - 1;
  802.     diff.tv_usec = tv2->tv_usec - tv1->tv_usec + 1000000;
  804.     return (diff.tv_sec * 1000 + diff.tv_usec / 1000);
  805. }
  807. /**
  808.  * Returns the difference (in u_long msec) between the two markers
  809.  */
  810. u_long
  811. uatime_diff(marker_t first, marker_t second)
  812. {
  813.     struct timeval *tv1, *tv2, diff;
  815.     tv1 = (struct timeval *) first;
  816.     tv2 = (struct timeval *) second;
  818.     diff.tv_sec = tv2->tv_sec - tv1->tv_sec - 1;
  819.     diff.tv_usec = tv2->tv_usec - tv1->tv_usec + 1000000;
  821.     return (((u_long) diff.tv_sec) * 1000 + diff.tv_usec / 1000);
  822. }
  824. /**
  825.  * Returns the difference (in u_long 1/100th secs) between the two markers
  826.  * (functionally this is what sysUpTime needs)
  827.  */
  828. u_long
  829. uatime_hdiff(marker_t first, marker_t second)
  830. {
  831.     struct timeval *tv1, *tv2, diff;
  832.     u_long          res;
  834.     tv1 = (struct timeval *) first;
  835.     tv2 = (struct timeval *) second;
  837.     diff.tv_sec = tv2->tv_sec - tv1->tv_sec - 1;
  838.     diff.tv_usec = tv2->tv_usec - tv1->tv_usec + 1000000;
  840.     res = ((u_long) diff.tv_sec) * 100 + diff.tv_usec / 10000;
  841.     return res;
  842. }
  844. /**
  845.  * Test: Has (marked time plus delta) exceeded current time (in msec) ?
  846.  * Returns 0 if test fails or cannot be tested (no marker).
  847.  */
  848. int
  849. atime_ready(marker_t pm, int deltaT)
  850. {
  851.     marker_t        now;
  852.     long            diff;
  853.     if (!pm)
  854.         return 0;
  856.     now = atime_newMarker();
  858.     diff = atime_diff(pm, now);
  859.     free(now);
  860.     if (diff < deltaT)
  861.         return 0;
  863.     return 1;
  864. }
  866. /**
  867.  * Test: Has (marked time plus delta) exceeded current time (in msec) ?
  868.  * Returns 0 if test fails or cannot be tested (no marker).
  869.  */
  870. int
  871. uatime_ready(marker_t pm, unsigned int deltaT)
  872. {
  873.     marker_t        now;
  874.     u_long          diff;
  875.     if (!pm)
  876.         return 0;
  878.     now = atime_newMarker();
  880.     diff = uatime_diff(pm, now);
  881.     free(now);
  882.     if (diff < deltaT)
  883.         return 0;
  885.     return 1;
  886. }
  889.         /*
  890.          * Time-related utility functions
  891.          */
  893. /**
  894.  * Return the number of timeTicks since the given marker 
  895.  */
  896. int
  897. marker_tticks(marker_t pm)
  898. {
  899.     int             res;
  900.     marker_t        now = atime_newMarker();
  902.     res = atime_diff(pm, now);
  903.     free(now);
  904.     return res / 10;            /* atime_diff works in msec, not csec */
  905. }
  907. int
  908. timeval_tticks(struct timeval *tv)
  909. {
  910.     return marker_tticks((marker_t) tv);
  911. }
  913. /**
  914.  * Non Windows:  Returns a pointer to the desired environment variable  
  915.  *               or NULL if the environment variable does not exist.  
  916.  *               
  917.  * Windows:      Returns a pointer to the desired environment variable  
  918.  *               if it exists.  If it does not, the variable is looked up
  919.  *               in the registry in HKCUNet-SNMP or HKLMNet-SNMP
  920.  *               (whichever it finds first) and stores the result in the 
  921.  *               environment variable.  It then returns a pointer to 
  922.  *               environment variable.
  923.  */
  925. char *netsnmp_getenv(const char *name)
  926. {
  927. #if !defined (WIN32) && !defined (cygwin)
  928.   return (getenv(name));
  929. #else
  930.   char *temp = NULL;  
  931.   HKEY hKey;
  932.   unsigned char * key_value = NULL;
  933.   DWORD key_value_size = 0;
  934.   DWORD key_value_type = 0;
  935.   DWORD getenv_worked = 0;
  937.   DEBUGMSGTL(("read_config", "netsnmp_getenv called with name: %sn",name));
  939.   if (!(name))
  940.     return NULL;
  941.   
  942.   /* Try environment variable first */ 
  943.   temp = getenv(name);
  944.   if (temp) {
  945.     getenv_worked = 1;
  946.     DEBUGMSGTL(("read_config", "netsnmp_getenv will return from ENV: %sn",temp));
  947.   }
  948.   
  949.   /* Next try HKCU */
  950.   if (temp == NULL)
  951.   {
  952.     if (RegOpenKeyExA(
  953.           HKEY_CURRENT_USER, 
  954.           "SOFTWARE\Net-SNMP", 
  955.           0, 
  956.           KEY_QUERY_VALUE, 
  957.           &hKey) == ERROR_SUCCESS) {   
  958.       
  959.       if (RegQueryValueExA(
  960.             hKey, 
  961.             name, 
  962.             NULL, 
  963.             &key_value_type, 
  964.             NULL,               /* Just get the size */
  965.             &key_value_size) == ERROR_SUCCESS) {
  967.         if (key_value)
  968.           SNMP_FREE(key_value);
  970.         /* Allocate memory needed +1 to allow RegQueryValueExA to NULL terminate the
  971.          * string data in registry is missing one (which is unlikely).
  972.          */
  973.         key_value = (char *) malloc((sizeof(char) * key_value_size)+sizeof(char));
  974.         
  975.         if (RegQueryValueExA(
  976.               hKey, 
  977.               name, 
  978.               NULL, 
  979.               &key_value_type, 
  980.               key_value, 
  981.               &key_value_size) == ERROR_SUCCESS) {
  982.         }
  983.         temp = key_value;
  984.       }
  985.       RegCloseKey(hKey);
  986.       if (temp)
  987.         DEBUGMSGTL(("read_config", "netsnmp_getenv will return from HKCU: %sn",temp));
  988.     }
  989.   }
  991.   /* Next try HKLM */
  992.   if (temp == NULL)
  993.   {
  994.     if (RegOpenKeyExA(
  995.           HKEY_LOCAL_MACHINE, 
  996.           "SOFTWARE\Net-SNMP", 
  997.           0, 
  998.           KEY_QUERY_VALUE, 
  999.           &hKey) == ERROR_SUCCESS) {   
  1000.       
  1001.       if (RegQueryValueExA(
  1002.             hKey, 
  1003.             name, 
  1004.             NULL, 
  1005.             &key_value_type, 
  1006.             NULL,               /* Just get the size */
  1007.             &key_value_size) == ERROR_SUCCESS) {
  1009.         if (key_value)
  1010.           SNMP_FREE(key_value);
  1012.         /* Allocate memory needed +1 to allow RegQueryValueExA to NULL terminate the
  1013.          * string data in registry is missing one (which is unlikely).
  1014.          */
  1015.         key_value = (char *) malloc((sizeof(char) * key_value_size)+sizeof(char));
  1016.         
  1017.         if (RegQueryValueExA(
  1018.               hKey, 
  1019.               name, 
  1020.               NULL, 
  1021.               &key_value_type, 
  1022.               key_value, 
  1023.               &key_value_size) == ERROR_SUCCESS) {
  1024.         }
  1025.         temp = key_value;
  1027.       }
  1028.       RegCloseKey(hKey);
  1029.       if (temp)
  1030.         DEBUGMSGTL(("read_config", "netsnmp_getenv will return from HKLM: %sn",temp));
  1031.     }
  1032.   }
  1033.   
  1034.   if (temp && !getenv_worked) {
  1035.     setenv(name, temp, 1);
  1036.     SNMP_FREE(temp);
  1037.   }
  1039.   DEBUGMSGTL(("read_config", "netsnmp_getenv returning: %sn",getenv(name)));
  1041.   return(getenv(name));
  1042. #endif
  1043. }