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

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

SNMP编程

开发平台：

Unix_Linux

hr_filesys.c：源码内容
  1. /*
  2.  *  Host Resources MIB - File System device group implementation - hr_filesys.c
  3.  *
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  7. #include "host_res.h"
  8. #include "hr_filesys.h"
  9. #include "hr_storage.h"
  10. #include <net-snmp/utilities.h>
  12. #if HAVE_MNTENT_H
  13. #include <mntent.h>
  14. #endif
  15. #if HAVE_SYS_MNTENT_H
  16. #include <sys/mntent.h>
  17. #endif
  18. #if HAVE_SYS_MNTTAB_H
  19. #include <sys/mnttab.h>
  20. #endif
  21. #if HAVE_SYS_STATVFS_H
  22. #include <sys/statvfs.h>
  23. #endif
  24. #if HAVE_SYS_VFS_H
  25. #include <sys/vfs.h>
  26. #endif
  27. #ifdef HAVE_SYS_PARAM_H
  28. #include <sys/param.h>
  29. #endif
  30. #ifdef HAVE_SYS_MOUNT_H
  31. #include <sys/mount.h>
  32. #endif
  34. #include <ctype.h>
  35. #if HAVE_STRING_H
  36. #include <string.h>
  37. #endif
  38. #if HAVE_STDLIB_H
  39. #include <stdlib.h>
  40. #endif
  42. #if defined(bsdi4) || defined(freebsd3) || defined(freebsd4) || defined(freebsd5)
  43. #if HAVE_GETFSSTAT
  44. #if defined(MFSNAMELEN)
  45. #define MOUNT_NFS "nfs"
  46. #define MNTTYPE_UFS "ufs"
  47. #define BerkelyFS
  48. #define MNTTYPE_FFS "ffs"
  49. #define MNTTYPE_NFS "nfs"
  50. #define MNTTYPE_NFS3 "nfs"
  51. #define MNTTYPE_MFS "mfs"
  52. #define MNTTYPE_MSDOS "msdos"
  53. #define MNTTYPE_LFS "lfs"
  54. #define MNTTYPE_FDESC "fdesc"
  55. #define MNTTYPE_PORTAL "portal"
  56. #define MNTTYPE_NULL "null"
  57. #define MNTTYPE_UMAP "umap"
  58. #define MNTTYPE_KERNFS "kernfs"
  59. #define MNTTYPE_PROCFS "procfs"
  60. #define MNTTYPE_AFS "afs"
  61. #define MNTTYPE_CD9660 "cd9660"
  62. #define MNTTYPE_UNION "union"
  63. #define MNTTYPE_ADOSFS "adosfs"
  64. #define MNTTYPE_EXT2FS "ext2fs"
  65. #define MNTTYPE_CFS "coda"
  66. #define MNTTYPE_NTFS "ntfs"
  67. #endif
  68. #endif
  69. #endif                          /* freebsd3 */
  71. #define HRFS_MONOTONICALLY_INCREASING
  73.         /*********************
  74.  *
  75.  *  Kernel & interface information,
  76.  *   and internal forward declarations
  77.  *
  78.  *********************/
  80. #ifdef solaris2
  82. struct mnttab   HRFS_entry_struct;
  83. struct mnttab  *HRFS_entry = &HRFS_entry_struct;
  84. #define HRFS_name mnt_special
  85. #define HRFS_mount mnt_mountp
  86. #define HRFS_type mnt_fstype
  87. #define HRFS_statfs statvfs
  89. #elif defined(HAVE_STATVFS) && defined(__NetBSD__)
  91. static struct statvfs *fsstats = NULL;
  92. struct statvfs *HRFS_entry;
  93. static int fscount;
  94. #define HRFS_mount f_mntonname
  95. #define HRFS_name f_mntfromname
  96. #define HRFS_statfs statvfs
  97. #define HRFS_type f_fstypename
  98. #elif defined(HAVE_GETFSSTAT)
  99. static struct statfs *fsstats = 0;
  100. static int      fscount;
  101. struct statfs  *HRFS_entry;
  102. #define HRFS_statfs statfs
  103. #ifdef MFSNAMELEN
  104. #define HRFS_type f_fstypename
  105. #else
  106. #define HRFS_type f_type
  107. #endif
  108. #define HRFS_mount f_mntonname
  109. #define HRFS_name f_mntfromname
  111. #elif defined(dynix)
  113. struct mntent  *HRFS_entry;
  114. #define HRFS_name mnt_fsname
  115. #define HRFS_mount mnt_dir
  116. #define HRFS_type mnt_type
  117. #define HRFS_statfs statvfs
  119. #else
  121. struct mntent  *HRFS_entry;
  122. #define HRFS_name mnt_fsname
  123. #define HRFS_mount mnt_dir
  124. #define HRFS_type mnt_type
  125. #define HRFS_statfs statfs
  127. #ifdef linux
  128. #define MNTTYPE_CD9660 "iso9660"
  129. #define MNTTYPE_EXT2FS "ext2"
  130. #define MNTTYPE_EXT3FS "ext3"
  131. #define MNTTYPE_SMBFS "smbfs"
  132. #define MNTTYPE_MSDOS "msdos"
  133. #define MNTTYPE_FAT32 "vfat"
  134. #define MNTTYPE_NTFS "ntfs"
  135. #endif /* linux */
  137. #endif
  139. #define FULL_DUMP 0
  140. #define PART_DUMP 1
  143. extern void     Init_HR_FileSys(void);
  144. extern int      Get_Next_HR_FileSys(void);
  145. char           *cook_device(char *);
  146. static u_char  *when_dumped(char *filesys, int level, size_t * length);
  147. int             header_hrfilesys(struct variable *, oid *, size_t *, int,
  148.                                  size_t *, WriteMethod **);
  150.         /*********************
  151.  *
  152.  *  Initialisation & common implementation functions
  153.  *
  154.  *********************/
  156. #define HRFSYS_INDEX 1
  157. #define HRFSYS_MOUNT 2
  158. #define HRFSYS_RMOUNT 3
  159. #define HRFSYS_TYPE 4
  160. #define HRFSYS_ACCESS 5
  161. #define HRFSYS_BOOT 6
  162. #define HRFSYS_STOREIDX 7
  163. #define HRFSYS_FULLDUMP 8
  164. #define HRFSYS_PARTDUMP 9
  166. struct variable4 hrfsys_variables[] = {
  167.     {HRFSYS_INDEX, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 1}},
  168.     {HRFSYS_MOUNT, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 2}},
  169.     {HRFSYS_RMOUNT, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 3}},
  170.     {HRFSYS_TYPE, ASN_OBJECT_ID, RONLY, var_hrfilesys, 2, {1, 4}},
  171.     {HRFSYS_ACCESS, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 5}},
  172.     {HRFSYS_BOOT, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 6}},
  173.     {HRFSYS_STOREIDX, ASN_INTEGER, RONLY, var_hrfilesys, 2, {1, 7}},
  174.     {HRFSYS_FULLDUMP, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 8}},
  175.     {HRFSYS_PARTDUMP, ASN_OCTET_STR, RONLY, var_hrfilesys, 2, {1, 9}},
  176. };
  177. oid             hrfsys_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 8 };
  179. void
  180. init_hr_filesys(void)
  181. {
  182.     REGISTER_MIB("host/hr_filesys", hrfsys_variables, variable4,
  183.                  hrfsys_variables_oid);
  184. }
  186. /*
  187.  * header_hrfilesys(...
  188.  * Arguments:
  189.  * vp     IN      - pointer to variable entry that points here
  190.  * name    IN/OUT  - IN/name requested, OUT/name found
  191.  * length  IN/OUT  - length of IN/OUT oid's 
  192.  * exact   IN      - TRUE if an exact match was requested
  193.  * var_len OUT     - length of variable or 0 if function returned
  194.  * write_method
  195.  * 
  196.  */
  198. int
  199. header_hrfilesys(struct variable *vp,
  200.                  oid * name,
  201.                  size_t * length,
  202.                  int exact, size_t * var_len, WriteMethod ** write_method)
  203. {
  204. #define HRFSYS_ENTRY_NAME_LENGTH 11
  205.     oid             newname[MAX_OID_LEN];
  206.     int             fsys_idx, LowIndex = -1;
  207.     int             result;
  209.     DEBUGMSGTL(("host/hr_filesys", "var_hrfilesys: "));
  210.     DEBUGMSGOID(("host/hr_filesys", name, *length));
  211.     DEBUGMSG(("host/hr_filesys", " %dn", exact));
  213.     memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
  214.     /*
  215.      * Find "next" file system entry 
  216.      */
  218.     Init_HR_FileSys();
  219.     for (;;) {
  220.         fsys_idx = Get_Next_HR_FileSys();
  221.         if (fsys_idx == -1)
  222.             break;
  223.         newname[HRFSYS_ENTRY_NAME_LENGTH] = fsys_idx;
  224.         result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
  225.         if (exact && (result == 0)) {
  226.             LowIndex = fsys_idx;
  227.             break;
  228.         }
  229.         if ((!exact && (result < 0)) &&
  230.             (LowIndex == -1 || fsys_idx < LowIndex)) {
  231.             LowIndex = fsys_idx;
  232. #ifdef HRFS_MONOTONICALLY_INCREASING
  233.             break;
  234. #endif
  235.         }
  236.     }
  238.     if (LowIndex == -1) {
  239.         DEBUGMSGTL(("host/hr_filesys", "... index out of rangen"));
  240.         return (MATCH_FAILED);
  241.     }
  243.     memcpy((char *) name, (char *) newname,
  244.            (vp->namelen + 1) * sizeof(oid));
  245.     *length = vp->namelen + 1;
  246.     *write_method = 0;
  247.     *var_len = sizeof(long);    /* default to 'long' results */
  249.     DEBUGMSGTL(("host/hr_filesys", "... get filesys stats "));
  250.     DEBUGMSGOID(("host/hr_filesys", name, *length));
  251.     DEBUGMSG(("host/hr_filesys", "n"));
  253.     return LowIndex;
  254. }
  257. oid             fsys_type_id[] = { 1, 3, 6, 1, 2, 1, 25, 3, 9, 1 };     /* hrFSOther */
  258. int             fsys_type_len =
  259.     sizeof(fsys_type_id) / sizeof(fsys_type_id[0]);
  261.         /*********************
  262.  *
  263.  *  System specific implementation functions
  264.  *
  265.  *********************/
  268. u_char         *
  269. var_hrfilesys(struct variable *vp,
  270.               oid * name,
  271.               size_t * length,
  272.               int exact, size_t * var_len, WriteMethod ** write_method)
  273. {
  274.     int             fsys_idx;
  275.     static char     string[1024];
  276.     char           *mnt_type;
  278.     fsys_idx =
  279.         header_hrfilesys(vp, name, length, exact, var_len, write_method);
  280.     if (fsys_idx == MATCH_FAILED)
  281.         return NULL;
  284.     switch (vp->magic) {
  285.     case HRFSYS_INDEX:
  286.         long_return = fsys_idx;
  287.         return (u_char *) & long_return;
  288.     case HRFSYS_MOUNT:
  289.         snprintf(string, sizeof(string), HRFS_entry->HRFS_mount);
  290.         string[ sizeof(string)-1 ] = 0;
  291.         *var_len = strlen(string);
  292.         return (u_char *) string;
  293.     case HRFSYS_RMOUNT:
  294.         if (Check_HR_FileSys_NFS()) {
  295.             snprintf(string, sizeof(string), HRFS_entry->HRFS_name);
  296.             string[ sizeof(string)-1 ] = 0;
  297.         } else
  298.             string[0] = '';
  299.         *var_len = strlen(string);
  300.         return (u_char *) string;
  302.     case HRFSYS_TYPE:
  303.         if (Check_HR_FileSys_NFS())
  304.             fsys_type_id[fsys_type_len - 1] = 14;
  305.         else {
  306.         /*
  307.          * Not sufficient to identity the file
  308.          *   type precisely, but it's a start.
  309.          */
  310. #if HAVE_GETFSSTAT && !defined(MFSNAMELEN)
  311.         switch (HRFS_entry->HRFS_type) {
  312.         case MOUNT_UFS:
  313.             fsys_type_id[fsys_type_len - 1] = 3;
  314.             break;
  315.         case MOUNT_NFS:
  316.             fsys_type_id[fsys_type_len - 1] = 14;
  317.             break;
  318.         case MOUNT_MFS:
  319.             fsys_type_id[fsys_type_len - 1] = 8;
  320.             break;
  321.         case MOUNT_MSDOS:
  322.             fsys_type_id[fsys_type_len - 1] = 5;
  323.             break;
  324.         case MOUNT_LFS:
  325.             fsys_type_id[fsys_type_len - 1] = 1;
  326.             break;
  327.         case MOUNT_LOFS:
  328.             fsys_type_id[fsys_type_len - 1] = 1;
  329.             break;
  330.         case MOUNT_FDESC:
  331.             fsys_type_id[fsys_type_len - 1] = 1;
  332.             break;
  333.         case MOUNT_PORTAL:
  334.             fsys_type_id[fsys_type_len - 1] = 1;
  335.             break;
  336.         case MOUNT_NULL:
  337.             fsys_type_id[fsys_type_len - 1] = 1;
  338.             break;
  339.         case MOUNT_UMAP:
  340.             fsys_type_id[fsys_type_len - 1] = 1;
  341.             break;
  342.         case MOUNT_KERNFS:
  343.             fsys_type_id[fsys_type_len - 1] = 1;
  344.             break;
  345.         case MOUNT_PROCFS:
  346.             fsys_type_id[fsys_type_len - 1] = 1;
  347.             break;
  348.         case MOUNT_AFS:
  349.             fsys_type_id[fsys_type_len - 1] = 16;
  350.             break;
  351.         case MOUNT_CD9660:
  352.             fsys_type_id[fsys_type_len - 1] = 12;
  353.             break;
  354.         case MOUNT_UNION:
  355.             fsys_type_id[fsys_type_len - 1] = 1;
  356.             break;
  357.         case MOUNT_DEVFS:
  358.             fsys_type_id[fsys_type_len - 1] = 1;
  359.             break;
  360. #ifdef MOUNT_EXT2FS
  361.         case MOUNT_EXT2FS:
  362.             fsys_type_id[fsys_type_len - 1] = 23;
  363.             break;
  364. #endif
  365. #ifdef MOUNT_TFS
  366.         case MOUNT_TFS:
  367.             fsys_type_id[fsys_type_len - 1] = 15;
  368.             break;
  369. #endif
  370.         }
  371. #else
  372.         mnt_type = HRFS_entry->HRFS_type;
  373.         if (mnt_type == NULL)
  374.             fsys_type_id[fsys_type_len - 1] = 2;        /* unknown */
  375. #ifdef MNTTYPE_HFS
  376.         else if (!strcmp(mnt_type, MNTTYPE_HFS))
  377. #ifdef BerkelyFS
  378.             fsys_type_id[fsys_type_len - 1] = 3;
  379. #else                           /* SysV */
  380.             fsys_type_id[fsys_type_len - 1] = 4;
  381. #endif
  382. #endif
  383. #ifdef MNTTYPE_UFS
  384.         else if (!strcmp(mnt_type, MNTTYPE_UFS))
  385. #if (defined(BerkelyFS) && !defined(MNTTYPE_HFS)) || defined(solaris2)
  386.             fsys_type_id[fsys_type_len - 1] = 3;
  387. #else                           /* SysV */
  388.             fsys_type_id[fsys_type_len - 1] = 4;        /* or 3? XXX */
  389. #endif
  390. #endif
  391. #ifdef MNTTYPE_SYSV
  392.         else if (!strcmp(mnt_type, MNTTYPE_SYSV))
  393.             fsys_type_id[fsys_type_len - 1] = 4;
  394. #endif
  395. #ifdef MNTTYPE_PC
  396.         else if (!strcmp(mnt_type, MNTTYPE_PC))
  397.             fsys_type_id[fsys_type_len - 1] = 5;
  398. #endif
  399. #ifdef MNTTYPE_MSDOS
  400.         else if (!strcmp(mnt_type, MNTTYPE_MSDOS))
  401.             fsys_type_id[fsys_type_len - 1] = 5;
  402. #endif
  403. #ifdef MNTTYPE_FAT32
  404.         else if (!strcmp(mnt_type, MNTTYPE_FAT32))
  405.             fsys_type_id[fsys_type_len - 1] = 22;
  406. #endif
  407. #ifdef MNTTYPE_CDFS
  408.         else if (!strcmp(mnt_type, MNTTYPE_CDFS))
  409. #ifdef RockRidge
  410.             fsys_type_id[fsys_type_len - 1] = 13;
  411. #else                           /* ISO 9660 */
  412.             fsys_type_id[fsys_type_len - 1] = 12;
  413. #endif
  414. #endif
  415. #ifdef MNTTYPE_HSFS
  416.         else if (!strcmp(mnt_type, MNTTYPE_HSFS))
  417.             fsys_type_id[fsys_type_len - 1] = 13;
  418. #endif
  419. #ifdef MNTTYPE_ISO9660
  420.         else if (!strcmp(mnt_type, MNTTYPE_ISO9660))
  421.             fsys_type_id[fsys_type_len - 1] = 12;
  422. #endif
  423. #ifdef MNTTYPE_CD9660
  424.         else if (!strcmp(mnt_type, MNTTYPE_CD9660))
  425.             fsys_type_id[fsys_type_len - 1] = 12;
  426. #endif
  427. #ifdef MNTTYPE_SMBFS
  428.         else if (!strcmp(mnt_type, MNTTYPE_SMBFS))
  429.             fsys_type_id[fsys_type_len - 1] = 14;
  430. #endif
  431. #ifdef MNTTYPE_NFS
  432.         else if (!strcmp(mnt_type, MNTTYPE_NFS))
  433.             fsys_type_id[fsys_type_len - 1] = 14;
  434. #endif
  435. #ifdef MNTTYPE_NFS3
  436.         else if (!strcmp(mnt_type, MNTTYPE_NFS3))
  437.             fsys_type_id[fsys_type_len - 1] = 14;
  438. #endif
  439. #ifdef MNTTYPE_MFS
  440.         else if (!strcmp(mnt_type, MNTTYPE_MFS))
  441.             fsys_type_id[fsys_type_len - 1] = 8;
  442. #endif
  443. #ifdef MNTTYPE_EXT2FS
  444.         else if (!strcmp(mnt_type, MNTTYPE_EXT2FS))
  445.             fsys_type_id[fsys_type_len - 1] = 23;
  446. #endif
  447. #ifdef MNTTYPE_EXT3FS
  448.         else if (!strcmp(mnt_type, MNTTYPE_EXT3FS))
  449.             fsys_type_id[fsys_type_len - 1] = 23;
  450. #endif
  451. #ifdef MNTTYPE_NTFS
  452.         else if (!strcmp(mnt_type, MNTTYPE_NTFS))
  453.             fsys_type_id[fsys_type_len - 1] = 9;
  454. #endif
  455.         else
  456.             fsys_type_id[fsys_type_len - 1] = 1;        /* Other */
  457. #endif                          /* HAVE_GETFSSTAT */
  458.         }
  460.         *var_len = sizeof(fsys_type_id);
  461.         return (u_char *) fsys_type_id;
  463.     case HRFSYS_ACCESS:
  464. #if defined(HAVE_STATVFS) && defined(__NetBSD__)
  465. long_return = HRFS_entry->f_flag & MNT_RDONLY ? 2 : 1;
  466. #elif defined(HAVE_GETFSSTAT)
  467.         long_return = HRFS_entry->f_flags & MNT_RDONLY ? 2 : 1;
  468. #elif defined(cygwin)
  469.         long_return = 1;
  470. #else
  471.         if (hasmntopt(HRFS_entry, "ro") != NULL)
  472.             long_return = 2;    /* Read Only */
  473.         else
  474.             long_return = 1;    /* Read-Write */
  475. #endif
  476.         return (u_char *) & long_return;
  477.     case HRFSYS_BOOT:
  478.         if (HRFS_entry->HRFS_mount[0] == '/' &&
  479.             HRFS_entry->HRFS_mount[1] == 0)
  480.             long_return = 1;    /* root is probably bootable! */
  481.         else
  482.             long_return = 2;    /* others probably aren't */
  483.         return (u_char *) & long_return;
  484.     case HRFSYS_STOREIDX:
  485.         long_return = fsys_idx + HRS_TYPE_FIXED_MAX;
  486.         return (u_char *) & long_return;
  487.     case HRFSYS_FULLDUMP:
  488.         return when_dumped(HRFS_entry->HRFS_name, FULL_DUMP, var_len);
  489.     case HRFSYS_PARTDUMP:
  490.         return when_dumped(HRFS_entry->HRFS_name, PART_DUMP, var_len);
  491.     default:
  492.         DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrfilesysn",
  493.                     vp->magic));
  494.     }
  495.     return NULL;
  496. }
  499.         /*********************
  500.  *
  501.  *  Internal implementation functions
  502.  *
  503.  *********************/
  505. static int      HRFS_index;
  506. #ifndef HAVE_GETFSSTAT
  507. static FILE    *fp;
  508. #endif
  510. void
  511. Init_HR_FileSys(void)
  512. {
  513. #if HAVE_GETFSSTAT
  514.     fscount = getfsstat(NULL, 0, MNT_NOWAIT);
  515.     if (fsstats)
  516.         free((char *) fsstats);
  517.     fsstats = NULL;
  518.     fsstats = malloc(fscount * sizeof(*fsstats));
  519.     getfsstat(fsstats, fscount * sizeof(*fsstats), MNT_NOWAIT);
  520.     HRFS_index = 0;
  521. #else
  522.     HRFS_index = 1;
  523.     if (fp != NULL)
  524.         fclose(fp);
  525.     fp = fopen(ETC_MNTTAB, "r");
  526. #endif
  527. }
  529. const char     *HRFS_ignores[] = {
  530. #ifdef MNTTYPE_IGNORE
  531.     MNTTYPE_IGNORE,
  532. #endif
  533. #ifdef MNTTYPE_SWAP
  534.     MNTTYPE_SWAP,
  535. #endif
  536. #ifdef MNTTYPE_PROC
  537.     MNTTYPE_PROC,
  538. #endif
  539. #ifdef MNTTYPE_PROCFS
  540.     MNTTYPE_PROCFS,
  541. #endif
  542. #ifdef MNTTYPE_AUTOFS
  543.     MNTTYPE_AUTOFS,
  544. #else
  545.     "autofs",
  546. #endif
  547. #ifdef linux
  548.     "devpts",
  549.     "devfs",
  550.     "usbdevfs",
  551.     "tmpfs",
  552.     "shm",
  553. #endif
  554. #ifdef solaris2
  555.     "mntfs",
  556.     "proc",
  557.     "fd",
  558. #endif
  559.     0
  560. };
  562. int
  563. Get_Next_HR_FileSys(void)
  564. {
  565. #if HAVE_GETFSSTAT
  566.     if (HRFS_index >= fscount)
  567.         return -1;
  568.     HRFS_entry = fsstats + HRFS_index;
  569.     return ++HRFS_index;
  570. #else
  571.     const char    **cpp;
  573.     if (fp == NULL)
  574.         return -1;
  576. #ifdef solaris2
  577.     if (getmntent(fp, HRFS_entry) != 0)
  578.         return -1;
  579. #else
  580.     HRFS_entry = getmntent(fp);
  581.     if (HRFS_entry == NULL)
  582.         return -1;
  583. #endif                          /* solaris2 */
  585.     for (cpp = HRFS_ignores; *cpp != NULL; ++cpp)
  586.         if (!strcmp(HRFS_entry->HRFS_type, *cpp))
  587.             return Get_Next_HR_FileSys();
  589.     /*
  590.      * Try and ensure that index values are persistent
  591.      *   at least within a single run of the agent
  592.      */
  593.     HRFS_index = se_find_value_in_slist("filesys", HRFS_entry->HRFS_name );
  594.     if (HRFS_index == SE_DNE) {
  595.         HRFS_index = se_find_free_value_in_slist("filesys");
  596.         if (HRFS_index == SE_DNE) { HRFS_index = 1; }
  597.         se_add_pair_to_slist( "filesys",
  598.                               strdup( HRFS_entry->HRFS_name ), HRFS_index);
  599.     }
  601.     return HRFS_index++;
  602. #endif                          /* HAVE_GETFSSTAT */
  603. }
  605. /*
  606.  * this function checks whether the current file system (info can be found
  607.  * in HRFS_entry) is a NFS file system
  608.  * HRFS_entry must be valid prior to calling this function
  609.  * returns 1 if NFS file system, 0 otherwise
  610.  */
  611. int
  612. Check_HR_FileSys_NFS (void)
  613. {
  614. #if HAVE_GETFSSTAT
  615. #if defined(MFSNAMELEN)
  616.     if (!strcmp(HRFS_entry->HRFS_type, MOUNT_NFS))
  617. #else
  618.     if (HRFS_entry->HRFS_type == MOUNT_NFS)
  619. #endif
  620. #else /* HAVE_GETFSSTAT */
  621.     if ( HRFS_entry->HRFS_type != NULL && (
  622. #if defined(MNTTYPE_NFS)
  623. !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS) ||
  624. #else
  625. !strcmp( HRFS_entry->HRFS_type, "nfs") ||
  626. #endif
  627. #if defined(MNTTYPE_NFS3)
  628.     !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS3) ||
  629. #endif
  630. #if defined(MNTTYPE_SMBFS)
  631.     !strcmp( HRFS_entry->HRFS_type, MNTTYPE_SMBFS) ||
  632. #endif
  633. #if defined(MNTTYPE_LOFS)
  634.     !strcmp( HRFS_entry->HRFS_type, MNTTYPE_LOFS) ||
  635. #endif
  636.     /*
  637.      * MVFS is Rational ClearCase's view file system
  638.      * it is similiar to NFS file systems in that it is mounted
  639.      * locally or remotely from the ClearCase server
  640.      */
  641.     !strcmp( HRFS_entry->HRFS_type, "mvfs")))
  642. #endif /* HAVE_GETFSSTAT */
  643. return 1; /* NFS file system */
  645.     return 0; /* no NFS file system */
  646. }
  648. void
  649. End_HR_FileSys(void)
  650. {
  651. #ifdef HAVE_GETFSSTAT
  652.     if (fsstats)
  653.         free((char *) fsstats);
  654.     fsstats = NULL;
  655. #else
  656.     if (fp != NULL)
  657.         fclose(fp);
  658.     fp = NULL;
  659. #endif
  660. }
  663. static u_char  *
  664. when_dumped(char *filesys, int level, size_t * length)
  665. {
  666.     time_t          dumpdate = 0, tmp;
  667.     FILE           *dump_fp;
  668.     char            line[1024];
  669.     char           *cp1, *cp2, *cp3;
  671.     /*
  672.      * Look for the relevent entries in /etc/dumpdates
  673.      *
  674.      * This is complicated by the fact that disks are
  675.      *   mounted using block devices, but dumps are
  676.      *   done via the raw character devices.
  677.      * Thus the device names in /etc/dumpdates and
  678.      *   /etc/mnttab don't match.
  679.      *   These comparisons are therefore made using the
  680.      *   final portion of the device name only.
  681.      */
  683.     if (*filesys == '')       /* No filesystem name? */
  684.         return date_n_time(NULL, length);
  685.     cp1 = strrchr(filesys, '/');        /* Find the last element of the current FS */
  687.     if (cp1 == NULL)
  688.         cp1 = filesys;
  690.     if ((dump_fp = fopen("/etc/dumpdates", "r")) == NULL)
  691.         return date_n_time(NULL, length);
  693.     while (fgets(line, sizeof(line), dump_fp) != NULL) {
  694.         cp2 = strchr(line, ' ');        /* Start by looking at the device name only */
  695.         if (cp2 != NULL) {
  696.             *cp2 = '';
  697.             cp3 = strrchr(line, '/');   /* and find the last element */
  698.             if (cp3 == NULL)
  699.                 cp3 = line;
  701.             if (strcmp(cp1, cp3) != 0)  /* Wrong FS */
  702.                 continue;
  704.             ++cp2;
  705.             while (isspace(*cp2))
  706.                 ++cp2;          /* Now find the dump level */
  708.             if (level == FULL_DUMP) {
  709.                 if (*(cp2++) != '0')
  710.                     continue;   /* Not interested in partial dumps */
  711.                 while (isspace(*cp2))
  712.                     ++cp2;
  714.                 dumpdate = ctime_to_timet(cp2);
  715.                 fclose(dump_fp);
  716.                 return date_n_time(&dumpdate, length);
  717.             } else {            /* Partial Dump */
  718.                 if (*(cp2++) == '0')
  719.                     continue;   /* Not interested in full dumps */
  720.                 while (isspace(*cp2))
  721.                     ++cp2;
  723.                 tmp = ctime_to_timet(cp2);
  724.                 if (tmp > dumpdate)
  725.                     dumpdate = tmp;     /* Remember the 'latest' partial dump */
  726.             }
  727.         }
  728.     }
  730.     fclose(dump_fp);
  732.     return date_n_time(&dumpdate, length);
  733. }
  736. #define RAW_DEVICE_PREFIX "/dev/rdsk"
  737. #define COOKED_DEVICE_PREFIX "/dev/dsk"
  739. char           *
  740. cook_device(char *dev)
  741. {
  742.     static char     cooked_dev[SNMP_MAXPATH+1];
  744.     if (!strncmp(dev, RAW_DEVICE_PREFIX, strlen(RAW_DEVICE_PREFIX))) {
  745.         strncpy(cooked_dev, COOKED_DEVICE_PREFIX, sizeof(cooked_dev)-1);
  746.         cooked_dev[ sizeof(cooked_dev)-1 ] = 0;
  747.         strncat(cooked_dev, dev + strlen(RAW_DEVICE_PREFIX),
  748.                 sizeof(cooked_dev)-strlen(cooked_dev)-1);
  749.         cooked_dev[ sizeof(cooked_dev)-1 ] = 0;
  750.     } else {
  751.         strncpy(cooked_dev, dev, sizeof(cooked_dev)-1);
  752.         cooked_dev[ sizeof(cooked_dev)-1 ] = 0;
  753.     }
  755.     return (cooked_dev);
  756. }
  759. int
  760. Get_FSIndex(char *dev)
  761. {
  762.     int             iindex;
  764.     Init_HR_FileSys();
  766.     while ((iindex = Get_Next_HR_FileSys()) != -1)
  767.         if (!strcmp(HRFS_entry->HRFS_name, cook_device(dev))) {
  768.             End_HR_FileSys();
  769.             return iindex;
  770.         }
  772.     End_HR_FileSys();
  773.     return 0;
  774. }
  776. long
  777. Get_FSSize(char *dev)
  778. {
  779.     struct HRFS_statfs statfs_buf;
  781.     Init_HR_FileSys();
  783.     while (Get_Next_HR_FileSys() != -1)
  784.         if (!strcmp(HRFS_entry->HRFS_name, cook_device(dev))) {
  785.             End_HR_FileSys();
  787.             if (HRFS_statfs(HRFS_entry->HRFS_mount, &statfs_buf) != -1)
  788.    /*
  789.     * with large file systems the following calculation produces
  790.     * an overflow:
  791.     * (statfs_buf.f_blocks*statfs_buf.f_bsize)/1024
  792.     *
  793.     * assumption: f_bsize is either 512 or a multiple of 1024
  794.     * in case of 512 (f_blocks/2) is returned
  795.     * otherwise (f_blocks*(f_bsize/1024)) is returned
  796.     */
  797. #if defined(solaris2) && defined(STRUCT_STATVFS_HAS_F_FRSIZE)
  798.                 return (statfs_buf.f_blocks*(statfs_buf.f_frsize/1024));
  799. #else
  800.    if (statfs_buf.f_bsize == 512)
  801.        return (statfs_buf.f_blocks/2);
  802.                 else
  803.        return (statfs_buf.f_blocks*(statfs_buf.f_bsize/1024));
  804. #endif
  805.             else
  806.                 return -1;
  807.         }
  809.     End_HR_FileSys();
  810.     return 0;
  811. }