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

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

SNMP编程

开发平台：

Unix_Linux

memory.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  3. #if HAVE_STDLIB_H
  4. #include <stdlib.h>
  5. #endif
  6. #if HAVE_UNISTD_H
  7. #include <unistd.h>
  8. #endif
  9. #if HAVE_FCNTL_H
  10. #include <fcntl.h>
  11. #endif
  12. #include <ctype.h>
  13. #include <signal.h>
  14. #if HAVE_MACHINE_PARAM_H
  15. #include <machine/param.h>
  16. #endif
  17. #if HAVE_SYS_VMMETER_H
  18. #if !defined(bsdi2) && !defined(netbsd1)
  19. #include <sys/vmmeter.h>
  20. #endif
  21. #endif
  22. #if HAVE_SYS_CONF_H
  23. #include <sys/conf.h>
  24. #endif
  25. #if HAVE_ASM_PAGE_H
  26. #include <asm/page.h>
  27. #endif
  28. #if HAVE_SYS_SWAP_H
  29. #include <sys/swap.h>
  30. #endif
  31. #if HAVE_SYS_FS_H
  32. #include <sys/fs.h>
  33. #else
  34. #if HAVE_UFS_FS_H
  35. #include <ufs/fs.h>
  36. #else
  37. #ifdef HAVE_SYS_STAT_H
  38. #include <sys/stat.h>
  39. #endif
  40. #ifdef HAVE_SYS_VNODE_H
  41. #include <sys/vnode.h>
  42. #endif
  43. #ifdef HAVE_UFS_UFS_QUOTA_H
  44. #include <ufs/ufs/quota.h>
  45. #endif
  46. #ifdef HAVE_UFS_UFS_INODE_H
  47. #include <ufs/ufs/inode.h>
  48. #endif
  49. #ifdef HAVE_SYS_PARAM_H
  50. #include <sys/param.h>
  51. #endif
  52. #if HAVE_UFS_FFS_FS_H
  53. #include <ufs/ffs/fs.h>
  54. #endif
  55. #endif
  56. #endif
  57. #if HAVE_MTAB_H
  58. #include <mtab.h>
  59. #endif
  60. #include <sys/stat.h>
  61. #include <errno.h>
  62. #if HAVE_FSTAB_H
  63. #include <fstab.h>
  64. #endif
  65. #if HAVE_SYS_STATVFS_H
  66. #include <sys/statvfs.h>
  67. #endif
  68. #if HAVE_SYS_VFS_H
  69. #include <sys/vfs.h>
  70. #endif
  71. #if (!defined(HAVE_STATVFS)) && defined(HAVE_STATFS)
  72. #if HAVE_SYS_PARAM_H
  73. #include <sys/param.h>
  74. #endif
  75. #if HAVE_SYS_MOUNT_H
  76. #include <sys/mount.h>
  77. #endif
  78. #if HAVE_SYS_SYSCTL_H
  79. #include <sys/sysctl.h>
  80. #endif
  81. #define statvfs statfs
  82. #endif
  83. #if HAVE_VM_SWAP_PAGER_H
  84. #include <vm/swap_pager.h>
  85. #endif
  86. #if HAVE_SYS_FIXPOINT_H
  87. #include <sys/fixpoint.h>
  88. #endif
  89. #if HAVE_MALLOC_H
  90. #include <malloc.h>
  91. #endif
  92. #if HAVE_STRING_H
  93. #include <string.h>
  94. #endif
  95. #if TIME_WITH_SYS_TIME
  96. # include <sys/time.h>
  97. # include <time.h>
  98. #else
  99. # if HAVE_SYS_TIME_H
  100. #  include <sys/time.h>
  101. # else
  102. #  include <time.h>
  103. # endif
  104. #endif
  105. #if defined(hpux10) || defined(hpux11)
  106. #include <sys/pstat.h>
  107. #endif
  109. #include <net-snmp/net-snmp-includes.h>
  110. #include <net-snmp/agent/net-snmp-agent-includes.h>
  111. #include <net-snmp/agent/auto_nlist.h>
  113. #include "mibdefs.h"
  114. #include "struct.h"
  115. #include "util_funcs.h"
  116. #include "memory.h"
  118. int             minimumswap;
  119. #ifndef linux
  120. static int      pageshift;      /* log base 2 of the pagesize */
  121. #else
  122. static int      log_procerr = 1;
  123. void
  124. getmem(unsigned long *memtotal, unsigned long *memfree, unsigned long *memshared, 
  125.        unsigned long *buffers, unsigned long *cached, unsigned long *swaptotal, 
  126.        unsigned long *swapfree);
  127. #endif
  129. #ifndef bsdi2
  130. #ifdef NSWAPDEV_SYMBOL
  131. int nswapdev=10;            /* taken from <machine/space.h> */
  132. #endif
  133. #ifdef NSWAPFS_SYMBOL
  134. int nswapfs=10;            /* taken from <machine/space.h> */
  135. #endif
  136. #endif      /* !bsdi2 */
  138. #define DEFAULTMINIMUMSWAP 16000        /* kilobytes */
  140. static FindVarMethod var_extensible_mem;
  142. void
  143. init_memory(void)
  144. {
  145. #ifdef linux
  146.     unsigned long memtotal, memfree, memshared, buffers, cached, swaptotal,
  147.         swapfree;
  148.     /*
  149.      * call once, to log errors for missing vars, then turn off logging
  150.      * of those errors.
  151.      */
  152.     getmem(&memtotal, &memfree, &memshared, &buffers, &cached, &swaptotal,
  153.            &swapfree);
  154.     log_procerr = 0;
  155. #else
  156.     int             pagesize;
  157. #ifdef PHYSMEM_SYMBOL
  158.     auto_nlist(PHYSMEM_SYMBOL, 0, 0);
  159. #endif
  160. #ifdef TOTAL_MEMORY_SYMBOL
  161.     auto_nlist(TOTAL_MEMORY_SYMBOL, 0, 0);
  162. #endif
  163. #ifdef MBSTAT_SYMBOL
  164.     auto_nlist(MBSTAT_SYMBOL, 0, 0);
  165. #endif
  166. #ifdef SWDEVT_SYMBOL
  167.     auto_nlist(SWDEVT_SYMBOL, 0, 0);
  168. #endif
  169. #ifdef FSWDEVT_SYMBOL
  170.     auto_nlist(FSWDEVT_SYMBOL, 0, 0);
  171. #endif
  172. #ifdef NSWAPFS_SYMBOL
  173.     auto_nlist(NSWAPFS_SYMBOL, 0, 0);
  174. #endif
  175. #ifdef NSWAPDEV_SYMBOL
  176.     auto_nlist(NSWAPDEV_SYMBOL, 0, 0);
  177. #endif
  179. #ifndef bsdi2
  180. #ifdef NSWAPDEV_SYMBOL
  181.     if (auto_nlist(NSWAPDEV_SYMBOL, (char *) &nswapdev, sizeof(nswapdev))
  182.         == 0)
  183.         return;
  184. #endif
  185. #ifdef NSWAPFS_SYMBOL
  186.     if (auto_nlist(NSWAPFS_SYMBOL, (char *) &nswapfs, sizeof(nswapfs)) ==
  187.         0)
  188.         return;
  189. #endif
  190. #endif /* bsdi2 */
  191.     pagesize = 1 << PGSHIFT;
  192.     pageshift = 0;
  193.     while (pagesize > 1) {
  194.         pageshift++;
  195.         pagesize >>= 1;
  196.     }
  197.     pageshift -= 10;
  198. #endif /* linux */
  199.     {
  200.         struct variable2 extensible_mem_variables[] = {
  201.             {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  202.              {MIBINDEX}},
  203.             {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_mem, 1,
  204.              {ERRORNAME}},
  205.             {MEMTOTALSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  206.              {MEMTOTALSWAP}},
  207.             {MEMAVAILSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  208.              {MEMAVAILSWAP}},
  209.             {MEMTOTALREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  210.              {MEMTOTALREAL}},
  211.             {MEMAVAILREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  212.              {MEMAVAILREAL}},
  213.             {MEMTOTALSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  214.              {MEMTOTALSWAPTXT}},
  215.             {MEMUSEDSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  216.              {MEMUSEDSWAPTXT}},
  217.             {MEMTOTALREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  218.              {MEMTOTALREALTXT}},
  219.             {MEMUSEDREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  220.              {MEMUSEDREALTXT}},
  221.             {MEMTOTALFREE, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  222.              {MEMTOTALFREE}},
  223.             {MEMSWAPMINIMUM, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  224.              {MEMSWAPMINIMUM}},
  225.             {MEMSHARED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  226.              {MEMSHARED}},
  227.             {MEMBUFFER, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  228.              {MEMBUFFER}},
  229.             {MEMCACHED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  230.              {MEMCACHED}},
  231.             {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  232.              {ERRORFLAG}},
  233.             {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_mem, 1,
  234.              {ERRORMSG}}
  235.         };
  237.         /*
  238.          * Define the OID pointer to the top of the mib tree that we're
  239.          * registering underneath 
  240.          */
  241.         oid             mem_variables_oid[] = { UCDAVIS_MIB, MEMMIBNUM };
  243.         /*
  244.          * register ourselves with the agent to handle our mib tree 
  245.          */
  246.         REGISTER_MIB("ucd-snmp/memory", extensible_mem_variables,
  247.                      variable2, mem_variables_oid);
  249.         snmpd_register_config_handler("swap", memory_parse_config,
  250.                                       memory_free_config, "min-avail");
  251.     }
  252. }
  254. void
  255. memory_parse_config(const char *token, char *cptr)
  256. {
  257.     minimumswap = atoi(cptr);
  258. }
  260. void
  261. memory_free_config(void)
  262. {
  263.     minimumswap = DEFAULTMINIMUMSWAP;
  264. }
  266. #ifdef linux
  267. #define MEMINFO_FILE "/proc/meminfo"
  269. void
  270. getmem(unsigned long *memtotal, unsigned long *memfree, unsigned long *memshared, 
  271.        unsigned long *buffers, unsigned long *cached, unsigned long *swaptotal, 
  272.        unsigned long *swapfree)
  273. {
  274.     int         statfd;
  275.     static char *buff = NULL;
  276.     static int  bsize = 0;
  277.     int len;
  279.     if ((statfd = open(MEMINFO_FILE, O_RDONLY, 0)) != -1) {
  280.         char *b;
  281.         if (bsize == 0) {
  282.             bsize = 128;
  283.             buff = malloc(bsize);
  284.         }
  285.         while ((len = read(statfd, buff, bsize)) == bsize) {
  286.             bsize += 256;
  287.             buff = realloc(buff, bsize);
  288.             close(statfd);
  289.             statfd = open(MEMINFO_FILE, O_RDONLY, 0);
  290.         }
  291.         close(statfd);
  292. buff[len] = 0;
  293.         b = strstr(buff, "MemTotal: ");
  294.         if (b) 
  295.             sscanf(b, "MemTotal: %lu", memtotal);
  296.         else {
  297.             if(log_procerr)
  298.             snmp_log(LOG_ERR, "No MemTotal line in /proc/meminfon");
  299.             *memtotal = 0;
  300.         }
  301.         b = strstr(buff, "MemFree: ");
  302.         if (b) 
  303.             sscanf(b, "MemFree: %lu", memfree);
  304.         else {
  305.             if(log_procerr)
  306.             snmp_log(LOG_ERR, "No MemFree line in /proc/meminfon");
  307.             *memfree = 0;
  308.         }
  309.         b = strstr(buff, "MemShared: ");
  310.         if (b)
  311.             sscanf(b, "MemShared: %lu", memshared);
  312.         else {
  313.             if(log_procerr)
  314.             {
  315.             if (0 == netsnmp_os_prematch("Linux","2.4"))
  316.             snmp_log(LOG_ERR, "No MemShared line in /proc/meminfon");
  317.             }
  318.             *memshared = 0;
  319.         }
  320.         b = strstr(buff, "Buffers: ");
  321.         if (b)
  322.             sscanf(b, "Buffers: %lu", buffers);
  323.         else {
  324.             if(log_procerr)
  325.             snmp_log(LOG_ERR, "No Buffers line in /proc/meminfon");
  326.             *buffers = 0;
  327.         }
  328.         b = strstr(buff, "Cached: ");
  329.         if (b)
  330.             sscanf(b, "Cached: %lu", cached);
  331.         else {
  332.             if(log_procerr)
  333.             snmp_log(LOG_ERR, "No Cached line in /proc/meminfon");
  334.             *cached = 0;
  335.         }
  336.         b = strstr(buff, "SwapTotal: ");
  337.         if (b)
  338.             sscanf(b, "SwapTotal: %lu", swaptotal);
  339.         else {
  340.             if(log_procerr)
  341.             snmp_log(LOG_ERR, "No SwapTotal line in /proc/meminfon");
  342.             *swaptotal = 0;
  343.         }
  344.         b = strstr(buff, "SwapFree: ");
  345.         if (b)
  346.             sscanf(b, "SwapFree: %lu", swapfree);
  347.         else {
  348.             if(log_procerr)
  349.             snmp_log(LOG_ERR, "No SwapFree line in /proc/meminfon");
  350.             *swapfree = 0;
  351.         }
  352.     } else {
  353.         snmp_log_perror(MEMINFO_FILE);
  354.     }
  355. }
  357. enum memory_index { memtotal, memfree, memshared, buffers, cached, swaptotal, 
  358.     swapfree
  359. };
  361. unsigned
  362. memory(int iindex)
  363. {
  364.     unsigned long   mem_total[2], mem_free[2], mem_shared[2], mem_buffers[2], 
  365.                     mem_cached[2],  swap_total[2], swap_free[2];
  367.     getmem(mem_total, mem_free, mem_shared, mem_buffers, mem_cached, swap_total,
  368.            swap_free);
  369.     switch (iindex) {
  370.         case memtotal:
  371.             return *(mem_total);
  372.         case memfree:
  373.             return *(mem_free);
  374.         case memshared:
  375.             return *(mem_shared);
  376.         case buffers:
  377.             return *(mem_buffers);
  378.         case cached:
  379.             return *(mem_cached);
  380.         case swaptotal:
  381.             return *(swap_total);
  382.         case swapfree:
  383.             return *(swap_free);
  384.         default:
  385.             return -1;
  386.     }
  387. }
  389. #else
  390. #define pagetok(size) ((size) << pageshift)
  391. #endif
  393. #define SWAPGETLEFT 0
  394. #define SWAPGETTOTAL 1
  396. static long
  397. getswap(int rettype)
  398. {
  399.     long            spaceleft = 0, spacetotal = 0;
  401. #if defined(linux)
  402.     spaceleft = memory(swapfree);
  403.     spacetotal = memory(swaptotal);
  404. #elif defined(bsdi2)
  405.     struct swapstats swapst;
  406.     size_t          size = sizeof(swapst);
  407.     static int      mib[] = { CTL_VM, VM_SWAPSTATS };
  408.     if (sysctl(mib, 2, &swapst, &size, NULL, 0) < 0)
  409.         return (0);
  410.     spaceleft = swapst.swap_free / 2;
  411.     spacetotal = swapst.swap_total / 2;
  412. #elif defined (hpux10) || defined(hpux11)
  413.     struct pst_swapinfo pst_buf;
  414.     int ndx = 0;
  415.     long pgs, pgs_free;
  416.   
  417.     while (pstat_getswap(&pst_buf, sizeof(struct pst_swapinfo), 1, ndx) > 0) {
  418.         if (pst_buf.pss_flags & SW_BLOCK) {
  419.             pgs = pst_buf.pss_nblksenabled;
  420.             pgs_free = pst_buf.pss_nblksavail;
  421.         }
  422.         else if (pst_buf.pss_flags & SW_FS) {
  423.             pgs = pst_buf.pss_limit;
  424.             pgs_free = pgs - pst_buf.pss_allocated - pst_buf.pss_reserve;
  425.             /*
  426.              * the following calculation is done this way to avoid integer overflow!
  427.              * pss_swapchunk is either 512 or a multiple of 1024!
  428.              */
  429.             if (pst_buf.pss_swapchunk == 512) {
  430.                 pgs_free /= 2;
  431.                 pgs /= 2;
  432.             } else {
  433.                 pgs_free *= (pst_buf.pss_swapchunk / 1024);
  434.                 pgs *= (pst_buf.pss_swapchunk / 1024);
  435.             }
  436.         }
  437.         else {
  438.             pgs = pgs_free = 0;
  439.         }
  440.         spaceleft += pgs_free;
  441.         spacetotal += pgs;
  442.         ndx = pst_buf.pss_idx + 1;
  443.     }
  444. #else /* !linux && !bsdi2 && !hpux10 && !hpux11 */
  445.     struct swdevt   swdevt[100];
  446.     struct fswdevt  fswdevt[100];
  447.     FILE           *file;
  448.     struct extensible ex;
  449.     int             i, fd;
  450.     char           *cp;
  452.     if (auto_nlist
  453.         (SWDEVT_SYMBOL, (char *) swdevt, sizeof(struct swdevt) * nswapdev)
  454.         == 0)
  455.         return (0);
  456.     DEBUGMSGTL(("ucd-snmp/memory", "%d block swap devices: n", nswapdev));
  457.     for (i = 0; i < nswapdev; i++) {
  458.         DEBUGMSGTL(("ucd-snmp/memory", "swdevt[%d]: %dn", i,
  459.                     swdevt[i].sw_enable));
  460.         if (swdevt[i].sw_enable)
  461.         {
  462. #ifdef STRUCT_SWDEVT_HAS_SW_NBLKSENABLED
  463.             DEBUGMSGTL(("ucd-snmp/memory",
  464.                         "  swdevt.sw_nblksenabled:     %dn",
  465.                         swdevt[i].sw_nblksenabled));
  466.             spacetotal += swdevt[i].sw_nblksenabled;
  467. #else
  468.             DEBUGMSGTL(("ucd-snmp/memory", "  swdevt.sw_nblks:     %dn",
  469.                         swdevt[i].sw_nblks));
  470.             spacetotal += swdevt[i].sw_nblks;
  471. #endif
  472.             DEBUGMSGTL(("ucd-snmp/memory", "  swdevt.sw_nfpgs:     %dn",
  473.                         swdevt[i].sw_nfpgs));
  474.             spaceleft += (swdevt[i].sw_nfpgs * 4);
  475.         }
  476.     }
  477.     if (auto_nlist
  478.         (FSWDEVT_SYMBOL, (char *) fswdevt,
  479.          sizeof(struct fswdevt) * nswapfs)
  480.         == 0)
  481.         return (0);
  482.     DEBUGMSGTL(("ucd-snmp/memory", "%d fs swap devices: n", nswapfs));
  483.     for (i = 0; i < nswapfs; i++) {
  484.         DEBUGMSGTL(("ucd-snmp/memory", "fswdevt[%d]: %dn", i,
  485.                     fswdevt[i].fsw_enable));
  486.         if (fswdevt[i].fsw_enable)
  487.         {
  488.             spacetotal += (fswdevt[i].fsw_limit * 2048);        /* 2048=bytes per page? */
  489.             spaceleft += (fswdevt[i].fsw_limit * 2048 -
  490.                           ((fswdevt[i].fsw_allocated -
  491.                             fswdevt[i].fsw_min) * 37));
  492.             DEBUGMSGTL(("ucd-snmp/memory",
  493.                         "  fswdevt[i].fsw_limit:     %dn",
  494.                         fswdevt[i].fsw_limit));
  495.             DEBUGMSGTL(("ucd-snmp/memory",
  496.                         "  fswdevt[i].fsw_allocated: %dn",
  497.                         fswdevt[i].fsw_allocated));
  498.             DEBUGMSGTL(("ucd-snmp/memory",
  499.                         "  fswdevt[i].fsw_min:       %dn",
  500.                         fswdevt[i].fsw_min));
  501.             DEBUGMSGTL(("ucd-snmp/memory",
  502.                         "  fswdevt[i].fsw_reserve:   %dn",
  503.                         fswdevt[i].fsw_reserve));
  504.             /*
  505.              * 37 = calculated value I know it makes no sense, nor is it accurate 
  506.              */
  507.         }
  508.     }
  509.     /*
  510.      * this is a real hack.  I need to get the hold info from swapinfo, but
  511.      * I can't figure out how to read it out of the kernel directly
  512.      * -- Wes 
  513.      */
  514.     strcpy(ex.command, "/etc/swapinfo -h");
  515.     if ((fd = get_exec_output(&ex)) != -1) {
  516.         file = fdopen(fd, "r");
  517.         for (i = 1;
  518.              i <= 2 && fgets(ex.output, sizeof(ex.output), file) != NULL;
  519.              i++);
  520.         if (fgets(ex.output, sizeof(ex.output), file) != NULL) {
  521.             cp = skip_white(ex.output); /* not there should be any */
  522.             cp = skip_not_white(cp);    /* skip over "reserve" */
  523.             cp = skip_white(cp);
  524.             cp = skip_not_white(cp);    /* avail swap, a '-' in most cases */
  525.             cp = skip_white(cp);
  526.             spaceleft -= atoi(cp);      /* reserved swap */
  527.         }
  528.         fclose(file);
  529.         wait_on_exec(&ex);
  530.     } else {
  531.         return (0);
  532.     }
  533. #endif                          /* !linux && !bsdi2 && !hpux10 && !hpux11 */
  535.     switch (rettype) {
  536.     case SWAPGETLEFT:
  537.         return (spaceleft);
  538.     case SWAPGETTOTAL:
  539.         return (spacetotal);
  540.     }
  541.     return 0;
  542. }
  544. static
  545. unsigned char  *
  546. var_extensible_mem(struct variable *vp,
  547.                    oid * name,
  548.                    size_t * length,
  549.                    int exact,
  550.                    size_t * var_len, WriteMethod ** write_method)
  551. {
  553.     static long     long_ret;
  554.     static char     errmsg[1024];
  555. #if !defined(linux)
  556. #if defined(hpux10) || defined(hpux11)
  557.     struct pst_dynamic pst_buf;
  558. #elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
  559.     struct vmtotal total;
  560. #endif
  561. #endif
  563.     long_ret = 0;               /* set to 0 as default */
  565.     if (header_generic(vp, name, length, exact, var_len, write_method))
  566.         return (NULL);
  568. #if !defined(linux)
  569. #if defined(hpux10) || defined(hpux11)
  570.     if (pstat_getdynamic(&pst_buf, sizeof(struct pst_dynamic), 1, 0) < 0)
  571.         return NULL;
  572. #elif defined(USE_SYSCTL_VM)
  573.     /*
  574.      * sum memory statistics 
  575.      */
  576.     {
  577.         size_t          size = sizeof(total);
  578.         static int      mib[] = { CTL_VM, VM_TOTAL };
  579.         if (sysctl(mib, 2, &total, &size, NULL, 0) < 0)
  580.             return NULL;
  581.     }
  582. #elif defined(TOTAL_MEMORY_SYMBOL)
  583.     if (auto_nlist(TOTAL_MEMORY_SYMBOL, (char *) &total, sizeof(total)) ==
  584.         0)
  585.         return NULL;
  586. #endif
  587. #endif                          /* !linux */
  589.     switch (vp->magic) {
  590.     case MIBINDEX:
  591.         long_ret = 0;
  592.         return ((u_char *) (&long_ret));
  593.     case ERRORNAME:            /* dummy name */
  594.         sprintf(errmsg, "swap");
  595.         *var_len = strlen(errmsg);
  596.         return ((u_char *) (errmsg));
  597.     case MEMTOTALSWAP:
  598.         long_ret = getswap(SWAPGETTOTAL);
  599.         return ((u_char *) (&long_ret));
  600.     case MEMAVAILSWAP:
  601.         long_ret = getswap(SWAPGETLEFT);
  602.         return ((u_char *) (&long_ret));
  603.     case MEMSWAPMINIMUM:
  604.         long_ret = minimumswap;
  605.         return ((u_char *) (&long_ret));
  606.     case MEMTOTALREAL:
  607. #if defined(USE_SYSCTL)
  608.         {
  609.             size_t          size = sizeof(long_ret);
  610.             static int      mib[] = { CTL_HW, HW_PHYSMEM };
  611.             if (sysctl(mib, 2, &long_ret, &size, NULL, 0) < 0)
  612.                 return NULL;
  613.             long_ret = long_ret / 1024;
  614.         }
  615. #elif defined(hpux10) || defined(hpux11)
  616.         {
  617.             struct pst_static pst_buf;
  618.             if (pstat_getstatic(&pst_buf, sizeof(struct pst_static), 1, 0)
  619.                 < 0)
  620.                 return NULL;
  621.             long_ret =
  622.                 pst_buf.physical_memory * (pst_buf.page_size / 1024);
  623.         }
  624. #elif defined(linux)
  625.         long_ret = memory(memtotal);
  626. #elif defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
  627.         long_ret =
  628.             sysconf(_SC_PHYS_PAGES) * (sysconf(_SC_PAGESIZE) / 1024);
  629. #elif defined(PHYSMEM_SYMBOL)
  630.         {
  631.             int             result;
  632.             if (auto_nlist
  633.                 (PHYSMEM_SYMBOL, (char *) &result, sizeof(result)) == 0)
  634.                 return NULL;
  635.             long_ret = result * 1000;   /* ??? */
  636.         }
  637. #else
  638.         return NULL;            /* no dummy values */
  639. #endif
  640.         return ((u_char *) (&long_ret));
  641.     case MEMAVAILREAL:
  642. #ifdef linux
  643.         long_ret = memory(memfree);
  644. #elif defined(hpux10) || defined(hpux11)
  645.         long_ret = pagetok((int) pst_buf.psd_arm);
  646. #elif defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
  647.         long_ret = pagetok((int) total.t_arm);
  648. #else
  649.         return NULL;            /* no dummy values */
  650. #endif
  651.         return ((u_char *) (&long_ret));
  652. #ifndef linux
  653.     case MEMTOTALSWAPTXT:
  654. #if defined(hpux10) || defined(hpux11)
  655.         long_ret = pagetok((int) pst_buf.psd_vmtxt);
  656. #elif !defined(bsdi2)
  657.         long_ret = pagetok(total.t_vmtxt);
  658. #else
  659.         return NULL;            /* no dummy values */
  660. #endif
  661.         return ((u_char *) (&long_ret));
  662.     case MEMUSEDSWAPTXT:
  663. #if defined(hpux10) || defined(hpux11)
  664.         long_ret = pagetok((int) pst_buf.psd_avmtxt);
  665. #elif !defined(bsdi2)
  666.         long_ret = pagetok(total.t_avmtxt);
  667. #else
  668.         return NULL;            /* no dummy values */
  669. #endif
  670.         return ((u_char *) (&long_ret));
  671.     case MEMTOTALREALTXT:
  672. #if defined(hpux10) || defined(hpux11)
  673.         long_ret = pagetok((int) pst_buf.psd_rmtxt);
  674. #elif !defined(bsdi2)
  675.         long_ret = pagetok(total.t_rmtxt);
  676. #else
  677.         return NULL;            /* no dummy values */
  678. #endif
  679.         return ((u_char *) (&long_ret));
  680.     case MEMUSEDREALTXT:
  681. #if defined(hpux10) || defined(hpux11)
  682.         long_ret = pagetok((int) pst_buf.psd_armtxt);
  683. #elif !defined(bsdi2)
  684.         long_ret = pagetok(total.t_armtxt);
  685. #else
  686.         return NULL;            /* no dummy values */
  687. #endif
  688.         return ((u_char *) (&long_ret));
  689. #endif                          /* linux */
  690.     case MEMTOTALFREE:
  691. #ifdef linux
  692.         long_ret = memory(memfree) + memory(swapfree);
  693. #elif defined(hpux10) || defined(hpux11)
  694.         long_ret = pagetok((int) pst_buf.psd_free);
  695. #else
  696.         long_ret = pagetok(total.t_free);
  697. #endif
  698.         return ((u_char *) (&long_ret));
  699.     case MEMCACHED:
  700. #ifdef linux
  701.         long_ret = memory(cached);
  702. #else
  703.         return NULL;            /* no dummy values */
  704. #endif
  705.         return ((u_char *) (&long_ret));
  706.     case MEMBUFFER:
  707. #ifdef linux
  708.         long_ret = memory(buffers);
  709. #else
  710.         return NULL;            /* no dummy values */
  711. #endif
  712.         return ((u_char *) (&long_ret));
  713.     case MEMSHARED:
  714. #ifdef linux
  715.         long_ret = memory(memshared);
  716. #else
  717.         return NULL;            /* no dummy values */
  718. #endif
  719.         return ((u_char *) (&long_ret));
  720.     case ERRORFLAG:
  721.         long_ret = getswap(SWAPGETLEFT);
  722.         long_ret = (long_ret > minimumswap) ? 0 : 1;
  723.         return ((u_char *) (&long_ret));
  724.     case ERRORMSG:
  725.         long_ret = getswap(SWAPGETLEFT);
  726.         if ((long_ret > minimumswap) ? 0 : 1)
  727.             sprintf(errmsg, "Running out of swap space (%ld)",
  728.                     getswap(SWAPGETLEFT));
  729.         else
  730.             errmsg[0] = 0;
  731.         *var_len = strlen(errmsg);
  732.         return ((u_char *) (errmsg));
  733.     }
  734.     return NULL;
  735. }