/* A file system is `remote' if its Fs_name contains a `:'
or if (it is of type (smbfs or cifs) and its Fs_name starts with `//'). */
# define ME_REMOTE(Fs_name, Fs_type) \
(strchr (Fs_name, ':') != NULL \
|| ((Fs_name)[0] == '/' \
&& (Fs_name)[1] == '/' \
&& (strcmp (Fs_type, "smbfs") == 0 \
|| strcmp (Fs_type, "cifs") == 0)))
#endif
#endif // HAIKU / BEOS
#ifdef MOUNTED_GETMNTINFO
# if ! HAVE_STRUCT_STATFS_F_FSTYPENAME
static char *
fstype_to_string (short int t)
{
switch (t)
{
# ifdef MOUNT_PC
case MOUNT_PC:
return "pc";
# endif
# ifdef MOUNT_MFS
case MOUNT_MFS:
return "mfs";
# endif
# ifdef MOUNT_LO
case MOUNT_LO:
return "lo";
# endif
# ifdef MOUNT_TFS
case MOUNT_TFS:
return "tfs";
# endif
# ifdef MOUNT_TMP
case MOUNT_TMP:
return "tmp";
# endif
# ifdef MOUNT_UFS
case MOUNT_UFS:
return "ufs" ;
# endif
# ifdef MOUNT_NFS
case MOUNT_NFS:
return "nfs" ;
# endif
# ifdef MOUNT_MSDOS
case MOUNT_MSDOS:
return "msdos" ;
# endif
# ifdef MOUNT_LFS
case MOUNT_LFS:
return "lfs" ;
# endif
# ifdef MOUNT_LOFS
case MOUNT_LOFS:
return "lofs" ;
# endif
# ifdef MOUNT_FDESC
case MOUNT_FDESC:
return "fdesc" ;
# endif
# ifdef MOUNT_PORTAL
case MOUNT_PORTAL:
return "portal" ;
# endif
# ifdef MOUNT_NULL
case MOUNT_NULL:
return "null" ;
# endif
# ifdef MOUNT_UMAP
case MOUNT_UMAP:
return "umap" ;
# endif
# ifdef MOUNT_KERNFS
case MOUNT_KERNFS:
return "kernfs" ;
# endif
# ifdef MOUNT_PROCFS
case MOUNT_PROCFS:
return "procfs" ;
# endif
# ifdef MOUNT_AFS
case MOUNT_AFS:
return "afs" ;
# endif
# ifdef MOUNT_CD9660
case MOUNT_CD9660:
return "cd9660" ;
# endif
# ifdef MOUNT_UNION
case MOUNT_UNION:
return "union" ;
# endif
# ifdef MOUNT_DEVFS
case MOUNT_DEVFS:
return "devfs" ;
# endif
# ifdef MOUNT_EXT2FS
case MOUNT_EXT2FS:
return "ext2fs" ;
# endif
default:
return "?";
}
}
# endif
static char *
fsp_to_string (const struct statfs *fsp)
{
# if HAVE_STRUCT_STATFS_F_FSTYPENAME
return (char *) (fsp->f_fstypename);
# else
return fstype_to_string (fsp->f_type);
# endif
}
#endif /* MOUNTED_GETMNTINFO */
#ifdef MOUNTED_VMOUNT /* AIX. */
static char *
fstype_to_string (int t)
{
struct vfs_ent *e;
e = getvfsbytype (t);
if (!e || !e->vfsent_name)
return "none";
else
return e->vfsent_name;
}
static const char *zbx_get_vfs_name_by_type(int type)
{
extern struct vfs_ent *getvfsbytype(int type);
struct vfs_ent *vfs;
static char *vfs_names[MNT_AIXLAST + 1] = {};
if (NULL == vfs_names[type] && NULL != (vfs = getvfsbytype(type)))
vfs_names[type] = zbx_strdup(vfs_names[type], vfs->vfsent_name);
return NULL != vfs_names[type] ? vfs_names[type] : "unknown";
}
KMountPoint::List KMountPoint::currentMountPoints(int infoNeeded)
{
KMountPoint::List result;
#ifdef HAVE_GETMNTINFO
#ifdef GETMNTINFO_USES_STATVFS
struct statvfs *mounted;
#else
struct statfs *mounted;
#endif
int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
for (int i=0;i<num_fs;i++)
{
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(mounted[i].f_mntfromname);
mp->m_mountPoint = TQFile::decodeName(mounted[i].f_mntonname);
#ifdef __osf__
mp->m_mountType = TQFile::decodeName(mnt_names[mounted[i].f_type]);
#else
mp->m_mountType = TQFile::decodeName(mounted[i].f_fstypename);
#endif
if (infoNeeded & NeedMountOptions)
{
struct fstab *ft = getfsfile(mounted[i].f_mntonname);
TQString options = TQFile::decodeName(ft->fs_mntops);
mp->m_mountOptions = TQStringList::split(',', options);
}
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
// TODO: Strip trailing '/' ?
result.append(mp);
}
#elif defined(_AIX)
struct vmount *mntctl_buffer;
struct vmount *vm;
char *mountedfrom;
char *mountedto;
int fsname_len, num;
int buf_sz = 4096;
mntctl_buffer = (struct vmount*)malloc(buf_sz);
num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
if (num == 0)
{
buf_sz = *(int*)mntctl_buffer;
free(mntctl_buffer);
mntctl_buffer = (struct vmount*)malloc(buf_sz);
num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
}
if (num > 0)
{
/* iterate through items in the vmount structure: */
vm = (struct vmount *)mntctl_buffer;
for ( ; num > 0; num-- )
{
/* get the name of the mounted file systems: */
fsname_len = vmt2datasize(vm, VMT_STUB);
mountedto = (char*)malloc(fsname_len + 1);
mountedto[fsname_len] = '\0';
strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
fsname_len = vmt2datasize(vm, VMT_OBJECT);
mountedfrom = (char*)malloc(fsname_len + 1);
mountedfrom[fsname_len] = '\0';
strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
/* Look up the string for the file system type,
* as listed in /etc/vfs.
* ex.: nfs,jfs,afs,cdrfs,sfs,cachefs,nfs3,autofs
*/
struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype);
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(mountedfrom);
mp->m_mountPoint = TQFile::decodeName(mountedto);
mp->m_mountType = TQFile::decodeName(ent->vfsent_name);
free(mountedfrom);
free(mountedto);
if (infoNeeded & NeedMountOptions)
{
// TODO
}
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
result.append(mp);
/* goto the next vmount structure: */
vm = (struct vmount *)((char *)vm + vm->vmt_length);
}
endvfsent( );
}
free( mntctl_buffer );
#elif defined(Q_WS_WIN)
//TODO?
#else
STRUCT_SETMNTENT mnttab;
if ((mnttab = SETMNTENT(MNTTAB, "r")) == 0)
return result;
STRUCT_MNTENT fe;
while (GETMNTENT(mnttab, fe))
{
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(FSNAME(fe));
mp->m_mountPoint = TQFile::decodeName(MOUNTPOINT(fe));
mp->m_mountType = TQFile::decodeName(MOUNTTYPE(fe));
//Devices using supermount have their device names in the mount options
//instead of the device field. That's why we need to read the mount options
if (infoNeeded & NeedMountOptions || (mp->m_mountType == "supermount"))
{
TQString options = TQFile::decodeName(MOUNTOPTIONS(fe));
mp->m_mountOptions = TQStringList::split(',', options);
}
if (mp->m_mountType == "supermount")
mp->m_mountedFrom = devNameFromOptions(mp->m_mountOptions);
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
// TODO: Strip trailing '/' ?
result.append(mp);
}
ENDMNTENT(mnttab);
#endif
return result;
}
/**
* OS specific function to load the different mntents into the cache.
* This function should be called with a write lock on the mntent_cache.
*/
static void refresh_mount_cache(mntent_cache_entry_t *handle_entry(uint32_t dev,
const char *special,
const char *mountpoint,
const char *fstype,
const char *mntopts))
{
#if defined(HAVE_GETMNTENT)
FILE *fp;
struct stat st;
#if defined(HAVE_LINUX_OS) || \
defined(HAVE_HPUX_OS) || \
defined(HAVE_IRIX_OS) || \
defined(HAVE_AIX_OS) || \
defined(HAVE_HURD_OS)
struct mntent *mnt;
#if defined(HAVE_LINUX_OS)
if ((fp = setmntent("/proc/mounts", "r")) == (FILE *)NULL) {
if ((fp = setmntent(_PATH_MOUNTED, "r")) == (FILE *)NULL) {
return;
}
}
#elif defined(HAVE_HPUX_OS)
if ((fp = fopen(MNT_MNTTAB, "r")) == (FILE *)NULL) {
return;
}
#elif defined(HAVE_IRIX_OS)
if ((fp = setmntent(MOUNTED, "r")) == (FILE *)NULL) {
return;
}
#elif defined(HAVE_AIX_OS)
if ((fp = setmntent(MNTTAB, "r")) == (FILE *)NULL) {
return;
}
#elif defined(HAVE_HURD_OS)
if ((fp = setmntent(_PATH_MNTTAB, "r")) == (FILE *)NULL) {
return;
}
#endif
while ((mnt = getmntent(fp)) != (struct mntent *)NULL) {
if (skip_fstype(mnt->mnt_type)) {
continue;
}
if (stat(mnt->mnt_dir, &st) < 0) {
continue;
}
handle_entry(st.st_dev,
mnt->mnt_fsname,
mnt->mnt_dir,
mnt->mnt_type,
mnt->mnt_opts);
}
endmntent(fp);
#elif defined(HAVE_SUN_OS)
struct mnttab mnt;
if ((fp = fopen(MNTTAB, "r")) == (FILE *)NULL)
return;
while (getmntent(fp, &mnt) == 0) {
if (skip_fstype(mnt.mnt_fstype)) {
continue;
}
if (stat(mnt.mnt_mountp, &st) < 0) {
continue;
}
handle_entry(st.st_dev,
mnt.mnt_special,
mnt.mnt_mountp,
mnt.mnt_fstype,
mnt.mnt_mntopts);
}
fclose(fp);
#endif /* HAVE_SUN_OS */
#elif defined(HAVE_GETMNTINFO)
int cnt;
struct stat st;
#if defined(HAVE_NETBSD_OS)
struct statvfs *mntinfo;
#else
struct statfs *mntinfo;
#endif
#if defined(ST_NOWAIT)
int flags = ST_NOWAIT;
#elif defined(MNT_NOWAIT)
int flags = MNT_NOWAIT;
#else
int flags = 0;
#endif
if ((cnt = getmntinfo(&mntinfo, flags)) > 0) {
while (cnt > 0) {
if (!skip_fstype(mntinfo->f_fstypename) &&
stat(mntinfo->f_mntonname, &st) == 0) {
handle_entry(st.st_dev,
mntinfo->f_mntfromname,
mntinfo->f_mntonname,
mntinfo->f_fstypename,
NULL);
}
mntinfo++;
cnt--;
}
}
#elif defined(HAVE_AIX_OS)
int bufsize;
char *entries, *current;
struct vmount *vmp;
struct stat st;
struct vfs_ent *ve;
int n_entries, cnt;
if (mntctl(MCTL_QUERY, sizeof(bufsize), (struct vmount *)&bufsize) != 0) {
return;
}
entries = malloc(bufsize);
if ((n_entries = mntctl(MCTL_QUERY, bufsize, (struct vmount *) entries)) < 0) {
free(entries);
return;
}
cnt = 0;
current = entries;
while (cnt < n_entries) {
vmp = (struct vmount *)current;
if (skip_fstype(ve->vfsent_name)) {
continue;
}
if (stat(current + vmp->vmt_data[VMT_STUB].vmt_off, &st) < 0) {
continue;
}
ve = getvfsbytype(vmp->vmt_gfstype);
if (ve && ve->vfsent_name) {
handle_entry(st.st_dev,
current + vmp->vmt_data[VMT_OBJECT].vmt_off,
current + vmp->vmt_data[VMT_STUB].vmt_off,
ve->vfsent_name,
current + vmp->vmt_data[VMT_ARGS].vmt_off);
}
current = current + vmp->vmt_length;
cnt++;
}
free(entries);
#elif defined(HAVE_OSF1_OS)
struct statfs *entries, *current;
struct stat st;
int n_entries, cnt;
int size;
if ((n_entries = getfsstat((struct statfs *)0, 0L, MNT_NOWAIT)) < 0) {
return;
}
size = (n_entries + 1) * sizeof(struct statfs);
entries = malloc(size);
if ((n_entries = getfsstat(entries, size, MNT_NOWAIT)) < 0) {
free(entries);
return;
}
cnt = 0;
current = entries;
while (cnt < n_entries) {
if (skip_fstype(current->f_fstypename)) {
continue;
}
if (stat(current->f_mntonname, &st) < 0) {
continue;
}
handle_entry(st.st_dev,
current->f_mntfromname,
current->f_mntonname,
current->f_fstypename,
NULL);
current++;
cnt++;
}
free(stats);
#endif
}
