1064 lines
34 KiB
C++
1064 lines
34 KiB
C++
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
*
|
|
* Copyright (C) 2007 by Dominik Wenger
|
|
*
|
|
* All files in this archive are subject to the GNU General Public License.
|
|
* See the file COPYING in the source tree root for full license agreement.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "utils.h"
|
|
#include "rockboxinfo.h"
|
|
#include "system.h"
|
|
#include "rbsettings.h"
|
|
#include "playerbuildinfo.h"
|
|
#include "Logger.h"
|
|
|
|
#if !defined(_UNICODE)
|
|
#define _UNICODE
|
|
#endif
|
|
|
|
#include <QtCore>
|
|
#include <QDebug>
|
|
#include <cstdlib>
|
|
#include <stdio.h>
|
|
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
|
|
#include <sys/statvfs.h>
|
|
#endif
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
|
|
#include <stdio.h>
|
|
#endif
|
|
#if defined(Q_OS_LINUX)
|
|
#include <mntent.h>
|
|
#endif
|
|
#if defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
|
|
#include <sys/param.h>
|
|
#include <sys/ucred.h>
|
|
#include <sys/mount.h>
|
|
#endif
|
|
#if defined(Q_OS_WIN32)
|
|
#include <stdio.h>
|
|
#include <tchar.h>
|
|
#include <windows.h>
|
|
#include <setupapi.h>
|
|
#include <winioctl.h>
|
|
#include <tlhelp32.h>
|
|
#endif
|
|
#if defined(Q_OS_MACX)
|
|
#include <Carbon/Carbon.h>
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <CoreServices/CoreServices.h>
|
|
#include <IOKit/IOKitLib.h>
|
|
#endif
|
|
|
|
// recursive function to delete a dir with files
|
|
bool Utils::recursiveRmdir( const QString &dirName )
|
|
{
|
|
QString dirN = dirName;
|
|
QDir dir(dirN);
|
|
// make list of entries in directory
|
|
QStringList list = dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot);
|
|
QFileInfo fileInfo;
|
|
QString curItem;
|
|
for(int i = 0; i < list.size(); i++){ // loop through all items of list
|
|
QString name = list.at(i);
|
|
curItem = dirN + "/" + name;
|
|
fileInfo.setFile(curItem);
|
|
if(fileInfo.isDir()) // is directory
|
|
recursiveRmdir(curItem); // call recRmdir() recursively for
|
|
// deleting subdirectory
|
|
else // is file
|
|
QFile::remove(curItem); // ok, delete file
|
|
}
|
|
dir.cdUp();
|
|
return dir.rmdir(dirN); // delete empty dir and return if (now empty)
|
|
// dir-removing was successfull
|
|
}
|
|
|
|
|
|
//! @brief resolves the given path, ignoring case.
|
|
//! @param path absolute path to resolve.
|
|
//! @return returns exact casing of path, empty string if path not found.
|
|
QString Utils::resolvePathCase(QString path)
|
|
{
|
|
int start;
|
|
QString realpath;
|
|
#if QT_VERSION >= 0x050e00
|
|
QStringList elems = path.split("/", Qt::SkipEmptyParts);
|
|
#else
|
|
QStringList elems = path.split("/", QString::SkipEmptyParts);
|
|
#endif
|
|
|
|
if(path.isEmpty())
|
|
return QString();
|
|
#if defined(Q_OS_WIN32)
|
|
// on windows we must make sure to start with the first entry (i.e. the
|
|
// drive letter) instead of a single / to make resolving work.
|
|
start = 1;
|
|
realpath = elems.at(0) + "/";
|
|
#else
|
|
start = 0;
|
|
realpath = "/";
|
|
#endif
|
|
|
|
for(int i = start; i < elems.size(); i++) {
|
|
QStringList direlems
|
|
= QDir(realpath).entryList(QDir::AllEntries|QDir::Hidden|QDir::System);
|
|
if(direlems.contains(elems.at(i), Qt::CaseInsensitive)) {
|
|
// need to filter using QRegExp as QStringList::filter(QString)
|
|
// matches any substring
|
|
QString expr = QString("^" + elems.at(i) + "$");
|
|
QRegularExpression rx = QRegularExpression(expr,
|
|
QRegularExpression::CaseInsensitiveOption);
|
|
QStringList a = direlems.filter(rx);
|
|
|
|
if(a.size() != 1)
|
|
return QString("");
|
|
if(!realpath.endsWith("/"))
|
|
realpath += "/";
|
|
realpath += a.at(0);
|
|
}
|
|
else
|
|
return QString("");
|
|
}
|
|
LOG_INFO() << "resolving path" << path << "->" << realpath;
|
|
return realpath;
|
|
}
|
|
|
|
|
|
QString Utils::filesystemType(QString path)
|
|
{
|
|
#if defined(Q_OS_LINUX)
|
|
FILE *mn = setmntent("/etc/mtab", "r");
|
|
if(!mn)
|
|
return QString("");
|
|
|
|
struct mntent *ent;
|
|
while((ent = getmntent(mn))) {
|
|
if(QString(ent->mnt_dir) == path) {
|
|
endmntent(mn);
|
|
LOG_INFO() << "device type is" << ent->mnt_type;
|
|
return QString(ent->mnt_type);
|
|
}
|
|
}
|
|
endmntent(mn);
|
|
#endif
|
|
|
|
#if defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
|
|
int num;
|
|
struct statfs *mntinf;
|
|
|
|
num = getmntinfo(&mntinf, MNT_WAIT);
|
|
while(num--) {
|
|
if(QString(mntinf->f_mntonname) == path) {
|
|
LOG_INFO() << "device type is" << mntinf->f_fstypename;
|
|
return QString(mntinf->f_fstypename);
|
|
}
|
|
mntinf++;
|
|
}
|
|
#endif
|
|
|
|
#if defined(Q_OS_WIN32)
|
|
wchar_t t[64];
|
|
memset(t, 0, 32);
|
|
if(GetVolumeInformationW((LPCWSTR)path.utf16(),
|
|
NULL, 0, NULL, NULL, NULL, t, 64)) {
|
|
LOG_INFO() << "device type is" << t;
|
|
return QString::fromWCharArray(t);
|
|
}
|
|
#endif
|
|
return QString("-");
|
|
}
|
|
|
|
|
|
QString Utils::filesystemName(QString path)
|
|
{
|
|
QString name;
|
|
#if defined(Q_OS_WIN32)
|
|
wchar_t volname[MAX_PATH+1];
|
|
bool res = GetVolumeInformationW((LPTSTR)path.utf16(), volname, MAX_PATH+1,
|
|
NULL, NULL, NULL, NULL, 0);
|
|
if(res) {
|
|
name = QString::fromWCharArray(volname);
|
|
}
|
|
#endif
|
|
#if defined(Q_OS_MACX)
|
|
// BSD label does not include folder.
|
|
QString bsd = Utils::resolveDevicename(path).remove("/dev/");
|
|
if(bsd.isEmpty()) {
|
|
return name;
|
|
}
|
|
OSStatus result;
|
|
ItemCount index = 1;
|
|
|
|
do {
|
|
FSVolumeRefNum volrefnum;
|
|
HFSUniStr255 volname;
|
|
|
|
result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, index, &volrefnum,
|
|
kFSVolInfoFSInfo, NULL, &volname, NULL);
|
|
|
|
if(result == noErr) {
|
|
GetVolParmsInfoBuffer volparms;
|
|
/* PBHGetVolParmsSync() is not available for 64bit while
|
|
FSGetVolumeParms() is available in 10.5+. Thus we need to use
|
|
PBHGetVolParmsSync() for 10.4, and that also requires 10.4 to
|
|
always use 32bit.
|
|
Qt 4 supports 32bit on 10.6 Cocoa only.
|
|
*/
|
|
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
|
|
if(FSGetVolumeParms(volrefnum, &volparms, sizeof(volparms)) == noErr)
|
|
#else
|
|
HParamBlockRec hpb;
|
|
hpb.ioParam.ioNamePtr = NULL;
|
|
hpb.ioParam.ioVRefNum = volrefnum;
|
|
hpb.ioParam.ioBuffer = (Ptr)&volparms;
|
|
hpb.ioParam.ioReqCount = sizeof(volparms);
|
|
if(PBHGetVolParmsSync(&hpb) == noErr)
|
|
#endif
|
|
{
|
|
if(volparms.vMServerAdr == 0) {
|
|
if(bsd == (char*)volparms.vMDeviceID) {
|
|
name = QString::fromUtf16((const ushort*)volname.unicode,
|
|
(int)volname.length);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
index++;
|
|
} while(result == noErr);
|
|
#endif
|
|
|
|
LOG_INFO() << "Volume name of" << path << "is" << name;
|
|
return name;
|
|
}
|
|
|
|
|
|
//! @brief figure the free disk space on a filesystem
|
|
//! @param path path on the filesystem to check
|
|
//! @return size in bytes
|
|
qulonglong Utils::filesystemFree(QString path)
|
|
{
|
|
qulonglong size = filesystemSize(path, FilesystemFree);
|
|
LOG_INFO() << "free disk space for" << path << size;
|
|
return size;
|
|
}
|
|
|
|
|
|
qulonglong Utils::filesystemTotal(QString path)
|
|
{
|
|
qulonglong size = filesystemSize(path, FilesystemTotal);
|
|
LOG_INFO() << "total disk space for" << path << size;
|
|
return size;
|
|
}
|
|
|
|
|
|
qulonglong Utils::filesystemSize(QString path, enum Utils::Size type)
|
|
{
|
|
qulonglong size = 0;
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
|
|
// the usage of statfs() is deprecated by the LSB so use statvfs().
|
|
struct statvfs fs;
|
|
int ret;
|
|
|
|
ret = statvfs(qPrintable(path), &fs);
|
|
|
|
if(ret == 0) {
|
|
if(type == FilesystemFree) {
|
|
size = (qulonglong)fs.f_frsize * (qulonglong)fs.f_bavail;
|
|
}
|
|
if(type == FilesystemTotal) {
|
|
size = (qulonglong)fs.f_frsize * (qulonglong)fs.f_blocks;
|
|
}
|
|
if(type == FilesystemClusterSize) {
|
|
size = (qulonglong)fs.f_frsize;
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(Q_OS_WIN32)
|
|
BOOL ret;
|
|
ULARGE_INTEGER freeAvailBytes;
|
|
ULARGE_INTEGER totalNumberBytes;
|
|
|
|
ret = GetDiskFreeSpaceExW((LPCTSTR)path.utf16(), &freeAvailBytes,
|
|
&totalNumberBytes, NULL);
|
|
if(ret) {
|
|
if(type == FilesystemFree) {
|
|
size = freeAvailBytes.QuadPart;
|
|
}
|
|
if(type == FilesystemTotal) {
|
|
size = totalNumberBytes.QuadPart;
|
|
}
|
|
if(type == FilesystemClusterSize) {
|
|
DWORD sectorsPerCluster;
|
|
DWORD bytesPerSector;
|
|
DWORD freeClusters;
|
|
DWORD totalClusters;
|
|
ret = GetDiskFreeSpaceW((LPCTSTR)path.utf16(), §orsPerCluster,
|
|
&bytesPerSector, &freeClusters, &totalClusters);
|
|
if(ret) {
|
|
size = bytesPerSector * sectorsPerCluster;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return size;
|
|
}
|
|
|
|
//! \brief searches for a Executable in the Environement Path
|
|
QString Utils::findExecutable(QString name)
|
|
{
|
|
//try autodetect tts
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
|
|
#if QT_VERSION >= 0x050e00
|
|
QStringList path = QString(getenv("PATH")).split(":", Qt::SkipEmptyParts);
|
|
#else
|
|
QStringList path = QString(getenv("PATH")).split(":", QString::SkipEmptyParts);
|
|
#endif
|
|
#elif defined(Q_OS_WIN)
|
|
#if QT_VERSION >= 0x050e00
|
|
QStringList path = QString(getenv("PATH")).split(";", Qt::SkipEmptyParts);
|
|
#else
|
|
QStringList path = QString(getenv("PATH")).split(";", QString::SkipEmptyParts);
|
|
#endif
|
|
#endif
|
|
LOG_INFO() << "system path:" << path;
|
|
for(int i = 0; i < path.size(); i++)
|
|
{
|
|
QString executable = QDir::fromNativeSeparators(path.at(i)) + "/" + name;
|
|
#if defined(Q_OS_WIN)
|
|
executable += ".exe";
|
|
#if QT_VERSION >= 0x050e00
|
|
QStringList ex = executable.split("\"", Qt::SkipEmptyParts);
|
|
#else
|
|
QStringList ex = executable.split("\"", QString::SkipEmptyParts);
|
|
#endif
|
|
executable = ex.join("");
|
|
#endif
|
|
if(QFileInfo(executable).isExecutable())
|
|
{
|
|
LOG_INFO() << "findExecutable: found" << executable;
|
|
return QDir::toNativeSeparators(executable);
|
|
}
|
|
}
|
|
LOG_INFO() << "findExecutable: could not find" << name;
|
|
return "";
|
|
}
|
|
|
|
|
|
/** @brief checks different Enviroment things. Ask if user wants to continue.
|
|
* @param permission if it should check for permission
|
|
* @return string with error messages if problems occurred, empty strings if none.
|
|
*/
|
|
QString Utils::checkEnvironment(bool permission)
|
|
{
|
|
LOG_INFO() << "checking environment";
|
|
QString text = "";
|
|
|
|
// check permission
|
|
if(permission)
|
|
{
|
|
#if defined(Q_OS_WIN32)
|
|
if(System::userPermissions() != System::ADMIN)
|
|
{
|
|
text += tr("<li>Permissions insufficient for bootloader "
|
|
"installation.\nAdministrator priviledges are necessary.</li>");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Check TargetId
|
|
RockboxInfo rbinfo(RbSettings::value(RbSettings::Mountpoint).toString());
|
|
QString installed = rbinfo.target();
|
|
if(!installed.isEmpty() && installed !=
|
|
RbSettings::value(RbSettings::CurrentPlatform).toString().split(".").at(0))
|
|
{
|
|
text += tr("<li>Target mismatch detected.<br/>"
|
|
"Installed target: %1<br/>Selected target: %2.</li>")
|
|
.arg(PlayerBuildInfo::instance()->value(
|
|
PlayerBuildInfo::DisplayName, installed).toString(),
|
|
PlayerBuildInfo::instance()->value(
|
|
PlayerBuildInfo::DisplayName).toString());
|
|
}
|
|
|
|
if(!text.isEmpty())
|
|
return tr("Problem detected:") + "<ul>" + text + "</ul>";
|
|
else
|
|
return text;
|
|
}
|
|
|
|
/** @brief Trim version string from filename to version part only.
|
|
* @param s Version string
|
|
* @return Version part of string if found, input string on error.
|
|
*/
|
|
QString Utils::trimVersionString(QString s)
|
|
{
|
|
QRegularExpression r = QRegularExpression("^\\D*([\\d\\.]+\\d+[a-z]?).*");
|
|
QRegularExpressionMatch match = r.match(s);
|
|
if(match.hasMatch()) {
|
|
return match.captured(1);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
/** @brief Compare two version strings.
|
|
* @param s1 first version string
|
|
* @param s2 second version string
|
|
* @return 0 if strings identical, 1 if second is newer, -1 if first.
|
|
*/
|
|
int Utils::compareVersionStrings(QString s1, QString s2)
|
|
{
|
|
LOG_INFO() << "comparing version strings" << s1 << "and" << s2;
|
|
QString a = s1.trimmed();
|
|
QString b = s2.trimmed();
|
|
// if strings are identical return 0.
|
|
if(a.isEmpty())
|
|
return 1;
|
|
if(b.isEmpty())
|
|
return -1;
|
|
|
|
while(!a.isEmpty() || !b.isEmpty()) {
|
|
// trim all leading non-digits and non-dots (dots are removed afterwards)
|
|
a.remove(QRegularExpression("^[^\\d\\.]*"));
|
|
b.remove(QRegularExpression("^[^\\d\\.]*"));
|
|
|
|
// trim all trailing non-digits for conversion (QString::toInt()
|
|
// requires this). Copy strings first as replace() changes the string.
|
|
QString numa = a;
|
|
QString numb = b;
|
|
numa.remove(QRegularExpression("\\D+.*$"));
|
|
numb.remove(QRegularExpression("\\D+.*$"));
|
|
|
|
// convert to number
|
|
bool ok1, ok2;
|
|
unsigned int vala = numa.toUInt(&ok1);
|
|
unsigned int valb = numb.toUInt(&ok2);
|
|
// if none of the numbers converted successfully we're at trailing garbage.
|
|
if(!ok1 && !ok2)
|
|
break;
|
|
if(!ok1)
|
|
return 1;
|
|
if(!ok2)
|
|
return -1;
|
|
|
|
// if numbers mismatch we have a decision.
|
|
if(vala != valb)
|
|
return (vala > valb) ? -1 : 1;
|
|
|
|
// trim leading digits.
|
|
a.remove(QRegularExpression("^\\d*"));
|
|
b.remove(QRegularExpression("^\\d*"));
|
|
|
|
// If only one of the following characters is a dot that one is
|
|
// "greater" then anything else. Make sure it's followed by a number,
|
|
// Otherwise it might be the end of the string or suffix. Do this
|
|
// before version addon characters check to avoid stopping too early.
|
|
bool adot = a.contains(QRegularExpression("^[a-zA-Z]*\\.[0-9]"));
|
|
bool bdot = b.contains(QRegularExpression("^[a-zA-Z]*\\.[0-9]"));
|
|
if(adot && !bdot)
|
|
return -1;
|
|
if(!adot && bdot)
|
|
return 1;
|
|
// if number is immediately followed by a character consider it as
|
|
// version addon (like 1.2.3b). In this case compare characters and end
|
|
// (version numbers like 1.2b.3 aren't handled).
|
|
QChar ltra;
|
|
QChar ltrb;
|
|
if(a.contains(QRegularExpression("^[a-zA-Z]")))
|
|
ltra = a.at(0);
|
|
if(b.contains(QRegularExpression("^[a-zA-Z]")))
|
|
ltrb = b.at(0);
|
|
if(ltra != ltrb)
|
|
return (ltra < ltrb) ? 1 : -1;
|
|
|
|
// both are identical or no addon characters, ignore.
|
|
// remove modifiers and following dot.
|
|
a.remove(QRegularExpression("^[a-zA-Z]*\\."));
|
|
b.remove(QRegularExpression("^[a-zA-Z]*\\."));
|
|
}
|
|
|
|
// no differences found.
|
|
return 0;
|
|
}
|
|
|
|
|
|
/** Resolve mountpoint to devicename / disk number
|
|
* @param path mountpoint path / drive letter
|
|
* @return devicename / disk number
|
|
*/
|
|
QString Utils::resolveDevicename(QString path)
|
|
{
|
|
LOG_INFO() << "resolving device name" << path;
|
|
#if defined(Q_OS_LINUX)
|
|
FILE *mn = setmntent("/etc/mtab", "r");
|
|
if(!mn)
|
|
return QString("");
|
|
|
|
struct mntent *ent;
|
|
while((ent = getmntent(mn))) {
|
|
// check for valid filesystem type.
|
|
// Linux can handle hfs (and hfsplus), so consider it a valid file
|
|
// system. Otherwise resolving the device name would fail, which in
|
|
// turn would make it impossible to warn about a MacPod.
|
|
if(QString(ent->mnt_dir) == path
|
|
&& (QString(ent->mnt_type).contains("vfat", Qt::CaseInsensitive)
|
|
|| QString(ent->mnt_type).contains("hfs", Qt::CaseInsensitive))) {
|
|
endmntent(mn);
|
|
LOG_INFO() << "device name is" << ent->mnt_fsname;
|
|
return QString(ent->mnt_fsname);
|
|
}
|
|
}
|
|
endmntent(mn);
|
|
|
|
#endif
|
|
|
|
#if defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
|
|
int num;
|
|
struct statfs *mntinf;
|
|
|
|
num = getmntinfo(&mntinf, MNT_WAIT);
|
|
while(num--) {
|
|
// check for valid filesystem type. OS X can handle hfs (hfs+ is
|
|
// treated as hfs), BSD should be the same.
|
|
if(QString(mntinf->f_mntonname) == path
|
|
&& (QString(mntinf->f_fstypename).contains("msdos", Qt::CaseInsensitive)
|
|
|| QString(mntinf->f_fstypename).contains("hfs", Qt::CaseInsensitive))) {
|
|
LOG_INFO() << "device name is" << mntinf->f_mntfromname;
|
|
return QString(mntinf->f_mntfromname);
|
|
}
|
|
mntinf++;
|
|
}
|
|
#endif
|
|
|
|
#if defined(Q_OS_WIN32)
|
|
DWORD written;
|
|
HANDLE h;
|
|
TCHAR uncpath[MAX_PATH];
|
|
UCHAR buffer[0x400];
|
|
PVOLUME_DISK_EXTENTS extents = (PVOLUME_DISK_EXTENTS)buffer;
|
|
|
|
_stprintf(uncpath, _TEXT("\\\\.\\%c:"), path.toLatin1().at(0));
|
|
h = CreateFile(uncpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, NULL);
|
|
if(h == INVALID_HANDLE_VALUE) {
|
|
//LOG_INFO() << "error getting extents for" << uncpath;
|
|
return "";
|
|
}
|
|
// get the extents
|
|
if(DeviceIoControl(h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
|
|
NULL, 0, extents, sizeof(buffer), &written, NULL)) {
|
|
if(extents->NumberOfDiskExtents == 1) {
|
|
CloseHandle(h);
|
|
LOG_INFO() << "device name is" << extents->Extents[0].DiskNumber;
|
|
return QString("%1").arg(extents->Extents[0].DiskNumber);
|
|
}
|
|
LOG_INFO() << "resolving device name: volume spans multiple disks!";
|
|
}
|
|
CloseHandle(h);
|
|
#endif
|
|
return QString("");
|
|
|
|
}
|
|
|
|
|
|
/** resolve device name to mount point / drive letter
|
|
* @param device device name / disk number
|
|
* @return mount point / drive letter
|
|
*/
|
|
QString Utils::resolveMountPoint(QString device)
|
|
{
|
|
LOG_INFO() << "resolving mountpoint:" << device;
|
|
|
|
#if defined(Q_OS_LINUX)
|
|
FILE *mn = setmntent("/etc/mtab", "r");
|
|
if(!mn)
|
|
return QString("");
|
|
|
|
struct mntent *ent;
|
|
while((ent = getmntent(mn))) {
|
|
// Check for valid filesystem. Allow hfs too, as an Ipod might be a
|
|
// MacPod.
|
|
if(QString(ent->mnt_fsname) == device) {
|
|
QString result;
|
|
if(QString(ent->mnt_type).contains("vfat", Qt::CaseInsensitive)
|
|
|| QString(ent->mnt_type).contains("hfs", Qt::CaseInsensitive)) {
|
|
LOG_INFO() << "resolved mountpoint is:" << ent->mnt_dir;
|
|
result = QString(ent->mnt_dir);
|
|
}
|
|
else {
|
|
LOG_INFO() << "mountpoint is wrong filesystem!";
|
|
}
|
|
endmntent(mn);
|
|
return result;
|
|
}
|
|
}
|
|
endmntent(mn);
|
|
|
|
#endif
|
|
|
|
#if defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
|
|
int num;
|
|
struct statfs *mntinf;
|
|
|
|
num = getmntinfo(&mntinf, MNT_WAIT);
|
|
while(num--) {
|
|
// Check for valid filesystem. Allow hfs too, as an Ipod might be a
|
|
// MacPod.
|
|
if(QString(mntinf->f_mntfromname) == device) {
|
|
if(QString(mntinf->f_fstypename).contains("msdos", Qt::CaseInsensitive)
|
|
|| QString(mntinf->f_fstypename).contains("hfs", Qt::CaseInsensitive)) {
|
|
LOG_INFO() << "resolved mountpoint is:" << mntinf->f_mntonname;
|
|
return QString(mntinf->f_mntonname);
|
|
}
|
|
else {
|
|
LOG_INFO() << "mountpoint is wrong filesystem!";
|
|
return QString();
|
|
}
|
|
}
|
|
mntinf++;
|
|
}
|
|
#endif
|
|
|
|
#if defined(Q_OS_WIN32)
|
|
QString result;
|
|
unsigned int driveno = device.replace(QRegularExpression("^.*([0-9]+)"), "\\1").toInt();
|
|
|
|
char letter;
|
|
for(letter = 'A'; letter <= 'Z'; letter++) {
|
|
if(resolveDevicename(QString(letter)).toUInt() == driveno) {
|
|
result = letter;
|
|
LOG_INFO() << "resolved mountpoint is:" << result;
|
|
break;
|
|
}
|
|
}
|
|
if(!result.isEmpty())
|
|
return result + ":/";
|
|
#endif
|
|
LOG_INFO() << "resolving mountpoint failed!";
|
|
return QString("");
|
|
}
|
|
|
|
|
|
QStringList Utils::mountpoints(enum MountpointsFilter type)
|
|
{
|
|
QStringList supported;
|
|
QStringList tempList;
|
|
#if defined(Q_OS_WIN32)
|
|
supported << "FAT32" << "FAT16" << "FAT12" << "FAT" << "HFS";
|
|
QFileInfoList list = QDir::drives();
|
|
for(int i=0; i<list.size();i++)
|
|
{
|
|
wchar_t t[32];
|
|
memset(t, 0, 32);
|
|
if(GetVolumeInformationW((LPCWSTR)list.at(i).absolutePath().utf16(),
|
|
NULL, 0, NULL, NULL, NULL, t, 32) == 0) {
|
|
// on error empty retrieved type -- don't rely on
|
|
// GetVolumeInformation not changing it.
|
|
memset(t, 0, sizeof(t));
|
|
}
|
|
|
|
QString fstype = QString::fromWCharArray(t);
|
|
if(type == MountpointsAll || supported.contains(fstype)) {
|
|
tempList << list.at(i).absolutePath();
|
|
LOG_INFO() << "Added:" << list.at(i).absolutePath()
|
|
<< "type" << fstype;
|
|
}
|
|
else {
|
|
LOG_INFO() << "Ignored:" << list.at(i).absolutePath()
|
|
<< "type" << fstype;
|
|
}
|
|
}
|
|
|
|
#elif defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
|
|
supported << "vfat" << "msdos" << "hfs";
|
|
int num;
|
|
struct statfs *mntinf;
|
|
|
|
num = getmntinfo(&mntinf, MNT_WAIT);
|
|
while(num--) {
|
|
if(type == MountpointsAll || supported.contains(mntinf->f_fstypename)) {
|
|
tempList << QString(mntinf->f_mntonname);
|
|
LOG_INFO() << "Added:" << mntinf->f_mntonname
|
|
<< "is" << mntinf->f_mntfromname << "type" << mntinf->f_fstypename;
|
|
}
|
|
else {
|
|
LOG_INFO() << "Ignored:" << mntinf->f_mntonname
|
|
<< "is" << mntinf->f_mntfromname << "type" << mntinf->f_fstypename;
|
|
}
|
|
mntinf++;
|
|
}
|
|
#elif defined(Q_OS_LINUX)
|
|
supported << "vfat" << "msdos" << "hfsplus";
|
|
FILE *mn = setmntent("/etc/mtab", "r");
|
|
if(!mn)
|
|
return QStringList("");
|
|
|
|
struct mntent *ent;
|
|
while((ent = getmntent(mn))) {
|
|
if(type == MountpointsAll || supported.contains(ent->mnt_type)) {
|
|
tempList << QString(ent->mnt_dir);
|
|
LOG_INFO() << "Added:" << ent->mnt_dir
|
|
<< "is" << ent->mnt_fsname << "type" << ent->mnt_type;
|
|
}
|
|
else {
|
|
LOG_INFO() << "Ignored:" << ent->mnt_dir
|
|
<< "is" << ent->mnt_fsname << "type" << ent->mnt_type;
|
|
}
|
|
}
|
|
endmntent(mn);
|
|
|
|
#else
|
|
#error Unknown Platform
|
|
#endif
|
|
return tempList;
|
|
}
|
|
|
|
|
|
/** Check if a process with a given name is running
|
|
* @param names list of names to filter on. All processes if empty list.
|
|
* @return list of processname, process ID pairs.
|
|
*/
|
|
QMap<QString, QList<int> > Utils::findRunningProcess(QStringList names)
|
|
{
|
|
QMap<QString, QList<int> > processlist;
|
|
QMap<QString, QList<int> > found;
|
|
#if defined(Q_OS_WIN32)
|
|
HANDLE hdl;
|
|
PROCESSENTRY32 entry;
|
|
bool result;
|
|
|
|
hdl = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
|
if(hdl == INVALID_HANDLE_VALUE) {
|
|
LOG_ERROR() << "CreateToolhelp32Snapshot failed.";
|
|
return found;
|
|
}
|
|
entry.dwSize = sizeof(PROCESSENTRY32);
|
|
entry.szExeFile[0] = '\0';
|
|
if(!Process32First(hdl, &entry)) {
|
|
LOG_ERROR() << "Process32First failed.";
|
|
return found;
|
|
}
|
|
|
|
do {
|
|
int pid = entry.th32ProcessID; // FIXME: DWORD vs int!
|
|
QString name = QString::fromWCharArray(entry.szExeFile);
|
|
if(processlist.find(name) == processlist.end()) {
|
|
processlist.insert(name, QList<int>());
|
|
}
|
|
processlist[name].append(pid);
|
|
entry.dwSize = sizeof(PROCESSENTRY32);
|
|
entry.szExeFile[0] = '\0';
|
|
result = Process32Next(hdl, &entry);
|
|
} while(result);
|
|
CloseHandle(hdl);
|
|
#endif
|
|
#if defined(Q_OS_MACX)
|
|
ProcessSerialNumber psn = { 0, kNoProcess };
|
|
OSErr err;
|
|
do {
|
|
pid_t pid;
|
|
err = GetNextProcess(&psn);
|
|
err = GetProcessPID(&psn, &pid);
|
|
if(err == noErr) {
|
|
char buf[32] = {0};
|
|
ProcessInfoRec info;
|
|
memset(&info, 0, sizeof(ProcessInfoRec));
|
|
info.processName = (unsigned char*)buf;
|
|
info.processInfoLength = sizeof(ProcessInfoRec);
|
|
err = GetProcessInformation(&psn, &info);
|
|
if(err == noErr) {
|
|
// some processes start with nonprintable characters. Skip those.
|
|
int i;
|
|
for(i = 0; i < 32; i++) {
|
|
if(isprint(buf[i])) break;
|
|
}
|
|
// avoid adding duplicates.
|
|
QString name = QString::fromUtf8(&buf[i]);
|
|
if(processlist.find(name) == processlist.end()) {
|
|
processlist.insert(name, QList<int>());
|
|
}
|
|
processlist[name].append(pid);
|
|
}
|
|
}
|
|
} while(err == noErr);
|
|
#endif
|
|
#if defined(Q_OS_LINUX)
|
|
// not implemented for Linux!
|
|
#endif
|
|
// Filter for names (unless empty)
|
|
if(names.size() > 0) {
|
|
for(int i = 0; i < names.size(); ++i) {
|
|
QStringList k(processlist.keys());
|
|
#if defined(Q_OS_WIN32)
|
|
// the process name might be truncated. Allow the extension to be partial.
|
|
int index = k.indexOf(QRegularExpression(names.at(i) + "(\\.(e(x(e?)?)?)?)?",
|
|
QRegularExpression::CaseInsensitiveOption));
|
|
#else
|
|
int index = k.indexOf(names.at(i));
|
|
#endif
|
|
if(index != -1) {
|
|
found.insert(k[index], processlist[k[index]]);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
found = processlist;
|
|
}
|
|
LOG_INFO() << "Looking for processes" << names << "found" << found;
|
|
return found;
|
|
}
|
|
|
|
|
|
/** Suspends/resumes processes
|
|
* @param pidlist a list of PIDs to suspend/resume
|
|
* @param suspend processes are suspended if true, or resumed when false
|
|
* @return a list of PIDs successfully suspended/resumed
|
|
*/
|
|
QList<int> Utils::suspendProcess(QList<int> pidlist, bool suspend)
|
|
{
|
|
QList<int> result;
|
|
#if defined(Q_OS_WIN32)
|
|
// Enable debug privilege
|
|
HANDLE hToken = NULL;
|
|
LUID seDebugValue;
|
|
TOKEN_PRIVILEGES tNext, tPrev;
|
|
DWORD sPrev;
|
|
if(LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &seDebugValue)) {
|
|
if(OpenProcessToken(GetCurrentProcess(),
|
|
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
|
|
memset(&tNext, 0, sizeof(tNext));
|
|
tNext.PrivilegeCount = 1;
|
|
tNext.Privileges[0].Luid = seDebugValue;
|
|
tNext.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
if(!AdjustTokenPrivileges(hToken, FALSE, &tNext, sizeof(tNext),
|
|
&tPrev, &sPrev) || GetLastError() != 0) {
|
|
CloseHandle(hToken);
|
|
hToken = NULL;
|
|
LOG_ERROR() << "AdjustTokenPrivileges(next) error" << GetLastError();
|
|
}
|
|
}
|
|
else {
|
|
LOG_ERROR() << "OpenProcessToken error" << GetLastError();
|
|
}
|
|
}
|
|
else {
|
|
LOG_ERROR() << "LookupPrivilegeValue error" << GetLastError();
|
|
}
|
|
|
|
// Suspend/resume threads
|
|
for(int i = 0; i < pidlist.size(); i++) {
|
|
HANDLE hdl = INVALID_HANDLE_VALUE;
|
|
THREADENTRY32 entry;
|
|
int n_fails = 0;
|
|
|
|
hdl = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
|
|
if(hdl == INVALID_HANDLE_VALUE) {
|
|
LOG_ERROR() << "CreateToolhelp32Snapshot error" << GetLastError();
|
|
continue;
|
|
}
|
|
entry.dwSize = sizeof(THREADENTRY32);
|
|
if(!Thread32First(hdl, &entry)) {
|
|
LOG_ERROR() << "Process32First error" << GetLastError();
|
|
CloseHandle(hdl);
|
|
continue;
|
|
}
|
|
|
|
do {
|
|
if(entry.th32OwnerProcessID != (DWORD)(pidlist[i]))
|
|
continue;
|
|
HANDLE thr = OpenThread(THREAD_SUSPEND_RESUME,
|
|
FALSE, entry.th32ThreadID);
|
|
if(!thr) {
|
|
LOG_ERROR() << "OpenThread" << entry.th32ThreadID
|
|
<< "error" << GetLastError();
|
|
n_fails++;
|
|
continue;
|
|
}
|
|
if(suspend) {
|
|
// Execution of the specified thread is suspended and
|
|
// the thread's suspend count is incremented.
|
|
if(SuspendThread(thr) == (DWORD)(-1)) {
|
|
LOG_ERROR() << "SuspendThread" << entry.th32ThreadID
|
|
<< "error" << GetLastError();
|
|
n_fails++;
|
|
}
|
|
}
|
|
else {
|
|
// Decrements a thread's suspend count. When the
|
|
// suspend count is decremented to zero, the
|
|
// execution of the thread is resumed.
|
|
if(ResumeThread(thr) == (DWORD)(-1)) {
|
|
LOG_ERROR() << "ResumeThread" << entry.th32ThreadID
|
|
<< "error" << GetLastError();
|
|
n_fails++;
|
|
}
|
|
}
|
|
CloseHandle(thr);
|
|
} while(Thread32Next(hdl, &entry));
|
|
if (!n_fails)
|
|
result.append(pidlist[i]);
|
|
CloseHandle(hdl);
|
|
}
|
|
|
|
// Restore previous debug privilege
|
|
if (hToken) {
|
|
if(!AdjustTokenPrivileges(hToken, FALSE,
|
|
&tPrev, sPrev, NULL, NULL) || GetLastError() != 0) {
|
|
LOG_ERROR() << "AdjustTokenPrivileges(prev) error" << GetLastError();
|
|
}
|
|
CloseHandle(hToken);
|
|
}
|
|
#endif
|
|
#if defined(Q_OS_MACX)
|
|
int signal = suspend ? SIGSTOP : SIGCONT;
|
|
for(int i = 0; i < pidlist.size(); i++) {
|
|
pid_t pid = pidlist[i];
|
|
if(kill(pid, signal) != 0) {
|
|
LOG_ERROR() << "kill signal" << signal
|
|
<< "for PID" << pid << "error:" << errno;
|
|
}
|
|
else {
|
|
result.append(pidlist[i]);
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(Q_OS_LINUX)
|
|
// not implemented for Linux!
|
|
#endif
|
|
LOG_INFO() << (suspend ? "Suspending" : "Resuming")
|
|
<< "PIDs" << pidlist << "result" << result;
|
|
return result;
|
|
}
|
|
|
|
|
|
/** Eject device from PC.
|
|
* Request the OS to eject the player.
|
|
* @param device mountpoint of the device
|
|
* @return true on success, fals otherwise.
|
|
*/
|
|
bool Utils::ejectDevice(QString device)
|
|
{
|
|
#if defined(Q_OS_WIN32)
|
|
/* See http://support.microsoft.com/kb/165721 on the procedure to eject a
|
|
* device. */
|
|
bool success = false;
|
|
int i;
|
|
HANDLE hdl;
|
|
DWORD bytesReturned;
|
|
TCHAR volume[8];
|
|
|
|
/* CreateFile */
|
|
_stprintf(volume, _TEXT("\\\\.\\%c:"), device.toLatin1().at(0));
|
|
hdl = CreateFile(volume, GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
OPEN_EXISTING, 0, NULL);
|
|
if(hdl == INVALID_HANDLE_VALUE)
|
|
return false;
|
|
|
|
/* lock volume to make sure no other application is accessing the volume.
|
|
* Try up to 10 times. */
|
|
for(i = 0; i < 10; i++) {
|
|
if(DeviceIoControl(hdl, FSCTL_LOCK_VOLUME,
|
|
NULL, 0, NULL, 0, &bytesReturned, NULL))
|
|
break;
|
|
/* short break before retry */
|
|
Sleep(100);
|
|
}
|
|
if(i < 10) {
|
|
/* successfully locked, now dismount */
|
|
if(DeviceIoControl(hdl, FSCTL_DISMOUNT_VOLUME,
|
|
NULL, 0, NULL, 0, &bytesReturned, NULL)) {
|
|
/* make sure media can be removed. */
|
|
PREVENT_MEDIA_REMOVAL pmr;
|
|
pmr.PreventMediaRemoval = false;
|
|
if(DeviceIoControl(hdl, IOCTL_STORAGE_MEDIA_REMOVAL,
|
|
&pmr, sizeof(PREVENT_MEDIA_REMOVAL),
|
|
NULL, 0, &bytesReturned, NULL)) {
|
|
/* eject the media */
|
|
if(DeviceIoControl(hdl, IOCTL_STORAGE_EJECT_MEDIA,
|
|
NULL, 0, NULL, 0, &bytesReturned, NULL))
|
|
success = true;
|
|
}
|
|
}
|
|
}
|
|
/* close handle */
|
|
CloseHandle(hdl);
|
|
return success;
|
|
|
|
#endif
|
|
#if defined(Q_OS_MACX)
|
|
// FIXME: FSUnmountVolumeSync is deprecated starting with 10.8.
|
|
// Use DADiskUnmount / DiskArbitration framework eventually.
|
|
// BSD label does not include folder.
|
|
QString bsd = Utils::resolveDevicename(device).remove("/dev/");
|
|
OSStatus result;
|
|
ItemCount index = 1;
|
|
bool found = false;
|
|
|
|
do {
|
|
FSVolumeRefNum volrefnum;
|
|
|
|
result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, index, &volrefnum,
|
|
kFSVolInfoFSInfo, NULL, NULL, NULL);
|
|
if(result == noErr) {
|
|
GetVolParmsInfoBuffer volparms;
|
|
/* See above -- PBHGetVolParmsSync() is not available for 64bit,
|
|
* and FSGetVolumeParms() on 10.5+ only. */
|
|
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
|
|
if(FSGetVolumeParms(volrefnum, &volparms, sizeof(volparms)) == noErr)
|
|
#else
|
|
HParamBlockRec hpb;
|
|
hpb.ioParam.ioNamePtr = NULL;
|
|
hpb.ioParam.ioVRefNum = volrefnum;
|
|
hpb.ioParam.ioBuffer = (Ptr)&volparms;
|
|
hpb.ioParam.ioReqCount = sizeof(volparms);
|
|
if(PBHGetVolParmsSync(&hpb) == noErr)
|
|
#endif
|
|
{
|
|
if(volparms.vMServerAdr == 0) {
|
|
if(bsd == (char*)volparms.vMDeviceID) {
|
|
pid_t dissenter;
|
|
result = FSUnmountVolumeSync(volrefnum, 0, &dissenter);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
index++;
|
|
} while(result == noErr);
|
|
if(result == noErr && found)
|
|
return true;
|
|
|
|
#endif
|
|
#if defined(Q_OS_LINUX)
|
|
(void)device;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
|
|
qint64 Utils::recursiveFolderSize(QString path)
|
|
{
|
|
qint64 size = 0;
|
|
QList<QFileInfo> items = QDir(path).entryInfoList(QDir::Files | QDir::NoDotAndDotDot);
|
|
for (const auto &item: qAsConst(items)) {
|
|
size += item.size();
|
|
}
|
|
QList<QString> folders = QDir(path).entryList(QDir::Dirs | QDir::NoDotAndDotDot);
|
|
for (auto const& folder: qAsConst(folders)) {
|
|
size += recursiveFolderSize(path + "/" + folder);
|
|
}
|
|
return size;
|
|
}
|