Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2014 Ivan Komissarov <ABBAPOH@gmail.com>
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qstorageinfo_p.h"
#include <QtCore/qfileinfo.h>
#include <QtCore/qtextstream.h>
#include <QtCore/private/qcore_unix_p.h>
#include <QtCore/private/qlocale_tools_p.h>
#include <errno.h>
#include <sys/stat.h>
#if defined(Q_OS_BSD4)
# include <sys/mount.h>
# include <sys/statvfs.h>
#elif defined(Q_OS_HURD)
# include <mntent.h>
# include <sys/statvfs.h>
# include <sys/sysmacros.h>
#elif defined(Q_OS_SOLARIS)
# include <sys/mnttab.h>
# include <sys/statvfs.h>
#elif defined(Q_OS_HAIKU)
# include <Directory.h>
# include <Path.h>
# include <Volume.h>
# include <VolumeRoster.h>
# include <fs_info.h>
# include <sys/statvfs.h>
#else
# include <sys/statvfs.h>
#endif
#if defined(Q_OS_BSD4)
# if defined(Q_OS_NETBSD)
# define QT_STATFSBUF struct statvfs
# define QT_STATFS ::statvfs
# else
# define QT_STATFSBUF struct statfs
# define QT_STATFS ::statfs
# endif
# if !defined(ST_RDONLY)
# define ST_RDONLY MNT_RDONLY
# endif
# if !defined(_STATFS_F_FLAGS) && !defined(Q_OS_NETBSD)
# define _STATFS_F_FLAGS 1
# endif
#elif defined(Q_OS_HAIKU) || defined(Q_OS_CYGWIN)
# define QT_STATFSBUF struct statvfs
# define QT_STATFS ::statvfs
#else
# if defined(QT_LARGEFILE_SUPPORT)
# define QT_STATFSBUF struct statvfs64
# define QT_STATFS ::statvfs64
# else
# define QT_STATFSBUF struct statvfs
# define QT_STATFS ::statvfs
# endif // QT_LARGEFILE_SUPPORT
#endif // Q_OS_BSD4
#if __has_include(<paths.h>)
# include <paths.h>
#endif
#ifndef _PATH_MOUNTED
# define _PATH_MOUNTED "/etc/mnttab"
#endif
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
class QStorageIterator
{
public:
QStorageIterator();
~QStorageIterator();
inline bool isValid() const;
inline bool next();
inline QString rootPath() const;
inline QByteArray fileSystemType() const;
inline QByteArray device() const;
inline QByteArray options() const;
inline QByteArray subvolume() const;
private:
#if defined(Q_OS_BSD4)
QT_STATFSBUF *stat_buf;
int entryCount;
int currentIndex;
#elif defined(Q_OS_SOLARIS)
FILE *fp;
mnttab mnt;
#elif defined(Q_OS_HURD)
FILE *fp;
QByteArray buffer;
struct mntent mnt;
#elif defined(Q_OS_HAIKU)
BVolumeRoster m_volumeRoster;
QByteArray m_rootPath;
QByteArray m_fileSystemType;
QByteArray m_device;
#endif
};
#if defined(Q_OS_BSD4)
#ifndef MNT_NOWAIT
# define MNT_NOWAIT 0
#endif
inline QStorageIterator::QStorageIterator()
: entryCount(::getmntinfo(&stat_buf, MNT_NOWAIT)),
currentIndex(-1)
{
}
inline QStorageIterator::~QStorageIterator()
{
}
inline bool QStorageIterator::isValid() const
{
return entryCount != -1;
}
inline bool QStorageIterator::next()
{
return ++currentIndex < entryCount;
}
inline QString QStorageIterator::rootPath() const
{
return QFile::decodeName(stat_buf[currentIndex].f_mntonname);
}
inline QByteArray QStorageIterator::fileSystemType() const
{
return QByteArray(stat_buf[currentIndex].f_fstypename);
}
inline QByteArray QStorageIterator::device() const
{
return QByteArray(stat_buf[currentIndex].f_mntfromname);
}
inline QByteArray QStorageIterator::options() const
{
return QByteArray();
}
inline QByteArray QStorageIterator::subvolume() const
{
return QByteArray();
}
#elif defined(Q_OS_SOLARIS)
inline QStorageIterator::QStorageIterator()
{
const int fd = qt_safe_open(_PATH_MOUNTED, O_RDONLY);
fp = ::fdopen(fd, "r");
}
inline QStorageIterator::~QStorageIterator()
{
if (fp)
::fclose(fp);
}
inline bool QStorageIterator::isValid() const
{
return fp != nullptr;
}
inline bool QStorageIterator::next()
{
return ::getmntent(fp, &mnt) == 0;
}
inline QString QStorageIterator::rootPath() const
{
return QFile::decodeName(mnt.mnt_mountp);
}
inline QByteArray QStorageIterator::fileSystemType() const
{
return QByteArray(mnt.mnt_fstype);
}
inline QByteArray QStorageIterator::device() const
{
return QByteArray(mnt.mnt_mntopts);
}
inline QByteArray QStorageIterator::subvolume() const
{
return QByteArray();
}
#elif defined(Q_OS_HURD)
static const int bufferSize = 1024; // 2 paths (mount point+device) and metainfo;
// should be enough
inline QStorageIterator::QStorageIterator() :
buffer(QByteArray(bufferSize, 0))
{
fp = ::setmntent(_PATH_MOUNTED, "r");
}
inline QStorageIterator::~QStorageIterator()
{
if (fp)
::endmntent(fp);
}
inline bool QStorageIterator::isValid() const
{
return fp != nullptr;
}
inline bool QStorageIterator::next()
{
return ::getmntent_r(fp, &mnt, buffer.data(), buffer.size()) != nullptr;
}
inline QString QStorageIterator::rootPath() const
{
return QFile::decodeName(mnt.mnt_dir);
}
inline QByteArray QStorageIterator::fileSystemType() const
{
return QByteArray(mnt.mnt_type);
}
inline QByteArray QStorageIterator::device() const
{
return QByteArray(mnt.mnt_fsname);
}
inline QByteArray QStorageIterator::options() const
{
return QByteArray(mnt.mnt_opts);
}
inline QByteArray QStorageIterator::subvolume() const
{
return QByteArray();
}
#elif defined(Q_OS_HAIKU)
inline QStorageIterator::QStorageIterator()
{
}
inline QStorageIterator::~QStorageIterator()
{
}
inline bool QStorageIterator::isValid() const
{
return true;
}
inline bool QStorageIterator::next()
{
BVolume volume;
if (m_volumeRoster.GetNextVolume(&volume) != B_OK)
return false;
BDirectory directory;
if (volume.GetRootDirectory(&directory) != B_OK)
return false;
const BPath path(&directory);
fs_info fsInfo;
memset(&fsInfo, 0, sizeof(fsInfo));
if (fs_stat_dev(volume.Device(), &fsInfo) != 0)
return false;
m_rootPath = path.Path();
m_fileSystemType = QByteArray(fsInfo.fsh_name);
const QByteArray deviceName(fsInfo.device_name);
m_device = (deviceName.isEmpty() ? QByteArray::number(qint32(volume.Device())) : deviceName);
return true;
}
inline QString QStorageIterator::rootPath() const
{
return QFile::decodeName(m_rootPath);
}
inline QByteArray QStorageIterator::fileSystemType() const
{
return m_fileSystemType;
}
inline QByteArray QStorageIterator::device() const
{
return m_device;
}
inline QByteArray QStorageIterator::options() const
{
return QByteArray();
}
inline QByteArray QStorageIterator::subvolume() const
{
return QByteArray();
}
#else
inline QStorageIterator::QStorageIterator()
{
}
inline QStorageIterator::~QStorageIterator()
{
}
inline bool QStorageIterator::isValid() const
{
return false;
}
inline bool QStorageIterator::next()
{
return false;
}
inline QString QStorageIterator::rootPath() const
{
return QString();
}
inline QByteArray QStorageIterator::fileSystemType() const
{
return QByteArray();
}
inline QByteArray QStorageIterator::device() const
{
return QByteArray();
}
inline QByteArray QStorageIterator::options() const
{
return QByteArray();
}
inline QByteArray QStorageIterator::subvolume() const
{
return QByteArray();
}
#endif
static inline QString retrieveLabel(const QByteArray &device)
{
#if defined Q_OS_HAIKU
fs_info fsInfo;
memset(&fsInfo, 0, sizeof(fsInfo));
int32 pos = 0;
dev_t dev;
while ((dev = next_dev(&pos)) >= 0) {
if (fs_stat_dev(dev, &fsInfo) != 0)
continue;
if (qstrcmp(fsInfo.device_name, device.constData()) == 0)
return QString::fromLocal8Bit(fsInfo.volume_name);
}
#else
Q_UNUSED(device);
#endif
return QString();
}
void QStorageInfoPrivate::doStat()
{
valid = ready = false;
initRootPath();
if (rootPath.isEmpty())
return;
retrieveVolumeInfo();
name = retrieveLabel(device);
}
void QStorageInfoPrivate::retrieveVolumeInfo()
{
QT_STATFSBUF statfs_buf;
int result;
QT_EINTR_LOOP(result, QT_STATFS(QFile::encodeName(rootPath).constData(), &statfs_buf));
valid = ready = (result == 0);
if (valid) {
#if defined(Q_OS_INTEGRITY) || (defined(Q_OS_BSD4) && !defined(Q_OS_NETBSD)) || defined(Q_OS_RTEMS)
bytesTotal = statfs_buf.f_blocks * statfs_buf.f_bsize;
bytesFree = statfs_buf.f_bfree * statfs_buf.f_bsize;
bytesAvailable = statfs_buf.f_bavail * statfs_buf.f_bsize;
#else
bytesTotal = statfs_buf.f_blocks * statfs_buf.f_frsize;
bytesFree = statfs_buf.f_bfree * statfs_buf.f_frsize;
bytesAvailable = statfs_buf.f_bavail * statfs_buf.f_frsize;
#endif
blockSize = int(statfs_buf.f_bsize);
#if defined(Q_OS_ANDROID) || defined(Q_OS_BSD4) || defined(Q_OS_INTEGRITY) || defined(Q_OS_RTEMS)
#if defined(_STATFS_F_FLAGS)
readOnly = (statfs_buf.f_flags & ST_RDONLY) != 0;
#endif
#else
readOnly = (statfs_buf.f_flag & ST_RDONLY) != 0;
#endif
}
}
void QStorageInfoPrivate::initRootPath()
{
rootPath = QFileInfo(rootPath).canonicalFilePath();
if (rootPath.isEmpty())
return;
QStorageIterator it;
if (!it.isValid()) {
rootPath = QStringLiteral("/");
return;
}
int maxLength = 0;
const QString oldRootPath = rootPath;
rootPath.clear();
while (it.next()) {
const QString mountDir = it.rootPath();
const QByteArray fsName = it.fileSystemType();
// we try to find most suitable entry
if (maxLength < mountDir.size() && isParentOf(mountDir, oldRootPath)) {
maxLength = mountDir.size();
rootPath = mountDir;
device = it.device();
fileSystemType = fsName;
subvolume = it.subvolume();
}
}
}
QList<QStorageInfo> QStorageInfoPrivate::mountedVolumes()
{
QStorageIterator it;
if (!it.isValid())
return QList<QStorageInfo>() << root();
QList<QStorageInfo> volumes;
while (it.next()) {
if (!shouldIncludeFs(it.rootPath(), it.fileSystemType()))
continue;
const QString mountDir = it.rootPath();
QStorageInfo info(mountDir);
info.d->device = it.device();
info.d->fileSystemType = it.fileSystemType();
info.d->subvolume = it.subvolume();
if (info.bytesTotal() <= 0 && info != root())
continue;
volumes.append(info);
}
return volumes;
}
QT_END_NAMESPACE