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

SNMP编程

开发平台:

Unix_Linux

  1. /**************************************************************
  2.  * Copyright (C) 2001 Alex Rozin, Optical Access 
  3.  *
  4.  *                     All Rights Reserved
  5.  *
  6.  * Permission to use, copy, modify and distribute this software and its
  7.  * documentation for any purpose and without fee is hereby granted,
  8.  * provided that the above copyright notice appear in all copies and that
  9.  * both that copyright notice and this permission notice appear in
  10.  * supporting documentation.
  11.  * 
  12.  * ALEX ROZIN DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  13.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  14.  * ALEX ROZIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  15.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  16.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  17.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  18.  * SOFTWARE.
  19.  ******************************************************************/
  20. #include <net-snmp/net-snmp-config.h>
  21. #include <net-snmp/net-snmp-includes.h>
  22. #include <net-snmp/agent/net-snmp-agent-includes.h>
  23. #include "util_funcs.h"
  24. #include "agutil.h"
  25. #include "agutil_api.h"
  26. #ifndef OPTICALL_ACESS          /* in OpticalAccess case : find them in ~agent/mibgroup/nbase directory */
  27. void
  28. ag_trace(const char *format, ...)
  29. {
  30. #define AG_MAX_MSG_LEN  120
  31.     char            msg[AG_MAX_MSG_LEN];
  32.     va_list         args;
  33.     /*
  34.      * create msg 
  35.      */
  36.     va_start(args, format);
  37.     vsnprintf(msg, AG_MAX_MSG_LEN - 1, format, args);
  38.     snmp_log(LOG_INFO, "%sn", msg);
  39.     va_end(args);
  40. }
  41. int
  42. AGUTIL_advance_index_name(struct variable *vp, oid * name,
  43.                           size_t * length, int exact)
  44. {
  45.     int             result;
  46.     if (exact)
  47.         return 0;
  48.     if (*length <= vp->namelen) {
  49.         result =
  50.             snmp_oid_compare(name, *length, vp->name, (int) vp->namelen);
  51.         memcpy((char *) name, (char *) vp->name,
  52.                ((int) vp->namelen) * sizeof(oid));
  53.         *length = vp->namelen;
  54.     } else {
  55.         /*
  56.          * If the name is given with indexes - compare only the oids. 
  57.          */
  58.         result =
  59.             snmp_oid_compare(name, (int) vp->namelen, vp->name,
  60.                              (int) vp->namelen);
  61.         /*
  62.          * If it's not the same oid - change name to the new oid 
  63.          */
  64.         if (result < 0) {
  65.             memcpy((char *) name, (char *) vp->name,
  66.                    ((int) vp->namelen) * sizeof(oid));
  67.             *length = vp->namelen;
  68.         }
  69.     }
  70.     if (result > 0) {
  71.         ag_trace("*length=%d result=%d !!!", (int) *length, (int) result);
  72.         return -1;
  73.     }
  74.     return 0;
  75. }
  76. /*********************************************************************
  77.  * Function: AGUTIL_get_int_value
  78.  *
  79.  * Description:
  80.  *   Check/Get long value from the PDU..
  81.  *   The parameters 'min_value' & 'max_value' allow to check the diaposon
  82.  *   of the value. If (max_value <= min_value) we avoid this checking.
  83.  *
  84.  * Returns:
  85.  *   SNMP_ERR_NOERROR
  86.  *   SNMP_ERR_WRONGTYPE
  87.  *   SNMP_ERR_WRONGLENGTH
  88.  *   SNMP_ERR_WRONGENCODING
  89.  *   SNMP_ERR_BADVALUE
  90.  *********************************************************************/
  91. int
  92. AGUTIL_get_int_value(u_char * var_val, u_char var_val_type,
  93.                      size_t var_val_len, long min_value, long max_value,
  94.                      long *long_tmp)
  95. {
  96.     if (var_val_type != ASN_INTEGER && var_val_type != ASN_TIMETICKS) {
  97.         ag_trace("not ASN_INTEGER 0x%lx", (long) var_val_type);
  98.         return SNMP_ERR_WRONGTYPE;
  99.     }
  100.     if (var_val_len > sizeof(long)) {
  101.         ag_trace("wrong len=%d", (int) var_val_len);
  102.         return SNMP_ERR_WRONGLENGTH;
  103.     }
  104.     *long_tmp = *((long *) var_val);
  105.     if (max_value > min_value) {
  106.         if (*long_tmp < min_value) {
  107.             ag_trace("%ld=long_tmp < min=%ld", (long) *long_tmp,
  108.                      (long) min_value);
  109.             return SNMP_ERR_BADVALUE;
  110.         }
  111.         if (*long_tmp > max_value) {
  112.             ag_trace("%ld=long_tmp > max=%ld", (long) *long_tmp,
  113.                      (long) max_value);
  114.             return SNMP_ERR_BADVALUE;
  115.         }
  116.     }
  117.     return SNMP_ERR_NOERROR;
  118. }
  119. /*********************************************************************
  120.  * Function: AGUTIL_get_string_value
  121.  *
  122.  * Description:
  123.  *   Check/Get 'DisplayString' value from the PDU..
  124.  *
  125.  * Returns:
  126.  *   SNMP_ERR_NOERROR
  127.  *   SNMP_ERR_WRONGTYPE
  128.  *   SNMP_ERR_WRONGLENGTH
  129.  *   SNMP_ERR_WRONGENCODING
  130.  *   SNMP_ERR_BADVALUE
  131.  *********************************************************************/
  132. int
  133. AGUTIL_get_string_value(u_char * var_val, u_char var_val_type,
  134.                         size_t var_val_len, size_t buffer_max_size,
  135.                         u_char should_zero_limited,
  136.                         size_t * buffer_actual_size, char *buffer)
  137. {
  138.     if (var_val_type != ASN_OCTET_STR) {
  139.         ag_trace("not ASN_OCTET_STR 0x%lx", (long) var_val_type);
  140.         return SNMP_ERR_WRONGTYPE;
  141.     }
  142.     if (var_val_len > buffer_max_size) {
  143.         ag_trace("wrong len=%d > %d", (int) var_val_len, buffer_max_size);
  144.         return SNMP_ERR_WRONGLENGTH;
  145.     }
  146.     if (buffer_actual_size)
  147.         *buffer_actual_size = var_val_len;
  148.     memcpy(buffer, var_val, var_val_len);
  149.     if (should_zero_limited) {
  150.         buffer[var_val_len] = 0;
  151.         if (buffer_actual_size)
  152.             *buffer_actual_size += 1;
  153.     }
  154.     return SNMP_ERR_NOERROR;
  155. }
  156. #endif
  157. int
  158. AGUTIL_get_oid_value(u_char * var_val, u_char var_val_type,
  159.                      size_t var_val_len, VAR_OID_T * data_source_ptr)
  160. {
  161.     register int    iii;
  162.     register oid   *oid_var;
  163.     if (var_val_len > MAX_OID_LEN) {
  164.         ag_trace("wrong len=%d > %d", (int) var_val_len, MAX_OID_LEN);
  165.         return SNMP_ERR_WRONGLENGTH;
  166.     }
  167.     var_val_len /= sizeof(oid);
  168.     data_source_ptr->length = var_val_len;
  169.     oid_var = (oid *) var_val;
  170.     for (iii = 0; iii < (int)data_source_ptr->length; iii++)
  171.         data_source_ptr->objid[iii] = oid_var[iii];
  172.     return SNMP_ERR_NOERROR;
  173. }
  174. u_long
  175. AGUTIL_sys_up_time(void)
  176. {
  177.     struct timeval  current, delta;
  178.     extern struct timeval starttime;
  179.     gettimeofday(&current, NULL);
  180.     current.tv_sec--;
  181.     current.tv_usec += 1000000L;
  182.     delta.tv_sec = current.tv_sec - starttime.tv_sec;
  183.     delta.tv_usec = current.tv_usec - starttime.tv_usec;
  184.     if (delta.tv_usec > 1000000L) {
  185.         delta.tv_usec -= 1000000L;
  186.         delta.tv_sec++;
  187.     }
  188.     return delta.tv_sec * 100 + delta.tv_usec / 10000;
  189. }
  190. /*
  191.  * NOTE: this function is a template for system dependent
  192.  * implementation. Actually it (in debug purposes) returns
  193.  * random (but likely) data */
  194. void
  195. SYSTEM_get_eth_statistics(VAR_OID_T * data_source, ETH_STATS_T * where)
  196. {
  197. #if OPTICALL_ACESS
  198.     where->ifIndex = data_source->objid[data_source->length - 1];
  199.     agent_get_Rmon_ethernet_statistics(where->ifIndex, 1,       /* exact */
  200.                                        where);
  201. #else                           /* OPTICALL_ACESS */
  202.     static ETH_STATS_T prev = { -1, -1 };
  203.     static time_t   ifLastRead = 0;
  204.     time_t          curr_time;
  205.     u_char          need_to_read;
  206.     u_long          rc;
  207.     where->ifIndex = data_source->objid[data_source->length - 1];
  208.     need_to_read = (where->ifIndex != prev.ifIndex);
  209.     if (!need_to_read) {
  210.         curr_time = time(NULL);
  211.         need_to_read = (curr_time - ifLastRead > 1);
  212.     }
  213.     if (need_to_read) {
  214.         rc = (u_long) (1.0 +
  215.                        ((double) rand() / (double) RAND_MAX) * 100.0);
  216.         ifLastRead = time(NULL);
  217.         prev.ifIndex = where->ifIndex;
  218.     } else
  219.         rc = 0;
  220.     memcpy(where, &prev, sizeof(ETH_STATS_T));
  221.     where->octets += rc * 100 * 200;
  222.     where->packets += rc * 100;
  223.     where->bcast_pkts += rc * 2;
  224.     where->mcast_pkts += rc * 3;
  225.     where->crc_align += rc;
  226.     where->undersize += 0;
  227.     where->oversize += 0;
  228.     where->fragments += rc / 2;
  229.     where->jabbers += 0;
  230.     where->collisions += rc / 4;
  231.     where->pkts_64 += rc * 10;
  232.     where->pkts_65_127 += rc * 50;
  233.     where->pkts_128_255 += rc * 20;
  234.     where->pkts_256_511 += rc * 10;
  235.     where->pkts_512_1023 += rc * 15;
  236.     where->pkts_1024_1518 += rc * 5;
  237.     need_to_read = prev.ifIndex;
  238.     memcpy(&prev, where, sizeof(ETH_STATS_T));
  239.     prev.ifIndex = need_to_read;
  240. #endif                          /* OPTICALL_ACESS */
  241. }
  242. #if 0                           /* for memory debug */
  243. static u_long   dbg_mem_cnt = 0;
  244. void           *
  245. dbg_f_AGMALLOC(size_t size)
  246. {
  247.     dbg_mem_cnt++;
  248.     return malloc(size);
  249. }
  250. void
  251. dbg_f_AGFREE(void *ptr)
  252. {
  253.     dbg_mem_cnt--;
  254.     free(ptr);
  255. }
  256. char           *
  257. dbg_f_AGSTRDUP(const char *s)
  258. {
  259.     dbg_mem_cnt++;
  260.     return strdup(s);
  261. }
  262. void
  263. dbg_f_AG_MEM_REPORT(void)
  264. {
  265.     ag_trace("dbg_mem_cnt=%ld", (long) dbg_mem_cnt);
  266. }
  267. #endif
  268. void
  269. init_agutil(void)
  270. {
  271. }