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

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

SNMP编程

开发平台：

C/C++

lcd_time.c：源码内容
  1. /*
  2.  * lcd_time.c
  3.  *
  4.  * XXX Should etimelist entries with <0,0> time tuples be timed out?
  5.  * XXX Need a routine to free the memory?  (Perhaps at shutdown?)
  6.  */
  8. #include <config.h>
  10. #include <sys/types.h>
  11. #if HAVE_WINSOCK_H
  12. #include <ip/socket.h>
  13. #endif
  14. #include <stdio.h>
  15. #ifdef HAVE_STDLIB_H
  16. #include <stdlib.h>
  17. #endif
  18. #if HAVE_STRING_H
  19. #include <string.h>
  20. #else
  21. #include <strings.h>
  22. #endif
  23. #if TIME_WITH_SYS_TIME
  24. # ifdef WIN32
  25. #  include <sys/timeb.h>
  26. # else
  27. #  include <time.h>
  28. # endif
  29. # include <time.h>
  30. #else
  31. # if HAVE_SYS_TIME_H
  32. #  include <sys/time.h>
  33. # else
  34. #  include <time.h>
  35. # endif
  36. #endif
  37. #ifdef HAVE_NETINET_IN_H
  38. #include <netinet/in.h>
  39. #endif
  41. #if HAVE_DMALLOC_H
  42. #include <dmalloc.h>
  43. #endif
  45. #include "asn1.h"
  46. #include "snmp_api.h"
  47. #include "callback.h"
  48. #include "snmpusm.h"
  49. #include "lcd_time.h"
  50. #include "snmp_debug.h"
  51. #include "tools.h"
  52. #include "scapi.h"
  54. #include "transform_oids.h"
  57. /*
  58.  * Global static hashlist to contain Enginetime entries.
  59.  *
  60.  * New records are prepended to the appropriate list at the hash index.
  61.  */
  62. static Enginetime etimelist[ETIMELIST_SIZE];
  63. extern time_t time(time_t *);
  66. /*******************************************************************-o-******
  67.  * get_enginetime
  68.  *
  69.  * Parameters:
  70.  * *engineID
  71.  *  engineID_len
  72.  * *engineboot
  73.  * *engine_time
  74.  *      
  75.  * Returns:
  76.  * SNMPERR_SUCCESS Success -- when a record for engineID is found.
  77.  * SNMPERR_GENERR Otherwise.
  78.  *
  79.  *
  80.  * Lookup engineID and return the recorded values for the
  81.  * <engine_time, engineboot> tuple adjusted to reflect the estimated time
  82.  * at the engine in question.
  83.  *
  84.  * Special case: if engineID is NULL or if engineID_len is 0 then
  85.  * the time tuple is returned immediately as zero.
  86.  *
  87.  * XXX What if timediff wraps?  >shrug<
  88.  * XXX  Then: you need to increment the boots value.  Now.  Detecting
  89.  *            this is another matter.
  90.  */
  91. int
  92. get_enginetime( u_char *engineID,
  93. u_int  engineID_len,
  94. u_int *engineboot,
  95. u_int *engine_time,
  96. u_int   authenticated)
  97. {
  98. int rval  = SNMPERR_SUCCESS;
  99. time_t timediff = 0;
  100. Enginetime e  = NULL;
  104. /*
  105.  * Sanity check.
  106.  */
  107. if ( !engine_time || !engineboot ) {
  108. QUITFUN(SNMPERR_GENERR, get_enginetime_quit);
  109. }
  112. /*
  113.  * Compute estimated current engine_time tuple at engineID if
  114.  * a record is cached for it.
  115.  */
  116. *engine_time = *engineboot = 0;
  118. if ( !engineID || (engineID_len<=0) ) {
  119. QUITFUN(SNMPERR_GENERR, get_enginetime_quit);
  120. }
  122. if ( !(e = search_enginetime_list(engineID, engineID_len)) ) {
  123. QUITFUN(SNMPERR_GENERR, get_enginetime_quit);
  124. }
  126. #ifdef LCD_TIME_SYNC_OPT
  127.         if (!authenticated || e->authenticatedFlag) {
  128. #endif
  129. *engine_time = e->engineTime;
  130. *engineboot = e->engineBoot;
  132. timediff = time(&timediff) - e->lastReceivedEngineTime;
  133. #ifdef LCD_TIME_SYNC_OPT
  134.         }
  135. #endif
  137. if ( timediff > (int)(ENGINETIME_MAX - *engine_time) ) {
  138. *engine_time = (timediff - (ENGINETIME_MAX - *engine_time));
  140. /* FIX -- move this check up... should not change anything
  141.  * if engineboot is already locked.  ???
  142.  */
  143. if (*engineboot < ENGINEBOOT_MAX) {
  144. *engineboot += 1;
  145. }
  147. } else {
  148. *engine_time += timediff;
  149. }
  151.         DEBUGMSGTL(("lcd_get_enginetime", "engineID "));
  152.         DEBUGMSGHEX(("lcd_get_enginetime", engineID, engineID_len));
  153.         DEBUGMSG(("lcd_get_enginetime", ": boots=%d, time=%dn", *engineboot,
  154.                   *engine_time));
  156. get_enginetime_quit:
  157. return rval;
  159. }  /* end get_enginetime() */
  161. /*******************************************************************-o-******
  162.  * get_enginetime
  163.  *
  164.  * Parameters:
  165.  * *engineID
  166.  *  engineID_len
  167.  * *engineboot
  168.  * *engine_time
  169.  *      
  170.  * Returns:
  171.  * SNMPERR_SUCCESS Success -- when a record for engineID is found.
  172.  * SNMPERR_GENERR Otherwise.
  173.  *
  174.  *
  175.  * Lookup engineID and return the recorded values for the
  176.  * <engine_time, engineboot> tuple adjusted to reflect the estimated time
  177.  * at the engine in question.
  178.  *
  179.  * Special case: if engineID is NULL or if engineID_len is 0 then
  180.  * the time tuple is returned immediately as zero.
  181.  *
  182.  * XXX What if timediff wraps?  >shrug<
  183.  * XXX  Then: you need to increment the boots value.  Now.  Detecting
  184.  *            this is another matter.
  185.  */
  186. int
  187. get_enginetime_ex( u_char *engineID,
  188. u_int  engineID_len,
  189. u_int *engineboot,
  190. u_int *engine_time,
  191. u_int *last_engine_time,
  192. u_int   authenticated)
  193. {
  194. int rval  = SNMPERR_SUCCESS;
  195. time_t timediff = 0;
  196. Enginetime e  = NULL;
  200. /*
  201.  * Sanity check.
  202.  */
  203. if ( !engine_time || !engineboot || !last_engine_time) {
  204. QUITFUN(SNMPERR_GENERR, get_enginetime_ex_quit);
  205. }
  208. /*
  209.  * Compute estimated current engine_time tuple at engineID if
  210.  * a record is cached for it.
  211.  */
  212. *last_engine_time = *engine_time = *engineboot = 0;
  214. if ( !engineID || (engineID_len<=0) ) {
  215. QUITFUN(SNMPERR_GENERR, get_enginetime_ex_quit);
  216. }
  218. if ( !(e = search_enginetime_list(engineID, engineID_len)) ) {
  219. QUITFUN(SNMPERR_GENERR, get_enginetime_ex_quit);
  220. }
  222. #ifdef LCD_TIME_SYNC_OPT
  223.         if (!authenticated || e->authenticatedFlag) {
  224. #endif
  225. *last_engine_time = *engine_time = e->engineTime;
  226. *engineboot = e->engineBoot;
  228. timediff = time(&timediff) - e->lastReceivedEngineTime;
  229. #ifdef LCD_TIME_SYNC_OPT
  230.         }
  231. #endif
  233. if ( timediff > (int)(ENGINETIME_MAX - *engine_time) ) {
  234. *engine_time = (timediff - (ENGINETIME_MAX - *engine_time));
  236. /* FIX -- move this check up... should not change anything
  237.  * if engineboot is already locked.  ???
  238.  */
  239. if (*engineboot < ENGINEBOOT_MAX) {
  240. *engineboot += 1;
  241. }
  243. } else {
  244. *engine_time += timediff;
  245. }
  247.         DEBUGMSGTL(("lcd_get_enginetime_ex", "engineID "));
  248.         DEBUGMSGHEX(("lcd_get_enginetime_ex", engineID, engineID_len));
  249.         DEBUGMSG(("lcd_get_enginetime_ex", ": boots=%d, time=%dn", *engineboot,
  250.                   *engine_time));
  252. get_enginetime_ex_quit:
  253. return rval;
  255. }  /* end get_enginetime_ex() */
  260. /*******************************************************************-o-******
  261.  * set_enginetime
  262.  *
  263.  * Parameters:
  264.  * *engineID
  265.  *  engineID_len
  266.  *  engineboot
  267.  *  engine_time
  268.  *      
  269.  * Returns:
  270.  * SNMPERR_SUCCESS Success.
  271.  * SNMPERR_GENERR Otherwise.
  272.  *
  273.  *
  274.  * Lookup engineID and store the given <engine_time, engineboot> tuple
  275.  * and then stamp the record with a consistent source of local time.
  276.  * If the engineID record does not exist, create one.
  277.  *
  278.  * Special case: engineID is NULL or engineID_len is 0 defines an engineID
  279.  * that is "always set."
  280.  *
  281.  * XXX "Current time within the local engine" == time(NULL)...
  282.  */
  283. int
  284. set_enginetime( u_char *engineID,
  285. u_int  engineID_len,
  286. u_int  engineboot,
  287. u_int    engine_time,
  288. u_int    authenticated)
  289. {
  290. int rval = SNMPERR_SUCCESS,
  291. iindex;
  292. Enginetime e = NULL;
  293. time_t t_temp;
  297. /*
  298.  * Sanity check.
  299.  */
  300. if ( !engineID || (engineID_len <= 0) ) {
  301. return rval;
  302. }
  305. /*
  306.  * Store the given <engine_time, engineboot> tuple in the record
  307.  * for engineID.  Create a new record if necessary.
  308.  */
  309. if ( !(e = search_enginetime_list(engineID, engineID_len)) )
  310. {
  311. if ( (iindex = hash_engineID(engineID, engineID_len)) < 0 )
  312. {
  313. QUITFUN(SNMPERR_GENERR, set_enginetime_quit);
  314. }
  316. e = (Enginetime) calloc(1,sizeof(*e));
  318. e->next = etimelist[iindex];
  319. etimelist[iindex] = e;
  321. e->engineID = (u_char *) calloc(1,engineID_len);
  322. memcpy(e->engineID, engineID, engineID_len);
  324. e->engineID_len = engineID_len;
  325. }
  326. #ifdef LCD_TIME_SYNC_OPT
  327. if (authenticated || !e->authenticatedFlag) {
  328.   e->authenticatedFlag = authenticated;
  329. #else
  330. if (authenticated) {
  331. #endif
  332.   e->engineTime   = engine_time;
  333.   e->engineBoot   = engineboot;
  334.   e->lastReceivedEngineTime = time(&t_temp);
  335.         }
  337. e = NULL; /* Indicates a successful update. */
  339.         DEBUGMSGTL(("lcd_set_enginetime", "engineID "));
  340.         DEBUGMSGHEX(("lcd_set_enginetime", engineID, engineID_len));
  341.         DEBUGMSG(("lcd_set_enginetime", ": boots=%d, time=%dn", engineboot,
  342.                   engine_time));
  344. set_enginetime_quit:
  345. SNMP_FREE(e);
  347. return rval;
  349. }  /* end set_enginetime() */
  354. /*******************************************************************-o-******
  355.  * search_enginetime_list
  356.  *
  357.  * Parameters:
  358.  * *engineID
  359.  *  engineID_len
  360.  *      
  361.  * Returns:
  362.  * Pointer to a etimelist record with engineID <engineID>  -OR-
  363.  * NULL if no record exists.
  364.  *
  365.  *
  366.  * Search etimelist for an entry with engineID.
  367.  *
  368.  * ASSUMES that no engineID will have more than one record in the list.
  369.  */
  370. Enginetime
  371. search_enginetime_list(u_char *engineID, u_int engineID_len)
  372. {
  373. int rval = SNMPERR_SUCCESS;
  374. Enginetime e    = NULL;
  377. /*
  378.  * Sanity check.
  379.  */
  380. if ( !engineID || (engineID_len<=0) ) {
  381. QUITFUN(SNMPERR_GENERR, search_enginetime_list_quit);
  382. }
  385. /*
  386.  * Find the entry for engineID if there be one.
  387.  */
  388. rval = hash_engineID(engineID, engineID_len);
  389. if (rval < 0) {
  390. QUITFUN(SNMPERR_GENERR, search_enginetime_list_quit);
  391. }
  392. e = etimelist[rval];
  394. for ( /*EMPTY*/; e; e = e->next )
  395. {
  396. if ( (engineID_len == e->engineID_len)
  397. && !memcmp(e->engineID, engineID, engineID_len) )
  398. {
  399. break;
  400. }
  401. }
  404. search_enginetime_list_quit:
  405. return e;
  407. }  /* end search_enginetime_list() */
  413. /*******************************************************************-o-******
  414.  * hash_engineID
  415.  *
  416.  * Parameters:
  417.  * *engineID
  418.  *  engineID_len
  419.  *      
  420.  * Returns:
  421.  * >0 etimelist index for this engineID.
  422.  * SNMPERR_GENERR Error.
  423.  *
  424.  * 
  425.  * Use a cheap hash to build an index into the etimelist.  Method is 
  426.  * to hash the engineID, then split the hash into u_int's and add them up
  427.  * and modulo the size of the list.
  428.  *
  429.  */
  430. int
  431. hash_engineID(u_char *engineID, u_int engineID_len)
  432. {
  433. int  rval = SNMPERR_GENERR;
  434. size_t  buf_len = SNMP_MAXBUF;
  435. u_int  additive = 0;
  436. u_char *bufp,
  437.  buf[SNMP_MAXBUF];
  438. void *context = NULL;
  442. /*
  443.  * Sanity check.
  444.  */
  445. if ( !engineID || (engineID_len <= 0) ) {
  446. QUITFUN(SNMPERR_GENERR, hash_engineID_quit);
  447. }
  450. /*
  451.  * Hash engineID into a list index.
  452.  */
  453.         rval = sc_hash(usmHMACMD5AuthProtocol,
  454.                        sizeof(usmHMACMD5AuthProtocol)/sizeof(oid),
  455.                        engineID, engineID_len,
  456.                        buf, &buf_len);
  457. QUITFUN(rval, hash_engineID_quit);
  458.         
  459. for ( bufp = buf; (bufp-buf) < (int)buf_len; bufp += 4 ) {
  460. additive += (u_int) *bufp;
  461. }
  463. hash_engineID_quit:
  464. SNMP_FREE(context);
  465. memset(buf, 0, SNMP_MAXBUF);
  467. return (rval < 0) ? rval : (additive % ETIMELIST_SIZE);
  469. }  /* end hash_engineID() */
  474. #ifdef SNMP_TESTING_CODE
  475. /*******************************************************************-o-******
  476.  * dump_etimelist_entry
  477.  *
  478.  * Parameters:
  479.  * e
  480.  * count
  481.  */
  482. void
  483. dump_etimelist_entry(Enginetime e, int count)
  484. {
  485. u_int  buflen;
  486. char  tabs[SNMP_MAXBUF],
  487. *t = tabs, 
  488. *s;
  489. time_t  t_temp;
  493. count += 1;
  494. while (count--) {
  495. t += sprintf(t, "  ");
  496. }
  499. buflen = e->engineID_len;
  500. #ifdef SNMP_TESTING_CODE
  501. if ( !(s = dump_snmpEngineID(e->engineID, &buflen)) ) {
  502. #endif
  503. binary_to_hex(e->engineID, e->engineID_len, &s);
  504. #ifdef SNMP_TESTING_CODE
  505. }
  506. #endif
  508. DEBUGMSGTL(("dump_etimelist", "%sn",tabs));
  509. DEBUGMSGTL(("dump_etimelist", "%s%s (len=%d) <%d,%d>n", tabs,
  510.                     s, e->engineID_len,
  511.                     e->engineTime, e->engineBoot));
  512. DEBUGMSGTL(("dump_etimelist", "%s%ld (%ld) -- %s", tabs,
  513.                     e->lastReceivedEngineTime,
  514.                     time(&t_temp) - e->lastReceivedEngineTime,
  515.                     ctime(&e->lastReceivedEngineTime)));
  517. SNMP_FREE(s);
  519. }  /* end dump_etimelist_entry() */
  524. /*******************************************************************-o-******
  525.  * dump_etimelist
  526.  */
  527. void
  528. dump_etimelist(void)
  529. {
  530. int iindex = -1,
  531. count = 0;
  532. Enginetime e;
  536. DEBUGMSGTL(("dump_etimelist", "n"));
  538. while (++iindex < ETIMELIST_SIZE) {
  539. DEBUGMSG(("dump_etimelist", "[%d]", iindex));
  541. count = 0;
  542. e = etimelist[iindex];
  544. while (e) {
  545. dump_etimelist_entry(e, count++);
  546. e = e->next;
  547. }
  549. if (count > 0) {
  550. DEBUGMSG(("dump_etimelist", "n"));
  551. }
  552. }  /* endwhile */
  554. DEBUGMSG(("dump_etimelist", "n"));
  556. }  /* end dump_etimelist() */
  557. #endif /* SNMP_TESTING_CODE */