/* * Host Resources MIB - File System device group implementation - hr_filesys.c * */ /* Portions of this file are subject to the following copyright(s). See * the Net-SNMP's COPYING file for more details and other copyrights * that may apply: */ /* * Portions of this file are copyrighted by: * Copyright (C) 2007 Apple, Inc. All rights reserved. * Use is subject to license terms specified in the COPYING file * distributed with the Net-SNMP package. */ #include #include #include #include #include #include "host_res.h" #include "hr_filesys.h" #include "hr_storage.h" #include "hr_disk.h" #include #if HAVE_MNTENT_H #include #endif #if HAVE_SYS_MNTENT_H #include #endif #if HAVE_SYS_MNTTAB_H #include #endif #if HAVE_SYS_STATVFS_H #include #endif #if HAVE_SYS_VFS_H #include #endif #ifdef HAVE_SYS_PARAM_H #include #endif #ifdef HAVE_SYS_MOUNT_H #include #endif #include #if HAVE_STRING_H #include #endif #if HAVE_STDLIB_H #include #endif #if HAVE_NBUTIL_H #include #endif #if defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) #include #include #include #endif netsnmp_feature_require(se_find_free_value_in_slist); netsnmp_feature_require(date_n_time); netsnmp_feature_require(ctime_to_timet); #ifndef MNTTYPE_AUTOFS #define MNTTYPE_AUTOFS "autofs" #endif #if defined(bsdi4) || defined(freebsd3) || defined(freebsd4) || defined(freebsd5) || defined(darwin) #if HAVE_GETFSSTAT && defined(MFSNAMELEN) #define MOUNT_NFS "nfs" #define MNTTYPE_UFS "ufs" #define BerkelyFS #define MNTTYPE_FFS "ffs" #define MNTTYPE_NFS "nfs" #define MNTTYPE_NFS3 "nfs" #define MNTTYPE_HFS "hfs" #define MNTTYPE_MFS "mfs" #define MNTTYPE_MSDOS "msdos" #define MNTTYPE_LFS "lfs" #define MNTTYPE_FDESC "fdesc" #define MNTTYPE_PORTAL "portal" #define MNTTYPE_NULL "null" #define MNTTYPE_UMAP "umap" #define MNTTYPE_KERNFS "kernfs" #define MNTTYPE_PROCFS "procfs" #define MNTTYPE_AFS "afs" #define MNTTYPE_CD9660 "cd9660" #define MNTTYPE_UNION "union" #define MNTTYPE_ADOSFS "adosfs" #define MNTTYPE_EXT2FS "ext2fs" #define MNTTYPE_CFS "coda" #define MNTTYPE_NTFS "ntfs" #endif #endif /* freebsd3 */ #define HRFS_MONOTONICALLY_INCREASING /********************* * * Kernel & interface information, * and internal forward declarations * *********************/ #ifdef solaris2 struct mnttab HRFS_entry_struct; struct mnttab *HRFS_entry = &HRFS_entry_struct; #define HRFS_name mnt_special #define HRFS_mount mnt_mountp #define HRFS_type mnt_fstype #define HRFS_statfs statvfs #elif defined(HAVE_STATVFS) && defined(__NetBSD__) #if !defined(MFSNAMELEN) && defined(_VFS_NAMELEN) #define MFSNAMELEN _VFS_NAMELEN #endif #define getfsstat getvfsstat static struct statvfs *fsstats = NULL; struct statvfs *HRFS_entry; static int fscount; #define HRFS_mount f_mntonname #define HRFS_name f_mntfromname #define HRFS_statfs statvfs #define HRFS_type f_fstypename #elif defined(HAVE_GETFSSTAT) && !defined(HAVE_STATFS) && defined(HAVE_STATVFS) static struct statfs *fsstats = NULL; struct statfs *HRFS_entry; static int fscount; #define HRFS_mount f_mntonname #define HRFS_name f_mntfromname #define HRFS_statfs statvfs #define HRFS_type f_fstypename #elif defined(HAVE_GETFSSTAT) static struct statfs *fsstats = 0; static int fscount; struct statfs *HRFS_entry; #define HRFS_statfs statfs #ifdef MFSNAMELEN #define HRFS_type f_fstypename #else #define HRFS_type f_type #endif #define HRFS_mount f_mntonname #define HRFS_name f_mntfromname #elif defined(dynix) struct mntent *HRFS_entry; #define HRFS_name mnt_fsname #define HRFS_mount mnt_dir #define HRFS_type mnt_type #define HRFS_statfs statvfs #elif defined(WIN32) struct win_statfs *HRFS_entry; static int fscount; #define HRFS_mount f_driveletter #define HRFS_name f_fsid #define HRFS_statfs win_statfs #define HRFS_type f_type #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) struct vmount *aixmnt, *aixcurr; struct HRFS_entry { char *HRFS_name; char *HRFS_mount; int HRFS_type; int HRFS_flags; } *HRFS_entry; #define HRFS_statfs statfs #else struct mntent *HRFS_entry; #define HRFS_name mnt_fsname #define HRFS_mount mnt_dir #define HRFS_type mnt_type #define HRFS_statfs statfs #ifdef linux #define MNTTYPE_CD9660 "iso9660" #define MNTTYPE_EXT2FS "ext2" #define MNTTYPE_EXT3FS "ext3" #define MNTTYPE_SMBFS "smbfs" #define MNTTYPE_MSDOS "msdos" #define MNTTYPE_FAT32 "vfat" #define MNTTYPE_NTFS "ntfs" #define MNTTYPE_NFS4 "nfs4" #endif /* linux */ #endif #define FULL_DUMP 0 #define PART_DUMP 1 static u_char *when_dumped(char *filesys, int level, size_t * length); /********************* * * Initialisation & common implementation functions * *********************/ #define HRFSYS_INDEX 1 #define HRFSYS_MOUNT 2 #define HRFSYS_RMOUNT 3 #define HRFSYS_TYPE 4 #define HRFSYS_ACCESS 5 #define HRFSYS_BOOT 6 #define HRFSYS_STOREIDX 7 #define HRFSYS_FULLDUMP 8 #define HRFSYS_PARTDUMP 9 struct variable4 hrfsys_variables[] = { {HRFSYS_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 1}}, {HRFSYS_MOUNT, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 2}}, {HRFSYS_RMOUNT, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 3}}, {HRFSYS_TYPE, ASN_OBJECT_ID, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 4}}, {HRFSYS_ACCESS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 5}}, {HRFSYS_BOOT, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 6}}, {HRFSYS_STOREIDX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 7}}, {HRFSYS_FULLDUMP, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 8}}, {HRFSYS_PARTDUMP, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, var_hrfilesys, 2, {1, 9}}, }; oid hrfsys_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 8 }; void init_hr_filesys(void) { REGISTER_MIB("host/hr_filesys", hrfsys_variables, variable4, hrfsys_variables_oid); #if defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) /* something leaks, make it idiot-safe */ aixmnt = NULL; aixcurr = NULL; #endif } /* * header_hrfilesys(... * Arguments: * vp IN - pointer to variable entry that points here * name IN/OUT - IN/name requested, OUT/name found * length IN/OUT - length of IN/OUT oid's * exact IN - TRUE if an exact match was requested * var_len OUT - length of variable or 0 if function returned * write_method * */ int header_hrfilesys(struct variable *vp, oid * name, size_t * length, int exact, size_t * var_len, WriteMethod ** write_method) { #define HRFSYS_ENTRY_NAME_LENGTH 11 oid newname[MAX_OID_LEN]; int fsys_idx, LowIndex = -1; int result; DEBUGMSGTL(("host/hr_filesys", "var_hrfilesys: ")); DEBUGMSGOID(("host/hr_filesys", name, *length)); DEBUGMSG(("host/hr_filesys", " %d\n", exact)); memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid)); /* * Find "next" file system entry */ Init_HR_FileSys(); for (;;) { fsys_idx = Get_Next_HR_FileSys(); if (fsys_idx == -1) break; newname[HRFSYS_ENTRY_NAME_LENGTH] = fsys_idx; result = snmp_oid_compare(name, *length, newname, vp->namelen + 1); if (exact && (result == 0)) { LowIndex = fsys_idx; break; } if ((!exact && (result < 0)) && (LowIndex == -1 || fsys_idx < LowIndex)) { LowIndex = fsys_idx; #ifdef HRFS_MONOTONICALLY_INCREASING break; #endif } } if (LowIndex == -1) { DEBUGMSGTL(("host/hr_filesys", "... index out of range\n")); return (MATCH_FAILED); } memcpy((char *) name, (char *) newname, (vp->namelen + 1) * sizeof(oid)); *length = vp->namelen + 1; *write_method = (WriteMethod*)0; *var_len = sizeof(long); /* default to 'long' results */ DEBUGMSGTL(("host/hr_filesys", "... get filesys stats ")); DEBUGMSGOID(("host/hr_filesys", name, *length)); DEBUGMSG(("host/hr_filesys", "\n")); return LowIndex; } oid fsys_type_id[] = { 1, 3, 6, 1, 2, 1, 25, 3, 9, 1 }; /* hrFSOther */ int fsys_type_len = sizeof(fsys_type_id) / sizeof(fsys_type_id[0]); /********************* * * System specific implementation functions * *********************/ u_char * var_hrfilesys(struct variable *vp, oid * name, size_t * length, int exact, size_t * var_len, WriteMethod ** write_method) { int fsys_idx; static char string[1024]; char *mnt_type; fsys_idx = header_hrfilesys(vp, name, length, exact, var_len, write_method); if (fsys_idx == MATCH_FAILED) return NULL; switch (vp->magic) { case HRFSYS_INDEX: long_return = fsys_idx; return (u_char *) & long_return; case HRFSYS_MOUNT: strlcpy(string, HRFS_entry->HRFS_mount, sizeof(string)); *var_len = strlen(string); return (u_char *) string; case HRFSYS_RMOUNT: if (Check_HR_FileSys_NFS()) strlcpy(string, HRFS_entry->HRFS_name, sizeof(string)); else string[0] = '\0'; *var_len = strlen(string); return (u_char *) string; case HRFSYS_TYPE: if (Check_HR_FileSys_NFS()) fsys_type_id[fsys_type_len - 1] = 14; else { /* * Not sufficient to identity the file * type precisely, but it's a start. */ #if HAVE_GETFSSTAT && !defined(MFSNAMELEN) switch (HRFS_entry->HRFS_type) { case MOUNT_UFS: fsys_type_id[fsys_type_len - 1] = 3; break; case MOUNT_NFS: fsys_type_id[fsys_type_len - 1] = 14; break; case MOUNT_HFS: fsys_type_id[fsys_type_len - 1] = 7; break; case MOUNT_MFS: fsys_type_id[fsys_type_len - 1] = 8; break; case MOUNT_MSDOS: fsys_type_id[fsys_type_len - 1] = 5; break; case MOUNT_LFS: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_LOFS: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_FDESC: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_PORTAL: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_NULL: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_UMAP: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_KERNFS: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_PROCFS: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_AFS: fsys_type_id[fsys_type_len - 1] = 16; break; case MOUNT_CD9660: fsys_type_id[fsys_type_len - 1] = 12; break; case MOUNT_UNION: fsys_type_id[fsys_type_len - 1] = 1; break; case MOUNT_DEVFS: fsys_type_id[fsys_type_len - 1] = 1; break; #ifdef MOUNT_EXT2FS case MOUNT_EXT2FS: fsys_type_id[fsys_type_len - 1] = 23; break; #endif #ifdef MOUNT_TFS case MOUNT_TFS: fsys_type_id[fsys_type_len - 1] = 15; break; #endif } #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) switch (HRFS_entry->HRFS_type) { case MNT_AIX: case MNT_JFS: fsys_type_id[fsys_type_len - 1] = 3; break; case MNT_CDROM: fsys_type_id[fsys_type_len - 1] = 12; break; #ifdef MNT_NAMEFS case MNT_NAMEFS: #endif #ifdef MNT_PROCFS case MNT_PROCFS: #endif case MNT_SFS: case MNT_CACHEFS: fsys_type_id[fsys_type_len - 1] = 1; break; case MNT_NFS: case MNT_NFS3: case MNT_AUTOFS: fsys_type_id[fsys_type_len - 1] = 14; break; } #else mnt_type = HRFS_entry->HRFS_type; if (mnt_type == NULL) fsys_type_id[fsys_type_len - 1] = 2; /* unknown */ #ifdef MNTTYPE_HFS else if (!strcmp(mnt_type, MNTTYPE_HFS)) fsys_type_id[fsys_type_len - 1] = 7; #endif #ifdef MNTTYPE_UFS else if (!strcmp(mnt_type, MNTTYPE_UFS)) #if (defined(BerkelyFS) && !defined(MNTTYPE_HFS)) || defined(solaris2) fsys_type_id[fsys_type_len - 1] = 3; #else /* SysV */ fsys_type_id[fsys_type_len - 1] = 4; /* or 3? XXX */ #endif #endif #ifdef MNTTYPE_SYSV else if (!strcmp(mnt_type, MNTTYPE_SYSV)) fsys_type_id[fsys_type_len - 1] = 4; #endif #ifdef MNTTYPE_PC else if (!strcmp(mnt_type, MNTTYPE_PC)) fsys_type_id[fsys_type_len - 1] = 5; #endif #ifdef MNTTYPE_MSDOS else if (!strcmp(mnt_type, MNTTYPE_MSDOS)) fsys_type_id[fsys_type_len - 1] = 5; #endif #ifdef MNTTYPE_FAT32 else if (!strcmp(mnt_type, MNTTYPE_FAT32)) fsys_type_id[fsys_type_len - 1] = 22; #endif #ifdef MNTTYPE_CDFS else if (!strcmp(mnt_type, MNTTYPE_CDFS)) #ifdef RockRidge fsys_type_id[fsys_type_len - 1] = 13; #else /* ISO 9660 */ fsys_type_id[fsys_type_len - 1] = 12; #endif #endif #ifdef MNTTYPE_HSFS else if (!strcmp(mnt_type, MNTTYPE_HSFS)) fsys_type_id[fsys_type_len - 1] = 13; #endif #ifdef MNTTYPE_ISO9660 else if (!strcmp(mnt_type, MNTTYPE_ISO9660)) fsys_type_id[fsys_type_len - 1] = 12; #endif #ifdef MNTTYPE_CD9660 else if (!strcmp(mnt_type, MNTTYPE_CD9660)) fsys_type_id[fsys_type_len - 1] = 12; #endif #ifdef MNTTYPE_SMBFS else if (!strcmp(mnt_type, MNTTYPE_SMBFS)) fsys_type_id[fsys_type_len - 1] = 14; #endif #ifdef MNTTYPE_NFS else if (!strcmp(mnt_type, MNTTYPE_NFS)) fsys_type_id[fsys_type_len - 1] = 14; #endif #ifdef MNTTYPE_NFS3 else if (!strcmp(mnt_type, MNTTYPE_NFS3)) fsys_type_id[fsys_type_len - 1] = 14; #endif #ifdef MNTTYPE_NFS4 else if (!strcmp(mnt_type, MNTTYPE_NFS4)) fsys_type_id[fsys_type_len - 1] = 14; #endif #ifdef MNTTYPE_MFS else if (!strcmp(mnt_type, MNTTYPE_MFS)) fsys_type_id[fsys_type_len - 1] = 8; #endif #ifdef MNTTYPE_EXT2FS else if (!strcmp(mnt_type, MNTTYPE_EXT2FS)) fsys_type_id[fsys_type_len - 1] = 23; #endif #ifdef MNTTYPE_EXT3FS else if (!strcmp(mnt_type, MNTTYPE_EXT3FS)) fsys_type_id[fsys_type_len - 1] = 23; #endif #ifdef MNTTYPE_NTFS else if (!strcmp(mnt_type, MNTTYPE_NTFS)) fsys_type_id[fsys_type_len - 1] = 9; #endif else fsys_type_id[fsys_type_len - 1] = 1; /* Other */ #endif /* HAVE_GETFSSTAT */ } *var_len = sizeof(fsys_type_id); return (u_char *) fsys_type_id; case HRFSYS_ACCESS: #if defined(HAVE_STATVFS) && defined(__NetBSD__) long_return = HRFS_entry->f_flag & MNT_RDONLY ? 2 : 1; #elif defined(HAVE_GETFSSTAT) #if HAVE_STRUCT_STATFS_F_FLAGS long_return = HRFS_entry->f_flags & MNT_RDONLY ? 2 : 1; #else long_return = HRFS_entry->f_flag & MNT_RDONLY ? 2 : 1; #endif #elif defined(cygwin) long_return = 1; #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) long_return = (HRFS_entry->HRFS_flags & MNT_READONLY) == 0 ? 1 : 2; #else #if HAVE_HASMNTOPT if (hasmntopt(HRFS_entry, "ro") != NULL) long_return = 2; /* Read Only */ else #endif long_return = 1; /* Read-Write */ #endif return (u_char *) & long_return; case HRFSYS_BOOT: if (HRFS_entry->HRFS_mount[0] == '/' && HRFS_entry->HRFS_mount[1] == 0) long_return = 1; /* root is probably bootable! */ else long_return = 2; /* others probably aren't */ return (u_char *) & long_return; case HRFSYS_STOREIDX: long_return = fsys_idx + NETSNMP_MEM_TYPE_MAX; return (u_char *) & long_return; case HRFSYS_FULLDUMP: return when_dumped(HRFS_entry->HRFS_name, FULL_DUMP, var_len); case HRFSYS_PARTDUMP: return when_dumped(HRFS_entry->HRFS_name, PART_DUMP, var_len); default: DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrfilesys\n", vp->magic)); } return NULL; } /********************* * * Internal implementation functions * *********************/ static int HRFS_index; #ifndef HAVE_GETFSSTAT static FILE *fp; #endif void Init_HR_FileSys(void) { #if HAVE_GETFSSTAT #if defined(HAVE_STATVFS) && defined(__NetBSD__) fscount = getvfsstat(NULL, 0, ST_NOWAIT); #else fscount = getfsstat(NULL, 0, MNT_WAIT); #endif if (fsstats) free((char *) fsstats); fsstats = NULL; fsstats = malloc(fscount * sizeof(*fsstats)); #if defined(HAVE_STATVFS) && defined(__NetBSD__) getvfsstat(fsstats, fscount * sizeof(*fsstats), ST_NOWAIT); #else getfsstat(fsstats, fscount * sizeof(*fsstats), MNT_WAIT); #endif HRFS_index = 0; #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) int ret; uint size; ret = 0; size = 0; if(aixmnt != NULL) free(aixmnt); /* something leaks, make it idiot-safe */ aixmnt = NULL; aixcurr = NULL; HRFS_index = 0; ret = mntctl(MCTL_QUERY, sizeof(uint), &size); if(ret == 0 && size > 0) { aixmnt = malloc(size + sizeof(struct HRFS_entry)); if(aixmnt != NULL) { HRFS_entry = (char *) aixmnt + size; ret = mntctl(MCTL_QUERY, size, aixmnt); HRFS_index = 1; if(ret <= 0) { free(aixmnt); aixmnt = NULL; HRFS_entry = NULL; } else aixcurr = aixmnt; } } #else HRFS_index = 1; if (fp != NULL) fclose(fp); fp = fopen(ETC_MNTTAB, "r"); if (!fp) { netsnmp_config_error("Can't open mnttab %s\n", ETC_MNTTAB); } #endif } static const char *HRFS_ignores[] = { #ifdef MNTTYPE_IGNORE MNTTYPE_IGNORE, #endif #ifdef MNTTYPE_SWAP MNTTYPE_SWAP, #endif #ifdef MNTTYPE_PROC MNTTYPE_PROC, #endif #ifdef MNTTYPE_PROCFS MNTTYPE_PROCFS, #endif MNTTYPE_AUTOFS, #ifdef linux "bdev", "binfmt_misc", "cpuset", "debugfs", "devfs", "devpts", "eventpollfs", "futexfs", "hugetlbfs", "inotifyfs", "mqueue", "nfsd", "pipefs", "proc", "ramfs", "rootfs", "rpc_pipefs", "securityfs", "shm", "sockfs", "sysfs", "usbdevfs", "usbfs", #endif #ifdef solaris2 "mntfs", "proc", "fd", #endif NULL }; int Get_Next_HR_FileSys(void) { next: ; #if HAVE_GETFSSTAT if (HRFS_index >= fscount) return -1; HRFS_entry = fsstats + HRFS_index; return ++HRFS_index; #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) if(aixcurr == NULL) { if(aixmnt != NULL) free(aixmnt); aixmnt = NULL; HRFS_entry = NULL; return -1; } HRFS_entry->HRFS_name = vmt2dataptr(aixcurr, VMT_OBJECT); HRFS_entry->HRFS_mount = vmt2dataptr(aixcurr, VMT_STUB); HRFS_entry->HRFS_type = aixcurr->vmt_gfstype; HRFS_entry->HRFS_flags = aixcurr->vmt_flags; aixcurr = (char *) aixcurr + aixcurr->vmt_length; if((char *) aixcurr >= (char *) HRFS_entry) aixcurr = NULL; switch(HRFS_entry->HRFS_type) { #ifdef MNT_NAMEFS case MNT_NAMEFS: #endif #ifdef MNT_PROCFS case MNT_PROCFS: #endif case MNT_SFS: goto next; } return HRFS_index++; #else const char **cpp; if (fp == NULL) return -1; #ifdef solaris2 if (getmntent(fp, HRFS_entry) != 0) return -1; #else HRFS_entry = getmntent(fp); if (HRFS_entry == NULL) return -1; #endif /* solaris2 */ for (cpp = HRFS_ignores; *cpp != NULL; ++cpp) if (!strcmp(HRFS_entry->HRFS_type, *cpp)) goto next; /* * Try and ensure that index values are persistent * at least within a single run of the agent */ HRFS_index = se_find_value_in_slist("filesys", HRFS_entry->HRFS_name ); if (HRFS_index == SE_DNE) { HRFS_index = se_find_free_value_in_slist("filesys"); if (HRFS_index == SE_DNE) { HRFS_index = 1; } se_add_pair_to_slist( "filesys", strdup( HRFS_entry->HRFS_name ), HRFS_index); } return HRFS_index++; #endif /* HAVE_GETFSSTAT */ } /* * this function checks whether the current file system (info can be found * in HRFS_entry) is a NFS file system * HRFS_entry must be valid prior to calling this function * returns 1 if NFS file system, 0 otherwise */ int Check_HR_FileSys_NFS (void) { #if HAVE_GETFSSTAT && !defined(MFSNAMELEN) if ((HRFS_entry->HRFS_type == MOUNT_NFS) || (HRFS_entry->HRFS_type == MOUNT_AFS)) #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) if(HRFS_entry->HRFS_type == MNT_NFS || HRFS_entry->HRFS_type == MNT_NFS3) #else /* HAVE_GETFSSTAT */ if ( HRFS_entry->HRFS_type != NULL && ( #if defined(MNTTYPE_NFS) !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS) || #else !strcmp( HRFS_entry->HRFS_type, "nfs") || #endif #if defined(MNTTYPE_NFS3) !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS3) || #endif #if defined(MNTTYPE_NFS4) !strcmp( HRFS_entry->HRFS_type, MNTTYPE_NFS4) || #endif #if defined(MNTTYPE_SMBFS) !strcmp( HRFS_entry->HRFS_type, MNTTYPE_SMBFS) || #endif #if defined(MNTTYPE_LOFS) !strcmp( HRFS_entry->HRFS_type, MNTTYPE_LOFS) || #endif #if defined(MNTTYPE_AFP) !strcmp( HRFS_entry->HRFS_type, MNTTYPE_AFP) || #endif !strcmp( HRFS_entry->HRFS_type, "cifs") || /* * MVFS is Rational ClearCase's view file system * it is similiar to NFS file systems in that it is mounted * locally or remotely from the ClearCase server */ !strcmp( HRFS_entry->HRFS_type, "mvfs"))) #endif /* HAVE_GETFSSTAT */ return 1; /* NFS file system */ return 0; /* no NFS file system */ } /* This function checks whether current file system is an AutoFs * HRFS_entry must be valid prior to calling this function * return 1 if AutoFs, 0 otherwise */ int Check_HR_FileSys_AutoFs(void) { return HRFS_entry->HRFS_type && strcmp(HRFS_entry->HRFS_type, MNTTYPE_AUTOFS) == 0; } void End_HR_FileSys(void) { #ifdef HAVE_GETFSSTAT if (fsstats) free((char *) fsstats); fsstats = NULL; #elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7) if(aixmnt != NULL) { free(aixmnt); aixmnt = NULL; aixcurr = NULL; HRFS_entry = NULL; } #else if (fp != NULL) fclose(fp); fp = NULL; #endif } static u_char * when_dumped(char *filesys, int level, size_t * length) { time_t dumpdate = 0, tmp; FILE *dump_fp; char line[1024]; char *cp1, *cp2, *cp3; /* * Look for the relevent entries in /etc/dumpdates * * This is complicated by the fact that disks are * mounted using block devices, but dumps are * done via the raw character devices. * Thus the device names in /etc/dumpdates and * /etc/mnttab don't match. * These comparisons are therefore made using the * final portion of the device name only. */ if (*filesys == '\0') /* No filesystem name? */ return date_n_time(NULL, length); cp1 = strrchr(filesys, '/'); /* Find the last element of the current FS */ if (cp1 == NULL) cp1 = filesys; if ((dump_fp = fopen("/etc/dumpdates", "r")) == NULL) return date_n_time(NULL, length); while (fgets(line, sizeof(line), dump_fp) != NULL) { cp2 = strchr(line, ' '); /* Start by looking at the device name only */ if (cp2 != NULL) { *cp2 = '\0'; cp3 = strrchr(line, '/'); /* and find the last element */ if (cp3 == NULL) cp3 = line; if (strcmp(cp1, cp3) != 0) /* Wrong FS */ continue; ++cp2; while (isspace(*cp2 & 0xFF)) ++cp2; /* Now find the dump level */ if (level == FULL_DUMP) { if (*(cp2++) != '0') continue; /* Not interested in partial dumps */ while (isspace(*cp2 & 0xFF)) ++cp2; dumpdate = ctime_to_timet(cp2); fclose(dump_fp); return date_n_time(&dumpdate, length); } else { /* Partial Dump */ if (*(cp2++) == '0') continue; /* Not interested in full dumps */ while (isspace(*cp2 & 0xFF)) ++cp2; tmp = ctime_to_timet(cp2); if (tmp > dumpdate) dumpdate = tmp; /* Remember the 'latest' partial dump */ } } } fclose(dump_fp); return date_n_time(&dumpdate, length); } #define RAW_DEVICE_PREFIX "/dev/rdsk" #define COOKED_DEVICE_PREFIX "/dev/dsk" char * cook_device(char *dev) { static char cooked_dev[SNMP_MAXPATH+1]; if (!strncmp(dev, RAW_DEVICE_PREFIX, strlen(RAW_DEVICE_PREFIX))) { strlcpy(cooked_dev, COOKED_DEVICE_PREFIX, sizeof(cooked_dev)); strlcat(cooked_dev, dev + strlen(RAW_DEVICE_PREFIX), sizeof(cooked_dev)); } else { strlcpy(cooked_dev, dev, sizeof(cooked_dev)); } return cooked_dev; } int Get_FSIndex(char *dev) { int iindex; Init_HR_FileSys(); while ((iindex = Get_Next_HR_FileSys()) != -1) if (!strcmp(HRFS_entry->HRFS_name, cook_device(dev))) { End_HR_FileSys(); return iindex; } End_HR_FileSys(); return 0; } long Get_FSSize(char *dev) { struct HRFS_statfs statfs_buf; Init_HR_FileSys(); while (Get_Next_HR_FileSys() != -1) if (!strcmp(HRFS_entry->HRFS_name, cook_device(dev))) { End_HR_FileSys(); if (HRFS_statfs(HRFS_entry->HRFS_mount, &statfs_buf) != -1) /* * with large file systems the following calculation produces * an overflow: * (statfs_buf.f_blocks*statfs_buf.f_bsize)/1024 * * assumption: f_bsize is either 512 or a multiple of 1024 * in case of 512 (f_blocks/2) is returned * otherwise (f_blocks*(f_bsize/1024)) is returned */ #if defined(solaris2) && defined(HAVE_STRUCT_STATVFS_F_FRSIZE) return (statfs_buf.f_blocks*(statfs_buf.f_frsize/1024)); #else if (statfs_buf.f_bsize == 512) return (statfs_buf.f_blocks/2); else return (statfs_buf.f_blocks*(statfs_buf.f_bsize/1024)); #endif else return -1; } End_HR_FileSys(); return 0; }