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

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

SNMP编程

开发平台：

Unix_Linux

disk.c：源码内容
  1. /*
  2.  * disk.c
  3.  */
  5. #include <net-snmp/net-snmp-config.h>
  7. #include <stdio.h>
  9. #if HAVE_STDLIB_H
  10. #include <stdlib.h>
  11. #endif
  12. #if HAVE_UNISTD_H
  13. #include <unistd.h>
  14. #endif
  15. #if HAVE_FCNTL_H
  16. #include <fcntl.h>
  17. #endif
  18. #include <signal.h>
  19. #if HAVE_MACHINE_PARAM_H
  20. #include <machine/param.h>
  21. #endif
  22. #if HAVE_SYS_VMMETER_H
  23. #if !(defined(bsdi2) || defined(netbsd1))
  24. #include <sys/vmmeter.h>
  25. #endif
  26. #endif
  27. #if HAVE_SYS_PARAM_H
  28. #include <sys/param.h>
  29. #endif
  30. #if HAVE_SYS_CONF_H
  31. #include <sys/conf.h>
  32. #endif
  33. #if HAVE_ASM_PAGE_H
  34. #include <asm/page.h>
  35. #endif
  36. #if HAVE_SYS_SWAP_H
  37. #include <sys/swap.h>
  38. #endif
  39. #if HAVE_SYS_FS_H
  40. #include <sys/fs.h>
  41. #else
  42. #if HAVE_UFS_FS_H
  43. #include <ufs/fs.h>
  44. #else
  45. #ifdef HAVE_SYS_STAT_H
  46. #include <sys/stat.h>
  47. #endif
  48. #ifdef HAVE_SYS_VNODE_H
  49. #include <sys/vnode.h>
  50. #endif
  51. #ifdef HAVE_UFS_UFS_QUOTA_H
  52. #include <ufs/ufs/quota.h>
  53. #endif
  54. #ifdef HAVE_UFS_UFS_INODE_H
  55. #include <ufs/ufs/inode.h>
  56. #endif
  57. #if HAVE_UFS_FFS_FS_H
  58. #include <ufs/ffs/fs.h>
  59. #endif
  60. #endif
  61. #endif
  62. #if HAVE_MTAB_H
  63. #include <mtab.h>
  64. #endif
  65. #include <sys/stat.h>
  66. #include <errno.h>
  67. #if HAVE_SYS_STATFS_H
  68. #include <sys/statfs.h>
  69. #endif
  70. #if HAVE_SYS_STATVFS_H
  71. #include <sys/statvfs.h>
  72. #endif
  73. #if HAVE_SYS_VFS_H
  74. #include <sys/vfs.h>
  75. #endif
  76. #if defined(HAVE_STATFS)
  77. #if HAVE_SYS_MOUNT_H
  78. #include <sys/mount.h>
  79. #endif
  80. #if HAVE_SYS_SYSCTL_H
  81. #include <sys/sysctl.h>
  82. #endif
  83. #if !defined(HAVE_STATVFS)
  84. #define statvfs statfs
  85. #endif
  86. #endif
  87. #if HAVE_VM_VM_H
  88. #include <vm/vm.h>
  89. #endif
  90. #if HAVE_VM_SWAP_PAGER_H
  91. #include <vm/swap_pager.h>
  92. #endif
  93. #if HAVE_SYS_FIXPOINT_H
  94. #include <sys/fixpoint.h>
  95. #endif
  96. #if HAVE_MALLOC_H
  97. #include <malloc.h>
  98. #endif
  99. #if HAVE_STRING_H
  100. #include <string.h>
  101. #endif
  102. #if HAVE_FSTAB_H
  103. #include <fstab.h>
  104. #endif
  105. #if HAVE_MNTENT_H
  106. #include <mntent.h>
  107. #endif
  108. #if HAVE_SYS_MNTTAB_H
  109. #include <sys/mnttab.h>
  110. #endif
  111. #if HAVE_NETINET_IN_H
  112. #include <netinet/in.h>
  113. #endif
  114. #if TIME_WITH_SYS_TIME
  115. # ifdef WIN32
  116. #  include <sys/timeb.h>
  117. # else
  118. #  include <sys/time.h>
  119. # endif
  120. # include <time.h>
  121. #else
  122. # if HAVE_SYS_TIME_H
  123. #  include <sys/time.h>
  124. # else
  125. #  include <time.h>
  126. # endif
  127. #endif
  128. #if HAVE_WINSOCK_H
  129. #include <winsock.h>
  130. #endif
  132. #if HAVE_DMALLOC_H
  133. #include <dmalloc.h>
  134. #endif
  136. #include <net-snmp/net-snmp-includes.h>
  137. #include <net-snmp/agent/net-snmp-agent-includes.h>
  138. #include <net-snmp/agent/auto_nlist.h>
  140. #include "struct.h"
  141. #include "disk.h"
  142. #include "util_funcs.h"
  143. #if USING_UCD_SNMP_ERRORMIB_MODULE
  144. #include "errormib.h"
  145. #else
  146. #define setPerrorstatus(x) snmp_log_perror(x)
  147. #endif
  149. /*
  150.  *  * config file parsing routines
  151.  *   */
  152. static void       disk_free_config(void);
  153. static void       disk_parse_config(const char *, char *);
  154. static void       disk_parse_config_all(const char *, char *);
  155. static void       find_and_add_allDisks(int minpercent);
  156. static void       add_device(char *path, char *device,
  157.                      int minspace, int minpercent, int override);
  158. static void       modify_disk_parameters(int index, int minspace,
  159.                                  int minpercent);
  160. static int        disk_exists(char *path);
  161. static u_char    *find_device(char *path);
  163. struct diskpart {
  164.     char            device[STRMAX];
  165.     char            path[STRMAX];
  166.     int             minimumspace;
  167.     int             minpercent;
  168. };
  170. int             numdisks;
  171. int             allDisksIncluded = 0;
  172. struct diskpart disks[MAXDISKS];
  174. struct variable2 extensible_disk_variables[] = {
  175.   {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_disk, 1, {MIBINDEX}},
  176.   {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_disk, 1, {ERRORNAME}},
  177.   {DISKDEVICE, ASN_OCTET_STR, RONLY, var_extensible_disk, 1,
  178.    {DISKDEVICE}},
  179.   {DISKMINIMUM, ASN_INTEGER, RONLY, var_extensible_disk, 1,
  180.    {DISKMINIMUM}},
  181.   {DISKMINPERCENT, ASN_INTEGER, RONLY, var_extensible_disk, 1,
  182.    {DISKMINPERCENT}},
  183.   {DISKTOTAL, ASN_INTEGER, RONLY, var_extensible_disk, 1, {DISKTOTAL}},
  184.   {DISKAVAIL, ASN_INTEGER, RONLY, var_extensible_disk, 1, {DISKAVAIL}},
  185.   {DISKUSED, ASN_INTEGER, RONLY, var_extensible_disk, 1, {DISKUSED}},
  186.   {DISKPERCENT, ASN_INTEGER, RONLY, var_extensible_disk, 1,
  187.    {DISKPERCENT}},
  188.   {DISKPERCENTNODE, ASN_INTEGER, RONLY, var_extensible_disk, 1,
  189.    {DISKPERCENTNODE}},
  190.   {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_disk, 1, {ERRORFLAG}},
  191.   {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_disk, 1, {ERRORMSG}}
  192. };
  194. /*
  195.  * Define the OID pointer to the top of the mib tree that we're
  196.  * registering underneath 
  197.  */
  198. oid             disk_variables_oid[] = { UCDAVIS_MIB, DISKMIBNUM, 1 };
  200. void
  201. init_disk(void)
  202. {
  203.   /*
  204.    * register ourselves with the agent to handle our mib tree 
  205.    */
  206.   REGISTER_MIB("ucd-snmp/disk", extensible_disk_variables, variable2,
  207.        disk_variables_oid);
  209.   snmpd_register_config_handler("disk", disk_parse_config,
  210. disk_free_config,
  211. "path [ minspace | minpercent% ]");
  212.   snmpd_register_config_handler("includeAllDisks", disk_parse_config_all,
  213. disk_free_config,
  214. "minpercent%");
  215.   allDisksIncluded = 0;
  216. }
  218. static void
  219. disk_free_config(void)
  220. {
  221.   int             i;
  223.   numdisks = 0;
  224.   for (i = 0; i < MAXDISKS; i++) {    /* init/erase disk db */
  225.     disks[i].device[0] = 0;
  226.     disks[i].path[0] = 0;
  227.     disks[i].minimumspace = -1;
  228.     disks[i].minpercent = -1;
  229.   }
  230. }
  232. static void 
  233. disk_parse_config(const char *token, char *cptr)
  234. {
  235. #if HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS
  236.   char            tmpbuf[1024];
  237.   char            path[STRMAX];
  238.   int             minpercent;
  239.   int             minspace;
  241.   if (numdisks == MAXDISKS) {
  242.     config_perror("Too many disks specified.");
  243.     snprintf(tmpbuf, sizeof(tmpbuf), "tignoring:  %s", cptr);
  244.     tmpbuf[ sizeof(tmpbuf)-1 ] = 0;
  245.     config_perror(tmpbuf);
  246.   } else {
  247.     /*
  248.      * read disk path (eg, /1 or /usr) 
  249.      */
  250.     copy_nword(cptr, path, sizeof(path));
  251.     cptr = skip_not_white(cptr);
  252.     cptr = skip_white(cptr);
  254.     /*
  255.      * read optional minimum disk usage spec 
  256.      */
  257.     if(cptr != NULL) {
  258.       if(strchr(cptr, '%') == 0) {
  259. minspace = atoi(cptr);
  260. minpercent = -1;
  261.       }
  262.       else {
  263. minspace = -1;
  264. minpercent = atoi(cptr);
  265.       }
  266.     } else {
  267.       minspace = DEFDISKMINIMUMSPACE;
  268.       minpercent = -1;
  269.     }
  271.     /*
  272.      * check if the disk already exists, if so then modify its
  273.      * parameters. if it does not exist then add it
  274.      */
  275.     add_device(path, find_device(path), minspace, minpercent, 1);
  276.   }
  277. #endif /* HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS */
  278. }
  280. static void 
  281. disk_parse_config_all(const char *token, char *cptr)
  282. {
  283. #if HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS
  284.   char            tmpbuf[1024];
  285.   int             minpercent = DISKMINPERCENT;
  286.     
  287.   if (numdisks == MAXDISKS) {
  288.     config_perror("Too many disks specified.");
  289.     sprintf(tmpbuf, "tignoring:  %s", cptr);
  290.     config_perror(tmpbuf);
  291.   } else {
  292.     /*
  293.      * read the minimum disk usage percent
  294.      */
  295.     if(cptr != NULL) {
  296.       if(strchr(cptr, '%') != 0) {
  297. minpercent = atoi(cptr);
  298.       }
  299.     }
  300.     /*
  301.      * if we have already seen the "includeAllDisks" directive
  302.      * then search for the disk in the "disks" array and modify
  303.      * the values. if we havent seen the "includeAllDisks"
  304.      * directive then include this disk
  305.      */
  306.     if(allDisksIncluded) {
  307.       config_perror("includeAllDisks already specified.");
  308.       sprintf(tmpbuf, "tignoring: includeAllDisks %s", cptr);
  309.       config_perror(tmpbuf);
  310.     }
  311.     else {
  312.       allDisksIncluded = 1;
  313.       find_and_add_allDisks(minpercent);
  314.     }
  315.   }
  316. #endif /* HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS */
  317. }
  320. static void
  321. add_device(char *path, char *device, int minspace, int minpercent, int override) 
  322. {
  323.   int index;
  324.   if (numdisks == MAXDISKS) {
  325.     char tmpbuf[1024];
  326.     config_perror("Too many disks specified.");
  327.     snprintf(tmpbuf, sizeof(tmpbuf), "tignoring:  %s", device);
  328.     tmpbuf[ sizeof(tmpbuf)-1 ] = 0;
  329.     config_perror(tmpbuf);
  330.     return;
  331.   }
  333.   index = disk_exists(path);
  334.   if((index != -1) && (index < MAXDISKS) && (override==1)) {
  335.     modify_disk_parameters(index, minspace, minpercent);
  336.   }
  337.   else if(index == -1){
  338.     /* add if and only if the device was found */
  339.     if(device[0] != 0) {
  340.       copy_nword(path, disks[numdisks].path, 
  341.  sizeof(disks[numdisks].path));
  342.       copy_nword(device, disks[numdisks].device, 
  343.  sizeof(disks[numdisks].device));
  344.       disks[numdisks].minimumspace = minspace;
  345.       disks[numdisks].minpercent   = minpercent;
  346.       numdisks++;  
  347.     }
  348.     else {
  349.       disks[numdisks].minimumspace = -1;
  350.       disks[numdisks].minpercent = -1;
  351.       disks[numdisks].path[0] = 0;
  352.       disks[numdisks].device[0] = 0;
  353.     }
  354.   }
  355. }
  357. void
  358. modify_disk_parameters(int index, int minspace, int minpercent)
  359. {
  360.   disks[index].minimumspace = minspace;
  361.   disks[index].minpercent   = minpercent;
  362. }
  364. int disk_exists(char *path) 
  365. {
  366.   int index;
  367.   for(index = 0; index < numdisks; index++) {
  368.     DEBUGMSGTL(("ucd-snmp/disk:", "Checking for %s. Found %s at %d ", path, disks[index].path, index));
  369.     if(strcmp(path, disks[index].path) == 0) {
  370.       return index;
  371.     }
  372.   }
  373.   return -1;
  374. }
  376. static void 
  377. find_and_add_allDisks(int minpercent)
  378. {
  379. #if HAVE_GETMNTENT
  380. #if HAVE_SYS_MNTTAB_H
  381.   struct mnttab   mnttab;
  382. #else
  383.   struct mntent  *mntent;
  384. #endif
  385.   FILE           *mntfp;
  386. #elif HAVE_FSTAB_H
  387.   struct fstab   *fstab1;
  388. #elif HAVE_STATFS
  389.   struct statfs   statf;
  390. #endif
  391. #if defined(HAVE_GETMNTENT) && !defined(HAVE_SETMNTENT)
  392.   int             i;
  393. #endif
  395.   int dummy = 0;
  396.   char            tmpbuf[1024];
  397.   /* 
  398.    * find the device for the path and copy the device into the
  399.    * string declared above and at the end of the routine return it
  400.    * to the caller 
  401.    */
  402. #if HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS   
  403. #if HAVE_GETMNTENT
  404. #if HAVE_SETMNTENT
  405.   mntfp = setmntent(ETC_MNTTAB, "r");
  406.   while (NULL != (mntent = getmntent(mntfp))) {
  407.     add_device(mntent->mnt_dir, mntent->mnt_fsname, -1, minpercent, 0);
  408.     dummy = 1;
  409.   }
  410.   if (mntfp)
  411.     endmntent(mntfp);
  412.   if(dummy != 0) {
  413.     /*
  414.      * dummy clause for else below
  415.      */
  416.   }
  417. #else                           /* getmentent but not setmntent */
  418.   mntfp = fopen(ETC_MNTTAB, "r");
  419.   while ((i = getmntent(mntfp, &mnttab)) == 0) {
  420.     add_device(mnttab.mnt_mountp, mnttab.mnt_special, -1, minpercent, 0);
  421.     dummy = 1;
  422.   }
  423.   fclose(mntfp);
  424.   if(dummy != 0) {
  425.     /*
  426.      * dummy clause for else below
  427.      */
  428.   }
  429. #endif /* HAVE_SETMNTENT */
  430. #elif HAVE_FSTAB_H
  431.   setfsent(); /* open /etc/fstab */
  432.   while((fstab1 = getfsent()) != NULL) {
  433.     add_device(fstab1->fs_file, fstab1->fs_spec, -1, minpercent, 0);
  434.     dummy = 1;
  435.   }
  436.   endfsent(); /* close /etc/fstab */
  437.   if(dummy != 0) {
  438.     /*
  439.      * dummy clause for else below
  440.      */
  441.   }
  442. #elif HAVE_STATFS
  443.   /*
  444.    * since there is no way to get all the mounted systems with just
  445.    * statfs we default to the root partition "/"
  446.    */
  447.   if (statfs("/", &statf) == 0) {
  448.     add_device("/", statf.f_mntfromname, -1, minpercent, 0);
  449.   }
  450. #endif
  451.   else {
  452.     if (numdisks == MAXDISKS) {
  453.       return;
  454.     }
  455.     snprintf(tmpbuf, sizeof(tmpbuf),
  456.              "Couldn't find device for disk %s",
  457.              disks[numdisks].path);
  458.     tmpbuf[ sizeof(tmpbuf)-1 ] = 0;
  459.     config_pwarn(tmpbuf);
  460.     disks[numdisks].minimumspace = -1;
  461.     disks[numdisks].minpercent = -1;
  462.     disks[numdisks].path[0] = 0;
  463.   }
  464. #else
  465.   config_perror("'disk' checks not supported on this architecture.");
  466. #endif                   /* HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS */  
  467.  
  468. }
  470. static u_char *
  471. find_device(char *path)
  472. {
  473. #if HAVE_GETMNTENT
  474. #if HAVE_SYS_MNTTAB_H
  475.   struct mnttab   mnttab;
  476. #else
  477.   struct mntent  *mntent;
  478. #endif
  479.   FILE           *mntfp;
  480. #elif HAVE_FSTAB_H
  481.   struct fstab   *fstab;
  482.   struct stat     stat1;
  483. #elif HAVE_STATFS
  484.   struct statfs   statf;
  485. #endif
  486.   char            tmpbuf[1024];
  487.   static char     device[STRMAX];
  488. #if defined(HAVE_GETMNTENT) && !defined(HAVE_SETMNTENT)
  489.   int             i;
  490. #endif
  492.   device[0] = ''; /* null terminate the device */
  495.   /* find the device for the path and copy the device into the
  496.    * string declared above and at the end of the routine return it
  497.    * to the caller 
  498.    */
  499. #if HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS   
  500. #if HAVE_GETMNTENT
  501. #if HAVE_SETMNTENT
  502.   mntfp = setmntent(ETC_MNTTAB, "r");
  503.   while (NULL != (mntent = getmntent(mntfp)))
  504.     if (strcmp(path, mntent->mnt_dir) == 0) {
  505.       copy_nword(mntent->mnt_fsname, device,
  506.  sizeof(device));
  507.       DEBUGMSGTL(("ucd-snmp/disk", "Disk:  %sn",
  508.   mntent->mnt_fsname));
  509.       break;
  510.     } else {
  511.       DEBUGMSGTL(("ucd-snmp/disk", "  %s != %sn",
  512.   path, mntent->mnt_dir));
  513.     }
  514.   if (mntfp)
  515.     endmntent(mntfp);
  516. #else                           /* getmentent but not setmntent */
  517.   mntfp = fopen(ETC_MNTTAB, "r");
  518.   while ((i = getmntent(mntfp, &mnttab)) == 0)
  519.     if (strcmp(path, mnttab.mnt_mountp) == 0)
  520.       break;
  521.     else {
  522.       DEBUGMSGTL(("ucd-snmp/disk", "  %s != %sn",
  523.   path, mnttab.mnt_mountp));
  524.     }
  525.   fclose(mntfp);
  526.   if (i == 0) {
  527.     copy_nword(mnttab.mnt_special, device,
  528.        sizeof(device));
  529.   }
  530. #endif /* HAVE_SETMNTENT */
  531. #elif HAVE_FSTAB_H
  532.   stat(path, &stat1);
  533.   setfsent();
  534.   if ((fstab = getfsfile(path))) {
  535.     copy_nword(fstab->fs_spec, device,
  536.        sizeof(device));
  537.   }
  538.   endfsent();
  539.   if (device[0] != '') {
  540.      /*
  541.       * dummy clause for else below
  542.       */
  543.    }
  545. #elif HAVE_STATFS
  546.   if (statfs(path, &statf) == 0) {
  547.     copy_word(statf.f_mntfromname, device);
  548.     DEBUGMSGTL(("ucd-snmp/disk", "Disk:  %sn",
  549. statf.f_mntfromname));
  550.   }
  551. #endif
  552.   else {
  553.     sprintf(tmpbuf, "Couldn't find device for disk %s",
  554.     path);
  555.     config_pwarn(tmpbuf);
  556.   }
  557. #else
  558.   config_perror("'disk' checks not supported on this architecture.");
  559. #endif                   /* HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS */  
  560.   return device;
  561. }
  564. /*
  565.  * var_extensible_disk(...
  566.  * Arguments:
  567.  * vp     IN      - pointer to variable entry that points here
  568.  * name    IN/OUT  - IN/name requested, OUT/name found
  569.  * length  IN/OUT  - length of IN/OUT oid's 
  570.  * exact   IN      - TRUE if an exact match was requested
  571.  * var_len OUT     - length of variable or 0 if function returned
  572.  * write_method
  573.  * 
  574.  */
  575. u_char         *
  576. var_extensible_disk(struct variable *vp,
  577.                     oid * name,
  578.                     size_t * length,
  579.                     int exact,
  580.                     size_t * var_len, WriteMethod ** write_method)
  581. {
  583.     int             percent, iserror, disknum = 0;
  584. #if !defined(HAVE_SYS_STATVFS_H) && !defined(HAVE_STATFS)
  585.     double          totalblks, free, used, avail, availblks;
  586. #else
  587.     static long     avail;
  588. #if defined(STRUCT_STATVFS_HAS_F_FILES) || defined(STRUCT_STATFS_HAS_F_FILES)
  589.     int             percent_inode;
  590. #endif
  591. #endif
  592.     static long     long_ret;
  593.     static char     errmsg[300];
  594.     float           multiplier;
  596. #if defined(HAVE_STATVFS) || defined(HAVE_STATFS)
  597. #ifdef STAT_STATFS_FS_DATA
  598.     struct fs_data  fsd;
  599.     struct {
  600.         u_int           f_blocks, f_bfree, f_bavail, f_bsize;
  601.     } vfs;
  602. #else
  603.     struct statvfs  vfs;
  604. #endif
  605. #else
  606. #if HAVE_FSTAB_H
  607.     int             file;
  608.     union {
  609.         struct fs       iu_fs;
  610.         char            dummy[SBSIZE];
  611.     } sb;
  612. #define filesys sb.iu_fs
  613. #endif
  614. #endif
  616.     if (header_simple_table
  617.         (vp, name, length, exact, var_len, write_method, numdisks))
  618.         return (NULL);
  619.     disknum = name[*length - 1] - 1;
  620.     switch (vp->magic) {
  621.     case MIBINDEX:
  622.         long_ret = disknum + 1;
  623.         return ((u_char *) (&long_ret));
  624.     case ERRORNAME:            /* DISKPATH */
  625.         *var_len = strlen(disks[disknum].path);
  626.         return ((u_char *) disks[disknum].path);
  627.     case DISKDEVICE:
  628.         *var_len = strlen(disks[disknum].device);
  629.         return ((u_char *) disks[disknum].device);
  630.     case DISKMINIMUM:
  631.         long_ret = disks[disknum].minimumspace;
  632.         return ((u_char *) (&long_ret));
  633.     case DISKMINPERCENT:
  634.         long_ret = disks[disknum].minpercent;
  635.         return ((u_char *) (&long_ret));
  636.     }
  637. #if defined(HAVE_STATVFS) || defined(HAVE_STATFS)
  638. #ifdef STAT_STATFS_FS_DATA
  639.     if (statvfs(disks[disknum].path, &fsd) == -1)
  640. #else
  641.     if (statvfs(disks[disknum].path, &vfs) == -1)
  642. #endif
  643.     {
  644.         snmp_log(LOG_ERR, "Couldn't open device %sn",
  645.                  disks[disknum].device);
  646.         setPerrorstatus("statvfs dev/disk");
  647.         return NULL;
  648.     }
  649. #ifdef STAT_STATFS_FS_DATA
  650.     vfs.f_blocks = fsd.fd_btot;
  651.     vfs.f_bfree = fsd.fd_bfree;
  652.     vfs.f_bavail = fsd.fd_bfreen;
  653.     vfs.f_bsize = 1024;         /*  Ultrix f_bsize is a VM parameter apparently.  */
  654. #endif
  655. #if defined(HAVE_ODS)
  656.     vfs.f_blocks = vfs.f_spare[0];
  657.     vfs.f_bfree = vfs.f_spare[1];
  658.     vfs.f_bavail = vfs.f_spare[2];
  659. #endif
  660.     percent = vfs.f_bavail <= 0 ? 100 :
  661.         (int) ((double) (vfs.f_blocks - vfs.f_bfree) /
  662.                (double) (vfs.f_blocks -
  663.                          (vfs.f_bfree - vfs.f_bavail)) * 100.0 + 0.5);
  664.     multiplier = (float)vfs.f_bsize / (float)1024.0;
  665. #ifdef STRUCT_STATVFS_HAS_F_FRSIZE
  666.     if (vfs.f_frsize > 255)
  667.         multiplier = (float)vfs.f_frsize / (float)1024.0;
  668. #endif
  669.     avail = (long)(vfs.f_bavail * multiplier);
  670.     iserror = (disks[disknum].minimumspace >= 0 ?
  671.                avail < disks[disknum].minimumspace :
  672.                100 - percent <= disks[disknum].minpercent) ? 1 : 0;
  673. #if defined(STRUCT_STATVFS_HAS_F_FILES) || defined STRUCT_STATFS_HAS_F_FAVAIL
  674.     percent_inode = vfs.f_favail <= 0 ? 100 :
  675.         (int) ((double) (vfs.f_files - vfs.f_ffree) /
  676.                (double) (vfs.f_files -
  677.                          (vfs.f_ffree - vfs.f_favail)) * 100.0 + 0.5);
  678. #else
  679. #if defined(STRUCT_STATFS_HAS_F_FILES) && defined(STRUCT_STATFS_HAS_F_FFREE)
  680.    percent_inode = vfs.f_files == 0 ? 100.0 :
  681.       (int) ((double) (vfs.f_files - vfs.f_ffree) /
  682.           (double) (vfs.f_files) * 100.0 + 0.5);
  683. #endif 
  684. #endif /* defined(STRUCT_STATVFS_HAS_F_FILES) */ 
  685.     switch (vp->magic) {
  686.     case DISKTOTAL:
  687.         long_ret = (long)(vfs.f_blocks * multiplier);
  688.         return ((u_char *) (&long_ret));
  689.     case DISKAVAIL:
  690.         return ((u_char *) (&avail));
  691.     case DISKUSED:
  692.         long_ret = (long)((vfs.f_blocks - vfs.f_bfree) * multiplier);
  693.         return ((u_char *) (&long_ret));
  694.     case DISKPERCENT:
  695.         long_ret = percent;
  696.         return ((u_char *) (&long_ret));
  697. #if defined(STRUCT_STATVFS_HAS_F_FILES) || defined (STRUCT_STATFS_HAS_F_FILES)
  698.     case DISKPERCENTNODE:
  699.         long_ret = percent_inode;
  700.         return ((u_char *) (&long_ret));
  701. #endif
  702.     case ERRORFLAG:
  703.         long_ret = iserror;
  704.         return ((u_char *) (&long_ret));
  705.     case ERRORMSG:
  706.         if (iserror) {
  707.             if (disks[disknum].minimumspace >= 0)
  708.                 snprintf(errmsg, sizeof(errmsg),
  709.                         "%s: less than %d free (= %d)",
  710.                         disks[disknum].path, disks[disknum].minimumspace,
  711.                         (int) avail);
  712.             else
  713.                 snprintf(errmsg, sizeof(errmsg),
  714.                         "%s: less than %d%% free (= %d%%)",
  715.                         disks[disknum].path, disks[disknum].minpercent,
  716.                         percent);
  717.             errmsg[ sizeof(errmsg)-1 ] = 0;
  718.         } else
  719.             errmsg[0] = 0;
  720.         *var_len = strlen(errmsg);
  721.         return ((u_char *) (errmsg));
  722.     }
  723. #else
  724. #if HAVE_FSTAB_H
  725.     /*
  726.      * read the disk information 
  727.      */
  728.     if ((file = open(disks[disknum].device, 0)) < 0) {
  729.         snmp_log(LOG_ERR, "Couldn't open device %sn",
  730.                  disks[disknum].device);
  731.         setPerrorstatus("open dev/disk");
  732.         return (NULL);
  733.     }
  734.     lseek(file, (long) (SBLOCK * DEV_BSIZE), 0);
  735.     if (read(file, (char *) &filesys, SBSIZE) != SBSIZE) {
  736.         setPerrorstatus("open dev/disk");
  737.         snmp_log(LOG_ERR, "Error reading device %sn",
  738.                  disks[disknum].device);
  739.         close(file);
  740.         return (NULL);
  741.     }
  742.     close(file);
  743.     totalblks = filesys.fs_dsize;
  744.     free = filesys.fs_cstotal.cs_nbfree * filesys.fs_frag +
  745.         filesys.fs_cstotal.cs_nffree;
  746.     used = totalblks - free;
  747.     availblks = totalblks * (100 - filesys.fs_minfree) / 100;
  748.     avail = availblks > used ? availblks - used : 0;
  749.     percent =
  750.         availblks ==
  751.         0 ? 100 : (int) ((double) used / (double) totalblks * 100.0 + 0.5);
  752.     multiplier = (float)filesys.fs_fsize / (float)1024.0;
  753.     iserror =
  754.         (disks[disknum].minimumspace >= 0
  755.             ? avail * multiplier < disks[disknum].minimumspace
  756.             : 100 - percent <= disks[disknum].minpercent) ? 1 : 0;
  757.     switch (vp->magic) {
  758.     case DISKTOTAL:
  759.         long_ret = (long)(totalblks * multiplier);
  760.         return ((u_char *) (&long_ret));
  761.     case DISKAVAIL:
  762.         long_ret = (long)(avail * multiplier);
  763.         return ((u_char *) (&long_ret));
  764.     case DISKUSED:
  765.         long_ret = (long)(used * multiplier);
  766.         return ((u_char *) (&long_ret));
  767.     case DISKPERCENT:
  768.         long_ret = percent;
  769.         return ((u_char *) (&long_ret));
  770.     case ERRORFLAG:
  771.         long_ret = iserror;
  772.         return ((u_char *) (&long_ret));
  773.     case ERRORMSG:
  774.         if (iserror) {
  775.             if (disks[disknum].minimumspace >= 0)
  776.                 snprintf(errmsg, sizeof(errmsg),
  777.                         "%s: less than %d free (= %d)",
  778.                         disks[disknum].path, disks[disknum].minimumspace,
  779.                         avail * filesys.fs_fsize / 1024);
  780.             else
  781.                 snprintf(errmsg, sizeof(errmsg),
  782.                         "%s: less than %d%% free (= %d%%)",
  783.                         disks[disknum].path, disks[disknum].minpercent,
  784.                         percent);
  785.             errmsg[ sizeof(errmsg)-1 ] = 0;
  786.         } else
  787.             errmsg[0] = 0;
  788.         *var_len = strlen(errmsg);
  789.         return ((u_char *) (errmsg));
  790.     }
  791. #endif
  792. #endif
  793.     return NULL;
  794. }