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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
tools.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：12k
源码类别：

SNMP编程

开发平台：

C/C++

tools.c：源码内容
  1. /*
  2.  * tools.c
  3.  */
  5. #include <config.h>
  7. #include <ctype.h>
  8. #include <stdio.h>
  9. #include <sys/types.h>
  10. #if TIME_WITH_SYS_TIME
  11. # ifdef WIN32
  12. #  include <sys/timeb.h>
  13. # else
  14. #  include <time.h>
  15. # endif
  16. # include <time.h>
  17. #else
  18. # if HAVE_SYS_TIME_H
  19. #  include <sys/time.h> 
  20. # else
  21. #  include <time.h>
  22. # endif
  23. #endif
  24. #ifdef HAVE_SYS_SOCKET_H
  25. #include <sys/socket.h>
  26. #endif
  27. #if HAVE_WINSOCK_H
  28. #include <ip/socket.h>
  29. #endif
  30. #ifdef HAVE_STDLIB_H
  31. #include <stdlib.h>
  32. #endif
  33. #if HAVE_STRING_H
  34. #include <string.h>
  35. #else
  36. #include <strings.h>
  37. #endif
  38. #ifdef HAVE_NETINET_IN_H
  39. #include <netinet/in.h>
  40. #endif
  41. #ifdef HAVE_ARPA_INET_H
  42. #include <arpa/inet.h>
  43. #endif
  45. #if HAVE_DMALLOC_H
  46. #include <dmalloc.h>
  47. #endif
  49. #include "asn1.h" 
  50. #include "system.h"
  51. #include "snmp_api.h"
  52. #include "tools.h"
  53. #include "snmp_debug.h"
  54. #include "mib.h"
  55. #include "scapi.h" 
  57. #define timercmp(tvp, uvp, cmp) 
  58.         ((tvp)->tv_sec cmp (uvp)->tv_sec || 
  59.         ( (tvp)->tv_sec == (uvp)->tv_sec && (tvp)->tv_usec cmp (uvp)->tv_usec))
  61. /*******************************************************************-o-******
  62.  * free_zero
  63.  *
  64.  * Parameters:
  65.  * *buf Pointer at bytes to free.
  66.  * size Number of bytes in buf.
  67.  */
  68. void
  69. free_zero(void *buf, size_t size)
  70. {
  71. if (buf) {
  72. memset(buf, 0, size);
  73. free(buf);
  74. }
  76. }  /* end free_zero() */
  81. /*******************************************************************-o-******
  82.  * malloc_random
  83.  *
  84.  * Parameters:
  85.  * size Number of bytes to malloc() and fill with random bytes.
  86.  *      
  87.  * Returns pointer to allocaed & set buffer on success, size contains
  88.  * number of random bytes filled.
  89.  *
  90.  * buf is NULL and *size set to KMT error value upon failure.
  91.  *
  92.  */
  93. u_char *
  94. malloc_random(size_t *size)
  95. {
  96. int  rval = SNMPERR_SUCCESS;
  97. u_char *buf = (u_char *)calloc (1, *size);
  99. if (buf) {
  100. rval = sc_random(buf, size);
  102. if (rval < 0) {
  103. free_zero(buf, *size);
  104. buf = NULL;
  105. } else {
  106. *size = rval;
  107. }
  108. }
  110. return buf;
  112. }  /* end malloc_random() */
  116. #if 0
  117. /*******************************************************************-o-******
  118.  * memdup
  119.  *
  120.  * Parameters:
  121.  * to       Pointer to allocate and copy memory to.
  122.  *      from     Pointer to copy memory from.
  123.  *      size     Size of the data to be copied.
  124.  *      
  125.  * Returns
  126.  * SNMPERR_SUCCESS On success.
  127.  *      SNMPERR_GENERR On failure.
  128.  */
  129. extern int
  130. memdup(u_char **to, const u_char *from, size_t size);
  131. #endif
  132. /*fanghao(C): 2003-02-13, we implement this function 'memdup()' by ourselves
  133. from now on, previously, it was provided by PPP.
  134.  */
  135.  extern void *mymalloc (size_t size);
  136. int snmp_memdup(u_char **to, const u_char *from, size_t size)
  137. {
  138. *to = (u_char *)mymalloc(size + 1);
  139. if( NULL == *to )
  140. return SNMPERR_GENERR;
  142. memcpy( *to, from, size );
  143. (*to)[size] = '';
  145. return SNMPERR_SUCCESS;
  146. }
  149. /*******************************************************************-o-******
  150.  * binary_to_hex
  151.  *
  152.  * Parameters:
  153.  * *input Binary data.
  154.  * len Length of binary data.
  155.  * **output NULL terminated string equivalent in hex.
  156.  *      
  157.  * Returns:
  158.  * olen Length of output string not including NULL terminator.
  159.  *
  160.  * FIX Is there already one of these in the UCD SNMP codebase?
  161.  * The old one should be used, or this one should be moved to
  162.  * snmplib/snmp_api.c.
  163.  */
  164. u_int
  165. binary_to_hex(const u_char *input, size_t len, char **output)
  166. {
  167. u_int olen = (len * 2) + 1;
  168. char *s = (char *) calloc(1,olen),
  169. *op = s;
  170. const u_char *ip = input;
  173. while (ip-input < (int)len) {
  174. *op++ = (u_char)(VAL2HEX( (*ip >> 4) & 0xf ));
  175. *op++ = (u_char)VAL2HEX( *ip & 0xf );
  176. ip++;
  177. }
  178. *op = '';
  180. *output = s;
  181. return olen;
  183. }  /* end binary_to_hex() */
  188. /*******************************************************************-o-******
  189.  * hex_to_binary2
  190.  *
  191.  * Parameters:
  192.  * *input Printable data in base16.
  193.  * len Length in bytes of data.
  194.  * **output Binary data equivalent to input.
  195.  *      
  196.  * Returns:
  197.  * SNMPERR_GENERR Failure.
  198.  * <len> Otherwise, Length of allocated string.
  199.  *
  200.  *
  201.  * Input of an odd length is right aligned.
  202.  *
  203.  * FIX Another version of "hex-to-binary" which takes odd length input
  204.  * strings.  It also allocates the memory to hold the binary data.
  205.  * Should be integrated with the official hex_to_binary() function.
  206.  */
  207. int
  208. hex_to_binary2(const u_char *input, size_t len, char **output)
  209. {
  210. u_int olen = (len/2) + (len%2);
  211. char *s = (char *)calloc (1,olen),
  212. *op = s;
  213. const u_char *ip = input;
  216. *output = NULL;
  217. *op = 0;
  218. if (len%2) {
  219. if(!isxdigit(*ip)) goto hex_to_binary2_quit;
  220. *op++ = (u_char)HEX2VAL( *ip ); ip++;
  221. }
  223. while (ip-input < (int)len) {
  224. if(!isxdigit(*ip)) goto hex_to_binary2_quit;
  225. *op = (u_char)(HEX2VAL( *ip ) << 4); ip++;
  227. if(!isxdigit(*ip)) goto hex_to_binary2_quit;
  228. *op++ += HEX2VAL( *ip ); ip++;
  229. }
  231. *output = s;
  232. return olen;
  234. hex_to_binary2_quit:
  235. free_zero(s, olen);
  236. return -1;
  238. }  /* end hex_to_binary2() */
  243. /*******************************************************************-o-******
  244.  * dump_chunk
  245.  *
  246.  * Parameters:
  247.  * *title (May be NULL.)
  248.  * *buf
  249.  *  size
  250.  */
  251. void
  252. dump_chunk(const char *debugtoken, const char *title, const u_char *buf, int size)
  253. {
  254. u_int printunit = 64; /* XXX  Make global. */
  255. char chunk[SNMP_MAXBUF],
  256. *s, *sp;
  258. if ( title && (*title != '') ) {
  259.           DEBUGMSGTL((debugtoken, "%sn", title));
  260. }
  263. memset(chunk, 0, SNMP_MAXBUF);
  264. size = binary_to_hex(buf, size, &s);
  265. sp   = s;
  267. while (size > 0)
  268. {
  269. if (size > (int)printunit) {
  270. strncpy(chunk, sp, printunit);
  271. chunk[printunit] = '';
  272. DEBUGMSGTL((debugtoken, "t%sn", chunk));
  273. } else {
  274. DEBUGMSGTL((debugtoken, "t%sn", sp));
  275. }
  277. sp += printunit;
  278. size -= printunit;
  279. }
  282. SNMP_FREE(s);
  284. }  /* end dump_chunk() */
  289. /*******************************************************************-o-******
  290.  * dump_snmpEngineID
  291.  *
  292.  * Parameters:
  293.  * *estring
  294.  * *estring_len
  295.  *      
  296.  * Returns:
  297.  * Allocated memory pointing to a string of buflen char representing
  298.  * a printf'able form of the snmpEngineID.
  299.  *
  300.  * -OR- NULL on error.
  301.  *
  302.  *
  303.  * Translates the snmpEngineID TC into a printable string.  From RFC 2271,
  304.  * Section 5 (pp. 36-37):
  305.  *
  306.  * First bit: 0 Bit string structured by means non-SNMPv3.
  307.  *   1 Structure described by SNMPv3 SnmpEngineID TC.
  308.  *  
  309.  * Bytes 1-4: Enterprise ID.  (High bit of first byte is ignored.)
  310.  *  
  311.  * Byte 5: 0 (RESERVED by IANA.)
  312.  *   1 IPv4 address. (   4 octets)
  313.  *   2 IPv6 address. (  16 octets)
  314.  *   3 MAC address. (   6 octets)
  315.  *   4 Locally defined text. (0-27 octets)
  316.  *   5 Locally defined octets. (0-27 octets)
  317.  *   6-127 (RESERVED for enterprise.)
  318.  *  
  319.  * Bytes 6-32: (Determined by byte 5.)
  320.  *  
  321.  *
  322.  * Non-printable characters are given in hex.  Text is given in quotes.
  323.  * IP and MAC addresses are given in standard (UN*X) conventions.  Sections
  324.  * are comma separated.
  325.  *
  326.  * esp, remaining_len and s trace the state of the constructed buffer.
  327.  * s will be defined if there is something to return, and it will point
  328.  * to the end of the constructed buffer.
  329.  *
  330.  *
  331.  * ASSUME  "Text" means printable characters.
  332.  *
  333.  * XXX Must the snmpEngineID always have a minimum length of 12?
  334.  * (Cf. part 2 of the TC definition.)
  335.  * XXX Does not enforce upper-bound of 32 bytes.
  336.  * XXX Need a switch to decide whether to use DNS name instead of a simple
  337.  * IP address.
  338.  *
  339.  * FIX Use something other than sprint_hexstring which doesn't add 
  340.  * trailing spaces and (sometimes embedded) newlines...
  341.  */
  342. #ifdef SNMP_TESTING_CODE
  343. char *
  344. dump_snmpEngineID(const u_char *estring, size_t *estring_len)
  345. {
  346. #define eb(b) ( *(esp+b) & 0xff )
  348. int  rval = SNMPERR_SUCCESS,
  349.                          gotviolation = 0,
  350.                          slen           = 0;
  351. u_int    remaining_len;
  353. char    buf[SNMP_MAXBUF],
  354. *s = NULL,
  355. *t;
  356.         const u_char    *esp = estring;
  358. struct in_addr  iaddr;
  362. /*
  363.  * Sanity check.
  364.  */
  365. if ( !estring || (*estring_len <= 0) ) {
  366. QUITFUN(SNMPERR_GENERR, dump_snmpEngineID_quit);
  367. }
  368. remaining_len = *estring_len;
  369. memset(buf, 0, SNMP_MAXBUF);
  373. /*
  374.  * Test first bit.  Return immediately with a hex string, or
  375.  * begin by formatting the enterprise ID.
  376.  */
  377. if ( !(*esp & 0x80) ) {
  378. sprint_hexstring(buf, esp, remaining_len);
  379. s  = strchr(buf, '');
  380. s -= 1;
  381. goto dump_snmpEngineID_quit;
  382. }
  384. s = buf;
  385. s += sprintf(s, "enterprise %d, ", ((*(esp+0)&0x7f) << 24) |
  386. ((*(esp+1)&0xff) << 16) |
  387. ((*(esp+2)&0xff) <<  8) |
  388. ((*(esp+3)&0xff)) );
  389. /* XXX  Ick. */
  391. if (remaining_len < 5) { /* XXX Violating string. */
  392. goto dump_snmpEngineID_quit;
  393. }
  395. esp += 4; /* Incremented one more in the switch below. */
  396. remaining_len -= 5;
  400. /*
  401.  * Act on the fifth byte.
  402.  */
  403. switch ((int) *esp++) {
  404. case 1: /* IPv4 address. */
  406. if (remaining_len < 4) goto dump_snmpEngineID_violation;
  407. memcpy(&iaddr.s_addr, esp, 4);
  409. if ( !(t = inet_ntoa(iaddr)) ) goto dump_snmpEngineID_violation;
  410. s += sprintf(s, "%s", t);
  412. esp += 4;
  413. remaining_len -= 4;
  414. break;
  416. case 2: /* IPv6 address. */
  418. if (remaining_len < 16) goto dump_snmpEngineID_violation;
  420. s += sprintf( s,
  421. "%02X%02X %02X%02X %02X%02X %02X%02X::"
  422. "%02X%02X %02X%02X %02X%02X %02X%02X",
  423. eb(0),  eb(1),  eb(2),  eb(3),
  424. eb(4),  eb(5),  eb(6),  eb(7),
  425. eb(8),  eb(9),  eb(10), eb(11),
  426. eb(12), eb(13), eb(14), eb(15) );
  428. esp += 16;
  429. remaining_len -= 16;
  430. break;
  432. case 3: /* MAC address. */
  434. if (remaining_len < 6) goto dump_snmpEngineID_violation;
  436. s += sprintf( s, "%02X:%02X:%02X:%02X:%02X:%02X",
  437. eb(0), eb(1), eb(2), eb(3), eb(4), eb(5) );
  439. esp += 6;
  440. remaining_len -= 6;
  441. break;
  443. case 4: /* Text. */
  445.                 /* Doesn't exist on all (many) architectures */
  446.                 /* s += snprintf(s, remaining_len+3, ""%s"", esp); */
  447. s += sprintf(s, ""%s"", esp);
  448. goto dump_snmpEngineID_quit;
  449. break; /*NOTREACHED*/
  451. case 5: /* Octets. */
  453. sprint_hexstring(s, esp, remaining_len);
  454. s  = strchr(buf, '');
  455. s -= 1;
  456. goto dump_snmpEngineID_quit;
  457. break; /*NOTREACHED*/
  460. dump_snmpEngineID_violation:
  461. case 0: /* Violation of RESERVED, 
  462.  *   -OR- of expected length.
  463.  */
  464. gotviolation = 1;
  465. s += sprintf(s, "!!! ");
  467. default: /* Unknown encoding. */
  469. if ( !gotviolation ) {
  470. s += sprintf(s, "??? ");
  471. }
  472. sprint_hexstring(s, esp, remaining_len);
  473. s  = strchr(buf, '');
  474. s -= 1;
  476. goto dump_snmpEngineID_quit;
  478. }  /* endswitch */
  482. /*
  483.  * Cases 1-3 (IP and MAC addresses) should not have trailing
  484.  * octets, but perhaps they do.  Throw them in too.  XXX
  485.  */
  486. if (remaining_len > 0) {
  487. s += sprintf(s, " (??? ");
  489. sprint_hexstring(s, esp, remaining_len);
  490. s  = strchr(buf, '');
  491. s -= 1;
  493. s += sprintf(s, ")");
  494. }
  498. dump_snmpEngineID_quit:
  499. if (s) {
  500.                 slen = s-buf+1;
  501. s = calloc(1,slen);
  502. memcpy(s, buf, (slen)-1);
  503. }
  505. memset(buf, 0, SNMP_MAXBUF); /* XXX -- Overkill? XXX: Yes! */
  507. return s;
  509. #undef eb
  510. }  /* end dump_snmpEngineID() */
  511. #endif /* SNMP_TESTING_CODE */
  514. /*
  515.  * create a new time marker.
  516.  * NOTE: Caller must free time marker when no longer needed.
  517.  */
  518. marker_t atime_newMarker(void)
  519. {
  520.   marker_t pm = (marker_t)calloc(1,sizeof(struct timeval));
  521.   gettimeofday((struct timeval *)pm, 0);
  522.   return pm;
  523. }
  525. /*
  526.  * set a time marker.
  527.  */
  528. void atime_setMarker(marker_t pm)
  529. {
  530.   if (! pm) return;
  532.   gettimeofday((struct timeval *)pm, 0);
  533. }
  535. /*
  536.  * Test: Has (marked time plus delta) exceeded current time ?
  537.  * Returns 0 if test fails or cannot be tested (no marker).
  538.  */
  539. int atime_ready( marker_t pm, int deltaT)
  540. {
  541.   struct timeval txdelta, txnow;
  542.   if (! pm) return 0;
  544.   memcpy((void *)&txdelta, pm, sizeof(txdelta));
  545.   while (deltaT > 1000) {
  546.      txdelta.tv_sec ++;
  547.      deltaT -= 1000;
  548.   }
  549.   txdelta.tv_usec = (deltaT * 1000) + txdelta.tv_usec;
  551.   gettimeofday(&txnow, 0);
  552.   if (timercmp(&txnow, &txdelta, <))
  553.         return 0;
  555.   return 1;
  556. }