palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-06-26 14:18:12 +02:00
Code Issues Projects Releases Wiki Activity

Dependies for class QLockFile make it impossible easy backport this class to

Browse source 
Qt 5.0.0. I decided don't do this. And just disable using the class if
Qt version < Qt 5.1. It will open some issues, but for Unit testing this reason
not important.

--HG--
branch : develop
This commit is contained in:
Roman Telezhynskyi 2015-04-05 16:31:28 +02:00
parent 93eb3d692c
commit 36990d6531
41 changed files with 61 additions and 10756 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1251
src/app/core/backport/qabstractfileengine.cpp
View file

File diff suppressed because it is too large Load diff

251
src/app/core/backport/qabstractfileengine_p.h
View file

@ -1,251 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QABSTRACTFILEENGINE_P_H
#define QABSTRACTFILEENGINE_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 <QFile>
#include <QDir>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifdef open
#error qabstractfileengine_p.h must be included before any header file that defines open
#endif
class QVariant;
class QAbstractFileEngineIterator;
class QAbstractFileEnginePrivate;
class QAbstractFileEngine
{
public:
enum FileFlag {
//perms (overlaps the QFile::Permission)
ReadOwnerPerm = 0x4000, WriteOwnerPerm = 0x2000, ExeOwnerPerm = 0x1000,
ReadUserPerm = 0x0400, WriteUserPerm = 0x0200, ExeUserPerm = 0x0100,
ReadGroupPerm = 0x0040, WriteGroupPerm = 0x0020, ExeGroupPerm = 0x0010,
ReadOtherPerm = 0x0004, WriteOtherPerm = 0x0002, ExeOtherPerm = 0x0001,
//types
LinkType = 0x10000,
FileType = 0x20000,
DirectoryType = 0x40000,
BundleType = 0x80000,
//flags
HiddenFlag = 0x0100000,
LocalDiskFlag = 0x0200000,
ExistsFlag = 0x0400000,
RootFlag = 0x0800000,
Refresh = 0x1000000,
//masks
PermsMask = 0x0000FFFF,
TypesMask = 0x000F0000,
FlagsMask = 0x0FF00000,
FileInfoAll = FlagsMask | PermsMask | TypesMask
};
Q_DECLARE_FLAGS(FileFlags, FileFlag)
enum FileName {
DefaultName,
BaseName,
PathName,
AbsoluteName,
AbsolutePathName,
LinkName,
CanonicalName,
CanonicalPathName,
BundleName,
NFileNames = 9
};
enum FileOwner {
OwnerUser,
OwnerGroup
};
enum FileTime {
CreationTime,
ModificationTime,
AccessTime
};
virtual ~QAbstractFileEngine();
virtual bool open(QIODevice::OpenMode openMode);
virtual bool close();
virtual bool flush();
virtual bool syncToDisk();
virtual qint64 size() const;
virtual qint64 pos() const;
virtual bool seek(qint64 pos);
virtual bool isSequential() const;
virtual bool remove();
virtual bool copy(const QString &newName);
virtual bool rename(const QString &newName);
virtual bool renameOverwrite(const QString &newName);
virtual bool link(const QString &newName);
virtual bool mkdir(const QString &dirName, bool createParentDirectories) const;
virtual bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
virtual bool setSize(qint64 size);
virtual bool caseSensitive() const;
virtual bool isRelativePath() const;
virtual QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
virtual FileFlags fileFlags(FileFlags type=FileInfoAll) const;
virtual bool setPermissions(uint perms);
virtual QString fileName(FileName file=DefaultName) const;
virtual uint ownerId(FileOwner) const;
virtual QString owner(FileOwner) const;
virtual QDateTime fileTime(FileTime time) const;
virtual void setFileName(const QString &file);
virtual int handle() const;
bool atEnd() const;
uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
bool unmap(uchar *ptr);
typedef QAbstractFileEngineIterator Iterator;
virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
virtual Iterator *endEntryList();
virtual qint64 read(char *data, qint64 maxlen);
virtual qint64 readLine(char *data, qint64 maxlen);
virtual qint64 write(const char *data, qint64 len);
QFile::FileError error() const;
QString errorString() const;
enum Extension {
AtEndExtension,
FastReadLineExtension,
MapExtension,
UnMapExtension
};
class ExtensionOption
{};
class ExtensionReturn
{};
class MapExtensionOption : public ExtensionOption {
public:
qint64 offset;
qint64 size;
QFile::MemoryMapFlags flags;
};
class MapExtensionReturn : public ExtensionReturn {
public:
uchar *address;
};
class UnMapExtensionOption : public ExtensionOption {
public:
uchar *address;
};
virtual bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
virtual bool supportsExtension(Extension extension) const;
// Factory
static QAbstractFileEngine *create(const QString &fileName);
protected:
void setError(QFile::FileError error, const QString &str);
QAbstractFileEngine();
QAbstractFileEngine(QAbstractFileEnginePrivate &);
QScopedPointer<QAbstractFileEnginePrivate> d_ptr;
private:
Q_DECLARE_PRIVATE(QAbstractFileEngine)
Q_DISABLE_COPY(QAbstractFileEngine)
};
Q_DECLARE_OPERATORS_FOR_FLAGS(QAbstractFileEngine::FileFlags)
class QAbstractFileEngineHandler
{
public:
QAbstractFileEngineHandler();
virtual ~QAbstractFileEngineHandler();
virtual QAbstractFileEngine *create(const QString &fileName) const = 0;
};
class QAbstractFileEngineIteratorPrivate;
class QAbstractFileEngineIterator
{
public:
QAbstractFileEngineIterator(QDir::Filters filters, const QStringList &nameFilters);
virtual ~QAbstractFileEngineIterator();
virtual QString next() = 0;
virtual bool hasNext() const = 0;
QString path() const;
QStringList nameFilters() const;
QDir::Filters filters() const;
virtual QString currentFileName() const = 0;
virtual QFileInfo currentFileInfo() const;
QString currentFilePath() const;
protected:
enum EntryInfoType {
};
virtual QVariant entryInfo(EntryInfoType type) const;
private:
Q_DISABLE_COPY(QAbstractFileEngineIterator)
friend class QDirIterator;
friend class QDirIteratorPrivate;
void setPath(const QString &path);
QScopedPointer<QAbstractFileEngineIteratorPrivate> d;
};
class QAbstractFileEnginePrivate
{
public:
inline QAbstractFileEnginePrivate()
: fileError(QFile::UnspecifiedError)
{
}
inline virtual ~QAbstractFileEnginePrivate() { }
QFile::FileError fileError;
QString errorString;
QAbstractFileEngine *q_ptr;
Q_DECLARE_PUBLIC(QAbstractFileEngine)
};
QAbstractFileEngine *qt_custom_file_engine_handler_create(const QString &path);
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QABSTRACTFILEENGINE_P_H

61
src/app/core/backport/qcore_mac.cpp
View file

@ -1,61 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qcore_mac_p.h"
#include <new>
#include <QVarLengthArray>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
QString QCFString::toQString(CFStringRef str)
{
if(!str)
return QString();
CFIndex length = CFStringGetLength(str);
const UniChar *chars = CFStringGetCharactersPtr(str);
if (chars)
return QString(reinterpret_cast<const QChar *>(chars), length);
QVarLengthArray<UniChar> buffer(length);
CFStringGetCharacters(str, CFRangeMake(0, length), buffer.data());
return QString(reinterpret_cast<const QChar *>(buffer.constData()), length);
}
QCFString::operator QString() const
{
if (string.isEmpty() && type)
const_cast<QCFString*>(this)->string = toQString(type);
return string;
}
CFStringRef QCFString::toCFStringRef(const QString &string)
{
return CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(string.unicode()),
string.length());
}
QCFString::operator CFStringRef() const
{
if (!type)
const_cast<QCFString*>(this)->type = toCFStringRef(string);
return type;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

131
src/app/core/backport/qcore_mac_p.h
View file

@ -1,131 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QCORE_MAC_P_H
#define QCORE_MAC_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of other Qt classes. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#ifndef __IMAGECAPTURE__
# define __IMAGECAPTURE__
#endif
#if defined(QT_BOOTSTRAPPED)
#include <ApplicationServices/ApplicationServices.h>
#else
#include <CoreFoundation/CoreFoundation.h>
#endif
#include <QtGlobal>
#ifdef Q_OS_MACX
#include <CoreServices/CoreServices.h>
#endif
#ifdef __OBJC__
#include <Foundation/Foundation.h>
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#include <QString>
#if defined( __OBJC__) && defined(QT_NAMESPACE)
#define QT_NAMESPACE_ALIAS_OBJC_CLASS(__KLASS__) @compatibility_alias __KLASS__ QT_MANGLE_NAMESPACE(__KLASS__)
#else
#define QT_NAMESPACE_ALIAS_OBJC_CLASS(__KLASS__)
#endif
/*
Helper class that automates refernce counting for CFtypes.
After constructing the QCFType object, it can be copied like a
value-based type.
Note that you must own the object you are wrapping.
This is typically the case if you get the object from a Core
Foundation function with the word "Create" or "Copy" in it. If
you got the object from a "Get" function, either retain it or use
constructFromGet(). One exception to this rule is the
HIThemeGet*Shape functions, which in reality are "Copy" functions.
*/
template <typename T>
class QCFType
{
public:
inline QCFType(const T &t = 0) : type(t) {}
inline QCFType(const QCFType &helper) : type(helper.type) { if (type) CFRetain(type); }
inline ~QCFType() { if (type) CFRelease(type); }
inline operator T() { return type; }
inline QCFType operator =(const QCFType &helper)
{
if (helper.type)
CFRetain(helper.type);
CFTypeRef type2 = type;
type = helper.type;
if (type2)
CFRelease(type2);
return *this;
}
inline T *operator&() { return &type; }
template <typename X> X as() const { return reinterpret_cast<X>(type); }
static QCFType constructFromGet(const T &t)
{
CFRetain(t);
return QCFType<T>(t);
}
protected:
T type;
};
class Q_CORE_EXPORT QCFString : public QCFType<CFStringRef>
{
public:
inline QCFString(const QString &str) : QCFType<CFStringRef>(0), string(str) {}
inline QCFString(const CFStringRef cfstr = 0) : QCFType<CFStringRef>(cfstr) {}
inline QCFString(const QCFType<CFStringRef> &other) : QCFType<CFStringRef>(other) {}
operator QString() const;
operator CFStringRef() const;
static QString toQString(CFStringRef cfstr);
static CFStringRef toCFStringRef(const QString &str);
#ifdef __OBJC__
static QString toQString(const NSString *nsstr);
static NSString *toNSString(const QString &string);
#endif
private:
QString string;
};
#ifdef Q_OS_IOS
QSysInfo::MacVersion qt_ios_version();
#endif
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QCORE_MAC_P_H

109
src/app/core/backport/qcore_unix.cpp
View file

@ -1,109 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qcore_unix_p.h"
#include "qelapsedtimer.h"
#ifdef Q_OS_NACL
#elif !defined (Q_OS_VXWORKS)
# if !defined(Q_OS_HPUX) || defined(__ia64)
# include <sys/select.h>
# endif
# include <sys/time.h>
#else
# include <selectLib.h>
#endif
#include <stdlib.h>
#ifdef Q_OS_MAC
#include <mach/mach_time.h>
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
static inline bool time_update(struct timespec *tv, const struct timespec &start,
const struct timespec &timeout)
{
// clock source is (hopefully) monotonic, so we can recalculate how much timeout is left;
// if it isn't monotonic, we'll simply hope that it hasn't jumped, because we have no alternative
struct timespec now = qt_gettime();
*tv = timeout + start - now;
return tv->tv_sec >= 0;
}
int qt_safe_select(int nfds, fd_set *fdread, fd_set *fdwrite, fd_set *fdexcept,
const struct timespec *orig_timeout)
{
if (!orig_timeout) {
// no timeout -> block forever
int ret;
EINTR_LOOP(ret, select(nfds, fdread, fdwrite, fdexcept, 0));
return ret;
}
timespec start = qt_gettime();
timespec timeout = *orig_timeout;
// loop and recalculate the timeout as needed
int ret;
forever {
#ifndef Q_OS_QNX
ret = ::pselect(nfds, fdread, fdwrite, fdexcept, &timeout, 0);
#else
timeval timeoutVal;
timeoutVal.tv_sec = timeout.tv_sec;
timeoutVal.tv_usec = timeout.tv_nsec / 1000;
ret = ::select(nfds, fdread, fdwrite, fdexcept, &timeoutVal);
#endif
if (ret != -1 || errno != EINTR)
return ret;
// recalculate the timeout
if (!time_update(&timeout, start, *orig_timeout)) {
// timeout during update
// or clock reset, fake timeout error
return 0;
}
}
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

335
src/app/core/backport/qcore_unix_p.h
View file

@ -1,335 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QCORE_UNIX_P_H
#define QCORE_UNIX_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of Qt code on Unix. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include "qplatformdefs.h"
#include "qatomic.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef Q_OS_UNIX
# error "qcore_unix_p.h included on a non-Unix system"
#endif
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#if defined(Q_OS_VXWORKS)
# include <ioLib.h>
#endif
struct sockaddr;
#if defined(Q_OS_LINUX) && defined(O_CLOEXEC)
# define QT_UNIX_SUPPORTS_THREADSAFE_CLOEXEC 1
namespace QtLibcSupplement {
inline int accept4(int, sockaddr *, QT_SOCKLEN_T *, int)
{ errno = ENOSYS; return -1; }
inline int dup3(int, int, int)
{ errno = ENOSYS; return -1; }
inline int pipe2(int [], int )
{ errno = ENOSYS; return -1; }
}
using namespace QT_PREPEND_NAMESPACE(QtLibcSupplement);
#else
# define QT_UNIX_SUPPORTS_THREADSAFE_CLOEXEC 0
#endif
#define EINTR_LOOP(var, cmd) \
do { \
var = cmd; \
} while (var == -1 && errno == EINTR)
// Internal operator functions for timespecs
inline timespec &normalizedTimespec(timespec &t)
{
while (t.tv_nsec >= 1000000000) {
++t.tv_sec;
t.tv_nsec -= 1000000000;
}
while (t.tv_nsec < 0) {
--t.tv_sec;
t.tv_nsec += 1000000000;
}
return t;
}
inline bool operator<(const timespec &t1, const timespec &t2)
{ return t1.tv_sec < t2.tv_sec || (t1.tv_sec == t2.tv_sec && t1.tv_nsec < t2.tv_nsec); }
inline bool operator==(const timespec &t1, const timespec &t2)
{ return t1.tv_sec == t2.tv_sec && t1.tv_nsec == t2.tv_nsec; }
inline timespec &operator+=(timespec &t1, const timespec &t2)
{
t1.tv_sec += t2.tv_sec;
t1.tv_nsec += t2.tv_nsec;
return normalizedTimespec(t1);
}
inline timespec operator+(const timespec &t1, const timespec &t2)
{
timespec tmp;
tmp.tv_sec = t1.tv_sec + t2.tv_sec;
tmp.tv_nsec = t1.tv_nsec + t2.tv_nsec;
return normalizedTimespec(tmp);
}
inline timespec operator-(const timespec &t1, const timespec &t2)
{
timespec tmp;
tmp.tv_sec = t1.tv_sec - (t2.tv_sec - 1);
tmp.tv_nsec = t1.tv_nsec - (t2.tv_nsec + 1000000000);
return normalizedTimespec(tmp);
}
inline timespec operator*(const timespec &t1, int mul)
{
timespec tmp;
tmp.tv_sec = t1.tv_sec * mul;
tmp.tv_nsec = t1.tv_nsec * mul;
return normalizedTimespec(tmp);
}
inline void qt_ignore_sigpipe()
{
// Set to ignore SIGPIPE once only.
static QBasicAtomicInt atom = Q_BASIC_ATOMIC_INITIALIZER(0);
if (!atom.load()) {
// More than one thread could turn off SIGPIPE at the same time
// But that's acceptable because they all would be doing the same
// action
struct sigaction noaction;
memset(&noaction, 0, sizeof(noaction));
noaction.sa_handler = SIG_IGN;
::sigaction(SIGPIPE, &noaction, 0);
atom.store(1);
}
}
// don't call QT_OPEN or ::open
// call qt_safe_open
static inline int qt_safe_open(const char *pathname, int flags, mode_t mode = 0777)
{
#ifdef O_CLOEXEC
flags |= O_CLOEXEC;
#endif
int fd;
EINTR_LOOP(fd, QT_OPEN(pathname, flags, mode));
// unknown flags are ignored, so we have no way of verifying if
// O_CLOEXEC was accepted
if (fd != -1)
::fcntl(fd, F_SETFD, FD_CLOEXEC);
return fd;
}
#undef QT_OPEN
#define QT_OPEN qt_safe_open
#ifndef Q_OS_VXWORKS // no POSIX pipes in VxWorks
// don't call ::pipe
// call qt_safe_pipe
static inline int qt_safe_pipe(int pipefd[2], int flags = 0)
{
#ifdef O_CLOEXEC
Q_ASSERT((flags & ~(O_CLOEXEC | O_NONBLOCK)) == 0);
#else
Q_ASSERT((flags & ~O_NONBLOCK) == 0);
#endif
int ret;
#if QT_UNIX_SUPPORTS_THREADSAFE_CLOEXEC && defined(O_CLOEXEC)
// use pipe2
flags |= O_CLOEXEC;
ret = ::pipe2(pipefd, flags); // pipe2 is Linux-specific and is documented not to return EINTR
if (ret == 0 || errno != ENOSYS)
return ret;
#endif
ret = ::pipe(pipefd);
if (ret == -1)
return -1;
::fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
::fcntl(pipefd[1], F_SETFD, FD_CLOEXEC);
// set non-block too?
if (flags & O_NONBLOCK) {
::fcntl(pipefd[0], F_SETFL, ::fcntl(pipefd[0], F_GETFL) | O_NONBLOCK);
::fcntl(pipefd[1], F_SETFL, ::fcntl(pipefd[1], F_GETFL) | O_NONBLOCK);
}
return 0;
}
#endif // Q_OS_VXWORKS
// don't call dup or fcntl(F_DUPFD)
static inline int qt_safe_dup(int oldfd, int atleast = 0, int flags = FD_CLOEXEC)
{
Q_ASSERT(flags == FD_CLOEXEC || flags == 0);
int ret;
#ifdef F_DUPFD_CLOEXEC
// use this fcntl
if (flags & FD_CLOEXEC) {
ret = ::fcntl(oldfd, F_DUPFD_CLOEXEC, atleast);
if (ret != -1 || errno != EINVAL)
return ret;
}
#endif
// use F_DUPFD
ret = ::fcntl(oldfd, F_DUPFD, atleast);
if (flags && ret != -1)
::fcntl(ret, F_SETFD, flags);
return ret;
}
// don't call dup2
// call qt_safe_dup2
static inline int qt_safe_dup2(int oldfd, int newfd, int flags = FD_CLOEXEC)
{
Q_ASSERT(flags == FD_CLOEXEC || flags == 0);
int ret;
#if QT_UNIX_SUPPORTS_THREADSAFE_CLOEXEC && defined(O_CLOEXEC)
// use dup3
if (flags & FD_CLOEXEC) {
EINTR_LOOP(ret, ::dup3(oldfd, newfd, O_CLOEXEC));
if (ret == 0 || errno != ENOSYS)
return ret;
}
#endif
EINTR_LOOP(ret, ::dup2(oldfd, newfd));
if (ret == -1)
return -1;
if (flags)
::fcntl(newfd, F_SETFD, flags);
return 0;
}
static inline qint64 qt_safe_read(int fd, void *data, qint64 maxlen)
{
qint64 ret = 0;
EINTR_LOOP(ret, QT_READ(fd, data, maxlen));
return ret;
}
#undef QT_READ
#define QT_READ qt_safe_read
static inline qint64 qt_safe_write(int fd, const void *data, qint64 len)
{
qint64 ret = 0;
EINTR_LOOP(ret, QT_WRITE(fd, data, len));
return ret;
}
#undef QT_WRITE
#define QT_WRITE qt_safe_write
static inline qint64 qt_safe_write_nosignal(int fd, const void *data, qint64 len)
{
qt_ignore_sigpipe();
return qt_safe_write(fd, data, len);
}
static inline int qt_safe_close(int fd)
{
int ret;
EINTR_LOOP(ret, QT_CLOSE(fd));
return ret;
}
#undef QT_CLOSE
#define QT_CLOSE qt_safe_close
// - VxWorks doesn't have processes
#if !defined(Q_OS_VXWORKS)
static inline int qt_safe_execve(const char *filename, char *const argv[],
char *const envp[])
{
int ret;
EINTR_LOOP(ret, ::execve(filename, argv, envp));
return ret;
}
static inline int qt_safe_execv(const char *path, char *const argv[])
{
int ret;
EINTR_LOOP(ret, ::execv(path, argv));
return ret;
}
static inline int qt_safe_execvp(const char *file, char *const argv[])
{
int ret;
EINTR_LOOP(ret, ::execvp(file, argv));
return ret;
}
static inline pid_t qt_safe_waitpid(pid_t pid, int *status, int options)
{
int ret;
EINTR_LOOP(ret, ::waitpid(pid, status, options));
return ret;
}
#endif // Q_OS_VXWORKS
#if !defined(_POSIX_MONOTONIC_CLOCK)
# define _POSIX_MONOTONIC_CLOCK -1
#endif
// in qelapsedtimer_mac.cpp or qtimestamp_unix.cpp
timespec qt_gettime() Q_DECL_NOTHROW;
void qt_nanosleep(timespec amount);
int qt_safe_select(int nfds, fd_set *fdread, fd_set *fdwrite, fd_set *fdexcept, const struct timespec *tv);
// according to X/OPEN we have to define semun ourselves
// we use prefix as on some systems sem.h will have it
struct semid_ds;
union qt_semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif

164
src/app/core/backport/qfileinfo_p.h
View file

@ -1,164 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFILEINFO_P_H
#define QFILEINFO_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 <QFileInfo>
#include <QDateTime>
#include "qatomic.h"
#include <QSharedData>
#include "qfilesystemengine_p.h"
#include <QVector>
#include "qabstractfileengine_p.h"
#include "qfilesystementry_p.h"
#include "qfilesystemmetadata_p.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QFileInfoPrivate : public QSharedData
{
public:
enum { CachedFileFlags=0x01, CachedLinkTypeFlag=0x02, CachedBundleTypeFlag=0x04,
CachedMTime=0x10, CachedCTime=0x20, CachedATime=0x40,
CachedSize =0x08, CachedPerms=0x80 };
inline QFileInfoPrivate()
: QSharedData(), fileEngine(0),
cachedFlags(0),
isDefaultConstructed(true),
cache_enabled(true), fileFlags(0), fileSize(0)
{}
inline QFileInfoPrivate(const QFileInfoPrivate &copy)
: QSharedData(copy),
fileEntry(copy.fileEntry),
metaData(copy.metaData),
fileEngine(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(fileEntry, metaData)),
cachedFlags(0),
#ifndef QT_NO_FSFILEENGINE
isDefaultConstructed(false),
#else
isDefaultConstructed(!fileEngine),
#endif
cache_enabled(copy.cache_enabled), fileFlags(0), fileSize(0)
{}
inline QFileInfoPrivate(const QString &file)
: fileEntry(QDir::fromNativeSeparators(file)),
fileEngine(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(fileEntry, metaData)),
cachedFlags(0),
#ifndef QT_NO_FSFILEENGINE
isDefaultConstructed(false),
#else
isDefaultConstructed(!fileEngine),
#endif
cache_enabled(true), fileFlags(0), fileSize(0)
{
}
inline QFileInfoPrivate(const QFileSystemEntry &file, const QFileSystemMetaData &data)
: QSharedData(),
fileEntry(file),
metaData(data),
fileEngine(QFileSystemEngine::resolveEntryAndCreateLegacyEngine(fileEntry, metaData)),
cachedFlags(0),
isDefaultConstructed(false),
cache_enabled(true), fileFlags(0), fileSize(0)
{
//If the file engine is not null, this maybe a "mount point" for a custom file engine
//in which case we can't trust the metadata
if (fileEngine)
metaData = QFileSystemMetaData();
}
inline QFileInfoPrivate(const QFileSystemEntry &file, const QFileSystemMetaData &data, QAbstractFileEngine *engine)
: fileEntry(file),
metaData(data),
fileEngine(engine),
cachedFlags(0),
#ifndef QT_NO_FSFILEENGINE
isDefaultConstructed(false),
#else
isDefaultConstructed(!fileEngine),
#endif
cache_enabled(true), fileFlags(0), fileSize(0)
{
}
inline void clearFlags() const {
fileFlags = 0;
cachedFlags = 0;
if (fileEngine)
(void)fileEngine->fileFlags(QAbstractFileEngine::Refresh);
}
inline void clear() {
metaData.clear();
clearFlags();
for (int i = QAbstractFileEngine::NFileNames - 1 ; i >= 0 ; --i)
fileNames[i].clear();
fileOwners[1].clear();
fileOwners[0].clear();
}
uint getFileFlags(QAbstractFileEngine::FileFlags) const;
QDateTime &getFileTime(QAbstractFileEngine::FileTime) const;
QString getFileName(QAbstractFileEngine::FileName) const;
QString getFileOwner(QAbstractFileEngine::FileOwner own) const;
QFileSystemEntry fileEntry;
mutable QFileSystemMetaData metaData;
QScopedPointer<QAbstractFileEngine> const fileEngine;
mutable QString fileNames[QAbstractFileEngine::NFileNames];
mutable QString fileOwners[2];
mutable uint cachedFlags : 30;
bool const isDefaultConstructed : 1; // QFileInfo is a default constructed instance
bool cache_enabled : 1;
mutable uint fileFlags;
mutable qint64 fileSize;
// ### Qt6: FIXME: This vector is essentially a plain array
// mutable QDateTime fileTimes[3], but the array is slower
// to initialize than the QVector as QDateTime has a pimpl.
// In Qt 6, QDateTime should inline its data members,
// and this here can be an array again.
mutable QVector<QDateTime> fileTimes;
inline bool getCachedFlag(uint c) const
{ return cache_enabled ? (cachedFlags & c) : 0; }
inline void setCachedFlag(uint c) const
{ if (cache_enabled) cachedFlags |= c; }
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QFILEINFO_P_H

403
src/app/core/backport/qfilesystemengine.cpp
View file

@ -1,403 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qfilesystemengine_p.h"
#include <QDir>
#include <QSet>
#include <QStringBuilder>
#include "qabstractfileengine_p.h"
#ifdef QT_BUILD_CORE_LIB
#include "qresource_p.h"
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
/*!
\internal
Returns the canonicalized form of \a path (i.e., with all symlinks
resolved, and all redundant path elements removed.
*/
QString QFileSystemEngine::slowCanonicalized(const QString &path)
{
if (path.isEmpty())
return path;
QFileInfo fi;
const QChar slash(QLatin1Char('/'));
QString tmpPath = path;
int separatorPos = 0;
QSet<QString> nonSymlinks;
QSet<QString> known;
known.insert(path);
do {
#ifdef Q_OS_WIN
if (separatorPos == 0) {
if (tmpPath.size() >= 2 && tmpPath.at(0) == slash && tmpPath.at(1) == slash) {
// UNC, skip past the first two elements
separatorPos = tmpPath.indexOf(slash, 2);
} else if (tmpPath.size() >= 3 && tmpPath.at(1) == QLatin1Char(':') && tmpPath.at(2) == slash) {
// volume root, skip since it can not be a symlink
separatorPos = 2;
}
}
if (separatorPos != -1)
#endif
separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
if (!nonSymlinks.contains(prefix)) {
fi.setFile(prefix);
if (fi.isSymLink()) {
QString target = fi.symLinkTarget();
if(QFileInfo(target).isRelative())
target = fi.absolutePath() + slash + target;
if (separatorPos != -1) {
if (fi.isDir() && !target.endsWith(slash))
target.append(slash);
target.append(tmpPath.mid(separatorPos));
}
tmpPath = QDir::cleanPath(target);
separatorPos = 0;
if (known.contains(tmpPath))
return QString();
known.insert(tmpPath);
} else {
nonSymlinks.insert(prefix);
}
}
} while (separatorPos != -1);
return QDir::cleanPath(tmpPath);
}
static inline bool _q_checkEntry(QFileSystemEntry &entry, QFileSystemMetaData &data, bool resolvingEntry)
{
if (resolvingEntry) {
if (!QFileSystemEngine::fillMetaData(entry, data, QFileSystemMetaData::ExistsAttribute)
|| !data.exists()) {
data.clear();
return false;
}
}
return true;
}
static inline bool _q_checkEntry(QAbstractFileEngine *&engine, bool resolvingEntry)
{
if (resolvingEntry) {
if (!(engine->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::ExistsFlag)) {
delete engine;
engine = 0;
return false;
}
}
return true;
}
static bool _q_resolveEntryAndCreateLegacyEngine_recursive(QFileSystemEntry &entry, QFileSystemMetaData &data,
QAbstractFileEngine *&engine, bool resolvingEntry = false)
{
QString const &filePath = entry.filePath();
if ((engine = qt_custom_file_engine_handler_create(filePath)))
return _q_checkEntry(engine, resolvingEntry);
#if defined(QT_BUILD_CORE_LIB)
for (int prefixSeparator = 0; prefixSeparator < filePath.size(); ++prefixSeparator) {
QChar const ch = filePath[prefixSeparator];
if (ch == QLatin1Char('/'))
break;
if (ch == QLatin1Char(':')) {
if (prefixSeparator == 0) {
engine = new QResourceFileEngine(filePath);
return _q_checkEntry(engine, resolvingEntry);
}
if (prefixSeparator == 1)
break;
const QStringList &paths = QDir::searchPaths(filePath.left(prefixSeparator));
for (int i = 0; i < paths.count(); i++) {
entry = QFileSystemEntry(QDir::cleanPath(paths.at(i) % QLatin1Char('/') % filePath.mid(prefixSeparator + 1)));
// Recurse!
if (_q_resolveEntryAndCreateLegacyEngine_recursive(entry, data, engine, true))
return true;
}
// entry may have been clobbered at this point.
return false;
}
// There's no need to fully validate the prefix here. Consulting the
// unicode tables could be expensive and validation is already
// performed in QDir::setSearchPaths.
//
// if (!ch.isLetterOrNumber())
// break;
}
#endif // defined(QT_BUILD_CORE_LIB)
return _q_checkEntry(entry, data, resolvingEntry);
}
/*!
\internal
Resolves the \a entry (see QDir::searchPaths) and returns an engine for
it, but never a QFSFileEngine.
Returns a file engine that can be used to access the entry. Returns 0 if
QFileSystemEngine API should be used to query and interact with the file
system object.
*/
QAbstractFileEngine *QFileSystemEngine::resolveEntryAndCreateLegacyEngine(
QFileSystemEntry &entry, QFileSystemMetaData &data) {
QFileSystemEntry copy = entry;
QAbstractFileEngine *engine = 0;
if (_q_resolveEntryAndCreateLegacyEngine_recursive(copy, data, engine))
// Reset entry to resolved copy.
entry = copy;
else
data.clear();
return engine;
}
//these unix functions are in this file, because they are shared by symbian port
//for open C file handles.
#ifdef Q_OS_UNIX
//static
bool QFileSystemEngine::fillMetaData(int fd, QFileSystemMetaData &data)
{
data.entryFlags &= ~QFileSystemMetaData::PosixStatFlags;
data.knownFlagsMask |= QFileSystemMetaData::PosixStatFlags;
QT_STATBUF statBuffer;
if (QT_FSTAT(fd, &statBuffer) == 0) {
data.fillFromStatBuf(statBuffer);
return true;
}
return false;
}
#if defined(Q_OS_QNX)
static void fillStat64fromStat32(struct stat64 *statBuf64, const struct stat &statBuf32)
{
statBuf64->st_mode = statBuf32.st_mode;
statBuf64->st_size = statBuf32.st_size;
statBuf64->st_ctime = statBuf32.st_ctime;
statBuf64->st_mtime = statBuf32.st_mtime;
statBuf64->st_atime = statBuf32.st_atime;
statBuf64->st_uid = statBuf32.st_uid;
statBuf64->st_gid = statBuf32.st_gid;
}
#endif
void QFileSystemMetaData::fillFromStatBuf(const QT_STATBUF &statBuffer)
{
// Permissions
if (statBuffer.st_mode & S_IRUSR)
entryFlags |= QFileSystemMetaData::OwnerReadPermission;
if (statBuffer.st_mode & S_IWUSR)
entryFlags |= QFileSystemMetaData::OwnerWritePermission;
if (statBuffer.st_mode & S_IXUSR)
entryFlags |= QFileSystemMetaData::OwnerExecutePermission;
if (statBuffer.st_mode & S_IRGRP)
entryFlags |= QFileSystemMetaData::GroupReadPermission;
if (statBuffer.st_mode & S_IWGRP)
entryFlags |= QFileSystemMetaData::GroupWritePermission;
if (statBuffer.st_mode & S_IXGRP)
entryFlags |= QFileSystemMetaData::GroupExecutePermission;
if (statBuffer.st_mode & S_IROTH)
entryFlags |= QFileSystemMetaData::OtherReadPermission;
if (statBuffer.st_mode & S_IWOTH)
entryFlags |= QFileSystemMetaData::OtherWritePermission;
if (statBuffer.st_mode & S_IXOTH)
entryFlags |= QFileSystemMetaData::OtherExecutePermission;
// Type
if ((statBuffer.st_mode & S_IFMT) == S_IFREG)
entryFlags |= QFileSystemMetaData::FileType;
else if ((statBuffer.st_mode & S_IFMT) == S_IFDIR)
entryFlags |= QFileSystemMetaData::DirectoryType;
else
entryFlags |= QFileSystemMetaData::SequentialType;
// Attributes
entryFlags |= QFileSystemMetaData::ExistsAttribute;
size_ = statBuffer.st_size;
#if defined(Q_OS_MACX)
if (statBuffer.st_flags & UF_HIDDEN) {
entryFlags |= QFileSystemMetaData::HiddenAttribute;
knownFlagsMask |= QFileSystemMetaData::HiddenAttribute;
}
#endif
// Times
creationTime_ = statBuffer.st_ctime ? statBuffer.st_ctime : statBuffer.st_mtime;
modificationTime_ = statBuffer.st_mtime;
accessTime_ = statBuffer.st_atime;
userId_ = statBuffer.st_uid;
groupId_ = statBuffer.st_gid;
}
void QFileSystemMetaData::fillFromDirEnt(const QT_DIRENT &entry)
{
#if defined(Q_OS_QNX)
knownFlagsMask = 0;
entryFlags = 0;
for (dirent_extra *extra = _DEXTRA_FIRST(&entry); _DEXTRA_VALID(extra, &entry);
extra = _DEXTRA_NEXT(extra)) {
if (extra->d_type == _DTYPE_STAT || extra->d_type == _DTYPE_LSTAT) {
const struct dirent_extra_stat * const extra_stat =
reinterpret_cast<struct dirent_extra_stat *>(extra);
// Remember whether this was a link or not, this saves an lstat() call later.
if (extra->d_type == _DTYPE_LSTAT) {
knownFlagsMask |= QFileSystemMetaData::LinkType;
if (S_ISLNK(extra_stat->d_stat.st_mode))
entryFlags |= QFileSystemMetaData::LinkType;
}
// For symlinks, the extra type _DTYPE_LSTAT doesn't work for filling out the meta data,
// as we need the stat() information there, not the lstat() information.
// In this case, don't use the extra information.
// Unfortunately, readdir() never seems to return extra info of type _DTYPE_STAT, so for
// symlinks, we always incur the cost of an extra stat() call later.
if (S_ISLNK(extra_stat->d_stat.st_mode) && extra->d_type == _DTYPE_LSTAT)
continue;
#if defined(QT_USE_XOPEN_LFS_EXTENSIONS) && defined(QT_LARGEFILE_SUPPORT)
// Even with large file support, d_stat is always of type struct stat, not struct stat64,
// so it needs to be converted
struct stat64 statBuf;
fillStat64fromStat32(&statBuf, extra_stat->d_stat);
fillFromStatBuf(statBuf);
#else
fillFromStatBuf(extra_stat->d_stat);
#endif
knownFlagsMask |= QFileSystemMetaData::PosixStatFlags;
if (!S_ISLNK(extra_stat->d_stat.st_mode)) {
knownFlagsMask |= QFileSystemMetaData::ExistsAttribute;
entryFlags |= QFileSystemMetaData::ExistsAttribute;
}
}
}
#elif defined(_DIRENT_HAVE_D_TYPE) || defined(Q_OS_BSD4)
// BSD4 includes Mac OS X
// ### This will clear all entry flags and knownFlagsMask
switch (entry.d_type)
{
case DT_DIR:
knownFlagsMask = QFileSystemMetaData::LinkType
| QFileSystemMetaData::FileType
| QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::SequentialType
| QFileSystemMetaData::ExistsAttribute;
entryFlags = QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::ExistsAttribute;
break;
case DT_BLK:
case DT_CHR:
case DT_FIFO:
case DT_SOCK:
// ### System attribute
knownFlagsMask = QFileSystemMetaData::LinkType
| QFileSystemMetaData::FileType
| QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::BundleType
| QFileSystemMetaData::AliasType
| QFileSystemMetaData::SequentialType
| QFileSystemMetaData::ExistsAttribute;
entryFlags = QFileSystemMetaData::SequentialType
| QFileSystemMetaData::ExistsAttribute;
break;
case DT_LNK:
knownFlagsMask = QFileSystemMetaData::LinkType;
entryFlags = QFileSystemMetaData::LinkType;
break;
case DT_REG:
knownFlagsMask = QFileSystemMetaData::LinkType
| QFileSystemMetaData::FileType
| QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::BundleType
| QFileSystemMetaData::SequentialType
| QFileSystemMetaData::ExistsAttribute;
entryFlags = QFileSystemMetaData::FileType
| QFileSystemMetaData::ExistsAttribute;
break;
case DT_UNKNOWN:
default:
clear();
}
#else
Q_UNUSED(entry)
#endif
}
#endif
//static
QString QFileSystemEngine::resolveUserName(const QFileSystemEntry &entry, QFileSystemMetaData &metaData)
{
#if defined(Q_OS_WIN)
Q_UNUSED(metaData);
return QFileSystemEngine::owner(entry, QAbstractFileEngine::OwnerUser);
#else //(Q_OS_UNIX)
if (!metaData.hasFlags(QFileSystemMetaData::UserId))
QFileSystemEngine::fillMetaData(entry, metaData, QFileSystemMetaData::UserId);
return resolveUserName(metaData.userId());
#endif
}
//static
QString QFileSystemEngine::resolveGroupName(const QFileSystemEntry &entry, QFileSystemMetaData &metaData)
{
#if defined(Q_OS_WIN)
Q_UNUSED(metaData);
return QFileSystemEngine::owner(entry, QAbstractFileEngine::OwnerGroup);
#else //(Q_OS_UNIX)
if (!metaData.hasFlags(QFileSystemMetaData::GroupId))
QFileSystemEngine::fillMetaData(entry, metaData, QFileSystemMetaData::GroupId);
return resolveGroupName(metaData.groupId());
#endif
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

120
src/app/core/backport/qfilesystemengine_p.h
View file

@ -1,120 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFILESYSTEMENGINE_P_H
#define QFILESYSTEMENGINE_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 <QFile>
#include "qfilesystementry_p.h"
#include "qfilesystemmetadata_p.h"
#include "qsystemerror_p.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QFileSystemEngine
{
public:
static bool isCaseSensitive()
{
#ifndef Q_OS_WIN
return true;
#else
return false;
#endif
}
static QFileSystemEntry getLinkTarget(const QFileSystemEntry &link, QFileSystemMetaData &data);
static QFileSystemEntry canonicalName(const QFileSystemEntry &entry, QFileSystemMetaData &data);
static QFileSystemEntry absoluteName(const QFileSystemEntry &entry);
static QByteArray id(const QFileSystemEntry &entry);
static QString resolveUserName(const QFileSystemEntry &entry, QFileSystemMetaData &data);
static QString resolveGroupName(const QFileSystemEntry &entry, QFileSystemMetaData &data);
#if defined(Q_OS_UNIX)
static QString resolveUserName(uint userId);
static QString resolveGroupName(uint groupId);
#endif
#if defined(Q_OS_MACX)
static QString bundleName(const QFileSystemEntry &entry);
#else
static QString bundleName(const QFileSystemEntry &entry) { Q_UNUSED(entry) return QString(); }
#endif
static bool fillMetaData(const QFileSystemEntry &entry, QFileSystemMetaData &data,
QFileSystemMetaData::MetaDataFlags what);
#if defined(Q_OS_UNIX)
static bool fillMetaData(int fd, QFileSystemMetaData &data); // what = PosixStatFlags
#endif
#if defined(Q_OS_WIN)
static bool uncListSharesOnServer(const QString &server, QStringList *list); //Used also by QFSFileEngineIterator::hasNext()
static bool fillMetaData(int fd, QFileSystemMetaData &data,
QFileSystemMetaData::MetaDataFlags what);
static bool fillMetaData(HANDLE fHandle, QFileSystemMetaData &data,
QFileSystemMetaData::MetaDataFlags what);
static bool fillPermissions(const QFileSystemEntry &entry, QFileSystemMetaData &data,
QFileSystemMetaData::MetaDataFlags what);
static QString owner(const QFileSystemEntry &entry, QAbstractFileEngine::FileOwner own);
static QString nativeAbsoluteFilePath(const QString &path);
#endif
//homePath, rootPath and tempPath shall return clean paths
static QString homePath();
static QString rootPath();
static QString tempPath();
static bool createDirectory(const QFileSystemEntry &entry, bool createParents);
static bool removeDirectory(const QFileSystemEntry &entry, bool removeEmptyParents);
static bool createLink(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error);
static bool copyFile(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error);
static bool renameFile(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error);
static bool removeFile(const QFileSystemEntry &entry, QSystemError &error);
static bool setPermissions(const QFileSystemEntry &entry, QFile::Permissions permissions, QSystemError &error,
QFileSystemMetaData *data = 0);
static bool setCurrentPath(const QFileSystemEntry &entry);
static QFileSystemEntry currentPath();
static QAbstractFileEngine *resolveEntryAndCreateLegacyEngine(QFileSystemEntry &entry,
QFileSystemMetaData &data);
private:
static QString slowCanonicalized(const QString &path);
#if defined(Q_OS_WIN)
static void clearWinStatData(QFileSystemMetaData &data);
#endif
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // include guard

756
src/app/core/backport/qfilesystemengine_unix.cpp
View file

@ -1,756 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Samuel Gaist <samuel.gaist@edeltech.ch>>
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qplatformdefs.h"
#include "qfilesystemengine_p.h"
#include <QFile>
#include <QVarLengthArray>
#include <stdlib.h> // for realpath()
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#if defined(Q_OS_MAC)
# include "qcore_mac_p.h"
# include <CoreFoundation/CFBundle.h>
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#if defined(Q_OS_MACX)
static inline bool _q_isMacHidden(const char *nativePath)
{
OSErr err;
FSRef fsRef;
err = FSPathMakeRefWithOptions(reinterpret_cast<const UInt8 *>(nativePath),
kFSPathMakeRefDoNotFollowLeafSymlink, &fsRef, 0);
if (err != noErr)
return false;
FSCatalogInfo catInfo;
err = FSGetCatalogInfo(&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL);
if (err != noErr)
return false;
FileInfo * const fileInfo = reinterpret_cast<FileInfo*>(&catInfo.finderInfo);
return (fileInfo->finderFlags & kIsInvisible);
}
static bool isPackage(const QFileSystemMetaData &data, const QFileSystemEntry &entry)
{
if (!data.isDirectory())
return false;
QFileInfo info(entry.filePath());
QString suffix = info.suffix();
// First step: is the extenstion known ?
if (suffix == QLatin1String("app")
|| suffix == QLatin1String("debug")
|| suffix == QLatin1String("profile")
|| suffix == QLatin1String("bundle")
|| suffix == QLatin1String("pkg")) {
return true;
}
// Second step: check if an application knows the package type
const QByteArray &native = entry.nativeFilePath();
const char *nativeFilePath = native.constData();
int nativeFilePathLength = native.size();
QCFType<CFStringRef> path = CFStringCreateWithBytes(0,
reinterpret_cast<const UInt8*>(nativeFilePath),
nativeFilePathLength,
kCFStringEncodingUTF8,
false);
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, path, kCFURLPOSIXPathStyle, true);
UInt32 type, creator;
// Well created packages have the PkgInfo file
if (CFBundleGetPackageInfoInDirectory(url, &type, &creator))
return true;
// Find if an application other than Finder claims to know how to handle the package
if (suffix.length() > 0) {
QCFType<CFURLRef> application;
LSGetApplicationForURL(url,
kLSRolesEditor|kLSRolesViewer|kLSRolesViewer,
NULL,
&application);
if (application) {
CFStringRef path = CFURLGetString(application);
QString applicationPath = QCFString::toQString(path);
if (applicationPath != QLatin1String("file://localhost/System/Library/CoreServices/Finder.app/"))
return true;
}
}
// Third step: check if the directory has the package bit set
FSRef packageRef;
FSPathMakeRef((UInt8 *)nativeFilePath, &packageRef, NULL);
FSCatalogInfo catalogInfo;
FSGetCatalogInfo(&packageRef,
kFSCatInfoFinderInfo,
&catalogInfo,
NULL,
NULL,
NULL);
FolderInfo *folderInfo = reinterpret_cast<FolderInfo *>(catalogInfo.finderInfo);
return folderInfo->finderFlags & kHasBundle;
}
#else
static inline bool _q_isMacHidden(const char *nativePath)
{
Q_UNUSED(nativePath);
// no-op
return false;
}
#endif
//static
QFileSystemEntry QFileSystemEngine::getLinkTarget(const QFileSystemEntry &link, QFileSystemMetaData &data)
{
#if defined(__GLIBC__) && !defined(PATH_MAX)
#define PATH_CHUNK_SIZE 256
char *s = 0;
int len = -1;
int size = PATH_CHUNK_SIZE;
while (1) {
s = (char *) ::realloc(s, size);
Q_CHECK_PTR(s);
len = ::readlink(link.nativeFilePath().constData(), s, size);
if (len < 0) {
::free(s);
break;
}
if (len < size) {
break;
}
size *= 2;
}
#else
char s[PATH_MAX+1];
int len = readlink(link.nativeFilePath().constData(), s, PATH_MAX);
#endif
if (len > 0) {
QString ret;
if (!data.hasFlags(QFileSystemMetaData::DirectoryType))
fillMetaData(link, data, QFileSystemMetaData::DirectoryType);
if (data.isDirectory() && s[0] != '/') {
QDir parent(link.filePath());
parent.cdUp();
ret = parent.path();
if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
ret += QLatin1Char('/');
}
s[len] = '\0';
ret += QFile::decodeName(QByteArray(s));
#if defined(__GLIBC__) && !defined(PATH_MAX)
::free(s);
#endif
if (!ret.startsWith(QLatin1Char('/'))) {
if (link.filePath().startsWith(QLatin1Char('/'))) {
ret.prepend(link.filePath().left(link.filePath().lastIndexOf(QLatin1Char('/')))
+ QLatin1Char('/'));
} else {
ret.prepend(QDir::currentPath() + QLatin1Char('/'));
}
}
ret = QDir::cleanPath(ret);
if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
ret.chop(1);
return QFileSystemEntry(ret);
}
#if defined(Q_OS_MACX)
{
FSRef fref;
if (FSPathMakeRef((const UInt8 *)QFile::encodeName(QDir::cleanPath(link.filePath())).data(), &fref, 0) == noErr) {
// TODO get the meta data info from the QFileSystemMetaData object
Boolean isAlias, isFolder;
if (FSResolveAliasFile(&fref, true, &isFolder, &isAlias) == noErr && isAlias) {
AliasHandle alias;
if (FSNewAlias(0, &fref, &alias) == noErr && alias) {
QCFString cfstr;
if (FSCopyAliasInfo(alias, 0, 0, &cfstr, 0, 0) == noErr)
return QFileSystemEntry(QCFString::toQString(cfstr));
}
}
}
}
#endif
return QFileSystemEntry();
}
//static
QFileSystemEntry QFileSystemEngine::canonicalName(const QFileSystemEntry &entry, QFileSystemMetaData &data)
{
if (entry.isEmpty() || entry.isRoot())
return entry;
#if !defined(Q_OS_MAC) && !defined(Q_OS_QNX) && !defined(Q_OS_ANDROID) && _POSIX_VERSION < 200809L
// realpath(X,0) is not supported
Q_UNUSED(data);
return QFileSystemEntry(slowCanonicalized(absoluteName(entry).filePath()));
#else
char *ret = 0;
# if defined(Q_OS_MACX)
// When using -mmacosx-version-min=10.4, we get the legacy realpath implementation,
// which does not work properly with the realpath(X,0) form. See QTBUG-28282.
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) {
ret = (char*)malloc(PATH_MAX + 1);
if (ret && realpath(entry.nativeFilePath().constData(), (char*)ret) == 0) {
const int savedErrno = errno; // errno is checked below, and free() might change it
free(ret);
errno = savedErrno;
ret = 0;
}
} else {
// on 10.5 we can use FSRef to resolve the file path.
QString path = QDir::cleanPath(entry.filePath());
FSRef fsref;
if (FSPathMakeRef((const UInt8 *)path.toUtf8().data(), &fsref, 0) == noErr) {
CFURLRef urlref = CFURLCreateFromFSRef(NULL, &fsref);
CFStringRef canonicalPath = CFURLCopyFileSystemPath(urlref, kCFURLPOSIXPathStyle);
QString ret = QCFString::toQString(canonicalPath);
CFRelease(canonicalPath);
CFRelease(urlref);
return QFileSystemEntry(ret);
}
}
# else
# if _POSIX_VERSION >= 200801L
ret = realpath(entry.nativeFilePath().constData(), (char*)0);
# else
ret = (char*)malloc(PATH_MAX + 1);
if (realpath(entry.nativeFilePath().constData(), (char*)ret) == 0) {
const int savedErrno = errno; // errno is checked below, and free() might change it
free(ret);
errno = savedErrno;
ret = 0;
}
# endif
# endif
if (ret) {
data.knownFlagsMask |= QFileSystemMetaData::ExistsAttribute;
data.entryFlags |= QFileSystemMetaData::ExistsAttribute;
QString canonicalPath = QDir::cleanPath(QString::fromLocal8Bit(ret));
free(ret);
return QFileSystemEntry(canonicalPath);
} else if (errno == ENOENT) { // file doesn't exist
data.knownFlagsMask |= QFileSystemMetaData::ExistsAttribute;
data.entryFlags &= ~(QFileSystemMetaData::ExistsAttribute);
return QFileSystemEntry();
}
return entry;
#endif
}
//static
QFileSystemEntry QFileSystemEngine::absoluteName(const QFileSystemEntry &entry)
{
if (entry.isAbsolute() && entry.isClean())
return entry;
QByteArray orig = entry.nativeFilePath();
QByteArray result;
if (orig.isEmpty() || !orig.startsWith('/')) {
QFileSystemEntry cur(currentPath());
result = cur.nativeFilePath();
}
if (!orig.isEmpty() && !(orig.length() == 1 && orig[0] == '.')) {
if (!result.isEmpty() && !result.endsWith('/'))
result.append('/');
result.append(orig);
}
if (result.length() == 1 && result[0] == '/')
return QFileSystemEntry(result, QFileSystemEntry::FromNativePath());
const bool isDir = result.endsWith('/');
/* as long as QDir::cleanPath() operates on a QString we have to convert to a string here.
* ideally we never convert to a string since that loses information. Please fix after
* we get a QByteArray version of QDir::cleanPath()
*/
QFileSystemEntry resultingEntry(result, QFileSystemEntry::FromNativePath());
QString stringVersion = QDir::cleanPath(resultingEntry.filePath());
if (isDir)
stringVersion.append(QLatin1Char('/'));
return QFileSystemEntry(stringVersion);
}
//static
QByteArray QFileSystemEngine::id(const QFileSystemEntry &entry)
{
struct stat statResult;
if (stat(entry.nativeFilePath().constData(), &statResult)) {
qErrnoWarning("stat() failed for '%s'", entry.nativeFilePath().constData());
return QByteArray();
}
QByteArray result = QByteArray::number(quint64(statResult.st_dev), 16);
result += ':';
result += QByteArray::number(quint64(statResult.st_ino));
return result;
}
//static
QString QFileSystemEngine::resolveUserName(uint userId)
{
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
int size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
if (size_max == -1)
size_max = 1024;
QVarLengthArray<char, 1024> buf(size_max);
#endif
struct passwd *pw = 0;
#if !defined(Q_OS_INTEGRITY)
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD) && !defined(Q_OS_VXWORKS)
struct passwd entry;
getpwuid_r(userId, &entry, buf.data(), buf.size(), &pw);
#else
pw = getpwuid(userId);
#endif
#endif
if (pw)
return QFile::decodeName(QByteArray(pw->pw_name));
return QString();
}
//static
QString QFileSystemEngine::resolveGroupName(uint groupId)
{
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
int size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
if (size_max == -1)
size_max = 1024;
QVarLengthArray<char, 1024> buf(size_max);
#endif
struct group *gr = 0;
#if !defined(Q_OS_INTEGRITY)
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD) && !defined(Q_OS_VXWORKS)
size_max = sysconf(_SC_GETGR_R_SIZE_MAX);
if (size_max == -1)
size_max = 1024;
buf.resize(size_max);
struct group entry;
// Some large systems have more members than the POSIX max size
// Loop over by doubling the buffer size (upper limit 250k)
for (unsigned size = size_max; size < 256000; size += size)
{
buf.resize(size);
// ERANGE indicates that the buffer was too small
if (!getgrgid_r(groupId, &entry, buf.data(), buf.size(), &gr)
|| errno != ERANGE)
break;
}
#else
gr = getgrgid(groupId);
#endif
#endif
if (gr)
return QFile::decodeName(QByteArray(gr->gr_name));
return QString();
}
#if defined(Q_OS_MACX)
//static
QString QFileSystemEngine::bundleName(const QFileSystemEntry &entry)
{
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(entry.filePath()),
kCFURLPOSIXPathStyle, true);
if (QCFType<CFDictionaryRef> dict = CFBundleCopyInfoDictionaryForURL(url)) {
if (CFTypeRef name = (CFTypeRef)CFDictionaryGetValue(dict, kCFBundleNameKey)) {
if (CFGetTypeID(name) == CFStringGetTypeID())
return QCFString::toQString((CFStringRef)name);
}
}
return QString();
}
#endif
//static
bool QFileSystemEngine::fillMetaData(const QFileSystemEntry &entry, QFileSystemMetaData &data,
QFileSystemMetaData::MetaDataFlags what)
{
#if defined(Q_OS_MACX)
if (what & QFileSystemMetaData::BundleType) {
if (!data.hasFlags(QFileSystemMetaData::DirectoryType))
what |= QFileSystemMetaData::DirectoryType;
}
if (what & QFileSystemMetaData::HiddenAttribute) {
// Mac OS >= 10.5: st_flags & UF_HIDDEN
what |= QFileSystemMetaData::PosixStatFlags;
}
#endif // defined(Q_OS_MACX)
if (what & QFileSystemMetaData::PosixStatFlags)
what |= QFileSystemMetaData::PosixStatFlags;
if (what & QFileSystemMetaData::ExistsAttribute) {
// FIXME: Would other queries being performed provide this bit?
what |= QFileSystemMetaData::PosixStatFlags;
}
data.entryFlags &= ~what;
const char * nativeFilePath;
int nativeFilePathLength;
{
const QByteArray &path = entry.nativeFilePath();
nativeFilePath = path.constData();
nativeFilePathLength = path.size();
Q_UNUSED(nativeFilePathLength);
}
bool entryExists = true; // innocent until proven otherwise
QT_STATBUF statBuffer;
bool statBufferValid = false;
if (what & QFileSystemMetaData::LinkType) {
if (QT_LSTAT(nativeFilePath, &statBuffer) == 0) {
if (S_ISLNK(statBuffer.st_mode)) {
data.entryFlags |= QFileSystemMetaData::LinkType;
} else {
statBufferValid = true;
data.entryFlags &= ~QFileSystemMetaData::PosixStatFlags;
}
} else {
entryExists = false;
}
data.knownFlagsMask |= QFileSystemMetaData::LinkType;
}
if (statBufferValid || (what & QFileSystemMetaData::PosixStatFlags)) {
if (entryExists && !statBufferValid)
statBufferValid = (QT_STAT(nativeFilePath, &statBuffer) == 0);
if (statBufferValid)
data.fillFromStatBuf(statBuffer);
else {
entryExists = false;
data.creationTime_ = 0;
data.modificationTime_ = 0;
data.accessTime_ = 0;
data.size_ = 0;
data.userId_ = (uint) -2;
data.groupId_ = (uint) -2;
}
// reset the mask
data.knownFlagsMask |= QFileSystemMetaData::PosixStatFlags
| QFileSystemMetaData::ExistsAttribute;
}
#if defined(Q_OS_MACX)
if (what & QFileSystemMetaData::AliasType)
{
if (entryExists) {
FSRef fref;
if (FSPathMakeRef((const UInt8 *)nativeFilePath, &fref, NULL) == noErr) {
Boolean isAlias, isFolder;
if (FSIsAliasFile(&fref, &isAlias, &isFolder) == noErr) {
if (isAlias)
data.entryFlags |= QFileSystemMetaData::AliasType;
}
}
}
data.knownFlagsMask |= QFileSystemMetaData::AliasType;
}
#endif
if (what & QFileSystemMetaData::UserPermissions) {
// calculate user permissions
if (entryExists) {
if (what & QFileSystemMetaData::UserReadPermission) {
if (QT_ACCESS(nativeFilePath, R_OK) == 0)
data.entryFlags |= QFileSystemMetaData::UserReadPermission;
}
if (what & QFileSystemMetaData::UserWritePermission) {
if (QT_ACCESS(nativeFilePath, W_OK) == 0)
data.entryFlags |= QFileSystemMetaData::UserWritePermission;
}
if (what & QFileSystemMetaData::UserExecutePermission) {
if (QT_ACCESS(nativeFilePath, X_OK) == 0)
data.entryFlags |= QFileSystemMetaData::UserExecutePermission;
}
}
data.knownFlagsMask |= (what & QFileSystemMetaData::UserPermissions);
}
if (what & QFileSystemMetaData::HiddenAttribute
&& !data.isHidden()) {
QString fileName = entry.fileName();
if ((fileName.size() > 0 && fileName.at(0) == QLatin1Char('.'))
|| (entryExists && _q_isMacHidden(nativeFilePath)))
data.entryFlags |= QFileSystemMetaData::HiddenAttribute;
data.knownFlagsMask |= QFileSystemMetaData::HiddenAttribute;
}
#if defined(Q_OS_MACX)
if (what & QFileSystemMetaData::BundleType) {
if (entryExists && isPackage(data, entry))
data.entryFlags |= QFileSystemMetaData::BundleType;
data.knownFlagsMask |= QFileSystemMetaData::BundleType;
}
#endif
if (!entryExists) {
data.clearFlags(what);
return false;
}
return data.hasFlags(what);
}
//static
bool QFileSystemEngine::createDirectory(const QFileSystemEntry &entry, bool createParents)
{
QString dirName = entry.filePath();
if (createParents) {
dirName = QDir::cleanPath(dirName);
for (int oldslash = -1, slash=0; slash != -1; oldslash = slash) {
slash = dirName.indexOf(QDir::separator(), oldslash+1);
if (slash == -1) {
if (oldslash == dirName.length())
break;
slash = dirName.length();
}
if (slash) {
const QByteArray chunk = QFile::encodeName(dirName.left(slash));
if (QT_MKDIR(chunk.constData(), 0777) != 0) {
if (errno == EEXIST
#if defined(Q_OS_QNX)
// On QNX the QNet (VFS paths of other hosts mounted under a directory
// such as /net) mountpoint returns ENOENT, despite existing. stat()
// on the QNet mountpoint returns successfully and reports S_IFDIR.
|| errno == ENOENT
#endif
) {
QT_STATBUF st;
if (QT_STAT(chunk.constData(), &st) == 0 && (st.st_mode & S_IFMT) == S_IFDIR)
continue;
}
return false;
}
}
}
return true;
}
#if defined(Q_OS_DARWIN) // Mac X doesn't support trailing /'s
if (dirName.endsWith(QLatin1Char('/')))
dirName.chop(1);
#endif
return (QT_MKDIR(QFile::encodeName(dirName).constData(), 0777) == 0);
}
//static
bool QFileSystemEngine::removeDirectory(const QFileSystemEntry &entry, bool removeEmptyParents)
{
if (removeEmptyParents) {
QString dirName = QDir::cleanPath(entry.filePath());
for (int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {
const QByteArray chunk = QFile::encodeName(dirName.left(slash));
QT_STATBUF st;
if (QT_STAT(chunk.constData(), &st) != -1) {
if ((st.st_mode & S_IFMT) != S_IFDIR)
return false;
if (::rmdir(chunk.constData()) != 0)
return oldslash != 0;
} else {
return false;
}
slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);
}
return true;
}
return rmdir(QFile::encodeName(entry.filePath()).constData()) == 0;
}
//static
bool QFileSystemEngine::createLink(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error)
{
if (::symlink(source.nativeFilePath().constData(), target.nativeFilePath().constData()) == 0)
return true;
error = QSystemError(errno, QSystemError::StandardLibraryError);
return false;
}
//static
bool QFileSystemEngine::copyFile(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error)
{
Q_UNUSED(source);
Q_UNUSED(target);
error = QSystemError(ENOSYS, QSystemError::StandardLibraryError); //Function not implemented
return false;
}
//static
bool QFileSystemEngine::renameFile(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error)
{
if (::rename(source.nativeFilePath().constData(), target.nativeFilePath().constData()) == 0)
return true;
error = QSystemError(errno, QSystemError::StandardLibraryError);
return false;
}
//static
bool QFileSystemEngine::removeFile(const QFileSystemEntry &entry, QSystemError &error)
{
if (unlink(entry.nativeFilePath().constData()) == 0)
return true;
error = QSystemError(errno, QSystemError::StandardLibraryError);
return false;
}
//static
bool QFileSystemEngine::setPermissions(const QFileSystemEntry &entry, QFile::Permissions permissions, QSystemError &error, QFileSystemMetaData *data)
{
mode_t mode = 0;
if (permissions & QFile::ReadOwner)
mode |= S_IRUSR;
if (permissions & QFile::WriteOwner)
mode |= S_IWUSR;
if (permissions & QFile::ExeOwner)
mode |= S_IXUSR;
if (permissions & QFile::ReadUser)
mode |= S_IRUSR;
if (permissions & QFile::WriteUser)
mode |= S_IWUSR;
if (permissions & QFile::ExeUser)
mode |= S_IXUSR;
if (permissions & QFile::ReadGroup)
mode |= S_IRGRP;
if (permissions & QFile::WriteGroup)
mode |= S_IWGRP;
if (permissions & QFile::ExeGroup)
mode |= S_IXGRP;
if (permissions & QFile::ReadOther)
mode |= S_IROTH;
if (permissions & QFile::WriteOther)
mode |= S_IWOTH;
if (permissions & QFile::ExeOther)
mode |= S_IXOTH;
bool success = ::chmod(entry.nativeFilePath().constData(), mode) == 0;
if (success && data) {
data->entryFlags &= ~QFileSystemMetaData::Permissions;
data->entryFlags |= QFileSystemMetaData::MetaDataFlag(uint(permissions));
data->knownFlagsMask |= QFileSystemMetaData::Permissions;
}
if (!success)
error = QSystemError(errno, QSystemError::StandardLibraryError);
return success;
}
QString QFileSystemEngine::homePath()
{
QString home = QFile::decodeName(qgetenv("HOME"));
if (home.isEmpty())
home = rootPath();
return QDir::cleanPath(home);
}
QString QFileSystemEngine::rootPath()
{
return QLatin1String("/");
}
QString QFileSystemEngine::tempPath()
{
#ifdef QT_UNIX_TEMP_PATH_OVERRIDE
return QLatin1String(QT_UNIX_TEMP_PATH_OVERRIDE);
#elif defined(Q_OS_BLACKBERRY)
QString temp = QFile::decodeName(qgetenv("TEMP"));
if (temp.isEmpty())
temp = QFile::decodeName(qgetenv("TMPDIR"));
if (temp.isEmpty()) {
qWarning("Neither the TEMP nor the TMPDIR environment variable is set, falling back to /tmp.");
temp = QLatin1String("/tmp/");
}
return QDir::cleanPath(temp);
#else
QString temp = QFile::decodeName(qgetenv("TMPDIR"));
if (temp.isEmpty())
temp = QLatin1String("/tmp/");
return QDir::cleanPath(temp);
#endif
}
bool QFileSystemEngine::setCurrentPath(const QFileSystemEntry &path)
{
int r;
r = QT_CHDIR(path.nativeFilePath().constData());
return r >= 0;
}
QFileSystemEntry QFileSystemEngine::currentPath()
{
QFileSystemEntry result;
QT_STATBUF st;
if (QT_STAT(".", &st) == 0) {
#if defined(__GLIBC__) && !defined(PATH_MAX)
char *currentName = ::get_current_dir_name();
if (currentName) {
result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
::free(currentName);
}
#else
char currentName[PATH_MAX+1];
if (::getcwd(currentName, PATH_MAX)) {
#if defined(Q_OS_VXWORKS) && defined(VXWORKS_VXSIM)
QByteArray dir(currentName);
if (dir.indexOf(':') < dir.indexOf('/'))
dir.remove(0, dir.indexOf(':')+1);
qstrncpy(currentName, dir.constData(), PATH_MAX);
#endif
result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
}
# if defined(QT_DEBUG)
if (result.isEmpty())
qWarning("QFileSystemEngine::currentPath: getcwd() failed");
# endif
#endif
} else {
# if defined(QT_DEBUG)
qWarning("QFileSystemEngine::currentPath: stat(\".\") failed");
# endif
}
return result;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

1324
src/app/core/backport/qfilesystemengine_win.cpp
View file

File diff suppressed because it is too large Load diff

388
src/app/core/backport/qfilesystementry.cpp
View file

@ -1,388 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qfilesystementry_p.h"
#include <QDir>
#include <QFile>
#include "qfsfileengine_p.h"
#ifdef Q_OS_WIN
#include <QStringBuilder>
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifdef Q_OS_WIN
static bool isUncRoot(const QString &server)
{
QString localPath = QDir::toNativeSeparators(server);
if (!localPath.startsWith(QLatin1String("\\\\")))
return false;
int idx = localPath.indexOf(QLatin1Char('\\'), 2);
if (idx == -1 || idx + 1 == localPath.length())
return true;
localPath = localPath.right(localPath.length() - idx - 1).trimmed();
return localPath.isEmpty();
}
static inline QString fixIfRelativeUncPath(const QString &path)
{
QString currentPath = QDir::currentPath();
if (currentPath.startsWith(QLatin1String("//")))
return currentPath % QChar(QLatin1Char('/')) % path;
return path;
}
#endif
QFileSystemEntry::QFileSystemEntry()
: m_lastSeparator(-1),
m_firstDotInFileName(-1),
m_lastDotInFileName(-1)
{
}
/*!
\internal
Use this constructor when the path is supplied by user code, as it may contain a mix
of '/' and the native separator.
*/
QFileSystemEntry::QFileSystemEntry(const QString &filePath)
: m_filePath(QDir::fromNativeSeparators(filePath)),
m_lastSeparator(-2),
m_firstDotInFileName(-2),
m_lastDotInFileName(0)
{
}
/*!
\internal
Use this constructor when the path is guaranteed to be in internal format, i.e. all
directory separators are '/' and not the native separator.
*/
QFileSystemEntry::QFileSystemEntry(const QString &filePath, FromInternalPath /* dummy */)
: m_filePath(filePath),
m_lastSeparator(-2),
m_firstDotInFileName(-2),
m_lastDotInFileName(0)
{
}
/*!
\internal
Use this constructor when the path comes from a native API
*/
QFileSystemEntry::QFileSystemEntry(const NativePath &nativeFilePath, FromNativePath /* dummy */)
: m_nativeFilePath(nativeFilePath),
m_lastSeparator(-2),
m_firstDotInFileName(-2),
m_lastDotInFileName(0)
{
}
QFileSystemEntry::QFileSystemEntry(const QString &filePath, const NativePath &nativeFilePath)
: m_filePath(QDir::fromNativeSeparators(filePath)),
m_nativeFilePath(nativeFilePath),
m_lastSeparator(-2),
m_firstDotInFileName(-2),
m_lastDotInFileName(0)
{
}
QString QFileSystemEntry::filePath() const
{
resolveFilePath();
return m_filePath;
}
QFileSystemEntry::NativePath QFileSystemEntry::nativeFilePath() const
{
resolveNativeFilePath();
return m_nativeFilePath;
}
void QFileSystemEntry::resolveFilePath() const
{
if (m_filePath.isEmpty() && !m_nativeFilePath.isEmpty()) {
#if defined(QFILESYSTEMENTRY_NATIVE_PATH_IS_UTF16)
m_filePath = QDir::fromNativeSeparators(m_nativeFilePath);
#ifdef Q_OS_WIN
if (m_filePath.startsWith(QLatin1String("//?/UNC/")))
m_filePath = m_filePath.remove(2,6);
if (m_filePath.startsWith(QLatin1String("//?/")))
m_filePath = m_filePath.remove(0,4);
#endif
#else
m_filePath = QDir::fromNativeSeparators(QFile::decodeName(m_nativeFilePath));
#endif
}
}
void QFileSystemEntry::resolveNativeFilePath() const
{
if (!m_filePath.isEmpty() && m_nativeFilePath.isEmpty()) {
#ifdef Q_OS_WIN
QString filePath = m_filePath;
if (isRelative())
filePath = fixIfRelativeUncPath(m_filePath);
m_nativeFilePath = QFSFileEnginePrivate::longFileName(QDir::toNativeSeparators(filePath));
#elif defined(QFILESYSTEMENTRY_NATIVE_PATH_IS_UTF16)
m_nativeFilePath = QDir::toNativeSeparators(m_filePath);
#else
m_nativeFilePath = QFile::encodeName(QDir::toNativeSeparators(m_filePath));
#endif
}
}
QString QFileSystemEntry::fileName() const
{
findLastSeparator();
#if defined(Q_OS_WIN)
if (m_lastSeparator == -1 && m_filePath.length() >= 2 && m_filePath.at(1) == QLatin1Char(':'))
return m_filePath.mid(2);
#endif
return m_filePath.mid(m_lastSeparator + 1);
}
QString QFileSystemEntry::path() const
{
findLastSeparator();
if (m_lastSeparator == -1) {
#if defined(Q_OS_WIN)
if (m_filePath.length() >= 2 && m_filePath.at(1) == QLatin1Char(':'))
return QFSFileEngine::currentPath(m_filePath.left(2));
#endif
return QString(QLatin1Char('.'));
}
if (m_lastSeparator == 0)
return QString(QLatin1Char('/'));
#if defined(Q_OS_WIN)
if (m_lastSeparator == 2 && m_filePath.at(1) == QLatin1Char(':'))
return m_filePath.left(m_lastSeparator + 1);
#endif
return m_filePath.left(m_lastSeparator);
}
QString QFileSystemEntry::baseName() const
{
findFileNameSeparators();
int length = -1;
if (m_firstDotInFileName >= 0) {
length = m_firstDotInFileName;
if (m_lastSeparator != -1) // avoid off by one
length--;
}
#if defined(Q_OS_WIN)
if (m_lastSeparator == -1 && m_filePath.length() >= 2 && m_filePath.at(1) == QLatin1Char(':'))
return m_filePath.mid(2, length - 2);
#endif
return m_filePath.mid(m_lastSeparator + 1, length);
}
QString QFileSystemEntry::completeBaseName() const
{
findFileNameSeparators();
int length = -1;
if (m_firstDotInFileName >= 0) {
length = m_firstDotInFileName + m_lastDotInFileName;
if (m_lastSeparator != -1) // avoid off by one
length--;
}
#if defined(Q_OS_WIN)
if (m_lastSeparator == -1 && m_filePath.length() >= 2 && m_filePath.at(1) == QLatin1Char(':'))
return m_filePath.mid(2, length - 2);
#endif
return m_filePath.mid(m_lastSeparator + 1, length);
}
QString QFileSystemEntry::suffix() const
{
findFileNameSeparators();
if (m_lastDotInFileName == -1)
return QString();
return m_filePath.mid(qMax((qint16)0, m_lastSeparator) + m_firstDotInFileName + m_lastDotInFileName + 1);
}
QString QFileSystemEntry::completeSuffix() const
{
findFileNameSeparators();
if (m_firstDotInFileName == -1)
return QString();
return m_filePath.mid(qMax((qint16)0, m_lastSeparator) + m_firstDotInFileName + 1);
}
#if defined(Q_OS_WIN)
bool QFileSystemEntry::isRelative() const
{
resolveFilePath();
return (m_filePath.isEmpty() || (!m_filePath.isEmpty() && (m_filePath[0].unicode() != '/')
&& (!(m_filePath.length() >= 2 && m_filePath[1].unicode() == ':'))));
}
bool QFileSystemEntry::isAbsolute() const
{
resolveFilePath();
return (!m_filePath.isEmpty() && ((m_filePath.length() >= 3
&& (m_filePath[0].isLetter() && m_filePath[1].unicode() == ':' && m_filePath[2].unicode() == '/'))
|| (m_filePath.length() >= 2 && (m_filePath.at(0) == QLatin1Char('/') && m_filePath.at(1) == QLatin1Char('/')))
));
}
#else
bool QFileSystemEntry::isRelative() const
{
return !isAbsolute();
}
bool QFileSystemEntry::isAbsolute() const
{
resolveFilePath();
return (!m_filePath.isEmpty() && (m_filePath[0].unicode() == '/'));
}
#endif
#if defined(Q_OS_WIN)
bool QFileSystemEntry::isDriveRoot() const
{
resolveFilePath();
return (m_filePath.length() == 3
&& m_filePath.at(0).isLetter() && m_filePath.at(1) == QLatin1Char(':')
&& m_filePath.at(2) == QLatin1Char('/'));
}
#endif
bool QFileSystemEntry::isRoot() const
{
resolveFilePath();
if (m_filePath == QLatin1String("/")
#if defined(Q_OS_WIN)
|| isDriveRoot()
|| isUncRoot(m_filePath)
#endif
)
return true;
return false;
}
bool QFileSystemEntry::isEmpty() const
{
return m_filePath.isEmpty() && m_nativeFilePath.isEmpty();
}
// private methods
void QFileSystemEntry::findLastSeparator() const
{
if (m_lastSeparator == -2) {
resolveFilePath();
m_lastSeparator = -1;
for (int i = m_filePath.size() - 1; i >= 0; --i) {
if (m_filePath[i].unicode() == '/') {
m_lastSeparator = i;
break;
}
}
}
}
void QFileSystemEntry::findFileNameSeparators() const
{
if (m_firstDotInFileName == -2) {
resolveFilePath();
int firstDotInFileName = -1;
int lastDotInFileName = -1;
int lastSeparator = m_lastSeparator;
int stop;
if (lastSeparator < 0) {
lastSeparator = -1;
stop = 0;
} else {
stop = lastSeparator;
}
int i = m_filePath.size() - 1;
for (; i >= stop; --i) {
if (m_filePath[i].unicode() == '.') {
firstDotInFileName = lastDotInFileName = i;
break;
} else if (m_filePath[i].unicode() == '/') {
lastSeparator = i;
break;
}
}
if (lastSeparator != i) {
for (--i; i >= stop; --i) {
if (m_filePath[i].unicode() == '.')
firstDotInFileName = i;
else if (m_filePath[i].unicode() == '/') {
lastSeparator = i;
break;
}
}
}
m_lastSeparator = lastSeparator;
m_firstDotInFileName = firstDotInFileName == -1 ? -1 : firstDotInFileName - qMax(0, lastSeparator);
if (lastDotInFileName == -1)
m_lastDotInFileName = -1;
else if (firstDotInFileName == lastDotInFileName)
m_lastDotInFileName = 0;
else
m_lastDotInFileName = lastDotInFileName - firstDotInFileName;
}
}
bool QFileSystemEntry::isClean() const
{
resolveFilePath();
int dots = 0;
bool dotok = true; // checking for ".." or "." starts to relative paths
bool slashok = true;
for (QString::const_iterator iter = m_filePath.constBegin(); iter != m_filePath.constEnd(); iter++) {
if (*iter == QLatin1Char('/')) {
if (dots == 1 || dots == 2)
return false; // path contains "./" or "../"
if (!slashok)
return false; // path contains "//"
dots = 0;
dotok = true;
slashok = false;
} else if (dotok) {
slashok = true;
if (*iter == QLatin1Char('.')) {
dots++;
if (dots > 2)
dotok = false;
} else {
//path element contains a character other than '.', it's clean
dots = 0;
dotok = false;
}
}
}
return (dots != 1 && dots != 2); // clean if path doesn't end in . or ..
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

106
src/app/core/backport/qfilesystementry_p.h
View file

@ -1,106 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFILESYSTEMENTRY_P_H
#define QFILESYSTEMENTRY_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 <QString>
#include <QByteArray>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#if defined(Q_OS_WIN)
#define QFILESYSTEMENTRY_NATIVE_PATH_IS_UTF16
#endif
class QFileSystemEntry
{
public:
#ifndef QFILESYSTEMENTRY_NATIVE_PATH_IS_UTF16
typedef QByteArray NativePath;
#else
typedef QString NativePath;
#endif
struct FromNativePath{};
struct FromInternalPath{};
QFileSystemEntry();
explicit QFileSystemEntry(const QString &filePath);
QFileSystemEntry(const QString &filePath, FromInternalPath dummy);
QFileSystemEntry(const NativePath &nativeFilePath, FromNativePath dummy);
QFileSystemEntry(const QString &filePath, const NativePath &nativeFilePath);
QString filePath() const;
QString fileName() const;
QString path() const;
NativePath nativeFilePath() const;
QString baseName() const;
QString completeBaseName() const;
QString suffix() const;
QString completeSuffix() const;
bool isAbsolute() const;
bool isRelative() const;
bool isClean() const;
#if defined(Q_OS_WIN)
bool isDriveRoot() const;
#endif
bool isRoot() const;
bool isEmpty() const;
void clear()
{
*this = QFileSystemEntry();
}
private:
// creates the QString version out of the bytearray version
void resolveFilePath() const;
// creates the bytearray version out of the QString version
void resolveNativeFilePath() const;
// resolves the separator
void findLastSeparator() const;
// resolves the dots and the separator
void findFileNameSeparators() const;
mutable QString m_filePath; // always has slashes as separator
mutable NativePath m_nativeFilePath; // native encoding and separators
mutable qint16 m_lastSeparator; // index in m_filePath of last separator
mutable qint16 m_firstDotInFileName; // index after m_filePath for first dot (.)
mutable qint16 m_lastDotInFileName; // index after m_firstDotInFileName for last dot (.)
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // include guard

94
src/app/core/backport/qfilesystemiterator_p.h
View file

@ -1,94 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFILESYSTEMITERATOR_P_H
#define QFILESYSTEMITERATOR_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 <QtGlobal>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_FILESYSTEMITERATOR
#include <QDir>
#include <QDirIterator>
#include <QStringList>
#include "qfilesystementry_p.h"
#include "qfilesystemmetadata_p.h"
// Platform-specific headers
#if !defined(Q_OS_WIN)
#include <QScopedPointer>
#endif
class QFileSystemIterator
{
public:
QFileSystemIterator(const QFileSystemEntry &entry, QDir::Filters filters,
const QStringList &nameFilters, QDirIterator::IteratorFlags flags
= QDirIterator::FollowSymlinks | QDirIterator::Subdirectories);
~QFileSystemIterator();
bool advance(QFileSystemEntry &fileEntry, QFileSystemMetaData &metaData);
private:
QFileSystemEntry::NativePath nativePath;
// Platform-specific data
#if defined(Q_OS_WIN)
QString dirPath;
HANDLE findFileHandle;
QStringList uncShares;
bool uncFallback;
int uncShareIndex;
bool onlyDirs;
#else
QT_DIR *dir;
QT_DIRENT *dirEntry;
#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
// for readdir_r
QScopedPointer<QT_DIRENT, QScopedPointerPodDeleter> mt_file;
#if defined(Q_OS_QNX) && defined(__EXT_QNX__READDIR_R)
// for _readdir_r
size_t direntSize;
#endif
#endif
int lastError;
#endif
Q_DISABLE_COPY(QFileSystemIterator)
};
#endif // QT_NO_FILESYSTEMITERATOR
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // include guard

112
src/app/core/backport/qfilesystemiterator_unix.cpp
View file

@ -1,112 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qplatformdefs.h"
#include "qfilesystemiterator_p.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_FILESYSTEMITERATOR
#include <stdlib.h>
#include <errno.h>
QFileSystemIterator::QFileSystemIterator(const QFileSystemEntry &entry, QDir::Filters filters,
const QStringList &nameFilters, QDirIterator::IteratorFlags flags)
: nativePath(entry.nativeFilePath())
, dir(0)
, dirEntry(0)
#if defined(Q_OS_QNX) && defined(__EXT_QNX__READDIR_R)
, direntSize(0)
#endif
, lastError(0)
{
Q_UNUSED(filters)
Q_UNUSED(nameFilters)
Q_UNUSED(flags)
if ((dir = QT_OPENDIR(nativePath.constData())) == 0) {
lastError = errno;
} else {
if (!nativePath.endsWith('/'))
nativePath.append('/');
#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
// ### Race condition; we should use fpathconf and dirfd().
size_t maxPathName = ::pathconf(nativePath.constData(), _PC_NAME_MAX);
if (maxPathName == size_t(-1))
maxPathName = FILENAME_MAX;
maxPathName += sizeof(QT_DIRENT) + 1;
QT_DIRENT *p = reinterpret_cast<QT_DIRENT*>(::malloc(maxPathName));
Q_CHECK_PTR(p);
mt_file.reset(p);
#if defined(Q_OS_QNX) && defined(__EXT_QNX__READDIR_R)
direntSize = maxPathName;
// Include extra stat information in the readdir() call (d_stat member of dirent_extra_stat).
// This is used in QFileSystemMetaData::fillFromDirEnt() to avoid extra stat() calls when iterating
// over directories
if (dircntl(dir, D_SETFLAG, D_FLAG_STAT) == -1)
lastError = errno;
#endif
#endif
}
}
QFileSystemIterator::~QFileSystemIterator()
{
if (dir)
QT_CLOSEDIR(dir);
}
bool QFileSystemIterator::advance(QFileSystemEntry &fileEntry, QFileSystemMetaData &metaData)
{
if (!dir)
return false;
#if defined(Q_OS_QNX) && defined(__EXT_QNX__READDIR_R)
lastError = _readdir_r(dir, mt_file.data(), &dirEntry, direntSize);
if (lastError)
return false;
#elif defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_CYGWIN)
lastError = QT_READDIR_R(dir, mt_file.data(), &dirEntry);
if (lastError)
return false;
#else
// ### add local lock to prevent breaking reentrancy
dirEntry = QT_READDIR(dir);
#endif // _POSIX_THREAD_SAFE_FUNCTIONS
if (dirEntry) {
fileEntry = QFileSystemEntry(nativePath + QByteArray(dirEntry->d_name), QFileSystemEntry::FromNativePath());
metaData.fillFromDirEnt(*dirEntry);
return true;
}
lastError = errno;
return false;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QT_NO_FILESYSTEMITERATOR

129
src/app/core/backport/qfilesystemiterator_win.cpp
View file

@ -1,129 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#if _WIN32_WINNT < 0x0500
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#endif
#include "qfilesystemiterator_p.h"
#include "qfilesystemengine_p.h"
#include "qplatformdefs.h"
#include <qt_windows.h>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
bool done = true;
QFileSystemIterator::QFileSystemIterator(const QFileSystemEntry &entry, QDir::Filters filters,
const QStringList &nameFilters, QDirIterator::IteratorFlags flags)
: nativePath(entry.nativeFilePath())
, dirPath(entry.filePath())
, findFileHandle(INVALID_HANDLE_VALUE)
, uncFallback(false)
, uncShareIndex(0)
, onlyDirs(false)
{
Q_UNUSED(nameFilters)
Q_UNUSED(flags)
if (nativePath.endsWith(QLatin1String(".lnk"))) {
QFileSystemMetaData metaData;
QFileSystemEntry link = QFileSystemEngine::getLinkTarget(entry, metaData);
nativePath = link.nativeFilePath();
}
if (!nativePath.endsWith(QLatin1Char('\\')))
nativePath.append(QLatin1Char('\\'));
nativePath.append(QLatin1Char('*'));
if (!dirPath.endsWith(QLatin1Char('/')))
dirPath.append(QLatin1Char('/'));
if ((filters & (QDir::Dirs|QDir::Drives)) && (!(filters & (QDir::Files))))
onlyDirs = true;
}
QFileSystemIterator::~QFileSystemIterator()
{
if (findFileHandle != INVALID_HANDLE_VALUE)
FindClose(findFileHandle);
}
bool QFileSystemIterator::advance(QFileSystemEntry &fileEntry, QFileSystemMetaData &metaData)
{
bool haveData = false;
WIN32_FIND_DATA findData;
if (findFileHandle == INVALID_HANDLE_VALUE && !uncFallback) {
haveData = true;
int infoLevel = 0 ; // FindExInfoStandard;
DWORD dwAdditionalFlags = 0;
#ifndef Q_OS_WINCE
if (QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS7) {
dwAdditionalFlags = 2; // FIND_FIRST_EX_LARGE_FETCH
infoLevel = 1 ; // FindExInfoBasic;
}
#endif
int searchOps = 0; // FindExSearchNameMatch
if (onlyDirs)
searchOps = 1 ; // FindExSearchLimitToDirectories
findFileHandle = FindFirstFileEx((const wchar_t *)nativePath.utf16(), FINDEX_INFO_LEVELS(infoLevel), &findData,
FINDEX_SEARCH_OPS(searchOps), 0, dwAdditionalFlags);
if (findFileHandle == INVALID_HANDLE_VALUE) {
if (nativePath.startsWith(QLatin1String("\\\\?\\UNC\\"))) {
QStringList parts = nativePath.split(QLatin1Char('\\'), QString::SkipEmptyParts);
if (parts.count() == 4 && QFileSystemEngine::uncListSharesOnServer(
QLatin1String("\\\\") + parts.at(2), &uncShares)) {
if (uncShares.isEmpty())
return false; // No shares found in the server
else
uncFallback = true;
}
}
}
}
if (findFileHandle == INVALID_HANDLE_VALUE && !uncFallback)
return false;
// Retrieve the new file information.
if (!haveData) {
if (uncFallback) {
if (++uncShareIndex >= uncShares.count())
return false;
} else {
if (!FindNextFile(findFileHandle, &findData))
return false;
}
}
// Create the new file system entry & meta data.
if (uncFallback) {
fileEntry = QFileSystemEntry(dirPath + uncShares.at(uncShareIndex));
metaData.fillFromFileAttribute(FILE_ATTRIBUTE_DIRECTORY);
return true;
} else {
QString fileName = QString::fromWCharArray(findData.cFileName);
fileEntry = QFileSystemEntry(dirPath + fileName);
metaData = QFileSystemMetaData();
if (!fileName.endsWith(QLatin1String(".lnk"))) {
metaData.fillFromFindData(findData, true);
}
return true;
}
return false;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

341
src/app/core/backport/qfilesystemmetadata_p.h
View file

@ -1,341 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFILESYSTEMMETADATA_P_H
#define QFILESYSTEMMETADATA_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 "qplatformdefs.h"
#include <QtGlobal>
#include <QDateTime>
#include "qabstractfileengine_p.h"
// Platform-specific includes
#ifdef Q_OS_WIN
# include <QtCore/qt_windows.h>
# ifndef IO_REPARSE_TAG_SYMLINK
# define IO_REPARSE_TAG_SYMLINK (0xA000000CL)
# endif
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QFileSystemEngine;
class QFileSystemMetaData
{
public:
QFileSystemMetaData()
: knownFlagsMask(0)
{
}
enum MetaDataFlag {
// Permissions, overlaps with QFile::Permissions
OtherReadPermission = 0x00000004, OtherWritePermission = 0x00000002, OtherExecutePermission = 0x00000001,
GroupReadPermission = 0x00000040, GroupWritePermission = 0x00000020, GroupExecutePermission = 0x00000010,
UserReadPermission = 0x00000400, UserWritePermission = 0x00000200, UserExecutePermission = 0x00000100,
OwnerReadPermission = 0x00004000, OwnerWritePermission = 0x00002000, OwnerExecutePermission = 0x00001000,
OtherPermissions = OtherReadPermission | OtherWritePermission | OtherExecutePermission,
GroupPermissions = GroupReadPermission | GroupWritePermission | GroupExecutePermission,
UserPermissions = UserReadPermission | UserWritePermission | UserExecutePermission,
OwnerPermissions = OwnerReadPermission | OwnerWritePermission | OwnerExecutePermission,
ReadPermissions = OtherReadPermission | GroupReadPermission | UserReadPermission | OwnerReadPermission,
WritePermissions = OtherWritePermission | GroupWritePermission | UserWritePermission | OwnerWritePermission,
ExecutePermissions = OtherExecutePermission | GroupExecutePermission | UserExecutePermission | OwnerExecutePermission,
Permissions = OtherPermissions | GroupPermissions | UserPermissions | OwnerPermissions,
// Type
LinkType = 0x00010000,
FileType = 0x00020000,
DirectoryType = 0x00040000,
#if defined(Q_OS_MACX)
BundleType = 0x00080000,
AliasType = 0x08000000,
#else
BundleType = 0x0,
AliasType = 0x0,
#endif
#if defined(Q_OS_WIN)
WinLnkType = 0x08000000, // Note: Uses the same position for AliasType on Mac
#else
WinLnkType = 0x0,
#endif
SequentialType = 0x00800000, // Note: overlaps with QAbstractFileEngine::RootFlag
LegacyLinkType = LinkType | AliasType | WinLnkType,
Type = LinkType | FileType | DirectoryType | BundleType | SequentialType | AliasType,
// Attributes
HiddenAttribute = 0x00100000,
SizeAttribute = 0x00200000, // Note: overlaps with QAbstractFileEngine::LocalDiskFlag
ExistsAttribute = 0x00400000,
Attributes = HiddenAttribute | SizeAttribute | ExistsAttribute,
// Times
CreationTime = 0x01000000, // Note: overlaps with QAbstractFileEngine::Refresh
ModificationTime = 0x02000000,
AccessTime = 0x04000000,
Times = CreationTime | ModificationTime | AccessTime,
// Owner IDs
UserId = 0x10000000,
GroupId = 0x20000000,
OwnerIds = UserId | GroupId,
PosixStatFlags = QFileSystemMetaData::OtherPermissions
| QFileSystemMetaData::GroupPermissions
| QFileSystemMetaData::OwnerPermissions
| QFileSystemMetaData::FileType
| QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::SequentialType
| QFileSystemMetaData::SizeAttribute
| QFileSystemMetaData::Times
| QFileSystemMetaData::OwnerIds,
#if defined(Q_OS_WIN)
WinStatFlags = QFileSystemMetaData::FileType
| QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::HiddenAttribute
| QFileSystemMetaData::ExistsAttribute
| QFileSystemMetaData::SizeAttribute
| QFileSystemMetaData::Times,
#endif
AllMetaDataFlags = 0xFFFFFFFF
};
Q_DECLARE_FLAGS(MetaDataFlags, MetaDataFlag)
bool hasFlags(MetaDataFlags flags) const
{
return ((knownFlagsMask & flags) == flags);
}
MetaDataFlags missingFlags(MetaDataFlags flags)
{
return flags & ~knownFlagsMask;
}
void clear()
{
knownFlagsMask = 0;
}
void clearFlags(MetaDataFlags flags = AllMetaDataFlags)
{
knownFlagsMask &= ~flags;
}
bool exists() const { return (entryFlags & ExistsAttribute); }
bool isLink() const { return (entryFlags & LinkType); }
bool isFile() const { return (entryFlags & FileType); }
bool isDirectory() const { return (entryFlags & DirectoryType); }
bool isBundle() const;
bool isAlias() const;
bool isLegacyLink() const { return (entryFlags & LegacyLinkType); }
bool isSequential() const { return (entryFlags & SequentialType); }
bool isHidden() const { return (entryFlags & HiddenAttribute); }
#if defined(Q_OS_WIN)
bool isLnkFile() const { return (entryFlags & WinLnkType); }
#else
bool isLnkFile() const { return false; }
#endif
qint64 size() const { return size_; }
QFile::Permissions permissions() const { return QFile::Permissions(Permissions & entryFlags); }
QDateTime creationTime() const;
QDateTime modificationTime() const;
QDateTime accessTime() const;
QDateTime fileTime(QAbstractFileEngine::FileTime time) const;
uint userId() const;
uint groupId() const;
uint ownerId(QAbstractFileEngine::FileOwner owner) const;
#ifdef Q_OS_UNIX
void fillFromStatBuf(const QT_STATBUF &statBuffer);
void fillFromDirEnt(const QT_DIRENT &statBuffer);
#endif
#if defined(Q_OS_WIN)
inline void fillFromFileAttribute(DWORD fileAttribute, bool isDriveRoot = false);
inline void fillFromFindData(WIN32_FIND_DATA &findData, bool setLinkType = false, bool isDriveRoot = false);
inline void fillFromFindInfo(BY_HANDLE_FILE_INFORMATION &fileInfo);
#endif
private:
friend class QFileSystemEngine;
MetaDataFlags knownFlagsMask;
MetaDataFlags entryFlags;
qint64 size_;
// Platform-specific data goes here:
#if defined(Q_OS_WIN)
DWORD fileAttribute_;
FILETIME creationTime_;
FILETIME lastAccessTime_;
FILETIME lastWriteTime_;
#else
time_t creationTime_;
time_t modificationTime_;
time_t accessTime_;
uint userId_;
uint groupId_;
#endif
};
Q_DECLARE_OPERATORS_FOR_FLAGS(QFileSystemMetaData::MetaDataFlags)
#if defined(Q_OS_MACX)
inline bool QFileSystemMetaData::isBundle() const { return (entryFlags & BundleType); }
inline bool QFileSystemMetaData::isAlias() const { return (entryFlags & AliasType); }
#else
inline bool QFileSystemMetaData::isBundle() const { return false; }
inline bool QFileSystemMetaData::isAlias() const { return false; }
#endif
#if defined(Q_OS_UNIX) || defined (Q_OS_WIN)
inline QDateTime QFileSystemMetaData::fileTime(QAbstractFileEngine::FileTime time) const
{
switch (time) {
case QAbstractFileEngine::ModificationTime:
return modificationTime();
case QAbstractFileEngine::AccessTime:
return accessTime();
case QAbstractFileEngine::CreationTime:
return creationTime();
}
return QDateTime();
}
#endif
#if defined(Q_OS_UNIX)
inline QDateTime QFileSystemMetaData::creationTime() const { return QDateTime::fromTime_t(creationTime_); }
inline QDateTime QFileSystemMetaData::modificationTime() const { return QDateTime::fromTime_t(modificationTime_); }
inline QDateTime QFileSystemMetaData::accessTime() const { return QDateTime::fromTime_t(accessTime_); }
inline uint QFileSystemMetaData::userId() const { return userId_; }
inline uint QFileSystemMetaData::groupId() const { return groupId_; }
inline uint QFileSystemMetaData::ownerId(QAbstractFileEngine::FileOwner owner) const
{
if (owner == QAbstractFileEngine::OwnerUser)
return userId();
else
return groupId();
}
#endif
#if defined(Q_OS_WIN)
inline uint QFileSystemMetaData::userId() const { return (uint) -2; }
inline uint QFileSystemMetaData::groupId() const { return (uint) -2; }
inline uint QFileSystemMetaData::ownerId(QAbstractFileEngine::FileOwner owner) const
{
if (owner == QAbstractFileEngine::OwnerUser)
return userId();
else
return groupId();
}
inline void QFileSystemMetaData::fillFromFileAttribute(DWORD fileAttribute,bool isDriveRoot)
{
fileAttribute_ = fileAttribute;
// Ignore the hidden attribute for drives.
if (!isDriveRoot && (fileAttribute_ & FILE_ATTRIBUTE_HIDDEN))
entryFlags |= HiddenAttribute;
entryFlags |= ((fileAttribute & FILE_ATTRIBUTE_DIRECTORY) ? DirectoryType: FileType);
entryFlags |= ExistsAttribute;
knownFlagsMask |= FileType | DirectoryType | HiddenAttribute | ExistsAttribute;
}
inline void QFileSystemMetaData::fillFromFindData(WIN32_FIND_DATA &findData, bool setLinkType, bool isDriveRoot)
{
fillFromFileAttribute(findData.dwFileAttributes, isDriveRoot);
creationTime_ = findData.ftCreationTime;
lastAccessTime_ = findData.ftLastAccessTime;
lastWriteTime_ = findData.ftLastWriteTime;
if (fileAttribute_ & FILE_ATTRIBUTE_DIRECTORY) {
size_ = 0;
} else {
size_ = findData.nFileSizeHigh;
size_ <<= 32;
size_ += findData.nFileSizeLow;
}
knownFlagsMask |= Times | SizeAttribute;
if (setLinkType) {
knownFlagsMask |= LinkType;
entryFlags &= ~LinkType;
#if !defined(Q_OS_WINCE)
if ((fileAttribute_ & FILE_ATTRIBUTE_REPARSE_POINT)
&& (findData.dwReserved0 == IO_REPARSE_TAG_SYMLINK)) {
entryFlags |= LinkType;
}
#endif
}
}
inline void QFileSystemMetaData::fillFromFindInfo(BY_HANDLE_FILE_INFORMATION &fileInfo)
{
fillFromFileAttribute(fileInfo.dwFileAttributes);
creationTime_ = fileInfo.ftCreationTime;
lastAccessTime_ = fileInfo.ftLastAccessTime;
lastWriteTime_ = fileInfo.ftLastWriteTime;
if (fileAttribute_ & FILE_ATTRIBUTE_DIRECTORY) {
size_ = 0;
} else {
size_ = fileInfo.nFileSizeHigh;
size_ <<= 32;
size_ += fileInfo.nFileSizeLow;
}
knownFlagsMask |= Times | SizeAttribute;
}
#endif
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // include guard

942
src/app/core/backport/qfsfileengine.cpp
View file

@ -1,942 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qfsfileengine_p.h"
#include "qfsfileengine_iterator_p.h"
#include "qfilesystemengine_p.h"
#include <QDateTime>
#include <QDirIterator>
#include <QSet>
#include <QDebug>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_FSFILEENGINE
#if !defined(Q_OS_WINCE)
#include <errno.h>
#endif
#if defined(Q_OS_UNIX)
#include "qcore_unix_p.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#if defined(Q_OS_MAC)
# include "qcore_mac_p.h"
#endif
#ifdef Q_OS_WIN
# ifndef S_ISREG
# define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
# endif
# ifndef S_ISCHR
# define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR)
# endif
# ifndef S_ISFIFO
# define S_ISFIFO(x) false
# endif
# ifndef S_ISSOCK
# define S_ISSOCK(x) false
# endif
# ifndef INVALID_FILE_ATTRIBUTES
# define INVALID_FILE_ATTRIBUTES (DWORD (-1))
# endif
#endif
/*! \class QFSFileEngine
\inmodule QtCore
\brief The QFSFileEngine class implements Qt's default file engine.
\since 4.1
\internal
This class is part of the file engine framework in Qt. If you only want to
access files or directories, use QFile, QFileInfo or QDir instead.
QFSFileEngine is the default file engine for accessing regular files. It
is provided for convenience; by subclassing this class, you can alter its
behavior slightly, without having to write a complete QAbstractFileEngine
subclass. To install your custom file engine, you must also subclass
QAbstractFileEngineHandler and create an instance of your handler.
It can also be useful to create a QFSFileEngine object directly if you
need to use the local file system inside QAbstractFileEngine::create(), in
order to avoid recursion (as higher-level classes tend to call
QAbstractFileEngine::create()).
*/
//**************** QFSFileEnginePrivate
QFSFileEnginePrivate::QFSFileEnginePrivate() : QAbstractFileEnginePrivate()
{
init();
}
/*!
\internal
*/
void QFSFileEnginePrivate::init()
{
is_sequential = 0;
tried_stat = 0;
#if !defined(Q_OS_WINCE)
need_lstat = 1;
is_link = 0;
#endif
openMode = QIODevice::NotOpen;
fd = -1;
fh = 0;
lastIOCommand = IOFlushCommand;
lastFlushFailed = false;
closeFileHandle = false;
#ifdef Q_OS_WIN
fileAttrib = INVALID_FILE_ATTRIBUTES;
fileHandle = INVALID_HANDLE_VALUE;
mapHandle = NULL;
#ifndef Q_OS_WINCE
cachedFd = -1;
#endif
#endif
}
/*!
Constructs a QFSFileEngine for the file name \a file.
*/
QFSFileEngine::QFSFileEngine(const QString &file)
: QAbstractFileEngine(*new QFSFileEnginePrivate)
{
Q_D(QFSFileEngine);
d->fileEntry = QFileSystemEntry(file);
}
/*!
Constructs a QFSFileEngine.
*/
QFSFileEngine::QFSFileEngine() : QAbstractFileEngine(*new QFSFileEnginePrivate)
{
}
/*!
\internal
*/
QFSFileEngine::QFSFileEngine(QFSFileEnginePrivate &dd)
: QAbstractFileEngine(dd)
{
}
/*!
Destructs the QFSFileEngine.
*/
QFSFileEngine::~QFSFileEngine()
{
Q_D(QFSFileEngine);
if (d->closeFileHandle) {
if (d->fh) {
int ret;
do {
ret = fclose(d->fh);
} while (ret == EOF && errno == EINTR);
} else if (d->fd != -1) {
int ret;
do {
ret = QT_CLOSE(d->fd);
} while (ret == -1 && errno == EINTR);
}
}
QList<uchar*> keys = d->maps.keys();
for (int i = 0; i < keys.count(); ++i)
unmap(keys.at(i));
}
/*!
\reimp
*/
void QFSFileEngine::setFileName(const QString &file)
{
Q_D(QFSFileEngine);
d->init();
d->fileEntry = QFileSystemEntry(file);
}
/*!
\reimp
*/
bool QFSFileEngine::open(QIODevice::OpenMode openMode)
{
Q_D(QFSFileEngine);
if (d->fileEntry.isEmpty()) {
qWarning("QFSFileEngine::open: No file name specified");
setError(QFile::OpenError, QLatin1String("No file name specified"));
return false;
}
// Append implies WriteOnly.
if (openMode & QFile::Append)
openMode |= QFile::WriteOnly;
// WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
openMode |= QFile::Truncate;
d->openMode = openMode;
d->lastFlushFailed = false;
d->tried_stat = 0;
d->fh = 0;
d->fd = -1;
return d->nativeOpen(openMode);
}
/*!
Opens the file handle \a fh in \a openMode mode. Returns \c true on
success; otherwise returns \c false.
*/
bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh)
{
return open(openMode, fh, QFile::DontCloseHandle);
}
bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh, QFile::FileHandleFlags handleFlags)
{
Q_D(QFSFileEngine);
// Append implies WriteOnly.
if (openMode & QFile::Append)
openMode |= QFile::WriteOnly;
// WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
openMode |= QFile::Truncate;
d->openMode = openMode;
d->lastFlushFailed = false;
d->closeFileHandle = (handleFlags & QFile::AutoCloseHandle);
d->fileEntry.clear();
d->tried_stat = 0;
d->fd = -1;
return d->openFh(openMode, fh);
}
/*!
Opens the file handle \a fh using the open mode \a flags.
*/
bool QFSFileEnginePrivate::openFh(QIODevice::OpenMode openMode, FILE *fh)
{
Q_Q(QFSFileEngine);
this->fh = fh;
fd = -1;
// Seek to the end when in Append mode.
if (openMode & QIODevice::Append) {
int ret;
do {
ret = QT_FSEEK(fh, 0, SEEK_END);
} while (ret != 0 && errno == EINTR);
if (ret != 0) {
q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
qt_error_string(int(errno)));
this->openMode = QIODevice::NotOpen;
this->fh = 0;
return false;
}
}
return true;
}
/*!
Opens the file descriptor \a fd in \a openMode mode. Returns \c true
on success; otherwise returns \c false.
*/
bool QFSFileEngine::open(QIODevice::OpenMode openMode, int fd)
{
return open(openMode, fd, QFile::DontCloseHandle);
}
bool QFSFileEngine::open(QIODevice::OpenMode openMode, int fd, QFile::FileHandleFlags handleFlags)
{
Q_D(QFSFileEngine);
// Append implies WriteOnly.
if (openMode & QFile::Append)
openMode |= QFile::WriteOnly;
// WriteOnly implies Truncate if neither ReadOnly nor Append are sent.
if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
openMode |= QFile::Truncate;
d->openMode = openMode;
d->lastFlushFailed = false;
d->closeFileHandle = (handleFlags & QFile::AutoCloseHandle);
d->fileEntry.clear();
d->fh = 0;
d->fd = -1;
d->tried_stat = 0;
return d->openFd(openMode, fd);
}
/*!
Opens the file descriptor \a fd to the file engine, using the open mode \a
flags.
*/
bool QFSFileEnginePrivate::openFd(QIODevice::OpenMode openMode, int fd)
{
Q_Q(QFSFileEngine);
this->fd = fd;
fh = 0;
// Seek to the end when in Append mode.
if (openMode & QFile::Append) {
int ret;
do {
ret = QT_LSEEK(fd, 0, SEEK_END);
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
qt_error_string(int(errno)));
this->openMode = QIODevice::NotOpen;
this->fd = -1;
return false;
}
}
return true;
}
/*!
\reimp
*/
bool QFSFileEngine::close()
{
Q_D(QFSFileEngine);
d->openMode = QIODevice::NotOpen;
return d->nativeClose();
}
/*!
\internal
*/
bool QFSFileEnginePrivate::closeFdFh()
{
Q_Q(QFSFileEngine);
if (fd == -1 && !fh)
return false;
// Flush the file if it's buffered, and if the last flush didn't fail.
bool flushed = !fh || (!lastFlushFailed && q->flush());
bool closed = true;
tried_stat = 0;
// Close the file if we created the handle.
if (closeFileHandle) {
int ret;
do {
if (fh) {
// Close buffered file.
ret = fclose(fh) != 0 ? -1 : 0;
} else {
// Close unbuffered file.
ret = QT_CLOSE(fd);
}
} while (ret == -1 && errno == EINTR);
// We must reset these guys regardless; calling close again after a
// failed close causes crashes on some systems.
fh = 0;
fd = -1;
closed = (ret == 0);
}
// Report errors.
if (!flushed || !closed) {
if (flushed) {
// If not flushed, we want the flush error to fall through.
q->setError(QFile::UnspecifiedError, qt_error_string(errno));
}
return false;
}
return true;
}
/*!
\reimp
*/
bool QFSFileEngine::flush()
{
Q_D(QFSFileEngine);
if ((d->openMode & QIODevice::WriteOnly) == 0) {
// Nothing in the write buffers, so flush succeeds in doing
// nothing.
return true;
}
return d->nativeFlush();
}
/*!
\reimp
*/
bool QFSFileEngine::syncToDisk()
{
Q_D(QFSFileEngine);
if ((d->openMode & QIODevice::WriteOnly) == 0)
return true;
return d->nativeSyncToDisk();
}
/*!
\internal
*/
bool QFSFileEnginePrivate::flushFh()
{
Q_Q(QFSFileEngine);
// Never try to flush again if the last flush failed. Otherwise you can
// get crashes on some systems (AIX).
if (lastFlushFailed)
return false;
int ret = fflush(fh);
lastFlushFailed = (ret != 0);
lastIOCommand = QFSFileEnginePrivate::IOFlushCommand;
if (ret != 0) {
q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError,
qt_error_string(errno));
return false;
}
return true;
}
/*!
\reimp
*/
qint64 QFSFileEngine::size() const
{
Q_D(const QFSFileEngine);
return d->nativeSize();
}
#ifndef Q_OS_WIN
/*!
\internal
*/
qint64 QFSFileEnginePrivate::sizeFdFh() const
{
Q_Q(const QFSFileEngine);
const_cast<QFSFileEngine *>(q)->flush();
tried_stat = 0;
metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
if (!doStat(QFileSystemMetaData::SizeAttribute))
return 0;
return metaData.size();
}
#endif
/*!
\reimp
*/
qint64 QFSFileEngine::pos() const
{
Q_D(const QFSFileEngine);
return d->nativePos();
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::posFdFh() const
{
if (fh)
return qint64(QT_FTELL(fh));
return QT_LSEEK(fd, 0, SEEK_CUR);
}
/*!
\reimp
*/
bool QFSFileEngine::seek(qint64 pos)
{
Q_D(QFSFileEngine);
return d->nativeSeek(pos);
}
/*!
\internal
*/
bool QFSFileEnginePrivate::seekFdFh(qint64 pos)
{
Q_Q(QFSFileEngine);
// On Windows' stdlib implementation, the results of calling fread and
// fwrite are undefined if not called either in sequence, or if preceded
// with a call to fflush().
if (lastIOCommand != QFSFileEnginePrivate::IOFlushCommand && !q->flush())
return false;
if (pos < 0 || pos != qint64(QT_OFF_T(pos)))
return false;
if (fh) {
// Buffered stdlib mode.
int ret;
do {
ret = QT_FSEEK(fh, QT_OFF_T(pos), SEEK_SET);
} while (ret != 0 && errno == EINTR);
if (ret != 0) {
q->setError(QFile::ReadError, qt_error_string(int(errno)));
return false;
}
} else {
// Unbuffered stdio mode.
if (QT_LSEEK(fd, QT_OFF_T(pos), SEEK_SET) == -1) {
qWarning() << "QFile::at: Cannot set file position" << pos;
q->setError(QFile::PositionError, qt_error_string(errno));
return false;
}
}
return true;
}
/*!
\reimp
*/
int QFSFileEngine::handle() const
{
Q_D(const QFSFileEngine);
return d->nativeHandle();
}
/*!
\reimp
*/
qint64 QFSFileEngine::read(char *data, qint64 maxlen)
{
Q_D(QFSFileEngine);
// On Windows' stdlib implementation, the results of calling fread and
// fwrite are undefined if not called either in sequence, or if preceded
// with a call to fflush().
if (d->lastIOCommand != QFSFileEnginePrivate::IOReadCommand) {
flush();
d->lastIOCommand = QFSFileEnginePrivate::IOReadCommand;
}
return d->nativeRead(data, maxlen);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::readFdFh(char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (len < 0 || len != qint64(size_t(len))) {
q->setError(QFile::ReadError, qt_error_string(EINVAL));
return -1;
}
qint64 readBytes = 0;
bool eof = false;
if (fh) {
// Buffered stdlib mode.
size_t result;
bool retry = true;
do {
result = fread(data + readBytes, 1, size_t(len - readBytes), fh);
eof = feof(fh);
if (retry && eof && result == 0) {
// On Mac OS, this is needed, e.g., if a file was written to
// through another stream since our last read. See test
// tst_QFile::appendAndRead
QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET); // re-sync stream.
retry = false;
continue;
}
readBytes += result;
} while (!eof && (result == 0 ? errno == EINTR : readBytes < len));
} else if (fd != -1) {
// Unbuffered stdio mode.
#ifdef Q_OS_WIN
int result;
#else
ssize_t result;
#endif
do {
result = QT_READ(fd, data + readBytes, size_t(len - readBytes));
} while ((result == -1 && errno == EINTR)
|| (result > 0 && (readBytes += result) < len));
eof = !(result == -1);
}
if (!eof && readBytes == 0) {
readBytes = -1;
q->setError(QFile::ReadError, qt_error_string(errno));
}
return readBytes;
}
/*!
\reimp
*/
qint64 QFSFileEngine::readLine(char *data, qint64 maxlen)
{
Q_D(QFSFileEngine);
// On Windows' stdlib implementation, the results of calling fread and
// fwrite are undefined if not called either in sequence, or if preceded
// with a call to fflush().
if (d->lastIOCommand != QFSFileEnginePrivate::IOReadCommand) {
flush();
d->lastIOCommand = QFSFileEnginePrivate::IOReadCommand;
}
return d->nativeReadLine(data, maxlen);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::readLineFdFh(char *data, qint64 maxlen)
{
Q_Q(QFSFileEngine);
if (!fh)
return q->QAbstractFileEngine::readLine(data, maxlen);
QT_OFF_T oldPos = 0;
#ifdef Q_OS_WIN
bool seq = q->isSequential();
if (!seq)
#endif
oldPos = QT_FTELL(fh);
// QIODevice::readLine() passes maxlen - 1 to QFile::readLineData()
// because it has made space for the '\0' at the end of data. But fgets
// does the same, so we'd get two '\0' at the end - passing maxlen + 1
// solves this.
if (!fgets(data, int(maxlen + 1), fh)) {
if (!feof(fh))
q->setError(QFile::ReadError, qt_error_string(int(errno)));
return -1; // error
}
#ifdef Q_OS_WIN
if (seq)
return qstrlen(data);
#endif
qint64 lineLength = QT_FTELL(fh) - oldPos;
return lineLength > 0 ? lineLength : qstrlen(data);
}
/*!
\reimp
*/
qint64 QFSFileEngine::write(const char *data, qint64 len)
{
Q_D(QFSFileEngine);
// On Windows' stdlib implementation, the results of calling fread and
// fwrite are undefined if not called either in sequence, or if preceded
// with a call to fflush().
if (d->lastIOCommand != QFSFileEnginePrivate::IOWriteCommand) {
flush();
d->lastIOCommand = QFSFileEnginePrivate::IOWriteCommand;
}
return d->nativeWrite(data, len);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::writeFdFh(const char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (len < 0 || len != qint64(size_t(len))) {
q->setError(QFile::WriteError, qt_error_string(EINVAL));
return -1;
}
qint64 writtenBytes = 0;
if (fh) {
// Buffered stdlib mode.
size_t result;
do {
result = fwrite(data + writtenBytes, 1, size_t(len - writtenBytes), fh);
writtenBytes += result;
} while (result == 0 ? errno == EINTR : writtenBytes < len);
} else if (fd != -1) {
// Unbuffered stdio mode.
#ifdef Q_OS_WIN
int result;
#else
ssize_t result;
#endif
do {
result = QT_WRITE(fd, data + writtenBytes, size_t(len - writtenBytes));
} while ((result == -1 && errno == EINTR)
|| (result > 0 && (writtenBytes += result) < len));
}
if (len && writtenBytes == 0) {
writtenBytes = -1;
q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
}
return writtenBytes;
}
#ifndef QT_NO_FILESYSTEMITERATOR
/*!
\internal
*/
QAbstractFileEngine::Iterator *QFSFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
{
return new QFSFileEngineIterator(filters, filterNames);
}
/*!
\internal
*/
QAbstractFileEngine::Iterator *QFSFileEngine::endEntryList()
{
return 0;
}
#endif // QT_NO_FILESYSTEMITERATOR
/*!
\internal
*/
QStringList QFSFileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
{
return QAbstractFileEngine::entryList(filters, filterNames);
}
/*!
\reimp
*/
bool QFSFileEngine::isSequential() const
{
Q_D(const QFSFileEngine);
if (d->is_sequential == 0)
d->is_sequential = d->nativeIsSequential() ? 1 : 2;
return d->is_sequential == 1;
}
/*!
\internal
*/
#ifdef Q_OS_UNIX
bool QFSFileEnginePrivate::isSequentialFdFh() const
{
if (doStat(QFileSystemMetaData::SequentialType))
return metaData.isSequential();
return true;
}
#endif
/*!
\reimp
*/
bool QFSFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
{
Q_D(QFSFileEngine);
if (extension == AtEndExtension && d->fh && isSequential())
return feof(d->fh);
if (extension == MapExtension) {
const MapExtensionOption *options = (MapExtensionOption*)(option);
MapExtensionReturn *returnValue = static_cast<MapExtensionReturn*>(output);
returnValue->address = d->map(options->offset, options->size, options->flags);
return (returnValue->address != 0);
}
if (extension == UnMapExtension) {
UnMapExtensionOption *options = (UnMapExtensionOption*)option;
return d->unmap(options->address);
}
return false;
}
/*!
\reimp
*/
bool QFSFileEngine::supportsExtension(Extension extension) const
{
Q_D(const QFSFileEngine);
if (extension == AtEndExtension && d->fh && isSequential())
return true;
if (extension == FastReadLineExtension && d->fh)
return true;
if (extension == FastReadLineExtension && d->fd != -1 && isSequential())
return true;
if (extension == UnMapExtension || extension == MapExtension)
return true;
return false;
}
/*! \fn bool QFSFileEngine::caseSensitive() const
Returns \c true for Windows, false for Unix.
*/
/*! \fn bool QFSFileEngine::copy(const QString &copyName)
For windows, copy the file to file \a copyName.
Not implemented for Unix.
*/
/*! \fn QString QFSFileEngine::currentPath(const QString &fileName)
For Unix, returns the current working directory for the file
engine.
For Windows, returns the canonicalized form of the current path used
by the file engine for the drive specified by \a fileName. On
Windows, each drive has its own current directory, so a different
path is returned for file names that include different drive names
(e.g. A: or C:).
\sa setCurrentPath()
*/
/*! \fn QFileInfoList QFSFileEngine::drives()
For Windows, returns the list of drives in the file system as a list
of QFileInfo objects. On unix, Mac OS X and Windows CE, only the
root path is returned. On Windows, this function returns all drives
(A:\, C:\, D:\, etc.).
For Unix, the list contains just the root path "/".
*/
/*! \fn QString QFSFileEngine::fileName(FileName file) const
\reimp
*/
/*! \fn QDateTime QFSFileEngine::fileTime(FileTime time) const
\reimp
*/
/*! \fn QString QFSFileEngine::homePath()
Returns the home path of the current user.
\sa rootPath()
*/
/*! \fn bool QFSFileEngine::isRelativePath() const
\reimp
*/
/*! \fn bool QFSFileEngine::link(const QString &newName)
Creates a link from the file currently specified by fileName() to
\a newName. What a link is depends on the underlying filesystem
(be it a shortcut on Windows or a symbolic link on Unix). Returns
true if successful; otherwise returns \c false.
*/
/*! \fn bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
\reimp
*/
/*! \fn uint QFSFileEngine::ownerId(FileOwner own) const
In Unix, if stat() is successful, the \c uid is returned if
\a own is the owner. Otherwise the \c gid is returned. If stat()
is unsuccessful, -2 is reuturned.
For Windows, -2 is always returned.
*/
/*! \fn QString QFSFileEngine::owner(FileOwner own) const
\reimp
*/
/*! \fn bool QFSFileEngine::remove()
\reimp
*/
/*! \fn bool QFSFileEngine::rename(const QString &newName)
\reimp
*/
/*! \fn bool QFSFileEngine::renameOverwrite(const QString &newName)
\reimp
*/
/*! \fn bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
\reimp
*/
/*! \fn QString QFSFileEngine::rootPath()
Returns the root path.
\sa homePath()
*/
/*! \fn bool QFSFileEngine::setCurrentPath(const QString &path)
Sets the current path (e.g., for QDir), to \a path. Returns \c true if the
new path exists; otherwise this function does nothing, and returns \c false.
\sa currentPath()
*/
/*! \fn bool QFSFileEngine::setPermissions(uint perms)
\reimp
*/
/*! \fn bool QFSFileEngine::setSize(qint64 size)
\reimp
*/
/*! \fn QString QFSFileEngine::tempPath()
Returns the temporary path (i.e., a path in which it is safe
to store temporary files).
*/
/*! \fn QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions(QAbstractFileEngine::FileFlags type) const
\internal
*/
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QT_NO_FSFILEENGINE

85
src/app/core/backport/qfsfileengine_iterator.cpp
View file

@ -1,85 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qfsfileengine_iterator_p.h"
#include "qfileinfo_p.h"
#include <QVariant>
#ifndef QT_NO_FILESYSTEMITERATOR
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
QFSFileEngineIterator::QFSFileEngineIterator(QDir::Filters filters, const QStringList &filterNames)
: QAbstractFileEngineIterator(filters, filterNames)
, done(false)
{
}
QFSFileEngineIterator::~QFSFileEngineIterator()
{
}
bool QFSFileEngineIterator::hasNext() const
{
if (!done && !nativeIterator) {
nativeIterator.reset(new QFileSystemIterator(QFileSystemEntry(path()),
filters(), nameFilters()));
advance();
}
return !done;
}
QString QFSFileEngineIterator::next()
{
if (!hasNext())
return QString();
advance();
return currentFilePath();
}
void QFSFileEngineIterator::advance() const
{
currentInfo = nextInfo;
QFileSystemEntry entry;
QFileSystemMetaData data;
if (nativeIterator->advance(entry, data)) {
nextInfo = QFileInfo(new QFileInfoPrivate(entry, data));
} else {
done = true;
nativeIterator.reset();
}
}
QString QFSFileEngineIterator::currentFileName() const
{
return currentInfo.fileName();
}
QFileInfo QFSFileEngineIterator::currentFileInfo() const
{
return currentInfo;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QT_NO_FILESYSTEMITERATOR

70
src/app/core/backport/qfsfileengine_iterator_p.h
View file

@ -1,70 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFSFILEENGINE_ITERATOR_P_H
#define QFSFILEENGINE_ITERATOR_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 "qabstractfileengine_p.h"
#include "qfilesystemiterator_p.h"
#include <QDir>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_FILESYSTEMITERATOR
class QFSFileEngineIteratorPrivate;
class QFSFileEngineIteratorPlatformSpecificData;
class QFSFileEngineIterator : public QAbstractFileEngineIterator
{
public:
QFSFileEngineIterator(QDir::Filters filters, const QStringList &filterNames);
~QFSFileEngineIterator();
QString next();
bool hasNext() const;
QString currentFileName() const;
QFileInfo currentFileInfo() const;
private:
void advance() const;
mutable QScopedPointer<QFileSystemIterator> nativeIterator;
mutable QFileInfo currentInfo;
mutable QFileInfo nextInfo;
mutable bool done;
};
#endif // QT_NO_FILESYSTEMITERATOR
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QFSFILEENGINE_ITERATOR_P_H

218
src/app/core/backport/qfsfileengine_p.h
View file

@ -1,218 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QFSFILEENGINE_P_H
#define QFSFILEENGINE_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 "qplatformdefs.h"
#include "qabstractfileengine_p.h"
#include "qfilesystementry_p.h"
#include "qfilesystemmetadata_p.h"
#include <QHash>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_FSFILEENGINE
#if defined(Q_OS_WINCE_STD) && _WIN32_WCE < 0x600
#define Q_USE_DEPRECATED_MAP_API 1
#endif
class QFSFileEnginePrivate;
class QFSFileEngine : public QAbstractFileEngine
{
Q_DECLARE_PRIVATE(QFSFileEngine)
public:
QFSFileEngine();
explicit QFSFileEngine(const QString &file);
~QFSFileEngine();
bool open(QIODevice::OpenMode openMode);
bool open(QIODevice::OpenMode flags, FILE *fh);
bool close();
bool flush();
bool syncToDisk();
qint64 size() const;
qint64 pos() const;
bool seek(qint64);
bool isSequential() const;
bool remove();
bool copy(const QString &newName);
bool rename(const QString &newName);
bool renameOverwrite(const QString &newName);
bool link(const QString &newName);
bool mkdir(const QString &dirName, bool createParentDirectories) const;
bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
bool setSize(qint64 size);
bool caseSensitive() const;
bool isRelativePath() const;
QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
FileFlags fileFlags(FileFlags type) const;
bool setPermissions(uint perms);
QString fileName(FileName file) const;
uint ownerId(FileOwner) const;
QString owner(FileOwner) const;
QDateTime fileTime(FileTime time) const;
void setFileName(const QString &file);
int handle() const;
#ifndef QT_NO_FILESYSTEMITERATOR
Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
Iterator *endEntryList();
#endif
qint64 read(char *data, qint64 maxlen);
qint64 readLine(char *data, qint64 maxlen);
qint64 write(const char *data, qint64 len);
bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
bool supportsExtension(Extension extension) const;
//FS only!!
bool open(QIODevice::OpenMode flags, int fd);
bool open(QIODevice::OpenMode flags, int fd, QFile::FileHandleFlags handleFlags);
bool open(QIODevice::OpenMode flags, FILE *fh, QFile::FileHandleFlags handleFlags);
static bool setCurrentPath(const QString &path);
static QString currentPath(const QString &path = QString());
static QString homePath();
static QString rootPath();
static QString tempPath();
static QFileInfoList drives();
protected:
QFSFileEngine(QFSFileEnginePrivate &dd);
};
class QFSFileEnginePrivate : public QAbstractFileEnginePrivate
{
Q_DECLARE_PUBLIC(QFSFileEngine)
public:
#ifdef Q_OS_WIN
static QString longFileName(const QString &path);
#endif
QFileSystemEntry fileEntry;
QIODevice::OpenMode openMode;
bool nativeOpen(QIODevice::OpenMode openMode);
bool openFh(QIODevice::OpenMode flags, FILE *fh);
bool openFd(QIODevice::OpenMode flags, int fd);
bool nativeClose();
bool closeFdFh();
bool nativeFlush();
bool nativeSyncToDisk();
bool flushFh();
qint64 nativeSize() const;
#ifndef Q_OS_WIN
qint64 sizeFdFh() const;
#endif
qint64 nativePos() const;
qint64 posFdFh() const;
bool nativeSeek(qint64);
bool seekFdFh(qint64);
qint64 nativeRead(char *data, qint64 maxlen);
qint64 readFdFh(char *data, qint64 maxlen);
qint64 nativeReadLine(char *data, qint64 maxlen);
qint64 readLineFdFh(char *data, qint64 maxlen);
qint64 nativeWrite(const char *data, qint64 len);
qint64 writeFdFh(const char *data, qint64 len);
int nativeHandle() const;
bool nativeIsSequential() const;
#ifndef Q_OS_WIN
bool isSequentialFdFh() const;
#endif
uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
bool unmap(uchar *ptr);
mutable QFileSystemMetaData metaData;
FILE *fh;
#ifdef Q_OS_WIN
HANDLE fileHandle;
HANDLE mapHandle;
QHash<uchar *, DWORD /* offset % AllocationGranularity */> maps;
#ifndef Q_OS_WINCE
mutable int cachedFd;
#endif
mutable DWORD fileAttrib;
#else
QHash<uchar *, QPair<int /*offset % PageSize*/, size_t /*length + offset % PageSize*/> > maps;
#endif
int fd;
enum LastIOCommand
{
IOFlushCommand,
IOReadCommand,
IOWriteCommand
};
LastIOCommand lastIOCommand;
bool lastFlushFailed;
bool closeFileHandle;
mutable uint is_sequential : 2;
mutable uint could_stat : 1;
mutable uint tried_stat : 1;
#if !defined(Q_OS_WINCE)
mutable uint need_lstat : 1;
mutable uint is_link : 1;
#endif
#if defined(Q_OS_WIN)
bool doStat(QFileSystemMetaData::MetaDataFlags flags) const;
#else
bool doStat(QFileSystemMetaData::MetaDataFlags flags = QFileSystemMetaData::PosixStatFlags) const;
#endif
bool isSymlink() const;
#if defined(Q_OS_WIN32)
int sysOpen(const QString &, int flags);
#endif
protected:
QFSFileEnginePrivate();
void init();
QAbstractFileEngine::FileFlags getPermissions(QAbstractFileEngine::FileFlags type) const;
};
#endif // QT_NO_FSFILEENGINE
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QFSFILEENGINE_P_H

749
src/app/core/backport/qfsfileengine_unix.cpp
View file

@ -1,749 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qplatformdefs.h"
#include "qabstractfileengine_p.h"
#include "qfsfileengine_p.h"
#include "qcore_unix_p.h"
#include "qfilesystementry_p.h"
#include "qfilesystemengine_p.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_FSFILEENGINE
#include <QFile>
#include <QDir>
#include <QDateTime>
#include <QVarLengthArray>
#include <sys/mman.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#if !defined(QWS) && defined(Q_OS_MAC)
# include "qcore_mac_p.h"
#endif
/*!
\internal
Returns the stdlib open string corresponding to a QIODevice::OpenMode.
*/
static inline QByteArray openModeToFopenMode(QIODevice::OpenMode flags, const QFileSystemEntry &fileEntry,
QFileSystemMetaData &metaData)
{
QByteArray mode;
if ((flags & QIODevice::ReadOnly) && !(flags & QIODevice::Truncate)) {
mode = "rb";
if (flags & QIODevice::WriteOnly) {
metaData.clearFlags(QFileSystemMetaData::FileType);
if (!fileEntry.isEmpty()
&& QFileSystemEngine::fillMetaData(fileEntry, metaData, QFileSystemMetaData::FileType)
&& metaData.isFile()) {
mode += '+';
} else {
mode = "wb+";
}
}
} else if (flags & QIODevice::WriteOnly) {
mode = "wb";
if (flags & QIODevice::ReadOnly)
mode += '+';
}
if (flags & QIODevice::Append) {
mode = "ab";
if (flags & QIODevice::ReadOnly)
mode += '+';
}
#if defined(__GLIBC__) && (__GLIBC__ * 0x100 + __GLIBC_MINOR__) >= 0x0207
// must be glibc >= 2.7
mode += 'e';
#endif
return mode;
}
/*!
\internal
Returns the stdio open flags corresponding to a QIODevice::OpenMode.
*/
static inline int openModeToOpenFlags(QIODevice::OpenMode mode)
{
int oflags = QT_OPEN_RDONLY;
#ifdef QT_LARGEFILE_SUPPORT
oflags |= QT_OPEN_LARGEFILE;
#endif
if ((mode & QFile::ReadWrite) == QFile::ReadWrite) {
oflags = QT_OPEN_RDWR | QT_OPEN_CREAT;
} else if (mode & QFile::WriteOnly) {
oflags = QT_OPEN_WRONLY | QT_OPEN_CREAT;
}
if (mode & QFile::Append) {
oflags |= QT_OPEN_APPEND;
} else if (mode & QFile::WriteOnly) {
if ((mode & QFile::Truncate) || !(mode & QFile::ReadOnly))
oflags |= QT_OPEN_TRUNC;
}
return oflags;
}
/*!
\internal
Sets the file descriptor to close on exec. That is, the file
descriptor is not inherited by child processes.
*/
static inline bool setCloseOnExec(int fd)
{
return fd != -1 && fcntl(fd, F_SETFD, FD_CLOEXEC) != -1;
}
/*!
\internal
*/
bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode)
{
Q_Q(QFSFileEngine);
if (openMode & QIODevice::Unbuffered) {
int flags = openModeToOpenFlags(openMode);
// Try to open the file in unbuffered mode.
do {
fd = QT_OPEN(fileEntry.nativeFilePath().constData(), flags, 0666);
} while (fd == -1 && errno == EINTR);
// On failure, return and report the error.
if (fd == -1) {
q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
qt_error_string(errno));
return false;
}
if (!(openMode & QIODevice::WriteOnly)) {
// we don't need this check if we tried to open for writing because then
// we had received EISDIR anyway.
if (QFileSystemEngine::fillMetaData(fd, metaData)
&& metaData.isDirectory()) {
q->setError(QFile::OpenError, QLatin1String("file to open is a directory"));
QT_CLOSE(fd);
return false;
}
}
// Seek to the end when in Append mode.
if (flags & QFile::Append) {
int ret;
do {
ret = QT_LSEEK(fd, 0, SEEK_END);
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
qt_error_string(int(errno)));
return false;
}
}
fh = 0;
} else {
QByteArray fopenMode = openModeToFopenMode(openMode, fileEntry, metaData);
// Try to open the file in buffered mode.
do {
fh = QT_FOPEN(fileEntry.nativeFilePath().constData(), fopenMode.constData());
} while (!fh && errno == EINTR);
// On failure, return and report the error.
if (!fh) {
q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
qt_error_string(int(errno)));
return false;
}
if (!(openMode & QIODevice::WriteOnly)) {
// we don't need this check if we tried to open for writing because then
// we had received EISDIR anyway.
if (QFileSystemEngine::fillMetaData(QT_FILENO(fh), metaData)
&& metaData.isDirectory()) {
q->setError(QFile::OpenError, QLatin1String("file to open is a directory"));
fclose(fh);
return false;
}
}
setCloseOnExec(fileno(fh)); // ignore failure
// Seek to the end when in Append mode.
if (openMode & QIODevice::Append) {
int ret;
do {
ret = QT_FSEEK(fh, 0, SEEK_END);
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
qt_error_string(int(errno)));
return false;
}
}
fd = -1;
}
closeFileHandle = true;
return true;
}
/*!
\internal
*/
bool QFSFileEnginePrivate::nativeClose()
{
return closeFdFh();
}
/*!
\internal
*/
bool QFSFileEnginePrivate::nativeFlush()
{
return fh ? flushFh() : fd != -1;
}
/*!
\internal
\since 5.1
*/
bool QFSFileEnginePrivate::nativeSyncToDisk()
{
Q_Q(QFSFileEngine);
#if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
const int ret = fdatasync(nativeHandle());
#else
const int ret = fsync(nativeHandle());
#endif
if (ret != 0)
q->setError(QFile::WriteError, qt_error_string(errno));
return ret == 0;
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 len)
{
Q_Q(QFSFileEngine);
if (fh && nativeIsSequential()) {
size_t readBytes = 0;
int oldFlags = fcntl(QT_FILENO(fh), F_GETFL);
for (int i = 0; i < 2; ++i) {
// Unix: Make the underlying file descriptor non-blocking
if ((oldFlags & O_NONBLOCK) == 0)
fcntl(QT_FILENO(fh), F_SETFL, oldFlags | O_NONBLOCK);
// Cross platform stdlib read
size_t read = 0;
do {
read = fread(data + readBytes, 1, size_t(len - readBytes), fh);
} while (read == 0 && !feof(fh) && errno == EINTR);
if (read > 0) {
readBytes += read;
break;
} else {
if (readBytes)
break;
readBytes = read;
}
// Unix: Restore the blocking state of the underlying socket
if ((oldFlags & O_NONBLOCK) == 0) {
fcntl(QT_FILENO(fh), F_SETFL, oldFlags);
if (readBytes == 0) {
int readByte = 0;
do {
readByte = fgetc(fh);
} while (readByte == -1 && errno == EINTR);
if (readByte != -1) {
*data = uchar(readByte);
readBytes += 1;
} else {
break;
}
}
}
}
// Unix: Restore the blocking state of the underlying socket
if ((oldFlags & O_NONBLOCK) == 0) {
fcntl(QT_FILENO(fh), F_SETFL, oldFlags);
}
if (readBytes == 0 && !feof(fh)) {
// if we didn't read anything and we're not at EOF, it must be an error
q->setError(QFile::ReadError, qt_error_string(int(errno)));
return -1;
}
return readBytes;
}
return readFdFh(data, len);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::nativeReadLine(char *data, qint64 maxlen)
{
return readLineFdFh(data, maxlen);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::nativeWrite(const char *data, qint64 len)
{
return writeFdFh(data, len);
}
/*!
\internal
*/
qint64 QFSFileEnginePrivate::nativePos() const
{
return posFdFh();
}
/*!
\internal
*/
bool QFSFileEnginePrivate::nativeSeek(qint64 pos)
{
return seekFdFh(pos);
}
/*!
\internal
*/
int QFSFileEnginePrivate::nativeHandle() const
{
return fh ? fileno(fh) : fd;
}
/*!
\internal
*/
bool QFSFileEnginePrivate::nativeIsSequential() const
{
return isSequentialFdFh();
}
bool QFSFileEngine::remove()
{
Q_D(QFSFileEngine);
QSystemError error;
bool ret = QFileSystemEngine::removeFile(d->fileEntry, error);
d->metaData.clear();
if (!ret) {
setError(QFile::RemoveError, error.toString());
}
return ret;
}
bool QFSFileEngine::copy(const QString &newName)
{
Q_D(QFSFileEngine);
QSystemError error;
bool ret = QFileSystemEngine::copyFile(d->fileEntry, QFileSystemEntry(newName), error);
if (!ret) {
setError(QFile::CopyError, error.toString());
}
return ret;
}
bool QFSFileEngine::renameOverwrite(const QString &newName)
{
// On Unix, rename() overwrites.
return rename(newName);
}
bool QFSFileEngine::rename(const QString &newName)
{
Q_D(QFSFileEngine);
QSystemError error;
bool ret = QFileSystemEngine::renameFile(d->fileEntry, QFileSystemEntry(newName), error);
if (!ret) {
setError(QFile::RenameError, error.toString());
}
return ret;
}
bool QFSFileEngine::link(const QString &newName)
{
Q_D(QFSFileEngine);
QSystemError error;
bool ret = QFileSystemEngine::createLink(d->fileEntry, QFileSystemEntry(newName), error);
if (!ret) {
setError(QFile::RenameError, error.toString());
}
return ret;
}
qint64 QFSFileEnginePrivate::nativeSize() const
{
return sizeFdFh();
}
bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
{
return QFileSystemEngine::createDirectory(QFileSystemEntry(name), createParentDirectories);
}
bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
{
return QFileSystemEngine::removeDirectory(QFileSystemEntry(name), recurseParentDirectories);
}
bool QFSFileEngine::caseSensitive() const
{
return true;
}
bool QFSFileEngine::setCurrentPath(const QString &path)
{
return QFileSystemEngine::setCurrentPath(QFileSystemEntry(path));
}
QString QFSFileEngine::currentPath(const QString &)
{
return QFileSystemEngine::currentPath().filePath();
}
QString QFSFileEngine::homePath()
{
return QFileSystemEngine::homePath();
}
QString QFSFileEngine::rootPath()
{
return QFileSystemEngine::rootPath();
}
QString QFSFileEngine::tempPath()
{
return QFileSystemEngine::tempPath();
}
QFileInfoList QFSFileEngine::drives()
{
QFileInfoList ret;
ret.append(QFileInfo(rootPath()));
return ret;
}
bool QFSFileEnginePrivate::doStat(QFileSystemMetaData::MetaDataFlags flags) const
{
if (!tried_stat || !metaData.hasFlags(flags)) {
tried_stat = 1;
int localFd = fd;
if (fh && fileEntry.isEmpty())
localFd = QT_FILENO(fh);
if (localFd != -1)
QFileSystemEngine::fillMetaData(localFd, metaData);
if (metaData.missingFlags(flags) && !fileEntry.isEmpty())
QFileSystemEngine::fillMetaData(fileEntry, metaData, metaData.missingFlags(flags));
}
return metaData.exists();
}
bool QFSFileEnginePrivate::isSymlink() const
{
if (!metaData.hasFlags(QFileSystemMetaData::LinkType))
QFileSystemEngine::fillMetaData(fileEntry, metaData, QFileSystemMetaData::LinkType);
return metaData.isLink();
}
/*!
\reimp
*/
QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(FileFlags type) const
{
Q_D(const QFSFileEngine);
if (type & Refresh)
d->metaData.clear();
QAbstractFileEngine::FileFlags ret = 0;
if (type & FlagsMask)
ret |= LocalDiskFlag;
bool exists;
{
QFileSystemMetaData::MetaDataFlags queryFlags = 0;
queryFlags |= QFileSystemMetaData::MetaDataFlags(uint(type))
& QFileSystemMetaData::Permissions;
if (type & TypesMask)
queryFlags |= QFileSystemMetaData::AliasType
| QFileSystemMetaData::LinkType
| QFileSystemMetaData::FileType
| QFileSystemMetaData::DirectoryType
| QFileSystemMetaData::BundleType;
if (type & FlagsMask)
queryFlags |= QFileSystemMetaData::HiddenAttribute
| QFileSystemMetaData::ExistsAttribute;
queryFlags |= QFileSystemMetaData::LinkType;
exists = d->doStat(queryFlags);
}
if (!exists && !d->metaData.isLink())
return ret;
if (exists && (type & PermsMask))
ret |= FileFlags(uint(d->metaData.permissions()));
if (type & TypesMask) {
if (d->metaData.isAlias()) {
ret |= LinkType;
} else {
if ((type & LinkType) && d->metaData.isLink())
ret |= LinkType;
if (exists) {
if (d->metaData.isFile()) {
ret |= FileType;
} else if (d->metaData.isDirectory()) {
ret |= DirectoryType;
if ((type & BundleType) && d->metaData.isBundle())
ret |= BundleType;
}
}
}
}
if (type & FlagsMask) {
if (exists)
ret |= ExistsFlag;
if (d->fileEntry.isRoot())
ret |= RootFlag;
else if (d->metaData.isHidden())
ret |= HiddenFlag;
}
return ret;
}
QString QFSFileEngine::fileName(FileName file) const
{
Q_D(const QFSFileEngine);
if (file == BundleName) {
return QFileSystemEngine::bundleName(d->fileEntry);
} else if (file == BaseName) {
return d->fileEntry.fileName();
} else if (file == PathName) {
return d->fileEntry.path();
} else if (file == AbsoluteName || file == AbsolutePathName) {
QFileSystemEntry entry(QFileSystemEngine::absoluteName(d->fileEntry));
if (file == AbsolutePathName) {
return entry.path();
}
return entry.filePath();
} else if (file == CanonicalName || file == CanonicalPathName) {
QFileSystemEntry entry(QFileSystemEngine::canonicalName(d->fileEntry, d->metaData));
if (file == CanonicalPathName)
return entry.path();
return entry.filePath();
} else if (file == LinkName) {
if (d->isSymlink()) {
QFileSystemEntry entry = QFileSystemEngine::getLinkTarget(d->fileEntry, d->metaData);
return entry.filePath();
}
return QString();
}
return d->fileEntry.filePath();
}
bool QFSFileEngine::isRelativePath() const
{
Q_D(const QFSFileEngine);
return d->fileEntry.filePath().length() ? d->fileEntry.filePath()[0] != QLatin1Char('/') : true;
}
uint QFSFileEngine::ownerId(FileOwner own) const
{
Q_D(const QFSFileEngine);
static const uint nobodyID = (uint) -2;
if (d->doStat(QFileSystemMetaData::OwnerIds))
return d->metaData.ownerId(own);
return nobodyID;
}
QString QFSFileEngine::owner(FileOwner own) const
{
if (own == OwnerUser)
return QFileSystemEngine::resolveUserName(ownerId(own));
return QFileSystemEngine::resolveGroupName(ownerId(own));
}
bool QFSFileEngine::setPermissions(uint perms)
{
Q_D(QFSFileEngine);
QSystemError error;
if (!QFileSystemEngine::setPermissions(d->fileEntry, QFile::Permissions(perms), error, 0)) {
setError(QFile::PermissionsError, error.toString());
return false;
}
return true;
}
bool QFSFileEngine::setSize(qint64 size)
{
Q_D(QFSFileEngine);
bool ret = false;
if (d->fd != -1)
ret = QT_FTRUNCATE(d->fd, size) == 0;
else if (d->fh)
ret = QT_FTRUNCATE(QT_FILENO(d->fh), size) == 0;
else
ret = QT_TRUNCATE(d->fileEntry.nativeFilePath().constData(), size) == 0;
if (!ret)
setError(QFile::ResizeError, qt_error_string(errno));
return ret;
}
QDateTime QFSFileEngine::fileTime(FileTime time) const
{
Q_D(const QFSFileEngine);
if (d->doStat(QFileSystemMetaData::Times))
return d->metaData.fileTime(time);
return QDateTime();
}
uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
{
Q_Q(QFSFileEngine);
Q_UNUSED(flags);
if (openMode == QIODevice::NotOpen) {
q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
return 0;
}
if (offset < 0 || offset != qint64(QT_OFF_T(offset))
|| size < 0 || quint64(size) > quint64(size_t(-1))) {
q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
return 0;
}
// If we know the mapping will extend beyond EOF, fail early to avoid
// undefined behavior. Otherwise, let mmap have its say.
if (doStat(QFileSystemMetaData::SizeAttribute)
&& (QT_OFF_T(size) > metaData.size() - QT_OFF_T(offset)))
qWarning("QFSFileEngine::map: Mapping a file beyond its size is not portable");
int access = 0;
if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;
#if defined(Q_OS_INTEGRITY)
int pageSize = sysconf(_SC_PAGESIZE);
#else
int pageSize = getpagesize();
#endif
int extra = offset % pageSize;
if (quint64(size + extra) > quint64((size_t)-1)) {
q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
return 0;
}
size_t realSize = (size_t)size + extra;
QT_OFF_T realOffset = QT_OFF_T(offset);
realOffset &= ~(QT_OFF_T(pageSize - 1));
void *mapAddress = QT_MMAP((void*)0, realSize,
access, MAP_SHARED, nativeHandle(), realOffset);
if (MAP_FAILED != mapAddress) {
uchar *address = extra + static_cast<uchar*>(mapAddress);
maps[address] = QPair<int,size_t>(extra, realSize);
return address;
}
switch(errno) {
case EBADF:
q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
break;
case ENFILE:
case ENOMEM:
q->setError(QFile::ResourceError, qt_error_string(int(errno)));
break;
case EINVAL:
// size are out of bounds
default:
q->setError(QFile::UnspecifiedError, qt_error_string(int(errno)));
break;
}
return 0;
}
bool QFSFileEnginePrivate::unmap(uchar *ptr)
{
#if !defined(Q_OS_INTEGRITY)
Q_Q(QFSFileEngine);
if (!maps.contains(ptr)) {
q->setError(QFile::PermissionsError, qt_error_string(EACCES));
return false;
}
uchar *start = ptr - maps[ptr].first;
size_t len = maps[ptr].second;
if (-1 == munmap(start, len)) {
q->setError(QFile::UnspecifiedError, qt_error_string(errno));
return false;
}
maps.remove(ptr);
return true;
#else
return false;
#endif
}
#endif // QT_NO_FSFILEENGINE
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

1053
src/app/core/backport/qfsfileengine_win.cpp
View file

File diff suppressed because it is too large Load diff

331
src/app/core/backport/qlockfile.cpp
View file

@ -1,331 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qlockfile.h"
#include "qlockfile_p.h"
#include <QThread>
#include <QElapsedTimer>
#include <QDateTime>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QLockFileThread : public QThread
{
public:
static void msleep(unsigned long msecs) { QThread::msleep(msecs); }
};
/*!
\class QLockFile
\inmodule QtCore
\brief The QLockFile class provides locking between processes using a file.
\since 5.1
A lock file can be used to prevent multiple processes from accessing concurrently
the same resource. For instance, a configuration file on disk, or a socket, a port,
a region of shared memory...
Serialization is only guaranteed if all processes that access the shared resource
use QLockFile, with the same file path.
QLockFile supports two use cases:
to protect a resource for a short-term operation (e.g. verifying if a configuration
file has changed before saving new settings), and for long-lived protection of a
resource (e.g. a document opened by a user in an editor) for an indefinite amount of time.
When protecting for a short-term operation, it is acceptable to call lock() and wait
until any running operation finishes.
When protecting a resource over a long time, however, the application should always
call setStaleLockTime(0) and then tryLock() with a short timeout, in order to
warn the user that the resource is locked.
If the process holding the lock crashes, the lock file stays on disk and can prevent
any other process from accessing the shared resource, ever. For this reason, QLockFile
tries to detect such a "stale" lock file, based on the process ID written into the file,
and (in case that process ID got reused meanwhile), on the last modification time of
the lock file (30s by default, for the use case of a short-lived operation).
If the lock file is found to be stale, it will be deleted.
For the use case of protecting a resource over a long time, you should therefore call
setStaleLockTime(0), and when tryLock() returns LockFailedError, inform the user
that the document is locked, possibly using getLockInfo() for more details.
*/
/*!
\enum QLockFile::LockError
This enum describes the result of the last call to lock() or tryLock().
\value NoError The lock was acquired successfully.
\value LockFailedError The lock could not be acquired because another process holds it.
\value PermissionError The lock file could not be created, for lack of permissions
in the parent directory.
\value UnknownError Another error happened, for instance a full partition
prevented writing out the lock file.
*/
/*!
Constructs a new lock file object.
The object is created in an unlocked state.
When calling lock() or tryLock(), a lock file named \a fileName will be created,
if it doesn't already exist.
\sa lock(), unlock()
*/
QLockFile::QLockFile(const QString &fileName)
: d_ptr(new QLockFilePrivate(fileName))
{
}
/*!
Destroys the lock file object.
If the lock was acquired, this will release the lock, by deleting the lock file.
*/
QLockFile::~QLockFile()
{
unlock();
}
/*!
Sets \a staleLockTime to be the time in milliseconds after which
a lock file is considered stale.
The default value is 30000, i.e. 30 seconds.
If your application typically keeps the file locked for more than 30 seconds
(for instance while saving megabytes of data for 2 minutes), you should set
a bigger value using setStaleLockTime().
The value of \a staleLockTime is used by lock() and tryLock() in order
to determine when an existing lock file is considered stale, i.e. left over
by a crashed process. This is useful for the case where the PID got reused
meanwhile, so the only way to detect a stale lock file is by the fact that
it has been around for a long time.
\sa staleLockTime()
*/
void QLockFile::setStaleLockTime(int staleLockTime)
{
Q_D(QLockFile);
d->staleLockTime = staleLockTime;
}
/*!
Returns the time in milliseconds after which
a lock file is considered stale.
\sa setStaleLockTime()
*/
int QLockFile::staleLockTime() const
{
Q_D(const QLockFile);
return d->staleLockTime;
}
/*!
Returns \c true if the lock was acquired by this QLockFile instance,
otherwise returns \c false.
\sa lock(), unlock(), tryLock()
*/
bool QLockFile::isLocked() const
{
Q_D(const QLockFile);
return d->isLocked;
}
/*!
Creates the lock file.
If another process (or another thread) has created the lock file already,
this function will block until that process (or thread) releases it.
Calling this function multiple times on the same lock from the same
thread without unlocking first is not allowed. This function will
\e dead-lock when the file is locked recursively.
Returns \c true if the lock was acquired, false if it could not be acquired
due to an unrecoverable error, such as no permissions in the parent directory.
\sa unlock(), tryLock()
*/
bool QLockFile::lock()
{
return tryLock(-1);
}
/*!
Attempts to create the lock file. This function returns \c true if the
lock was obtained; otherwise it returns \c false. If another process (or
another thread) has created the lock file already, this function will
wait for at most \a timeout milliseconds for the lock file to become
available.
Note: Passing a negative number as the \a timeout is equivalent to
calling lock(), i.e. this function will wait forever until the lock
file can be locked if \a timeout is negative.
If the lock was obtained, it must be released with unlock()
before another process (or thread) can successfully lock it.
Calling this function multiple times on the same lock from the same
thread without unlocking first is not allowed, this function will
\e always return false when attempting to lock the file recursively.
\sa lock(), unlock()
*/
bool QLockFile::tryLock(int timeout)
{
Q_D(QLockFile);
QElapsedTimer timer;
if (timeout > 0)
timer.start();
int sleepTime = 100;
forever {
d->lockError = d->tryLock_sys();
switch (d->lockError) {
case NoError:
d->isLocked = true;
return true;
case PermissionError:
case UnknownError:
return false;
case LockFailedError:
if (!d->isLocked && d->isApparentlyStale()) {
// Stale lock from another thread/process
// Ensure two processes don't remove it at the same time
QLockFile rmlock(d->fileName + QStringLiteral(".rmlock"));
if (rmlock.tryLock()) {
if (d->isApparentlyStale() && d->removeStaleLock())
continue;
}
}
break;
}
if (timeout == 0 || (timeout > 0 && timer.hasExpired(timeout)))
return false;
QThread::msleep(sleepTime);
if (sleepTime < 5 * 1000)
sleepTime *= 2;
}
// not reached
return false;
}
/*!
\fn void QLockFile::unlock()
Releases the lock, by deleting the lock file.
Calling unlock() without locking the file first, does nothing.
\sa lock(), tryLock()
*/
/*!
Retrieves information about the current owner of the lock file.
If tryLock() returns \c false, and error() returns LockFailedError,
this function can be called to find out more information about the existing
lock file:
\list
\li the PID of the application (returned in \a pid)
\li the \a hostname it's running on (useful in case of networked filesystems),
\li the name of the application which created it (returned in \a appname),
\endlist
Note that tryLock() automatically deleted the file if there is no
running application with this PID, so LockFailedError can only happen if there is
an application with this PID (it could be unrelated though).
This can be used to inform users about the existing lock file and give them
the choice to delete it. After removing the file using removeStaleLockFile(),
the application can call tryLock() again.
This function returns \c true if the information could be successfully retrieved, false
if the lock file doesn't exist or doesn't contain the expected data.
This can happen if the lock file was deleted between the time where tryLock() failed
and the call to this function. Simply call tryLock() again if this happens.
*/
bool QLockFile::getLockInfo(qint64 *pid, QString *hostname, QString *appname) const
{
Q_D(const QLockFile);
return d->getLockInfo(pid, hostname, appname);
}
bool QLockFilePrivate::getLockInfo(qint64 *pid, QString *hostname, QString *appname) const
{
QFile reader(fileName);
if (!reader.open(QIODevice::ReadOnly))
return false;
QByteArray pidLine = reader.readLine();
pidLine.chop(1);
QByteArray appNameLine = reader.readLine();
appNameLine.chop(1);
QByteArray hostNameLine = reader.readLine();
hostNameLine.chop(1);
if (pidLine.isEmpty() || appNameLine.isEmpty())
return false;
qint64 thePid = pidLine.toLongLong();
if (pid)
*pid = thePid;
if (appname)
*appname = QString::fromUtf8(appNameLine);
if (hostname)
*hostname = QString::fromUtf8(hostNameLine);
return thePid > 0;
}
/*!
Attempts to forcefully remove an existing lock file.
Calling this is not recommended when protecting a short-lived operation: QLockFile
already takes care of removing lock files after they are older than staleLockTime().
This method should only be called when protecting a resource for a long time, i.e.
with staleLockTime(0), and after tryLock() returned LockFailedError, and the user
agreed on removing the lock file.
Returns \c true on success, false if the lock file couldn't be removed. This happens
on Windows, when the application owning the lock is still running.
*/
bool QLockFile::removeStaleLockFile()
{
Q_D(QLockFile);
if (d->isLocked) {
qWarning("removeStaleLockFile can only be called when not holding the lock");
return false;
}
return d->removeStaleLock();
}
/*!
Returns the lock file error status.
If tryLock() returns \c false, this function can be called to find out
the reason why the locking failed.
*/
QLockFile::LockError QLockFile::error() const
{
Q_D(const QLockFile);
return d->lockError;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

66
src/app/core/backport/qlockfile.h
View file

@ -1,66 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:LGPL21$
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QLOCKFILE_H
#define QLOCKFILE_H
#include <QString>
#include <QScopedPointer>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QLockFilePrivate;
class QLockFile
{
public:
QLockFile(const QString &fileName);
~QLockFile();
bool lock();
bool tryLock(int timeout = 0);
void unlock();
void setStaleLockTime(int);
int staleLockTime() const;
bool isLocked() const;
bool getLockInfo(qint64 *pid, QString *hostname, QString *appname) const;
bool removeStaleLockFile();
enum LockError {
NoError = 0,
LockFailedError = 1,
PermissionError = 2,
UnknownError = 3
};
LockError error() const;
protected:
QScopedPointer<QLockFilePrivate> d_ptr;
private:
Q_DECLARE_PRIVATE(QLockFile)
Q_DISABLE_COPY(QLockFile)
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QLOCKFILE_H

83
src/app/core/backport/qlockfile_p.h
View file

@ -1,83 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:LGPL21$
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QLOCKFILE_P_H
#define QLOCKFILE_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 "qlockfile.h"
#include <QFile>
#ifdef Q_OS_WIN
#include <qt_windows.h>
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QLockFilePrivate
{
public:
QLockFilePrivate(const QString &fn)
: fileName(fn),
#ifdef Q_OS_WIN
fileHandle(INVALID_HANDLE_VALUE),
#else
fileHandle(-1),
#endif
staleLockTime(30 * 1000), // 30 seconds
lockError(QLockFile::NoError),
isLocked(false)
{
}
QLockFile::LockError tryLock_sys();
bool removeStaleLock();
bool getLockInfo(qint64 *pid, QString *hostname, QString *appname) const;
// Returns \c true if the lock belongs to dead PID, or is old.
// The attempt to delete it will tell us if it was really stale or not, though.
bool isApparentlyStale() const;
#ifdef Q_OS_UNIX
static int checkFcntlWorksAfterFlock();
#endif
QString fileName;
#ifdef Q_OS_WIN
Qt::HANDLE fileHandle;
#else
int fileHandle;
#endif
int staleLockTime; // "int milliseconds" is big enough for 24 days
QLockFile::LockError lockError;
bool isLocked;
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif /* QLOCKFILE_P_H */

193
src/app/core/backport/qlockfile_unix.cpp
View file

@ -1,193 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qlockfile_p.h"
#include <QTemporaryFile>
#include <QCoreApplication>
#include <QFileInfo>
#include <QDebug>
#include <QDateTime>
#include "qcore_unix_p.h" // qt_safe_open
#include "qabstractfileengine_p.h"
//#include "qtemporaryfile_p.h"
#include <sys/file.h> // flock
#include <sys/types.h> // kill
#include <signal.h> // kill
#include <unistd.h> // gethostname
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
static QByteArray localHostName() // from QHostInfo::localHostName(), modified to return a QByteArray
{
QByteArray hostName(512, Qt::Uninitialized);
if (gethostname(hostName.data(), hostName.size()) == -1)
return QByteArray();
hostName.truncate(strlen(hostName.data()));
return hostName;
}
// ### merge into qt_safe_write?
static qint64 qt_write_loop(int fd, const char *data, qint64 len)
{
qint64 pos = 0;
while (pos < len) {
const qint64 ret = qt_safe_write(fd, data + pos, len - pos);
if (ret == -1) // e.g. partition full
return pos;
pos += ret;
}
return pos;
}
int QLockFilePrivate::checkFcntlWorksAfterFlock()
{
#ifndef QT_NO_TEMPORARYFILE
QTemporaryFile file;
if (!file.open())
return 0;
const int fd = file.d_func()->engine()->handle();
#if defined(LOCK_EX) && defined(LOCK_NB)
if (flock(fd, LOCK_EX | LOCK_NB) == -1) // other threads, and other processes on a local fs
return 0;
#endif
struct flock flockData;
flockData.l_type = F_WRLCK;
flockData.l_whence = SEEK_SET;
flockData.l_start = 0;
flockData.l_len = 0; // 0 = entire file
flockData.l_pid = getpid();
if (fcntl(fd, F_SETLK, &flockData) == -1) // for networked filesystems
return 0;
return 1;
#else
return 0;
#endif
}
static QBasicAtomicInt fcntlOK = Q_BASIC_ATOMIC_INITIALIZER(-1);
/*!
\internal
Checks that the OS isn't using POSIX locks to emulate flock().
Mac OS X is one of those.
*/
static bool fcntlWorksAfterFlock()
{
int value = fcntlOK.load();
if (Q_UNLIKELY(value == -1)) {
value = QLockFilePrivate::checkFcntlWorksAfterFlock();
fcntlOK.store(value);
}
return value == 1;
}
static bool setNativeLocks(int fd)
{
#if defined(LOCK_EX) && defined(LOCK_NB)
if (flock(fd, LOCK_EX | LOCK_NB) == -1) // other threads, and other processes on a local fs
return false;
#endif
struct flock flockData;
flockData.l_type = F_WRLCK;
flockData.l_whence = SEEK_SET;
flockData.l_start = 0;
flockData.l_len = 0; // 0 = entire file
flockData.l_pid = getpid();
if (fcntlWorksAfterFlock() && fcntl(fd, F_SETLK, &flockData) == -1) // for networked filesystems
return false;
return true;
}
QLockFile::LockError QLockFilePrivate::tryLock_sys()
{
// Assemble data, to write in a single call to write
// (otherwise we'd have to check every write call)
// Use operator% from the fast builder to avoid multiple memory allocations.
QByteArray fileData = QByteArray::number(QCoreApplication::applicationPid()) % '\n'
% qAppName().toUtf8() % '\n'
% localHostName() % '\n';
const QByteArray lockFileName = QFile::encodeName(fileName);
const int fd = qt_safe_open(lockFileName.constData(), O_WRONLY | O_CREAT | O_EXCL, 0644);
if (fd < 0) {
switch (errno) {
case EEXIST:
return QLockFile::LockFailedError;
case EACCES:
case EROFS:
return QLockFile::PermissionError;
default:
return QLockFile::UnknownError;
}
}
// Ensure nobody else can delete the file while we have it
if (!setNativeLocks(fd))
qWarning() << "setNativeLocks failed:" << strerror(errno);
// We hold the lock, continue.
fileHandle = fd;
QLockFile::LockError error = QLockFile::NoError;
if (qt_write_loop(fd, fileData.constData(), fileData.size()) < fileData.size())
error = QLockFile::UnknownError; // partition full
return error;
}
bool QLockFilePrivate::removeStaleLock()
{
const QByteArray lockFileName = QFile::encodeName(fileName);
const int fd = qt_safe_open(lockFileName.constData(), O_WRONLY, 0644);
if (fd < 0) // gone already?
return false;
bool success = setNativeLocks(fd) && (::unlink(lockFileName) == 0);
close(fd);
return success;
}
bool QLockFilePrivate::isApparentlyStale() const
{
qint64 pid;
QString hostname, appname;
if (!getLockInfo(&pid, &hostname, &appname))
return false;
if (hostname == QString::fromLocal8Bit(localHostName())) {
if (::kill(pid, 0) == -1 && errno == ESRCH)
return true; // PID doesn't exist anymore
}
const qint64 age = QFileInfo(fileName).lastModified().msecsTo(QDateTime::currentDateTime());
return staleLockTime > 0 && age > staleLockTime;
}
void QLockFile::unlock()
{
Q_D(QLockFile);
if (!d->isLocked)
return;
close(d->fileHandle);
d->fileHandle = -1;
QFile::remove(d->fileName);
d->lockError = QLockFile::NoError;
d->isLocked = false;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

116
src/app/core/backport/qlockfile_win.cpp
View file

@ -1,116 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 David Faure <faure+bluesystems@kde.org>
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qlockfile_p.h"
#include "qfilesystementry_p.h"
#include <qt_windows.h>
#include <QCoreApplication>
#include <QFileInfo>
#include <QDateTime>
#include <QDebug>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
QLockFile::LockError QLockFilePrivate::tryLock_sys()
{
SECURITY_ATTRIBUTES securityAtts = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE };
const QFileSystemEntry fileEntry(fileName);
// When writing, allow others to read.
// When reading, QFile will allow others to read and write, all good.
// Adding FILE_SHARE_DELETE would allow forceful deletion of stale files,
// but Windows doesn't allow recreating it while this handle is open anyway,
// so this would only create confusion (can't lock, but no lock file to read from).
const DWORD dwShareMode = FILE_SHARE_READ;
HANDLE fh = CreateFile((const wchar_t*)fileEntry.nativeFilePath().utf16(),
GENERIC_WRITE,
dwShareMode,
&securityAtts,
CREATE_NEW, // error if already exists
FILE_ATTRIBUTE_NORMAL,
NULL);
if (fh == INVALID_HANDLE_VALUE) {
const DWORD lastError = GetLastError();
switch (lastError) {
case ERROR_SHARING_VIOLATION:
case ERROR_ALREADY_EXISTS:
case ERROR_FILE_EXISTS:
case ERROR_ACCESS_DENIED: // readonly file, or file still in use by another process. Assume the latter, since we don't create it readonly.
return QLockFile::LockFailedError;
default:
qWarning() << "Got unexpected locking error" << lastError;
return QLockFile::UnknownError;
}
}
// We hold the lock, continue.
fileHandle = fh;
// Assemble data, to write in a single call to write
// (otherwise we'd have to check every write call)
QByteArray fileData;
fileData += QByteArray::number(QCoreApplication::applicationPid());
fileData += '\n';
fileData += qAppName().toUtf8();
fileData += '\n';
//fileData += localHostname(); // gethostname requires winsock init, see QHostInfo...
fileData += '\n';
DWORD bytesWritten = 0;
QLockFile::LockError error = QLockFile::NoError;
if (!WriteFile(fh, fileData.constData(), fileData.size(), &bytesWritten, NULL) || !FlushFileBuffers(fh))
error = QLockFile::UnknownError; // partition full
return error;
}
bool QLockFilePrivate::removeStaleLock()
{
// QFile::remove fails on Windows if the other process is still using the file, so it's not stale.
return QFile::remove(fileName);
}
bool QLockFilePrivate::isApparentlyStale() const
{
qint64 pid;
QString hostname, appname;
if (!getLockInfo(&pid, &hostname, &appname))
return false;
HANDLE procHandle = ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
if (!procHandle)
return true;
// We got a handle but check if process is still alive
DWORD dwR = ::WaitForSingleObject(procHandle, 0);
::CloseHandle(procHandle);
if (dwR == WAIT_TIMEOUT)
return true;
const qint64 age = QFileInfo(fileName).lastModified().msecsTo(QDateTime::currentDateTime());
return staleLockTime > 0 && age > staleLockTime;
}
void QLockFile::unlock()
{
Q_D(QLockFile);
if (!d->isLocked)
return;
CloseHandle(d->fileHandle);
QFile::remove(d->fileName);
d->lockError = QLockFile::NoError;
d->isLocked = false;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

133
src/app/core/backport/qmutexpool.cpp
View file

@ -1,133 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qatomic.h"
#include "qmutexpool_p.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_THREAD
Q_GLOBAL_STATIC_WITH_ARGS(QMutexPool, globalMutexPool, (QMutex::Recursive))
/*!
\class QMutexPool
\inmodule QtCore
\brief The QMutexPool class provides a pool of QMutex objects.
\internal
\ingroup thread
QMutexPool is a convenience class that provides access to a fixed
number of QMutex objects.
Typical use of a QMutexPool is in situations where it is not
possible or feasible to use one QMutex for every protected object.
The mutex pool will return a mutex based on the address of the
object that needs protection.
For example, consider this simple class:
\snippet code/src_corelib_thread_qmutexpool.cpp 0
Adding a QMutex member to the Number class does not make sense,
because it is so small. However, in order to ensure that access to
each Number is protected, you need to use a mutex. In this case, a
QMutexPool would be ideal.
Code to calculate the square of a number would then look something
like this:
\snippet code/src_corelib_thread_qmutexpool.cpp 1
This function will safely calculate the square of a number, since
it uses a mutex from a QMutexPool. The mutex is locked and
unlocked automatically by the QMutexLocker class. See the
QMutexLocker documentation for more details.
*/
/*!
Constructs a QMutexPool, reserving space for \a size QMutexes. All
mutexes in the pool are created with \a recursionMode. By default,
all mutexes are non-recursive.
The QMutexes are created when needed, and deleted when the
QMutexPool is destructed.
*/
QMutexPool::QMutexPool(QMutex::RecursionMode recursionMode, int size)
: mutexes(size), recursionMode(recursionMode)
{
for (int index = 0; index < mutexes.count(); ++index) {
mutexes[index].store(0);
}
}
/*!
Destructs a QMutexPool. All QMutexes that were created by the pool
are deleted.
*/
QMutexPool::~QMutexPool()
{
for (int index = 0; index < mutexes.count(); ++index)
delete mutexes[index].load();
}
/*!
Returns the global QMutexPool instance.
*/
QMutexPool *QMutexPool::instance()
{
return globalMutexPool();
}
/*!
\fn QMutexPool::get(const void *address)
Returns a QMutex from the pool. QMutexPool uses the value \a address
to determine which mutex is returned from the pool.
*/
/*!
\internal
create the mutex for the given index
*/
QMutex *QMutexPool::createMutex(int index)
{
// mutex not created, create one
QMutex *newMutex = new QMutex(recursionMode);
if (!mutexes[index].testAndSetRelease(0, newMutex))
delete newMutex;
return mutexes[index].load();
}
/*!
Returns a QMutex from the global mutex pool.
*/
QMutex *QMutexPool::globalInstanceGet(const void *address)
{
QMutexPool * const globalInstance = globalMutexPool();
if (globalInstance == 0)
return 0;
return globalInstance->get(address);
}
#endif // QT_NO_THREAD
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

70
src/app/core/backport/qmutexpool_p.h
View file

@ -1,70 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QMUTEXPOOL_P_H
#define QMUTEXPOOL_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of QSettings. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include "QtCore/qatomic.h"
#include <QMutex>
#include <QVarLengthArray>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifndef QT_NO_THREAD
class QMutexPool
{
public:
explicit QMutexPool(QMutex::RecursionMode recursionMode = QMutex::NonRecursive, int size = 131);
~QMutexPool();
inline QMutex *get(const void *address) {
int index = uint(quintptr(address)) % mutexes.count();
QMutex *m = mutexes[index].load();
if (m)
return m;
else
return createMutex(index);
}
static QMutexPool *instance();
static QMutex *globalInstanceGet(const void *address);
private:
QMutex *createMutex(int index);
QVarLengthArray<QAtomicPointer<QMutex>, 131> mutexes;
QMutex::RecursionMode recursionMode;
};
#endif // QT_NO_THREAD
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QMUTEXPOOL_P_H

77
src/app/core/backport/qresource.h
View file

@ -1,77 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QRESOURCE_H
#define QRESOURCE_H
#include <QString>
#include <QLocale>
#include <QStringList>
#include <QList>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QResourcePrivate;
class QResource
{
public:
QResource(const QString &file=QString(), const QLocale &locale=QLocale());
~QResource();
void setFileName(const QString &file);
QString fileName() const;
QString absoluteFilePath() const;
void setLocale(const QLocale &locale);
QLocale locale() const;
bool isValid() const;
bool isCompressed() const;
qint64 size() const;
const uchar *data() const;
static void addSearchPath(const QString &path);
static QStringList searchPaths();
static bool registerResource(const QString &rccFilename, const QString &resourceRoot=QString());
static bool unregisterResource(const QString &rccFilename, const QString &resourceRoot=QString());
static bool registerResource(const uchar *rccData, const QString &resourceRoot=QString());
static bool unregisterResource(const uchar *rccData, const QString &resourceRoot=QString());
protected:
friend class QResourceFileEngine;
friend class QResourceFileEngineIterator;
bool isDir() const;
inline bool isFile() const { return !isDir(); }
QStringList children() const;
protected:
QScopedPointer<QResourcePrivate> d_ptr;
private:
Q_DECLARE_PRIVATE(QResource)
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QRESOURCE_H

98
src/app/core/backport/qresource_p.h
View file

@ -1,98 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QRESOURCE_P_H
#define QRESOURCE_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 "qabstractfileengine_p.h"
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QResourceFileEnginePrivate;
class QResourceFileEngine : public QAbstractFileEngine
{
private:
Q_DECLARE_PRIVATE(QResourceFileEngine)
public:
explicit QResourceFileEngine(const QString &path);
~QResourceFileEngine();
virtual void setFileName(const QString &file);
virtual bool open(QIODevice::OpenMode flags) ;
virtual bool close();
virtual bool flush();
virtual qint64 size() const;
virtual qint64 pos() const;
virtual bool atEnd() const;
virtual bool seek(qint64);
virtual qint64 read(char *data, qint64 maxlen);
virtual qint64 write(const char *data, qint64 len);
virtual bool remove();
virtual bool copy(const QString &newName);
virtual bool rename(const QString &newName);
virtual bool link(const QString &newName);
virtual bool isSequential() const;
virtual bool isRelativePath() const;
virtual bool mkdir(const QString &dirName, bool createParentDirectories) const;
virtual bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
virtual bool setSize(qint64 size);
virtual QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
virtual bool caseSensitive() const;
virtual FileFlags fileFlags(FileFlags type) const;
virtual bool setPermissions(uint perms);
virtual QString fileName(QAbstractFileEngine::FileName file) const;
virtual uint ownerId(FileOwner) const;
virtual QString owner(FileOwner) const;
virtual QDateTime fileTime(FileTime time) const;
virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
virtual Iterator *endEntryList();
bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
bool supportsExtension(Extension extension) const;
};
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QRESOURCE_P_H

154
src/app/core/backport/qsystemerror.cpp
View file

@ -1,154 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtGlobal>
#include "qsystemerror_p.h"
#if !defined(Q_OS_WINCE)
# include <errno.h>
# if defined(Q_CC_MSVC)
# include <crtdbg.h>
# endif
#else
# if (_WIN32_WCE >= 0x700)
# include <errno.h>
# endif
#endif
#ifdef Q_OS_WIN
# include <qt_windows.h>
#endif
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#if !defined(Q_OS_WIN) && !defined(QT_NO_THREAD) && !defined(Q_OS_INTEGRITY) && !defined(Q_OS_QNX) && \
defined(_POSIX_THREAD_SAFE_FUNCTIONS) && _POSIX_VERSION >= 200112L
namespace {
// There are two incompatible versions of strerror_r:
// a) the XSI/POSIX.1 version, which returns an int,
// indicating success or not
// b) the GNU version, which returns a char*, which may or may not
// be the beginning of the buffer we used
// The GNU libc manpage for strerror_r says you should use the XSI
// version in portable code. However, it's impossible to do that if
// _GNU_SOURCE is defined so we use C++ overloading to decide what to do
// depending on the return type
static inline QString fromstrerror_helper(int, const QByteArray &buf)
{
return QString::fromLocal8Bit(buf);
}
static inline QString fromstrerror_helper(const char *str, const QByteArray &)
{
return QString::fromLocal8Bit(str);
}
}
#endif
#ifdef Q_OS_WIN
static QString windowsErrorString(int errorCode)
{
QString ret;
#ifndef Q_OS_WINRT
wchar_t *string = 0;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
errorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&string,
0,
NULL);
ret = QString::fromWCharArray(string);
LocalFree((HLOCAL)string);
#else
wchar_t errorString[1024];
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
errorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&errorString,
sizeof(errorString)/sizeof(wchar_t),
NULL);
ret = QString::fromWCharArray(errorString);
#endif // Q_OS_WINRT
if (ret.isEmpty() && errorCode == ERROR_MOD_NOT_FOUND)
ret = QString::fromLatin1("The specified module could not be found.");
return ret;
}
#endif
static QString standardLibraryErrorString(int errorCode)
{
const char *s = 0;
QString ret;
switch (errorCode) {
case 0:
break;
case EACCES:
s = QT_TRANSLATE_NOOP("QIODevice", "Permission denied");
break;
case EMFILE:
s = QT_TRANSLATE_NOOP("QIODevice", "Too many open files");
break;
case ENOENT:
s = QT_TRANSLATE_NOOP("QIODevice", "No such file or directory");
break;
case ENOSPC:
s = QT_TRANSLATE_NOOP("QIODevice", "No space left on device");
break;
default: {
#ifdef Q_OS_WINCE
ret = windowsErrorString(errorCode);
#else
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && _POSIX_VERSION >= 200112L && !defined(Q_OS_INTEGRITY) && !defined(Q_OS_QNX)
QByteArray buf(1024, '\0');
ret = fromstrerror_helper(strerror_r(errorCode, buf.data(), buf.size()), buf);
#else
ret = QString::fromLocal8Bit(strerror(errorCode));
#endif
#endif
break; }
}
if (s) {
// ######## this breaks moc build currently
// ret = QCoreApplication::translate("QIODevice", s);
ret = QString::fromLatin1(s);
}
return ret.trimmed();
}
QString QSystemError::toString()
{
switch(errorScope) {
case NativeError:
#if defined (Q_OS_WIN)
return windowsErrorString(errorCode);
#else
//unix: fall through as native and standard library are the same
#endif
case StandardLibraryError:
return standardLibraryErrorString(errorCode);
default:
qWarning("invalid error scope");
//fall through
case NoError:
return QLatin1String("No error");
}
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)

85
src/app/core/backport/qsystemerror_p.h
View file

@ -1,85 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QSYSTEMERROR_P_H
#define QSYSTEMERROR_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 <QString>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
class QSystemError
{
public:
enum ErrorScope
{
NoError,
StandardLibraryError,
NativeError
};
inline QSystemError(int error, ErrorScope scope);
inline QSystemError();
QString toString();
inline ErrorScope scope();
inline int error();
//data members
int errorCode;
ErrorScope errorScope;
};
QSystemError::QSystemError(int error, QSystemError::ErrorScope scope)
: errorCode(error), errorScope(scope)
{
}
QSystemError::QSystemError()
: errorCode(0), errorScope(NoError)
{
}
QSystemError::ErrorScope QSystemError::scope()
{
return errorScope;
}
int QSystemError::error()
{
return errorCode;
}
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif // QSYSTEMERROR_P_H

90
src/app/core/backport/qsystemlibrary_p.h
View file

@ -1,90 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** $QT_BEGIN_LICENSE:GPL$
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QSYSTEMLIBRARY_P_H
#define QSYSTEMLIBRARY_P_H
#include <QtGlobal>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#ifdef Q_OS_WIN
# include <QString>
# include <qt_windows.h>
class QSystemLibrary
{
public:
explicit QSystemLibrary(const QString &libraryName)
{
m_libraryName = libraryName;
m_handle = 0;
m_didLoad = false;
}
explicit QSystemLibrary(const wchar_t *libraryName)
{
m_libraryName = QString::fromWCharArray(libraryName);
m_handle = 0;
m_didLoad = false;
}
bool load(bool onlySystemDirectory = true)
{
m_handle = load((const wchar_t *)m_libraryName.utf16(), onlySystemDirectory);
m_didLoad = true;
return (m_handle != 0);
}
bool isLoaded()
{
return (m_handle != 0);
}
QFunctionPointer resolve(const char *symbol)
{
if (!m_didLoad)
load();
if (!m_handle)
return 0;
#ifdef Q_OS_WINCE
return QFunctionPointer(GetProcAddress(m_handle, (const wchar_t*)QString::fromLatin1(symbol).utf16()));
#else
return QFunctionPointer(GetProcAddress(m_handle, symbol));
#endif
}
static QFunctionPointer resolve(const QString &libraryName, const char *symbol)
{
return QSystemLibrary(libraryName).resolve(symbol);
}
static Q_CORE_EXPORT HINSTANCE load(const wchar_t *lpFileName, bool onlySystemDirectory = true);
private:
HINSTANCE m_handle;
QString m_libraryName;
bool m_didLoad;
};
#endif //Q_OS_WIN
#endif //QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
#endif //QSYSTEMLIBRARY_P_H

59
src/app/core/core.pri
View file

@ -6,66 +6,11 @@ HEADERS += \
$$PWD/undoevent.h \
$$PWD/vsettings.h \
$$PWD/backport/qcommandlineoption.h \
$$PWD/backport/qcommandlineparser.h \
$$PWD/backport/qlockfile.h \
$$PWD/backport/qlockfile_p.h \
$$PWD/backport/qfilesystementry_p.h \
$$PWD/backport/qfsfileengine_p.h \
$$PWD/backport/qabstractfileengine_p.h \
$$PWD/backport/qresource_p.h \
$$PWD/backport/qresource.h \
$$PWD/backport/qfilesystemmetadata_p.h \
$$PWD/backport/qfilesystemengine_p.h \
$$PWD/backport/qsystemerror_p.h \
$$PWD/backport/qfsfileengine_iterator_p.h \
$$PWD/backport/qfilesystemiterator_p.h \
$$PWD/backport/qfileinfo_p.h \
$$PWD/backport/qmutexpool_p.h \
$$PWD/backport/qsystemlibrary_p.h \
unix:!macx {
HEADERS += \
$$PWD/backport/qcore_unix_p.h
}
unix:macx {
HEADERS += \
$$PWD/backport/qcore_mac_p.h
}
$$PWD/backport/qcommandlineparser.h
SOURCES += \
$$PWD/vapplication.cpp \
$$PWD/undoevent.cpp \
$$PWD/vsettings.cpp \
$$PWD/backport/qcommandlineoption.cpp \
$$PWD/backport/qcommandlineparser.cpp \
$$PWD/backport/qlockfile.cpp \
$$PWD/backport/qfilesystementry.cpp \
$$PWD/backport/qfsfileengine.cpp \
$$PWD/backport/qabstractfileengine.cpp \
$$PWD/backport/qfilesystemengine.cpp \
$$PWD/backport/qsystemerror.cpp \
$$PWD/backport/qfsfileengine_iterator.cpp \
$$PWD/backport/qmutexpool.cpp
unix:!macx {
SOURCES += \
$$PWD/backport/qlockfile_unix.cpp \
$$PWD/backport/qfilesystemiterator_unix.cpp \
$$PWD/backport/qfsfileengine_unix.cpp \
$$PWD/backport/qfilesystemengine_unix.cpp \
$$PWD/backport/qcore_unix.cpp
}
unix:macx {
SOURCES += \
$$PWD/backport/qcore_mac.cpp
}
win32 {
SOURCES += \
$$PWD/backport/qlockfile_win.cpp \
$$PWD/backport/qfilesystemiterator_win.cpp \
$$PWD/backport/qfsfileengine_win.cpp \
$$PWD/backport/qfilesystemengine_win.cpp
}
$$PWD/backport/qcommandlineparser.cpp

34
src/app/core/vapplication.cpp
View file

@ -49,9 +49,7 @@
#include <QMessageBox>
#include <QThread>
#include <QDateTime>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
# include "backport/qlockfile.h"
#else
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
# include <QLockFile>
#endif
#include <QtXmlPatterns>
@ -169,7 +167,12 @@ VApplication::VApplication(int &argc, char **argv)
variables(QMap<QString, QmuTranslation>()), functions(QMap<QString, QmuTranslation>()),
postfixOperators(QMap<QString, QmuTranslation>()), stDescriptions(QMap<QString, QmuTranslation>()),
undoStack(nullptr), sceneView(nullptr), currentScene(nullptr), autoSaveTimer(nullptr), mainWindow(nullptr),
openingPattern(false), settings(nullptr), doc(nullptr), log(nullptr), out(nullptr), logLock(nullptr)
openingPattern(false), settings(nullptr), doc(nullptr), log(nullptr),
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
out(nullptr), logLock(nullptr)
#else
out(nullptr)
#endif
{
undoStack = new QUndoStack(this);
@ -192,7 +195,9 @@ VApplication::~VApplication()
{
log->close();
delete log;
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
delete logLock;
#endif
}
}
@ -342,6 +347,7 @@ double VApplication::fromPixel(double pix) const
return fromPixel(pix, _patternUnit);
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
//---------------------------------------------------------------------------------------------------------------------
bool VApplication::TryLock(QLockFile *lock)
{
@ -379,6 +385,8 @@ bool VApplication::TryLock(QLockFile *lock)
}
}
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
//---------------------------------------------------------------------------------------------------------------------
QString VApplication::translationsPath() const
{
@ -469,6 +477,7 @@ void VApplication::BeginLogging()
{
out = new QTextStream(log);
qInstallMessageHandler(noisyFailureMsgHandler);
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
logLock = new QLockFile(LogPath()+".lock");
logLock->setStaleLockTime(0);
if (TryLock(logLock))
@ -480,6 +489,7 @@ void VApplication::BeginLogging()
qCDebug(vApp, "Failed to lock %s", LogPath().toUtf8().constData());
qCDebug(vApp, "Error type: %d", logLock->error());
}
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
}
else
{
@ -505,6 +515,7 @@ void VApplication::ClearOldLogs() const
for (int i = 0; i < allFiles.size(); ++i)
{
QFileInfo info(allFiles.at(i));
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
QLockFile *lock = new QLockFile(info.absoluteFilePath() + ".lock");
if (TryLock(lock))
{
@ -523,8 +534,23 @@ void VApplication::ClearOldLogs() const
{
qCDebug(vApp, "Failed to lock %s", info.absoluteFilePath().toUtf8().constData());
}
delete lock;
lock = nullptr;
#else
if (info.created().daysTo(QDateTime::currentDateTime()) >= 3)
{
QFile oldLog(allFiles.at(i));
if (oldLog.remove())
{
qCDebug(vApp, "Deleted %s", info.absoluteFilePath().toUtf8().constData());
}
else
{
qCDebug(vApp, "Could not delete %s", info.absoluteFilePath().toUtf8().constData());
}
}
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
}
}
else

6
src/app/core/vapplication.h
View file

@ -41,7 +41,9 @@ class VMainGraphicsView;
class VMainGraphicsScene;
class VPattern;
class QFile;
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
class QLockFile;
#endif
#if defined(qApp)
#undef qApp
@ -70,7 +72,9 @@ public:
double fromPixel(double pix, const Unit &unit) const;
double fromPixel(double pix) const;
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
static bool TryLock(QLockFile *lock);
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
static const qreal PrintDPI;
QString translationsPath() const;
@ -167,7 +171,9 @@ private:
VPattern *doc;
QFile *log;
QTextStream *out;
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
QLockFile *logLock;
#endif
void InitLineWidth();
void InitMeasurements();
void InitVariables();

22
src/app/mainwindow.cpp
View file

@ -61,9 +61,7 @@
#include <QtGlobal>
#include <QDesktopWidget>
#include <QDesktopServices>
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
# include "core/backport/qlockfile.h"
#else
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
# include <QLockFile>
#endif
@ -81,7 +79,12 @@ MainWindow::MainWindow(QWidget *parent)
dialogHistory(nullptr), comboBoxDraws(nullptr), curFile(QString()), mode(Draw::Calculation), currentDrawIndex(0),
currentToolBoxIndex(0), drawMode(true), recentFileActs(),
separatorAct(nullptr), autoSaveTimer(nullptr), guiEnabled(true), gradationHeights(nullptr),
gradationSizes(nullptr), toolOptions(nullptr), lock(nullptr)
gradationSizes(nullptr),
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
toolOptions(nullptr), lock(nullptr)
#else
toolOptions(nullptr)
#endif
{
for (int i = 0; i < MaxRecentFiles; ++i)
{
@ -1444,9 +1447,11 @@ void MainWindow::Clear()
{
qCDebug(vMainWindow, "Reseting main window.");
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
delete lock; // Unlock pattern file
lock = nullptr;
qCDebug(vMainWindow, "Unlocked pattern file.");
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
ui->actionDetails->setChecked(false);
ui->actionDraw->setChecked(true);
@ -2438,7 +2443,9 @@ MainWindow::~MainWindow()
{
CancelTool();
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
delete lock; // Unlock pattern file
#endif
delete pattern;
delete doc;
delete sceneDetails;
@ -2468,6 +2475,7 @@ void MainWindow::LoadPattern(const QString &fileName)
return;
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
qCDebug(vMainWindow, "Loking file");
lock = new QLockFile(fileName+".lock");
lock->setStaleLockTime(0);
@ -2486,6 +2494,7 @@ void MainWindow::LoadPattern(const QString &fileName)
return;
}
}
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
// On this stage scene empty. Fit scene size to view size
VAbstractTool::NewSceneRect(sceneDraw, ui->view);
@ -2574,7 +2583,9 @@ void MainWindow::LoadPattern(const QString &fileName)
//---------------------------------------------------------------------------------------------------------------------
QStringList MainWindow::GetUnlokedRestoreFileList() const
{
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
QStringList restoreFiles;
//Take all files that need to be restored
QStringList files = qApp->getSettings()->GetRestoreFileList();
if (files.size() > 0)
{
@ -2601,6 +2612,9 @@ QStringList MainWindow::GetUnlokedRestoreFileList() const
}
return restoreFiles;
#else
return qApp->getSettings()->GetRestoreFileList();
#endif //QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
}
//---------------------------------------------------------------------------------------------------------------------

2
src/app/mainwindow.h
View file

@ -214,7 +214,9 @@ private:
QComboBox *gradationHeights;
QComboBox *gradationSizes;
VToolOptionsPropertyBrowser *toolOptions;
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
QLockFile *lock;
#endif
void ToolBarOption();
void ToolBarDraws();

6
src/app/stable.h
View file

@ -41,9 +41,9 @@
#include <csignal>
/*In all cases we need include core header for getting defined values*/
#ifdef QT_CORE_LIB
# include <QtCore>
#endif
//#ifdef QT_CORE_LIB
//# include <QtCore>
//#endif
#ifdef QT_GUI_LIB
# include <QtGui>