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

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

SNMP编程

开发平台：

Unix_Linux

hr_storage.c：源码内容
  1. /*
  2.  *  Host Resources MIB - storage group implementation - hr_storage.c
  3.  *
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  8. #if defined(freebsd5)
  9. /* undefine these in order to use getfsstat */
  10. #undef HAVE_STATVFS
  11. #undef STRUCT_STATVFS_HAS_F_FRSIZE
  12. #endif
  14. #include <sys/types.h>
  15. #include <sys/param.h>
  16. #if HAVE_UNISTD_H
  17. #include <unistd.h>
  18. #endif
  19. #if TIME_WITH_SYS_TIME
  20. # ifdef WIN32
  21. #  include <sys/timeb.h>
  22. # else
  23. #  include <sys/time.h>
  24. # endif
  25. # include <time.h>
  26. #else
  27. # if HAVE_SYS_TIME_H
  28. #  include <sys/time.h>
  29. # else
  30. #  include <time.h>
  31. # endif
  32. #endif
  34. #ifndef mingw32
  35. #if HAVE_UTMPX_H
  36. #include <utmpx.h>
  37. #else
  38. #include <utmp.h>
  39. #endif
  40. #endif /* mingw32 */
  41. #ifndef dynix
  42. #if HAVE_SYS_VM_H
  43. #include <sys/vm.h>
  44. #if (!defined(KERNEL) || defined(MACH_USER_API)) && defined(HAVE_SYS_VMMETER_H) /*OS X does not #include <sys/vmmeter.h> if (defined(KERNEL) && !defined(MACH_USER_API)) */
  45. #include <sys/vmmeter.h>
  46. #endif
  47. #else
  48. #if HAVE_VM_VM_H
  49. #include <vm/vm.h>
  50. #if HAVE_MACHINE_TYPES_H
  51. #include <machine/types.h>
  52. #endif
  53. #if HAVE_SYS_VMMETER_H
  54. #include <sys/vmmeter.h>
  55. #endif
  56. #if HAVE_VM_VM_PARAM_H
  57. #include <vm/vm_param.h>
  58. #endif
  59. #else
  60. #if HAVE_SYS_VMPARAM_H
  61. #include <sys/vmparam.h>
  62. #endif
  63. #if HAVE_SYS_VMMAC_H
  64. #include <sys/vmmac.h>
  65. #endif
  66. #if HAVE_SYS_VMMETER_H
  67. #include <sys/vmmeter.h>
  68. #endif
  69. #if HAVE_SYS_VMSYSTM_H
  70. #include <sys/vmsystm.h>
  71. #endif
  72. #endif                          /* vm/vm.h */
  73. #endif                          /* sys/vm.h */
  74. #if defined(HAVE_UVM_UVM_PARAM_H) && defined(HAVE_UVM_UVM_EXTERN_H)
  75. #include <uvm/uvm_param.h>
  76. #include <uvm/uvm_extern.h>
  77. #elif defined(HAVE_VM_VM_PARAM_H) && defined(HAVE_VM_VM_EXTERN_H)
  78. #include <vm/vm_param.h>
  79. #include <vm/vm_extern.h>
  80. #endif
  81. #if HAVE_KVM_H
  82. #include <kvm.h>
  83. #endif
  84. #if HAVE_FCNTL_H
  85. #include <fcntl.h>
  86. #endif
  87. #if HAVE_SYS_POOL_H
  88. #if defined(MBPOOL_SYMBOL) && defined(MCLPOOL_SYMBOL)
  89. #define __POOL_EXPOSE
  90. #include <sys/pool.h>
  91. #else
  92. #undef HAVE_SYS_POOL_H
  93. #endif
  94. #endif
  95. #if HAVE_SYS_MBUF_H
  96. #include <sys/mbuf.h>
  97. #endif
  98. #if HAVE_SYS_SYSCTL_H
  99. #include <sys/sysctl.h>
  100. #if defined(CTL_HW) && defined(HW_PAGESIZE)
  101. #define USE_SYSCTL
  102. #endif
  103. #if defined(CTL_VM) && (defined(VM_METER) || defined(VM_UVMEXP))
  104. #define USE_SYSCTL_VM
  105. #endif
  106. #endif
  107. #endif                          /* ifndef dynix */
  109. #include "host_res.h"
  110. #include "hr_storage.h"
  111. #include "hr_filesys.h"
  112. #include <net-snmp/agent/auto_nlist.h>
  114. #if HAVE_MNTENT_H
  115. #include <mntent.h>
  116. #endif
  117. #if HAVE_SYS_MNTTAB_H
  118. #include <sys/mnttab.h>
  119. #endif
  120. #if HAVE_SYS_STATVFS_H
  121. #include <sys/statvfs.h>
  122. #endif
  123. #if HAVE_SYS_VFS_H
  124. #include <sys/vfs.h>
  125. #endif
  126. #if HAVE_SYS_MOUNT_H
  127. #ifdef __osf__
  128. #undef m_next
  129. #undef m_data
  130. #endif
  131. #include <sys/mount.h>
  132. #endif
  133. #ifdef HAVE_MACHINE_PARAM_H
  134. #include <machine/param.h>
  135. #endif
  136. #include <sys/stat.h>
  138. #if defined(hpux10) || defined(hpux11)
  139. #include <sys/pstat.h>
  140. #endif
  141. #if defined(solaris2)
  142. #if HAVE_SYS_SWAP_H
  143. #include <sys/swap.h>
  144. #endif
  145. #endif
  147. #if HAVE_STRING_H
  148. #include <string.h>
  149. #else
  150. #include <strings.h>
  151. #endif
  153. #include <net-snmp/utilities.h>
  154. #include <net-snmp/output_api.h>
  156. #if solaris2
  157. #include "kernel_sunos5.h"
  158. #endif
  160. #include <net-snmp/agent/agent_read_config.h>
  161. #include <net-snmp/library/read_config.h>
  163. #define HRSTORE_MONOTONICALLY_INCREASING
  165.         /*********************
  166.  *
  167.  *  Kernel & interface information,
  168.  *   and internal forward declarations
  169.  *
  170.  *********************/
  173. #ifdef solaris2
  175. extern struct mnttab *HRFS_entry;
  176. #define HRFS_mount mnt_mountp
  177. #define HRFS_statfs statvfs
  178. #define HRFS_HAS_FRSIZE STRUCT_STATVFS_HAS_F_FRSIZE
  180. #elif defined(HAVE_STATVFS) && defined(__NetBSD__)
  182. extern struct statvfs *HRFS_entry;
  183. extern int      fscount;
  184. #define HRFS_statfs statvfs
  185. #define HRFS_mount f_mntonname
  186. #define HRFS_HAS_FRSIZE STRUCT_STATVFS_HAS_F_FRSIZE
  188. #elif defined(HAVE_STATVFS) && defined(STRUCT_STATVFS_HAS_MNT_DIR)
  190. extern struct mntent *HRFS_entry;
  191. extern int      fscount;
  192. #define HRFS_statfs statvfs
  193. #define HRFS_mount mnt_dir
  194. #define HRFS_HAS_FRSIZE STRUCT_STATVFS_HAS_F_FRSIZE
  196. #elif defined(HAVE_GETFSSTAT)
  198. extern struct statfs *HRFS_entry;
  199. extern int      fscount;
  200. #define HRFS_statfs statfs
  201. #define HRFS_mount f_mntonname
  202. #define HRFS_HAS_FRSIZE STRUCT_STATFS_HAS_F_FRSIZE
  204. #else
  206. extern struct mntent *HRFS_entry;
  207. #define HRFS_mount mnt_dir
  208. #define HRFS_statfs statfs
  209. #define HRFS_HAS_FRSIZE STRUCT_STATFS_HAS_F_FRSIZE
  211. #endif
  213. static int      physmem, pagesize;
  214. static void parse_storage_config(const char *, char *);
  216.         /*********************
  217.  *
  218.  *  Initialisation & common implementation functions
  219.  *
  220.  *********************/
  221. int             Get_Next_HR_Store(void);
  222. void            Init_HR_Store(void);
  223. int             header_hrstore(struct variable *, oid *, size_t *, int,
  224.                                size_t *, WriteMethod **);
  225. int             header_hrstoreEntry(struct variable *, oid *, size_t *,
  226.                                     int, size_t *, WriteMethod **);
  228. #ifdef linux
  229. int             linux_mem(int, int);
  230. #endif
  232. #ifdef solaris2
  233. void            sol_get_swapinfo(int *, int *);
  234. #endif
  236. #define HRSTORE_MEMSIZE 1
  237. #define HRSTORE_INDEX 2
  238. #define HRSTORE_TYPE 3
  239. #define HRSTORE_DESCR 4
  240. #define HRSTORE_UNITS 5
  241. #define HRSTORE_SIZE 6
  242. #define HRSTORE_USED 7
  243. #define HRSTORE_FAILS 8
  245. struct variable4 hrstore_variables[] = {
  246.     {HRSTORE_MEMSIZE, ASN_INTEGER, RONLY, var_hrstore, 1, {2}},
  247.     {HRSTORE_INDEX, ASN_INTEGER, RONLY, var_hrstore, 3, {3, 1, 1}},
  248.     {HRSTORE_TYPE, ASN_OBJECT_ID, RONLY, var_hrstore, 3, {3, 1, 2}},
  249.     {HRSTORE_DESCR, ASN_OCTET_STR, RONLY, var_hrstore, 3, {3, 1, 3}},
  250.     {HRSTORE_UNITS, ASN_INTEGER, RONLY, var_hrstore, 3, {3, 1, 4}},
  251.     {HRSTORE_SIZE, ASN_INTEGER, RONLY, var_hrstore, 3, {3, 1, 5}},
  252.     {HRSTORE_USED, ASN_INTEGER, RONLY, var_hrstore, 3, {3, 1, 6}},
  253.     {HRSTORE_FAILS, ASN_COUNTER, RONLY, var_hrstore, 3, {3, 1, 7}}
  254. };
  255. oid             hrstore_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 2 };
  258. void
  259. init_hr_storage(void)
  260. {
  261. #ifdef USE_SYSCTL
  262.     int             mib[2];
  263.     size_t          len;
  264. #elif defined(hpux10) || defined(hpux11)
  265.     struct pst_static pst_buf;
  266. #endif
  268. #ifdef USE_SYSCTL
  269.     mib[0] = CTL_HW;
  270.     mib[1] = HW_PHYSMEM;
  271.     len = sizeof(physmem);
  272.     if (sysctl(mib, 2, &physmem, &len, NULL, 0) == -1)
  273.         snmp_log_perror("sysctl: physmem");
  274.     mib[1] = HW_PAGESIZE;
  275.     len = sizeof(pagesize);
  276.     if (sysctl(mib, 2, &pagesize, &len, NULL, 0) == -1)
  277.         snmp_log_perror("sysctl: pagesize");
  278.     physmem /= pagesize;
  279. #elif defined(hpux10) || defined(hpux11)
  280.     if (pstat_getstatic(&pst_buf, sizeof(struct pst_static), 1, 0) < 0) {
  281.         snmp_log_perror("pstat_getstatic");
  282.     } else {
  283.         physmem = pst_buf.physical_memory;
  284.         pagesize = pst_buf.page_size;
  285.     }
  286. #else                           /* !USE_SYSCTL && !hpux10 && !hpux11 */
  287. #ifdef HAVE_GETPAGESIZE
  288.     pagesize = getpagesize();
  289. #elif defined(_SC_PAGESIZE)
  290.     pagesize = sysconf(_SC_PAGESIZE);
  291. #elif defined(PGSHIFT)
  292.     pagesize = 1 << PGSHIFT;
  293. #elif defined(PAGE_SHIFT)
  294.     pagesize = 1 << PAGE_SHIFT;
  295. #elif defined(PAGE_SIZE)
  296.     pagesize = PAGE_SIZE;
  297. #elif defined(linux)
  298.     {
  299.         struct stat     kc_buf;
  300.         if (stat("/proc/kcore", &kc_buf) == -1)
  301.     snmp_log_perror("/proc/kcore");
  302.         pagesize = kc_buf.st_size / 1024;       /* 4K too large ? */
  303.     }
  304. #else
  305.     pagesize = PAGESIZE;
  306. #endif
  307. #ifdef _SC_PHYS_PAGES
  308.     physmem = sysconf(_SC_PHYS_PAGES);
  309. #else
  310. #ifdef dynix
  311.     physmem = sysconf(_SC_PHYSMEM);
  312. #else
  313.     auto_nlist(PHYSMEM_SYMBOL, (char *) &physmem, sizeof(physmem));
  314. #endif
  315. #endif
  316. #endif                          /* !USE_SYSCTL && !hpux10 && !hpux11 */
  317. #ifdef TOTAL_MEMORY_SYMBOL
  318.     auto_nlist(TOTAL_MEMORY_SYMBOL, 0, 0);
  319. #endif
  320. #ifdef MBSTAT_SYMBOL
  321.     auto_nlist(MBSTAT_SYMBOL, 0, 0);
  322. #endif
  324.     REGISTER_MIB("host/hr_storage", hrstore_variables, variable4,
  325.                  hrstore_variables_oid);
  327.     snmpd_register_config_handler("storageUseNFS", parse_storage_config, NULL,
  328. "1 | 2tt(1 = enable, 2 = disable)");
  329. }
  331. static int storageUseNFS = 0; /* initially disabled */
  333. static void
  334. parse_storage_config(const char *token, char *cptr)
  335. {
  336.     char *val;
  337.     int ival;
  338.     char *st;
  340.     val = strtok_r(cptr, " t", &st);
  341.     if (!val) {
  342.         config_perror("Missing FLAG parameter in storageUseNFS");
  343.         return;
  344.     }
  345.     ival = atoi(val);
  346.     if (ival < 1 || ival > 2) {
  347.         config_perror("storageUseNFS must be 1 or 2");
  348.         return;
  349.     }
  350.     storageUseNFS = (ival == 1) ? 1 : 0;
  351. }
  353. /*
  354.  * header_hrstore(...
  355.  * Arguments:
  356.  * vp     IN      - pointer to variable entry that points here
  357.  * name    IN/OUT  - IN/name requested, OUT/name found
  358.  * length  IN/OUT  - length of IN/OUT oid's 
  359.  * exact   IN      - TRUE if an exact match was requested
  360.  * var_len OUT     - length of variable or 0 if function returned
  361.  * write_method
  362.  * 
  363.  */
  365. int
  366. header_hrstore(struct variable *vp,
  367.                oid * name,
  368.                size_t * length,
  369.                int exact, size_t * var_len, WriteMethod ** write_method)
  370. {
  371. #define HRSTORE_NAME_LENGTH 9
  372.     oid             newname[MAX_OID_LEN];
  373.     int             result;
  375.     DEBUGMSGTL(("host/hr_storage", "var_hrstore: "));
  376.     DEBUGMSGOID(("host/hr_storage", name, *length));
  377.     DEBUGMSG(("host/hr_storage", " %dn", exact));
  379.     memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
  380.     newname[HRSTORE_NAME_LENGTH] = 0;
  381.     result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
  382.     if ((exact && (result != 0)) || (!exact && (result >= 0)))
  383.         return (MATCH_FAILED);
  384.     memcpy((char *) name, (char *) newname,
  385.            (vp->namelen + 1) * sizeof(oid));
  386.     *length = vp->namelen + 1;
  388.     *write_method = 0;
  389.     *var_len = sizeof(long);    /* default to 'long' results */
  390.     return (MATCH_SUCCEEDED);
  391. }
  393. int
  394. header_hrstoreEntry(struct variable *vp,
  395.                     oid * name,
  396.                     size_t * length,
  397.                     int exact,
  398.                     size_t * var_len, WriteMethod ** write_method)
  399. {
  400. #define HRSTORE_ENTRY_NAME_LENGTH 11
  401.     oid             newname[MAX_OID_LEN];
  402.     int             storage_idx, LowIndex = -1;
  403.     int             result;
  405.     DEBUGMSGTL(("host/hr_storage", "var_hrstoreEntry: "));
  406.     DEBUGMSGOID(("host/hr_storage", name, *length));
  407.     DEBUGMSG(("host/hr_storage", " %dn", exact));
  409.     memcpy((char *) newname, (char *) vp->name,
  410.            (int) vp->namelen * sizeof(oid));
  411.     /*
  412.      * Find "next" storage entry 
  413.      */
  415.     Init_HR_Store();
  416.     for (;;) {
  417.         storage_idx = Get_Next_HR_Store();
  418.         DEBUGMSG(("host/hr_storage", "(index %d ....", storage_idx));
  419.         if (storage_idx == -1)
  420.             break;
  421.         newname[HRSTORE_ENTRY_NAME_LENGTH] = storage_idx;
  422.         DEBUGMSGOID(("host/hr_storage", newname, *length));
  423.         DEBUGMSG(("host/hr_storage", "n"));
  424.         result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
  425.         if (exact && (result == 0)) {
  426.             LowIndex = storage_idx;
  427.             /*
  428.              * Save storage status information 
  429.              */
  430.             break;
  431.         }
  432.         if ((!exact && (result < 0)) &&
  433.             (LowIndex == -1 || storage_idx < LowIndex)) {
  434.             LowIndex = storage_idx;
  435.             /*
  436.              * Save storage status information 
  437.              */
  438. #ifdef HRSTORE_MONOTONICALLY_INCREASING
  439.             break;
  440. #endif
  441.         }
  442.     }
  444.     if (LowIndex == -1) {
  445.         DEBUGMSGTL(("host/hr_storage", "... index out of rangen"));
  446.         return (MATCH_FAILED);
  447.     }
  449.     memcpy((char *) name, (char *) newname,
  450.            ((int) vp->namelen + 1) * sizeof(oid));
  451.     *length = vp->namelen + 1;
  452.     *write_method = 0;
  453.     *var_len = sizeof(long);    /* default to 'long' results */
  455.     DEBUGMSGTL(("host/hr_storage", "... get storage stats "));
  456.     DEBUGMSGOID(("host/hr_storage", name, *length));
  457.     DEBUGMSG(("host/hr_storage", "n"));
  458.     return LowIndex;
  459. }
  461. oid             storage_type_id[] = { 1, 3, 6, 1, 2, 1, 25, 2, 1, 1 };  /* hrStorageOther */
  462. int             storage_type_len =
  463.     sizeof(storage_type_id) / sizeof(storage_type_id[0]);
  465.         /*********************
  466.  *
  467.  *  System specific implementation functions
  468.  *
  469.  *********************/
  471. static const char *hrs_descr[] = {
  472.     NULL,
  473.     "Memory Buffers",           /* HRS_TYPE_MBUF */
  474.     "Real Memory",              /* HRS_TYPE_MEM */
  475.     "Swap Space"                /* HRS_TYPE_SWAP */
  476. };
  480. u_char         *
  481. var_hrstore(struct variable *vp,
  482.             oid * name,
  483.             size_t * length,
  484.             int exact, size_t * var_len, WriteMethod ** write_method)
  485. {
  486.     int             store_idx = 0;
  487. #if !defined(linux)
  488. #if defined(solaris2)
  489.     int             freemem;
  490.     int             swap_total, swap_used;
  491. #elif defined(hpux10) || defined(hpux11)
  492.     struct pst_dynamic pst_buf;
  493. #elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
  494. #ifdef VM_UVMEXP
  495.     struct uvmexp   uvmexp_totals;
  496. #endif
  497.     struct vmtotal  memory_totals;
  498. #endif
  499. #if HAVE_KVM_GETSWAPINFO
  500.     struct kvm_swap swapinfo;
  501.     static kvm_t *kd = NULL;
  502. #endif
  503. #if HAVE_SYS_POOL_H
  504.     struct pool     mbpool, mclpool;
  505.     int             i;
  506. #endif
  507. #ifdef MBSTAT_SYMBOL
  508.     struct mbstat   mbstat;
  509. #endif
  510. #endif                          /* !linux */
  511.     static char     string[1024];
  512.     struct HRFS_statfs stat_buf;
  514.     if (vp->magic == HRSTORE_MEMSIZE) {
  515.         if (header_hrstore(vp, name, length, exact, var_len, write_method)
  516.             == MATCH_FAILED)
  517.             return NULL;
  518.     } else {
  520. really_try_next:
  521. store_idx = header_hrstoreEntry(vp, name, length, exact, var_len,
  522. write_method);
  523. if (store_idx == MATCH_FAILED)
  524.     return NULL;
  526. if (store_idx > HRS_TYPE_FIXED_MAX) {
  527.     if (HRFS_statfs(HRFS_entry->HRFS_mount, &stat_buf) < 0) {
  528. snmp_log_perror(HRFS_entry->HRFS_mount);
  529. goto try_next;
  530.     }
  531. }
  532. #if !defined(linux) && !defined(solaris2)
  533.         else
  534.             switch (store_idx) {
  535.             case HRS_TYPE_MEM:
  536.             case HRS_TYPE_SWAP:
  537. #ifdef USE_SYSCTL_VM
  538.                 {
  539.                     int             mib[2];
  540.                     size_t          len = sizeof(memory_totals);
  541.                     mib[0] = CTL_VM;
  542.                     mib[1] = VM_METER;
  543.                     sysctl(mib, 2, &memory_totals, &len, NULL, 0);
  544. #ifdef VM_UVMEXP
  545.                     mib[1] = VM_UVMEXP;
  546.     len = sizeof(uvmexp_totals);
  547.                     sysctl(mib, 2, &uvmexp_totals, &len, NULL, 0);
  548. #endif
  549.                 }
  550. #elif defined(hpux10) || defined(hpux11)
  551.                 pstat_getdynamic(&pst_buf, sizeof(struct pst_dynamic), 1, 0);
  552. #elif defined(TOTAL_MEMORY_SYMBOL)
  553.                 auto_nlist(TOTAL_MEMORY_SYMBOL, (char *) &memory_totals,
  554.                            sizeof(struct vmtotal));
  555. #endif
  556. #if HAVE_KVM_GETSWAPINFO
  557. if (kd == NULL)
  558.     kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
  559. if (!kd) {
  560.     snmp_log_perror("kvm_openfiles");
  561.     goto try_next;
  562. }
  563. if (kvm_getswapinfo(kd, &swapinfo, 1, 0) < 0) {
  564.     snmp_log_perror("kvm_getswapinfo");
  565.     goto try_next;
  566. }
  567. #endif
  568.                 break;
  569. #if !defined(hpux10) && !defined(hpux11)
  570.             case HRS_TYPE_MBUF:
  571. #if HAVE_SYS_POOL_H
  572.                 auto_nlist(MBPOOL_SYMBOL, (char *) &mbpool,
  573.                            sizeof(mbpool));
  574.                 auto_nlist(MCLPOOL_SYMBOL, (char *) &mclpool,
  575.                            sizeof(mclpool));
  576. #endif
  577. #ifdef MBSTAT_SYMBOL
  578.                 auto_nlist(MBSTAT_SYMBOL, (char *) &mbstat,
  579.                            sizeof(mbstat));
  580. #endif
  581.                 break;
  582. #endif      /* !hpux10 && !hpux11 */
  583.             default:
  584.                 break;
  585.             }
  586. #endif                          /* !linux && !solaris2 */
  587.     }
  591.     switch (vp->magic) {
  592.     case HRSTORE_MEMSIZE:
  593.         long_return = physmem * (pagesize / 1024);
  594.         return (u_char *) & long_return;
  596.     case HRSTORE_INDEX:
  597.         long_return = store_idx;
  598.         return (u_char *) & long_return;
  599.     case HRSTORE_TYPE:
  600.         if (store_idx > HRS_TYPE_FIXED_MAX)
  601.             if (storageUseNFS && Check_HR_FileSys_NFS())
  602.                 storage_type_id[storage_type_len - 1] = 10;     /* Network Disk */
  603.             else
  604.                 storage_type_id[storage_type_len - 1] = 4;      /* Assume fixed */
  605.         else
  606.             switch (store_idx) {
  607.             case HRS_TYPE_MEM:
  608.                 storage_type_id[storage_type_len - 1] = 2;      /* RAM */
  609.                 break;
  610.             case HRS_TYPE_SWAP:
  611.                 storage_type_id[storage_type_len - 1] = 3;      /* Virtual Mem */
  612.                 break;
  613.             case HRS_TYPE_MBUF:
  614.                 storage_type_id[storage_type_len - 1] = 1;      /* Other */
  615.                 break;
  616.             default:
  617.                 storage_type_id[storage_type_len - 1] = 1;      /* Other */
  618.                 break;
  619.             }
  620.         *var_len = sizeof(storage_type_id);
  621.         return (u_char *) storage_type_id;
  622.     case HRSTORE_DESCR:
  623.         if (store_idx > HRS_TYPE_FIXED_MAX) {
  624.             strncpy(string, HRFS_entry->HRFS_mount, sizeof(string)-1);
  625.             string[ sizeof(string)-1 ] = 0;
  626.             *var_len = strlen(string);
  627.             return (u_char *) string;
  628.         } else {
  629.             /* store_idx = store_idx - 1; */
  630.             *var_len = strlen(hrs_descr[store_idx]);
  631.             return (u_char *) hrs_descr[store_idx];
  632.         }
  633.     case HRSTORE_UNITS:
  634.         if (store_idx > HRS_TYPE_FIXED_MAX)
  635. #if HRFS_HAS_FRSIZE
  636.             long_return = stat_buf.f_frsize;
  637. #else
  638.             long_return = stat_buf.f_bsize;
  639. #endif
  640.         else
  641.             switch (store_idx) {
  642.             case HRS_TYPE_MEM:
  643.             case HRS_TYPE_SWAP:
  644. #if defined(USE_SYSCTL) || defined(solaris2)
  645.                 long_return = pagesize;
  646. #elif defined(NBPG)
  647.                 long_return = NBPG;
  648. #else
  649.                 long_return = 1024;     /* Report in Kb */
  650. #endif
  651.                 break;
  652.             case HRS_TYPE_MBUF:
  653. #ifdef MSIZE
  654.                 long_return = MSIZE;
  655. #elif defined(linux)
  656.                 long_return = 1024;
  657. #else
  658.                 long_return = 256;
  659. #endif
  660.                 break;
  661.             default:
  662. #if NO_DUMMY_VALUES
  663.                 goto try_next;
  664. #endif
  665.                 long_return = 1024;     /* As likely as any! */
  666.                 break;
  667.             }
  668.         return (u_char *) & long_return;
  669.     case HRSTORE_SIZE:
  670.         if (store_idx > HRS_TYPE_FIXED_MAX)
  671.             long_return = stat_buf.f_blocks;
  672.         else
  673.             switch (store_idx) {
  674. #if defined(linux)
  675.             case HRS_TYPE_MEM:
  676.             case HRS_TYPE_SWAP:
  677.                 long_return = linux_mem(store_idx, HRSTORE_SIZE);
  678.                 break;
  679. #elif defined(solaris2)
  680.             case HRS_TYPE_MEM:
  681.                 long_return = physmem;
  682.                 break;
  683.             case HRS_TYPE_SWAP:
  684.                 sol_get_swapinfo(&swap_total, &swap_used);
  685.                 long_return = swap_total;
  686.                 break;
  687. #elif defined(hpux10) || defined(hpux11)
  688.             case HRS_TYPE_MEM:
  689.                 long_return = pst_buf.psd_rm;
  690.                 break;
  691.             case HRS_TYPE_SWAP:
  692.                 long_return = pst_buf.psd_vm;
  693.                 break;
  694. #elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
  695.             case HRS_TYPE_MEM:
  696.                 long_return = memory_totals.t_rm;
  697.                 break;
  698.             case HRS_TYPE_SWAP:
  699. #if HAVE_KVM_GETSWAPINFO
  700. long_return = swapinfo.ksw_total;
  701. #elif defined(VM_UVMEXP)
  702.                 long_return = uvmexp_totals.swpages;
  703. #else
  704.                 long_return = memory_totals.t_vm;
  705. #endif
  706.                 break;
  707. #else               /* !linux && !solaris2 && !hpux10 && !hpux11 && ... */
  708.             case HRS_TYPE_MEM:
  709.                 long_return = physmem;
  710.                 break;
  711.             case HRS_TYPE_SWAP:
  712. #if NO_DUMMY_VALUES
  713.                 goto try_next;
  714. #endif
  715.                 long_return = 0;
  716.                 break;
  717. #endif              /* !linux && !solaris2 && !hpux10 && !hpux11 && ... */
  718.             case HRS_TYPE_MBUF:
  719. #ifdef linux
  720.                 long_return = linux_mem(store_idx, HRSTORE_SIZE);
  721. #elif HAVE_SYS_POOL_H
  722.                 long_return = 0;
  723.                 for (i = 0;
  724.                      i <
  725.                      sizeof(mbstat.m_mtypes) / sizeof(mbstat.m_mtypes[0]);
  726.                      i++)
  727.                     long_return += mbstat.m_mtypes[i];
  728. #elif defined(MBSTAT_SYMBOL) && defined(STRUCT_MBSTAT_HAS_M_MBUFS)
  729.                 long_return = mbstat.m_mbufs;
  730. #elif defined(NO_DUMMY_VALUES)
  731.                 goto try_next;
  732. #else
  733.                 long_return = 0;
  734. #endif
  735.                 break;
  736.             default:
  737. #if NO_DUMMY_VALUES
  738.                 goto try_next;
  739. #endif
  740.                 long_return = 1024;
  741.                 break;
  742.             }
  743.         return (u_char *) & long_return;
  744.     case HRSTORE_USED:
  745.         if (store_idx > HRS_TYPE_FIXED_MAX)
  746.             long_return = (stat_buf.f_blocks - stat_buf.f_bfree);
  747.         else
  748.             switch (store_idx) {
  749. #if defined(linux)
  750.             case HRS_TYPE_MBUF:
  751.             case HRS_TYPE_MEM:
  752.             case HRS_TYPE_SWAP:
  753.                 long_return = linux_mem(store_idx, HRSTORE_USED);
  754.                 break;
  755. #elif defined(solaris2)
  756.             case HRS_TYPE_MEM:
  757.                 getKstatInt("unix", "system_pages", "freemem", &freemem);
  758.                 long_return = physmem - freemem;
  759.                 break;
  760.             case HRS_TYPE_SWAP:
  761.                 sol_get_swapinfo(&swap_total, &swap_used);
  762.                 long_return = swap_used;
  763.                 break;
  764. #elif defined(hpux10) || defined(hpux11)
  765.             case HRS_TYPE_MEM:
  766.                 long_return = pst_buf.psd_arm;
  767.                 break;
  768.             case HRS_TYPE_SWAP:
  769.                 long_return = pst_buf.psd_avm;
  770.                 break;
  771. #elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
  772.             case HRS_TYPE_MEM:
  773.                 long_return = memory_totals.t_arm;
  774.                 break;
  775.             case HRS_TYPE_SWAP:
  776. #if HAVE_KVM_GETSWAPINFO
  777. long_return = swapinfo.ksw_used;
  778. #elif defined(VM_UVMEXP)
  779. long_return = uvmexp_totals.swpginuse;
  780. #else
  781.                 long_return = memory_totals.t_avm;
  782. #endif
  783.                 break;
  784. #endif              /* linux || solaris2 || hpux10 || hpux11 || ... */
  786. #if !defined(linux) && !defined(solaris2) && !defined(hpux10) && !defined(hpux11)
  787.             case HRS_TYPE_MBUF:
  788. #if HAVE_SYS_POOL_H
  789.                 long_return =
  790.     (mbpool.pr_nget - mbpool.pr_nput) * mbpool.pr_size +
  791.     (mclpool.pr_nget - mclpool.pr_nput) * mclpool.pr_size;
  792. #ifdef MSIZE
  793. long_return /= MSIZE;
  794. #else
  795. long_return /= 256;
  796. #endif
  797. #elif defined(MBSTAT_SYMBOL) && defined(STRUCT_MBSTAT_HAS_M_CLUSTERS)
  798.                 long_return = mbstat.m_clusters - mbstat.m_clfree;      /* unlikely, but... */
  799. #elif defined(NO_DUMMY_VALUES)
  800.                 goto try_next;
  801. #else
  802.                 long_return = 0;
  803. #endif
  804.                 break;
  805. #endif                      /* !linux && !solaris2 && !hpux10 && !hpux11 && ... */
  806.             default:
  807. #if NO_DUMMY_VALUES
  808.                 goto try_next;
  809. #endif
  810.                 long_return = 1024;
  811.                 break;
  812.             }
  813.         return (u_char *) & long_return;
  814.     case HRSTORE_FAILS:
  815.         if (store_idx > HRS_TYPE_FIXED_MAX)
  816. #if NO_DUMMY_VALUES
  817.     goto try_next;
  818. #else
  819.             long_return = 0;
  820. #endif
  821.         else
  822.             switch (store_idx) {
  823.             case HRS_TYPE_MEM:
  824.             case HRS_TYPE_SWAP:
  825. #if NO_DUMMY_VALUES
  826.                 goto try_next;
  827. #endif
  828.                 long_return = 0;
  829.                 break;
  830. #if !defined(linux) && !defined(solaris2) && !defined(hpux10) && !defined(hpux11)  && defined(MBSTAT_SYMBOL)
  831.             case HRS_TYPE_MBUF:
  832.                 long_return = mbstat.m_drops;
  833.                 break;
  834. #endif                          /* !linux && !solaris2 && !hpux10 && !hpux11 && MBSTAT_SYMBOL */
  835.             default:
  836. #if NO_DUMMY_VALUES
  837.                 goto try_next;
  838. #endif
  839.                 long_return = 0;
  840.                 break;
  841.             }
  842.         return (u_char *) & long_return;
  843.     default:
  844.         DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrstoren",
  845.                     vp->magic));
  846.     }
  847.     return NULL;
  849.   try_next:
  850.     if (!exact)
  851.         goto really_try_next;
  853.     return NULL;
  854. }
  857.         /*********************
  858.  *
  859.  *  Internal implementation functions
  860.  *
  861.  *********************/
  863. static int      FS_storage;
  864. static int      HRS_index;
  866. void
  867. Init_HR_Store(void)
  868. {
  869. #if !defined(solaris2) && !defined(hpux10) && !defined(hpux11)
  870.     HRS_index = 0;
  871. #else
  872.     HRS_index = HRS_TYPE_MBUF;
  873. #endif
  875.     Init_HR_FileSys();
  876.     FS_storage = 0;             /* Start with file-based storage */
  877. }
  879. int
  880. Get_Next_HR_Store(void)
  881. {
  882.     /*
  883.      * Fixed-style 'other' storage types
  884.      */
  885.     long_return = -1;
  886.     if (FS_storage == 0) {
  887.         ++HRS_index;
  888.         if (HRS_index <= HRS_TYPE_FIXED_MAX)
  889.             return HRS_index;
  890.         else {
  891.             FS_storage = 1;
  892.             HRS_index = 0;
  893.         }
  894.     }
  896.     /*
  897.      * File-based storage 
  898.      */
  899.     HRS_index = Get_Next_HR_FileSys();
  901.     if (HRS_index >= 0)
  902.         return HRS_index + HRS_TYPE_FIXED_MAX;
  904.     return -1;
  905. }
  907. #ifdef linux
  908. int
  909. linux_mem(int mem_type, int size_or_used)
  910. {
  911.     FILE           *fp;
  912.     char            buf[1024];
  913.     int             size = -1, free = -1, buffers = -1;
  915.     if ((fp = fopen("/proc/meminfo", "r")) == NULL)
  916.         return -1;
  918.     while (fgets(buf, sizeof(buf), fp) != NULL) {
  919.        if ((!strncmp(buf, "MemTotal:", 9) && (mem_type == HRS_TYPE_MEM || mem_type == HRS_TYPE_MBUF)) ||
  920.             (!strncmp(buf, "SwapTotal:", 10) && mem_type == HRS_TYPE_SWAP))
  921.             sscanf(buf, "%*s %d", &size);
  923.        if ((!strncmp(buf, "MemFree:", 8) && mem_type == HRS_TYPE_MEM) ||
  924.             (!strncmp(buf, "SwapFree:", 9) && mem_type == HRS_TYPE_SWAP))
  925.             sscanf(buf, "%*s %d", &free);
  927.        if ((!strncmp(buf, "Buffers:", 8) && mem_type == HRS_TYPE_MBUF))
  928. sscanf(buf, "%*s %d", &buffers);
  929.     }
  931.     fclose(fp);
  933.     switch (mem_type) {
  934.         case HRS_TYPE_MBUF:
  935.             return (size_or_used == HRSTORE_SIZE ? size : buffers);
  936.         default:
  937.             return (size_or_used == HRSTORE_SIZE ? size : (size - free));
  938.     } /* switch */
  940. }
  941. #endif
  943. #ifdef solaris2
  944. void
  945. sol_get_swapinfo(int *totalP, int *usedP)
  946. {
  947.     struct anoninfo ainfo;
  949.     if (swapctl(SC_AINFO, &ainfo) < 0) {
  950.         *totalP = *usedP = 0;
  951.         return;
  952.     }
  954.     *totalP = ainfo.ani_max;
  955.     *usedP = ainfo.ani_resv;
  956. }
  957. #endif                          /* solaris2 */