qstorageinfo_p.h

Go to the documentation of this file.

// Copyright (C) 2014 Ivan Komissarov <ABBAPOH@gmail.com>
// 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
 
#ifndef QSTORAGEINFO_P_H
#define QSTORAGEINFO_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtCore/qloggingcategory.h>
#include <QtCore/qsystemdetection.h>
#include <QtCore/qtenvironmentvariables.h>
#include <QtCore/private/qglobal_p.h>
#include "qstorageinfo.h"
 
#ifdef Q_OS_UNIX
#include <sys/types.h> // dev_t
#endif
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(lcStorageInfo)
 
class QStorageInfoPrivate : public QSharedData
{
public:
    QStorageInfoPrivate() = default;
 
    void doStat();
 
    static QList<QStorageInfo> mountedVolumes();
 
    static QStorageInfo root()
    {
#ifdef Q_OS_WIN
        return QStorageInfo(QDir::fromNativeSeparators(QFile::decodeName(qgetenv("SystemDrive"))));
#else
        return QStorageInfo(QStringLiteral("/"));
#endif
    }
 
protected:
#if defined(Q_OS_WIN)
    void initRootPath();
    void retrieveVolumeInfo();
    void retrieveDiskFreeSpace();
    bool queryStorageProperty();
    void queryFileFsSectorSizeInformation();
#elif defined(Q_OS_DARWIN)
    void initRootPath();
    void retrievePosixInfo();
    void retrieveUrlProperties(bool initRootPath = false);
    void retrieveLabel();
#elif defined(Q_OS_LINUX)
    void retrieveVolumeInfo();
 
public:
    struct MountInfo {
        QString mountPoint;
        QByteArray fsType;
        QByteArray device;
        QByteArray fsRoot;
        dev_t stDev = 0;
        quint64 mntid = 0;
    };
 
    void setFromMountInfo(MountInfo &&info)
    {
        rootPath = std::move(info.mountPoint);
        fileSystemType = std::move(info.fsType);
        device = std::move(info.device);
        subvolume = std::move(info.fsRoot);
    }
 
    explicit QStorageInfoPrivate(MountInfo &&info)
    {
        setFromMountInfo(std::move(info));
    }
 
#elif defined(Q_OS_UNIX)
    void initRootPath();
    void retrieveVolumeInfo();
#endif
 
#ifdef Q_OS_UNIX
    // Common helper functions
    template <typename String>
    static bool isParentOf(const String &parent, const QString &dirName)
    {
        return dirName.startsWith(parent) &&
                (dirName.size() == parent.size() || dirName.at(parent.size()) == u'/' ||
                 parent.size() == 1);
    }
    static inline bool shouldIncludeFs(const QString &mountDir, const QByteArray &fsType);
#endif
 
public:
    QString rootPath;
    QByteArray device;
    QByteArray subvolume;
    QByteArray fileSystemType;
    QString name;
 
    qint64 bytesTotal = -1;
    qint64 bytesFree = -1;
    qint64 bytesAvailable = -1;
    int blockSize = -1;
 
    bool readOnly = false;
    bool ready = false;
    bool valid = false;
};
 
#ifdef Q_OS_UNIX
bool QStorageInfoPrivate::shouldIncludeFs(const QString &mountDir, const QByteArray &fsType)
{
#if defined(Q_OS_ANDROID)
    // "rootfs" is the filesystem type of "/" on Android
    static constexpr char RootFsStr[] = "";
#else
    // "rootfs" is a type of ramfs on Linux, used in the initrd on some distros
    static constexpr char RootFsStr[] = "rootfs";
#endif
 
    using namespace Qt::StringLiterals;
    /*
     * This function implements a heuristic algorithm to determine whether a
     * given mount should be reported to the user. Our objective is to list
     * only entries that the end-user would find useful.
     *
     * We therefore ignore:
     *  - mounted in /dev, /proc, /sys: special mounts
     *    (this will catch /sys/fs/cgroup, /proc/sys/fs/binfmt_misc, /dev/pts,
     *    some of which are tmpfs on Linux)
     *  - mounted in /var/run or /var/lock: most likely pseudofs
     *    (on earlier systemd versions, /var/run was a bind-mount of /run, so
     *    everything would be unnecessarily duplicated)
     *  - filesystem type is "rootfs": artifact of the root-pivot on some Linux
     *    initrd
     *  - if the filesystem total size is zero, it's a pseudo-fs (not checked here).
     */
 
    if (isParentOf("/dev"_L1, mountDir)
        || isParentOf("/proc"_L1, mountDir)
        || isParentOf("/sys"_L1, mountDir)
        || isParentOf("/var/run"_L1, mountDir)
        || isParentOf("/var/lock"_L1, mountDir)) {
        return false;
    }
 
    if (!fsType.isEmpty() && fsType == RootFsStr)
        return false;
 
    // size checking in QStorageInfo::mountedVolumes()
    return true;
}
#endif // Q_OS_UNIX
 
QT_END_NAMESPACE
 
#endif // QSTORAGEINFO_P_H