diff options
Diffstat (limited to 'src/corelib/io')
38 files changed, 863 insertions, 869 deletions
diff --git a/src/corelib/io/io.pri b/src/corelib/io/io.pri index b0cac59f42..38e5c23c05 100644 --- a/src/corelib/io/io.pri +++ b/src/corelib/io/io.pri @@ -118,16 +118,14 @@ win32 { !winrt { HEADERS += \ io/qwindowspipereader_p.h \ - io/qwindowspipewriter_p.h \ - io/qwinoverlappedionotifier_p.h + io/qwindowspipewriter_p.h SOURCES += \ io/qsettings_win.cpp \ io/qstandardpaths_win.cpp \ io/qstorageinfo_win.cpp \ io/qwindowspipereader.cpp \ - io/qwindowspipewriter.cpp \ - io/qwinoverlappedionotifier.cpp + io/qwindowspipewriter.cpp LIBS += -lmpr } else { diff --git a/src/corelib/io/qabstractfileengine.cpp b/src/corelib/io/qabstractfileengine.cpp index 9606ec68e9..85dc2f33a2 100644 --- a/src/corelib/io/qabstractfileengine.cpp +++ b/src/corelib/io/qabstractfileengine.cpp @@ -727,6 +727,18 @@ QString QAbstractFileEngine::owner(FileOwner owner) const } /*! + \fn bool QAbstractFileEngine::setFileTime(const QDateTime &newDate, FileTime time) + + \since 5.10 + Sets the file \a time to \a newDate, returning true if successful; + otherwise returns false. + + This virtual function must be reimplemented by all subclasses. + + \sa fileTime() +*/ + +/*! If \a time is \c CreationTime, return when the file was created. If \a time is \c ModificationTime, return when the file was most recently modified. If \a time is \c AccessTime, return when the @@ -832,6 +844,19 @@ bool QAbstractFileEngine::unmap(uchar *address) } /*! + \since 5.10 + + Copies the contents from the file specified by \a sourceHandle to this file + by cloning it. + Returns \c true on success; otherwise, \c false is returned. + */ +bool QAbstractFileEngine::clone(int sourceHandle) +{ + Q_UNUSED(sourceHandle); + return false; +} + +/*! \since 4.3 \class QAbstractFileEngineIterator \inmodule QtCore diff --git a/src/corelib/io/qabstractfileengine_p.h b/src/corelib/io/qabstractfileengine_p.h index 48b3dec324..9d0a101b49 100644 --- a/src/corelib/io/qabstractfileengine_p.h +++ b/src/corelib/io/qabstractfileengine_p.h @@ -144,9 +144,11 @@ public: virtual QString fileName(FileName file=DefaultName) const; virtual uint ownerId(FileOwner) const; virtual QString owner(FileOwner) const; + virtual bool setFileTime(const QDateTime &newDate, FileTime time) = 0; virtual QDateTime fileTime(FileTime time) const; virtual void setFileName(const QString &file); virtual int handle() const; + virtual bool clone(int sourceHandle); bool atEnd() const; uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags); bool unmap(uchar *ptr); diff --git a/src/corelib/io/qdatastream.cpp b/src/corelib/io/qdatastream.cpp index 9a42fb4a37..9044ad74b1 100644 --- a/src/corelib/io/qdatastream.cpp +++ b/src/corelib/io/qdatastream.cpp @@ -562,6 +562,7 @@ void QDataStream::setByteOrder(ByteOrder bo) \value Qt_5_7 Same as Qt_5_6 \value Qt_5_8 Same as Qt_5_6 \value Qt_5_9 Same as Qt_5_6 + \value Qt_5_10 Same as Qt_5_6 \omitvalue Qt_DefaultCompiledVersion \sa setVersion(), version() diff --git a/src/corelib/io/qdatastream.h b/src/corelib/io/qdatastream.h index 575607e147..0a429d091a 100644 --- a/src/corelib/io/qdatastream.h +++ b/src/corelib/io/qdatastream.h @@ -96,10 +96,11 @@ public: Qt_5_7 = Qt_5_6, Qt_5_8 = Qt_5_7, Qt_5_9 = Qt_5_8, -#if QT_VERSION >= 0x050a00 + Qt_5_10 = Qt_5_9, +#if QT_VERSION >= 0x050b00 #error Add the datastream version for this Qt version and update Qt_DefaultCompiledVersion #endif - Qt_DefaultCompiledVersion = Qt_5_9 + Qt_DefaultCompiledVersion = Qt_5_10 }; enum ByteOrder { diff --git a/src/corelib/io/qdebug.cpp b/src/corelib/io/qdebug.cpp index be33ec2d23..341400fd93 100644 --- a/src/corelib/io/qdebug.cpp +++ b/src/corelib/io/qdebug.cpp @@ -648,6 +648,21 @@ QDebug &QDebug::resetFormat() */ /*! + \since 5.10 + \fn QDebug &QDebug::operator<<(QStringView s) + + Writes the string view, \a s, to the stream and returns a reference to the + stream. Normally, QDebug prints the string inside quotes and transforms + non-printable characters to their Unicode values (\\u1234). + + To print non-printable characters without transformation, enable the + noquote() functionality. Note that some QDebug backends might not be 8-bit + clean. + + See the QString overload for examples. +*/ + +/*! \fn QDebug &QDebug::operator<<(QLatin1String s) Writes the string, \a s, to the stream and returns a reference to the diff --git a/src/corelib/io/qdebug.h b/src/corelib/io/qdebug.h index 186722b69b..ee8ef679a9 100644 --- a/src/corelib/io/qdebug.h +++ b/src/corelib/io/qdebug.h @@ -151,8 +151,11 @@ public: inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); } inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); } inline QDebug &operator<<(const char* t) { stream->ts << QString::fromUtf8(t); return maybeSpace(); } +#if QT_STRINGVIEW_LEVEL < 2 inline QDebug &operator<<(const QString & t) { putString(t.constData(), uint(t.length())); return maybeSpace(); } inline QDebug &operator<<(const QStringRef & t) { putString(t.constData(), uint(t.length())); return maybeSpace(); } +#endif + inline QDebug &operator<<(QStringView s) { putString(s.data(), size_t(s.size())); return maybeSpace(); } inline QDebug &operator<<(QLatin1String t) { putByteArray(t.latin1(), t.size(), ContainsLatin1); return maybeSpace(); } inline QDebug &operator<<(const QByteArray & t) { putByteArray(t.constData(), t.size(), ContainsBinary); return maybeSpace(); } inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); } diff --git a/src/corelib/io/qfile.cpp b/src/corelib/io/qfile.cpp index 06d706b915..ddd343b515 100644 --- a/src/corelib/io/qfile.cpp +++ b/src/corelib/io/qfile.cpp @@ -42,6 +42,7 @@ #include "qfile.h" #include "qfsfileengine_p.h" #include "qtemporaryfile.h" +#include "qtemporaryfile_p.h" #include "qlist.h" #include "qfileinfo.h" #include "private/qiodevice_p.h" @@ -790,25 +791,27 @@ QFile::copy(const QString &newName) close(); d->setError(QFile::CopyError, tr("Cannot open for output")); } else { - char block[4096]; - qint64 totalRead = 0; - while(!atEnd()) { - qint64 in = read(block, sizeof(block)); - if (in <= 0) - break; - totalRead += in; - if(in != out.write(block, in)) { - close(); - d->setError(QFile::CopyError, tr("Failure to write block")); - error = true; - break; + if (!out.d_func()->engine()->clone(d->engine()->handle())) { + char block[4096]; + qint64 totalRead = 0; + while (!atEnd()) { + qint64 in = read(block, sizeof(block)); + if (in <= 0) + break; + totalRead += in; + if (in != out.write(block, in)) { + close(); + d->setError(QFile::CopyError, tr("Failure to write block")); + error = true; + break; + } } - } - if (totalRead != size()) { - // Unable to read from the source. The error string is - // already set from read(). - error = true; + if (totalRead != size()) { + // Unable to read from the source. The error string is + // already set from read(). + error = true; + } } if (!error && !out.rename(newName)) { error = true; @@ -953,7 +956,9 @@ bool QFile::open(FILE *fh, OpenMode mode, FileHandleFlags handleFlags) qWarning("QFile::open: File access not specified"); return false; } - if (d->openExternalFile(mode, fh, handleFlags)) { + + // QIODevice provides the buffering, so request unbuffered file engines + if (d->openExternalFile(mode | Unbuffered, fh, handleFlags)) { QIODevice::open(mode); if (!(mode & Append) && !isSequential()) { qint64 pos = (qint64)QT_FTELL(fh); @@ -1009,7 +1014,9 @@ bool QFile::open(int fd, OpenMode mode, FileHandleFlags handleFlags) qWarning("QFile::open: File access not specified"); return false; } - if (d->openExternalFile(mode, fd, handleFlags)) { + + // QIODevice provides the buffering, so request unbuffered file engines + if (d->openExternalFile(mode | Unbuffered, fd, handleFlags)) { QIODevice::open(mode); if (!(mode & Append) && !isSequential()) { qint64 pos = (qint64)QT_LSEEK(fd, QT_OFF_T(0), SEEK_CUR); diff --git a/src/corelib/io/qfiledevice.cpp b/src/corelib/io/qfiledevice.cpp index 715dc7293a..8533602d63 100644 --- a/src/corelib/io/qfiledevice.cpp +++ b/src/corelib/io/qfiledevice.cpp @@ -738,6 +738,82 @@ bool QFileDevice::unmap(uchar *address) return false; } +/*! + \enum QFileDevice::FileTime + \since 5.10 + + This enum is used by the fileTime() and setFileTime() functions. + + \value FileCreationTime When the file was created (not supported on UNIX). + \value FileModificationTime When the file was most recently modified. + \value FileAccessTime When the file was most recently accessed (e.g. + read or written to). + + \sa setFileName(), fileTime() +*/ + +static inline QAbstractFileEngine::FileTime FileDeviceTimeToAbstractFileEngineTime(QFileDevice::FileTime time) +{ + switch (time) { + case QFileDevice::FileAccessTime: + return QAbstractFileEngine::AccessTime; + + case QFileDevice::FileCreationTime: + return QAbstractFileEngine::CreationTime; + + case QFileDevice::FileModificationTime: + return QAbstractFileEngine::ModificationTime; + } + + Q_UNREACHABLE(); + return QAbstractFileEngine::AccessTime; +} + +/*! + \since 5.10 + Returns the file time specified by \a time. + If the time cannot be determined return QDateTime() (an invalid + date time). + + \sa setFileName(), FileTime, QDateTime::isValid() +*/ +QDateTime QFileDevice::fileTime(QFileDevice::FileTime time) const +{ + Q_D(const QFileDevice); + + if (d->engine()) + return d->engine()->fileTime(FileDeviceTimeToAbstractFileEngineTime(time)); + + return QDateTime(); +} + +/*! + \since 5.10 + Sets the file \a time to \a newDate, returning true if successful; + otherwise returns false. + + \note The file must be open to use this function. + + \sa fileTime(), FileTime +*/ +bool QFileDevice::setFileTime(const QDateTime &newDate, QFileDevice::FileTime fileTime) +{ + Q_D(QFileDevice); + + if (!d->engine()) { + d->setError(QFileDevice::UnspecifiedError, tr("No file engine available")); + return false; + } + + if (!d->fileEngine->setFileTime(newDate, FileDeviceTimeToAbstractFileEngineTime(fileTime))) { + d->setError(d->fileEngine->error(), d->fileEngine->errorString()); + return false; + } + + unsetError(); + return true; +} + QT_END_NAMESPACE #ifndef QT_NO_QOBJECT diff --git a/src/corelib/io/qfiledevice.h b/src/corelib/io/qfiledevice.h index 4cfda1b044..3519a049a9 100644 --- a/src/corelib/io/qfiledevice.h +++ b/src/corelib/io/qfiledevice.h @@ -45,6 +45,7 @@ QT_BEGIN_NAMESPACE +class QDateTime; class QFileDevicePrivate; class Q_CORE_EXPORT QFileDevice : public QIODevice @@ -73,6 +74,12 @@ public: CopyError = 14 }; + enum FileTime { + FileCreationTime, + FileModificationTime, + FileAccessTime + }; + enum Permission { ReadOwner = 0x4000, WriteOwner = 0x2000, ExeOwner = 0x1000, ReadUser = 0x0400, WriteUser = 0x0200, ExeUser = 0x0100, @@ -119,6 +126,9 @@ public: uchar *map(qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions); bool unmap(uchar *address); + QDateTime fileTime(QFileDevice::FileTime time) const; + bool setFileTime(const QDateTime &newDate, QFileDevice::FileTime fileTime); + protected: QFileDevice(); #ifdef QT_NO_QOBJECT diff --git a/src/corelib/io/qfileinfo.cpp b/src/corelib/io/qfileinfo.cpp index 12fd7d3048..baac3117ea 100644 --- a/src/corelib/io/qfileinfo.cpp +++ b/src/corelib/io/qfileinfo.cpp @@ -42,6 +42,7 @@ #include "qglobal.h" #include "qdir.h" #include "qfileinfo_p.h" +#include "qdebug.h" QT_BEGIN_NAMESPACE @@ -262,8 +263,8 @@ QDateTime &QFileInfoPrivate::getFileTime(QAbstractFileEngine::FileTime request) info objects, just append one to the file name given to the constructors or setFile(). - The file's dates are returned by created(), lastModified() and - lastRead(). Information about the file's access permissions is + The file's dates are returned by created(), lastModified(), lastRead() and + fileTime(). Information about the file's access permissions is obtained with isReadable(), isWritable() and isExecutable(). The file's ownership is available from owner(), ownerId(), group() and groupId(). You can examine a file's permissions and ownership in a @@ -1324,7 +1325,7 @@ QDateTime QFileInfo::created() const /*! Returns the date and local time when the file was last modified. - \sa created(), lastRead() + \sa created(), lastRead(), fileTime() */ QDateTime QFileInfo::lastModified() const { @@ -1346,7 +1347,7 @@ QDateTime QFileInfo::lastModified() const On platforms where this information is not available, returns the same as lastModified(). - \sa created(), lastModified() + \sa created(), lastModified(), fileTime() */ QDateTime QFileInfo::lastRead() const { @@ -1363,6 +1364,45 @@ QDateTime QFileInfo::lastRead() const } /*! + \enum QFileInfo::FileTime + \since 5.10 + + This enum is used by the fileTime() function. + + \value FileCreationTime When the file was created (not supported on UNIX). + \value FileModificationTime When the file was most recently modified. + \value FileAccessTime When the file was most recently accessed (e.g. + read or written to). + + \sa fileTime() +*/ + +/*! + \since 5.10 + Returns the file time specified by \a time. + If the time cannot be determined return QDateTime() (an invalid + date time). + + \sa FileTime, QDateTime::isValid() +*/ +QDateTime QFileInfo::fileTime(QFileInfo::FileTime time) const +{ + switch (time) { + case QFileInfo::FileCreationTime: + return created(); + + case QFileInfo::FileModificationTime: + return lastModified(); + + case QFileInfo::FileAccessTime: + return lastRead(); + + default: + Q_UNREACHABLE(); + } +} + +/*! \internal */ QFileInfoPrivate* QFileInfo::d_func() @@ -1406,4 +1446,15 @@ void QFileInfo::setCaching(bool enable) Synonym for QList<QFileInfo>. */ +#ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug dbg, const QFileInfo &fi) +{ + QDebugStateSaver saver(dbg); + dbg.nospace(); + dbg.noquote(); + dbg << "QFileInfo(" << QDir::toNativeSeparators(fi.filePath()) << ')'; + return dbg; +} +#endif + QT_END_NAMESPACE diff --git a/src/corelib/io/qfileinfo.h b/src/corelib/io/qfileinfo.h index a160e8463e..d212b6dac2 100644 --- a/src/corelib/io/qfileinfo.h +++ b/src/corelib/io/qfileinfo.h @@ -57,6 +57,12 @@ class Q_CORE_EXPORT QFileInfo { friend class QDirIteratorPrivate; public: + enum FileTime { + FileCreationTime, + FileModificationTime, + FileAccessTime + }; + explicit QFileInfo(QFileInfoPrivate *d); QFileInfo(); @@ -132,6 +138,7 @@ public: QDateTime created() const; QDateTime lastModified() const; QDateTime lastRead() const; + QDateTime fileTime(QFileInfo::FileTime time) const; bool caching() const; void setCaching(bool on); @@ -151,6 +158,10 @@ Q_DECLARE_SHARED(QFileInfo) typedef QList<QFileInfo> QFileInfoList; +#ifndef QT_NO_DEBUG_STREAM +Q_CORE_EXPORT QDebug operator<<(QDebug, const QFileInfo &); +#endif + QT_END_NAMESPACE Q_DECLARE_METATYPE(QFileInfo) diff --git a/src/corelib/io/qfilesystemengine_unix.cpp b/src/corelib/io/qfilesystemengine_unix.cpp index e195afdae9..929db259ec 100644 --- a/src/corelib/io/qfilesystemengine_unix.cpp +++ b/src/corelib/io/qfilesystemengine_unix.cpp @@ -43,6 +43,7 @@ #include "qfilesystemengine_p.h" #include "qfile.h" +#include <QtCore/qoperatingsystemversion.h> #include <QtCore/qvarlengtharray.h> #include <stdlib.h> // for realpath() @@ -67,6 +68,9 @@ #endif #if defined(Q_OS_DARWIN) +# if QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(101200, 100000, 100000, 30000) +# include <sys/clonefile.h> +# endif // We cannot include <Foundation/Foundation.h> (it's an Objective-C header), but // we need these declarations: Q_FORWARD_DECLARE_OBJC_CLASS(NSString); @@ -642,8 +646,22 @@ bool QFileSystemEngine::createLink(const QFileSystemEntry &source, const QFileSy //static bool QFileSystemEngine::copyFile(const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error) { +#if QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(101200, 100000, 100000, 30000) + const auto current = QOperatingSystemVersion::current(); + if (current >= QOperatingSystemVersion::MacOSSierra || + current >= QOperatingSystemVersion(QOperatingSystemVersion::IOS, 10) || + current >= QOperatingSystemVersion(QOperatingSystemVersion::TvOS, 10) || + current >= QOperatingSystemVersion(QOperatingSystemVersion::WatchOS, 3)) { + if (::clonefile(source.nativeFilePath().constData(), + target.nativeFilePath().constData(), 0) == 0) + return true; + error = QSystemError(errno, QSystemError::StandardLibraryError); + return false; + } +#else Q_UNUSED(source); Q_UNUSED(target); +#endif error = QSystemError(ENOSYS, QSystemError::StandardLibraryError); //Function not implemented return false; } diff --git a/src/corelib/io/qfilesystemengine_win.cpp b/src/corelib/io/qfilesystemengine_win.cpp index b1e218de9c..d95a6de777 100644 --- a/src/corelib/io/qfilesystemengine_win.cpp +++ b/src/corelib/io/qfilesystemengine_win.cpp @@ -48,7 +48,6 @@ #include "qfile.h" #include "qdir.h" -#include "private/qmutexpool_p.h" #include "qvarlengtharray.h" #include "qdatetime.h" #include "qt_windows.h" @@ -179,6 +178,7 @@ static TRUSTEE_W worldTrusteeW; static PSID currentUserSID = 0; static PSID worldSID = 0; +namespace { /* Deletes the allocated SIDs during global static cleanup */ @@ -202,25 +202,10 @@ SidCleanup::~SidCleanup() Q_GLOBAL_STATIC(SidCleanup, initSidCleanup) -static void resolveLibs() +struct LibResolver { - static bool triedResolve = false; - if (!triedResolve) { - // need to resolve the security info functions - - // protect initialization -#ifndef QT_NO_THREAD - QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve)); - // check triedResolve again, since another thread may have already - // done the initialization - if (triedResolve) { - // another thread did initialize the security function pointers, - // so we shouldn't do it again. - return; - } -#endif - - triedResolve = true; + LibResolver() + { HINSTANCE advapiHnd = QSystemLibrary::load(L"advapi32"); if (advapiHnd) { ptrGetNamedSecurityInfoW = (PtrGetNamedSecurityInfoW)GetProcAddress(advapiHnd, "GetNamedSecurityInfoW"); @@ -267,9 +252,13 @@ static void resolveLibs() if (userenvHnd) ptrGetUserProfileDirectoryW = (PtrGetUserProfileDirectoryW)GetProcAddress(userenvHnd, "GetUserProfileDirectoryW"); } -} +}; +Q_GLOBAL_STATIC(LibResolver, resolveLibs) + +} // anonymous namespace #endif // QT_CONFIG(fslibs) +QT_BEGIN_INCLUDE_NAMESPACE typedef DWORD (WINAPI *PtrNetShareEnum)(LPWSTR, DWORD, LPBYTE*, DWORD, LPDWORD, LPDWORD, LPDWORD); static PtrNetShareEnum ptrNetShareEnum = 0; typedef DWORD (WINAPI *PtrNetApiBufferFree)(LPVOID); @@ -279,19 +268,13 @@ typedef struct _SHARE_INFO_1 { DWORD shi1_type; LPWSTR shi1_remark; } SHARE_INFO_1; +QT_END_INCLUDE_NAMESPACE - -static bool resolveUNCLibs() +namespace { +struct UNCLibResolver { - static bool triedResolve = false; - if (!triedResolve) { -#ifndef QT_NO_THREAD - QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve)); - if (triedResolve) { - return ptrNetShareEnum && ptrNetApiBufferFree; - } -#endif - triedResolve = true; + UNCLibResolver() + { #if !defined(Q_OS_WINRT) HINSTANCE hLib = QSystemLibrary::load(L"Netapi32"); if (hLib) { @@ -301,6 +284,13 @@ static bool resolveUNCLibs() } #endif // !Q_OS_WINRT } +}; +Q_GLOBAL_STATIC(UNCLibResolver, uncLibResolver) +} // anonymous namespace + +static bool resolveUNCLibs() +{ + uncLibResolver(); return ptrNetShareEnum && ptrNetApiBufferFree; } diff --git a/src/corelib/io/qfsfileengine.cpp b/src/corelib/io/qfsfileengine.cpp index 0b9cd0557f..75478f0467 100644 --- a/src/corelib/io/qfsfileengine.cpp +++ b/src/corelib/io/qfsfileengine.cpp @@ -195,6 +195,9 @@ void QFSFileEngine::setFileName(const QString &file) */ bool QFSFileEngine::open(QIODevice::OpenMode openMode) { + Q_ASSERT_X(openMode & QIODevice::Unbuffered, "QFSFileEngine::open", + "QFSFileEngine no longer supports buffered mode; upper layer must buffer"); + Q_D(QFSFileEngine); if (d->fileEntry.isEmpty()) { qWarning("QFSFileEngine::open: No file name specified"); @@ -230,6 +233,9 @@ bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh) bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh, QFile::FileHandleFlags handleFlags) { + Q_ASSERT_X(openMode & QIODevice::Unbuffered, "QFSFileEngine::open", + "QFSFileEngine no longer supports buffered mode; upper layer must buffer"); + Q_D(QFSFileEngine); // Append implies WriteOnly. @@ -255,6 +261,9 @@ bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh, QFile::FileHand */ bool QFSFileEnginePrivate::openFh(QIODevice::OpenMode openMode, FILE *fh) { + Q_ASSERT_X(openMode & QIODevice::Unbuffered, "QFSFileEngine::open", + "QFSFileEngine no longer supports buffered mode; upper layer must buffer"); + Q_Q(QFSFileEngine); this->fh = fh; fd = -1; @@ -860,9 +869,9 @@ bool QFSFileEngine::supportsExtension(Extension extension) const /*! \fn bool QFSFileEngine::copy(const QString ©Name) - For windows, copy the file to file \a copyName. + For Windows or Apple platforms, copy the file to file \a copyName. - Not implemented for Unix. + Not implemented for other Unix platforms. */ /*! \fn QString QFSFileEngine::currentPath(const QString &fileName) @@ -890,6 +899,10 @@ bool QFSFileEngine::supportsExtension(Extension extension) const \reimp */ +/*! \fn bool QFSFileEngine::setFileTime(const QDateTime &newDate, FileTime time) + \reimp +*/ + /*! \fn QDateTime QFSFileEngine::fileTime(FileTime time) const \reimp */ diff --git a/src/corelib/io/qfsfileengine_p.h b/src/corelib/io/qfsfileengine_p.h index 593ecc2687..80dd9363db 100644 --- a/src/corelib/io/qfsfileengine_p.h +++ b/src/corelib/io/qfsfileengine_p.h @@ -96,6 +96,7 @@ public: QString fileName(FileName file) const Q_DECL_OVERRIDE; uint ownerId(FileOwner) const Q_DECL_OVERRIDE; QString owner(FileOwner) const Q_DECL_OVERRIDE; + bool setFileTime(const QDateTime &newDate, FileTime time) Q_DECL_OVERRIDE; QDateTime fileTime(FileTime time) const Q_DECL_OVERRIDE; void setFileName(const QString &file) Q_DECL_OVERRIDE; int handle() const Q_DECL_OVERRIDE; @@ -108,6 +109,7 @@ public: qint64 read(char *data, qint64 maxlen) Q_DECL_OVERRIDE; qint64 readLine(char *data, qint64 maxlen) Q_DECL_OVERRIDE; qint64 write(const char *data, qint64 len) Q_DECL_OVERRIDE; + bool clone(int sourceHandle) override; bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0) Q_DECL_OVERRIDE; bool supportsExtension(Extension extension) const Q_DECL_OVERRIDE; diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp index e152b035e2..9f081e9295 100644 --- a/src/corelib/io/qfsfileengine_unix.cpp +++ b/src/corelib/io/qfsfileengine_unix.cpp @@ -65,46 +65,6 @@ QT_BEGIN_NAMESPACE /*! \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) @@ -130,17 +90,6 @@ static inline int openModeToOpenFlags(QIODevice::OpenMode mode) 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; -} - static inline QString msgOpenDirectory() { const char message[] = QT_TRANSLATE_NOOP("QIODevice", "file to open is a directory"); @@ -151,6 +100,44 @@ static inline QString msgOpenDirectory() #endif } +#if !QT_CONFIG(futimens) && (QT_CONFIG(futimes) || QT_CONFIG(futimesat)) +namespace { +namespace GetFileTimes { + +template <typename T> +static inline typename QtPrivate::QEnableIf<(&T::st_atim, &T::st_mtim, true)>::Type get(const T *p, struct timeval *access, struct timeval *modification) +{ + access->tv_sec = p->st_atim.tv_sec; + access->tv_usec = p->st_atim.tv_nsec / 1000; + + modification->tv_sec = p->st_mtim.tv_sec; + modification->tv_usec = p->st_mtim.tv_nsec / 1000; +} + +template <typename T> +static inline typename QtPrivate::QEnableIf<(&T::st_atimespec, &T::st_mtimespec, true)>::Type get(const T *p, struct timeval *access, struct timeval *modification) +{ + access->tv_sec = p->st_atimespec.tv_sec; + access->tv_usec = p->st_atimespec.tv_nsec / 1000; + + modification->tv_sec = p->st_mtimespec.tv_sec; + modification->tv_usec = p->st_mtimespec.tv_nsec / 1000; +} + +template <typename T> +static inline typename QtPrivate::QEnableIf<(&T::st_atimensec, &T::st_mtimensec, true)>::Type get(const T *p, struct timeval *access, struct timeval *modification) +{ + access->tv_sec = p->st_atime; + access->tv_usec = p->st_atimensec / 1000; + + modification->tv_sec = p->st_mtime; + modification->tv_usec = p->st_mtimensec / 1000; +} + +} +} +#endif + /*! \internal */ @@ -158,6 +145,8 @@ bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode) { Q_Q(QFSFileEngine); + Q_ASSERT_X(openMode & QIODevice::Unbuffered, "QFSFileEngine::open", + "QFSFileEngine no longer supports buffered mode; upper layer must buffer"); if (openMode & QIODevice::Unbuffered) { int flags = openModeToOpenFlags(openMode); @@ -199,49 +188,6 @@ bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode) } 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, msgOpenDirectory()); - 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; @@ -676,6 +622,83 @@ bool QFSFileEngine::setSize(qint64 size) return ret; } +bool QFSFileEngine::setFileTime(const QDateTime &newDate, FileTime time) +{ + Q_D(QFSFileEngine); + + if (d->openMode == QIODevice::NotOpen) { + setError(QFile::PermissionsError, qt_error_string(EACCES)); + return false; + } + + if (!newDate.isValid() || time == QAbstractFileEngine::CreationTime) { + setError(QFile::UnspecifiedError, qt_error_string(EINVAL)); + return false; + } + +#if QT_CONFIG(futimens) + struct timespec ts[2]; + + ts[0].tv_sec = ts[1].tv_sec = 0; + ts[0].tv_nsec = ts[1].tv_nsec = UTIME_OMIT; + + const qint64 msecs = newDate.toMSecsSinceEpoch(); + + if (time == QAbstractFileEngine::AccessTime) { + ts[0].tv_sec = msecs / 1000; + ts[0].tv_nsec = (msecs % 1000) * 1000000; + } else if (time == QAbstractFileEngine::ModificationTime) { + ts[1].tv_sec = msecs / 1000; + ts[1].tv_nsec = (msecs % 1000) * 1000000; + } + + if (futimens(d->nativeHandle(), ts) == -1) { + setError(QFile::PermissionsError, qt_error_string()); + return false; + } + + d->metaData.clearFlags(QFileSystemMetaData::Times); + + return true; +#elif QT_CONFIG(futimes) || QT_CONFIG(futimesat) + struct timeval tv[2]; + QT_STATBUF st; + + if (QT_FSTAT(d->nativeHandle(), &st) == -1) { + setError(QFile::PermissionsError, qt_error_string()); + return false; + } + + GetFileTimes::get(&st, &tv[0], &tv[1]); + + const qint64 msecs = newDate.toMSecsSinceEpoch(); + + if (time == QAbstractFileEngine::AccessTime) { + tv[0].tv_sec = msecs / 1000; + tv[0].tv_usec = (msecs % 1000) * 1000; + } else if (time == QAbstractFileEngine::ModificationTime) { + tv[1].tv_sec = msecs / 1000; + tv[1].tv_usec = (msecs % 1000) * 1000; + } + +#if QT_CONFIG(futimes) + if (futimes(d->nativeHandle(), tv) == -1) { +#else + if (futimesat(d->nativeHandle(), NULL, tv) == -1) { +#endif + setError(QFile::PermissionsError, qt_error_string()); + return false; + } + + d->metaData.clearFlags(QFileSystemMetaData::Times); + + return true; +#else + setError(QFile::UnspecifiedError, qt_error_string(ENOSYS)); + return false; +#endif +} + QDateTime QFSFileEngine::fileTime(FileTime time) const { Q_D(const QFSFileEngine); @@ -702,7 +725,6 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFla #endif Q_Q(QFSFileEngine); - Q_UNUSED(flags); if (openMode == QIODevice::NotOpen) { q->setError(QFile::PermissionsError, qt_error_string(int(EACCES))); return 0; @@ -793,6 +815,23 @@ bool QFSFileEnginePrivate::unmap(uchar *ptr) #endif } +/*! + \reimp +*/ +bool QFSFileEngine::clone(int sourceHandle) +{ +#if defined(Q_OS_LINUX) + Q_D(QFSFileEngine); +# if !defined FICLONE +# define FICLONE _IOW (0x94, 9, int) +# endif + return ::ioctl(d->fd, FICLONE, sourceHandle) == 0; +#else + Q_UNUSED(sourceHandle); + return false; +#endif +} + QT_END_NAMESPACE #endif // QT_NO_FSFILEENGINE diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp index 7d16e59195..5c6098c3b0 100644 --- a/src/corelib/io/qfsfileengine_win.cpp +++ b/src/corelib/io/qfsfileengine_win.cpp @@ -80,6 +80,39 @@ static inline bool isUncPath(const QString &path) && path.size() > 2 && path.at(2) != QLatin1Char('.')); } +static inline void QDateTimeToSystemTime(const QDateTime &date, SYSTEMTIME *systemTime) +{ + const QDate d = date.date(); + const QTime t = date.time(); + + systemTime->wYear = d.year(); + systemTime->wMonth = d.month(); + systemTime->wDay = d.day(); + systemTime->wHour = t.hour(); + systemTime->wMinute = t.minute(); + systemTime->wSecond = t.second(); + systemTime->wMilliseconds = t.msec(); + systemTime->wDayOfWeek = d.dayOfWeek() % 7; +} + +static inline bool QDateTimeToFileTime(const QDateTime &date, FILETIME *fileTime) +{ + SYSTEMTIME sTime; + +#if defined(Q_OS_WINCE) + QDateTimeToSystemTime(date, &sTime); +#else + SYSTEMTIME lTime; + + QDateTimeToSystemTime(date, &lTime); + + if (!::TzSpecificLocalTimeToSystemTime(0, &lTime, &sTime)) + return false; +#endif + + return ::SystemTimeToFileTime(&sTime, fileTime); +} + /*! \internal */ @@ -850,6 +883,69 @@ bool QFSFileEngine::setSize(qint64 size) return false; } +bool QFSFileEngine::setFileTime(const QDateTime &newDate, FileTime time) +{ + Q_D(QFSFileEngine); + + if (d->openMode == QFile::NotOpen) { + setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED)); + return false; + } + + if (!newDate.isValid()) { + setError(QFile::UnspecifiedError, qt_error_string(ERROR_INVALID_PARAMETER)); + return false; + } + + HANDLE handle = d->fileHandle; + +#ifndef Q_OS_WINCE + if (handle == INVALID_HANDLE_VALUE) { + if (d->fh) + handle = reinterpret_cast<HANDLE>(::_get_osfhandle(QT_FILENO(d->fh))); + else if (d->fd != -1) + handle = reinterpret_cast<HANDLE>(::_get_osfhandle(d->fd)); + } +#endif + + if (handle == INVALID_HANDLE_VALUE) { + setError(QFile::PermissionsError, qt_error_string(ERROR_ACCESS_DENIED)); + return false; + } + + FILETIME fTime; + FILETIME *pLastWrite = NULL; + FILETIME *pLastAccess = NULL; + FILETIME *pCreationTime = NULL; + + switch (time) { + case QAbstractFileEngine::ModificationTime: + pLastWrite = &fTime; + break; + + case QAbstractFileEngine::AccessTime: + pLastAccess = &fTime; + break; + + case QAbstractFileEngine::CreationTime: + pCreationTime = &fTime; + break; + } + + if (!QDateTimeToFileTime(newDate, &fTime)) { + setError(QFile::UnspecifiedError, qt_error_string()); + return false; + } + + if (!::SetFileTime(handle, pCreationTime, pLastAccess, pLastWrite)) { + setError(QFile::PermissionsError, qt_error_string()); + return false; + } + + d->metaData.clearFlags(QFileSystemMetaData::Times); + + return true; +} QDateTime QFSFileEngine::fileTime(FileTime time) const { @@ -998,4 +1094,13 @@ bool QFSFileEnginePrivate::unmap(uchar *ptr) return true; } +/*! + \reimp +*/ +bool QFSFileEngine::clone(int sourceHandle) +{ + Q_UNUSED(sourceHandle); + return false; +} + QT_END_NAMESPACE diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp index 2226b4435b..bb16b0c427 100644 --- a/src/corelib/io/qprocess.cpp +++ b/src/corelib/io/qprocess.cpp @@ -450,11 +450,6 @@ void QProcessPrivate::Channel::clear() process = 0; } -/*! \fn bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid) - -\internal - */ - /*! \class QProcess \inmodule QtCore @@ -2112,6 +2107,60 @@ void QProcess::start(OpenMode mode) } /*! + \since 5.10 + + Starts the program set by setProgram() with arguments set by setArguments() + in a new process, and detaches from it. Returns \c true on success; + otherwise returns \c false. If the calling process exits, the + detached process will continue to run unaffected. + + \b{Unix:} The started process will run in its own session and act + like a daemon. + + The process will be started in the directory set by setWorkingDirectory(). + If workingDirectory() is empty, the working directory is inherited + from the calling process. + + \note On QNX, this may cause all application threads to + temporarily freeze. + + If the function is successful then *\a pid is set to the process + identifier of the started process. + + Only the following property setters are supported by startDetached(): + \list + \li setArguments() + \li setCreateProcessArgumentsModifier() + \li setNativeArguments() + \li setProcessEnvironment() + \li setProgram() + \li setStandardErrorFile() + \li setStandardInputFile() + \li setStandardOutputFile() + \li setWorkingDirectory() + \endlist + All other properties of the QProcess object are ignored. + + \sa start() + \sa startDetached(const QString &program, const QStringList &arguments, + const QString &workingDirectory, qint64 *pid) + \sa startDetached(const QString &command) +*/ +bool QProcess::startDetached(qint64 *pid) +{ + Q_D(QProcess); + if (d->processState != NotRunning) { + qWarning("QProcess::startDetached: Process is already running"); + return false; + } + if (d->program.isEmpty()) { + d->setErrorAndEmit(QProcess::FailedToStart, tr("No program defined")); + return false; + } + return d->startDetached(pid); +} + +/*! Starts the program set by setProgram() with arguments set by setArguments(). The OpenMode is set to \a mode. @@ -2445,6 +2494,8 @@ int QProcess::execute(const QString &command) } /*! + \overload startDetached() + Starts the program \a program with the arguments \a arguments in a new process, and detaches from it. Returns \c true on success; otherwise returns \c false. If the calling process exits, the @@ -2452,16 +2503,10 @@ int QProcess::execute(const QString &command) Argument handling is identical to the respective start() overload. - \b{Unix:} The started process will run in its own session and act - like a daemon. - The process will be started in the directory \a workingDirectory. If \a workingDirectory is empty, the working directory is inherited from the calling process. - \note On QNX, this may cause all application threads to - temporarily freeze. - If the function is successful then *\a pid is set to the process identifier of the started process. @@ -2472,10 +2517,11 @@ bool QProcess::startDetached(const QString &program, const QString &workingDirectory, qint64 *pid) { - return QProcessPrivate::startDetached(program, - arguments, - workingDirectory, - pid); + QProcess process; + process.setProgram(program); + process.setArguments(arguments); + process.setWorkingDirectory(workingDirectory); + return process.startDetached(pid); } /*! @@ -2484,11 +2530,14 @@ bool QProcess::startDetached(const QString &program, bool QProcess::startDetached(const QString &program, const QStringList &arguments) { - return QProcessPrivate::startDetached(program, arguments); + QProcess process; + process.setProgram(program); + process.setArguments(arguments); + return process.startDetached(); } /*! - \overload + \overload startDetached() Starts the command \a command in a new process, and detaches from it. Returns \c true on success; otherwise returns \c false. @@ -2506,9 +2555,10 @@ bool QProcess::startDetached(const QString &command) if (args.isEmpty()) return false; - const QString prog = args.takeFirst(); - - return QProcessPrivate::startDetached(prog, args); + QProcess process; + process.setProgram(args.takeFirst()); + process.setArguments(args); + return process.startDetached(); } QT_BEGIN_INCLUDE_NAMESPACE diff --git a/src/corelib/io/qprocess.h b/src/corelib/io/qprocess.h index 19157bdd02..c8aef2f0b1 100644 --- a/src/corelib/io/qprocess.h +++ b/src/corelib/io/qprocess.h @@ -163,6 +163,7 @@ public: void start(const QString &command, OpenMode mode = ReadWrite); #endif void start(OpenMode mode = ReadWrite); + bool startDetached(qint64 *pid = nullptr); bool open(OpenMode mode = ReadWrite) Q_DECL_OVERRIDE; QString program() const; diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h index c5abf7b762..deb29dca0a 100644 --- a/src/corelib/io/qprocess_p.h +++ b/src/corelib/io/qprocess_p.h @@ -350,7 +350,7 @@ public: void start(QIODevice::OpenMode mode); void startProcess(); #if defined(Q_OS_UNIX) - void execChild(const char *workingDirectory, char **path, char **argv, char **envp); + void execChild(const char *workingDirectory, char **argv, char **envp); #endif bool processStarted(QString *errorMessage = Q_NULLPTR); void terminateProcess(); @@ -360,13 +360,13 @@ public: bool waitForDeadChild(); #endif #ifdef Q_OS_WIN + bool callCreateProcess(QProcess::CreateProcessArguments *cpargs); bool drainOutputPipes(); void flushPipeWriter(); qint64 pipeWriterBytesToWrite() const; #endif - static bool startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory = QString(), - qint64 *pid = 0); + bool startDetached(qint64 *pPid); int exitCode; QProcess::ExitStatus exitStatus; diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp index 6b7f187fee..cf9d38097a 100644 --- a/src/corelib/io/qprocess_unix.cpp +++ b/src/corelib/io/qprocess_unix.cpp @@ -87,6 +87,7 @@ QT_END_NAMESPACE #include "qprocess.h" #include "qprocess_p.h" +#include "qstandardpaths.h" #include "private/qcore_unix_p.h" #ifdef Q_OS_MAC @@ -420,8 +421,16 @@ void QProcessPrivate::startProcess() #endif // Add the program name to the argument list. - char *dupProgramName = ::strdup(encodedProgramName.constData()); - argv[0] = dupProgramName; + argv[0] = nullptr; + if (!program.contains(QLatin1Char('/'))) { + const QString &exeFilePath = QStandardPaths::findExecutable(program); + if (!exeFilePath.isEmpty()) { + const QByteArray &tmp = QFile::encodeName(exeFilePath); + argv[0] = ::strdup(tmp.constData()); + } + } + if (!argv[0]) + argv[0] = ::strdup(encodedProgramName.constData()); // Add every argument to the list for (int i = 0; i < arguments.count(); ++i) @@ -443,29 +452,6 @@ void QProcessPrivate::startProcess() workingDirPtr = encodedWorkingDirectory.constData(); } - // If the program does not specify a path, generate a list of possible - // locations for the binary using the PATH environment variable. - char **path = 0; - int pathc = 0; - if (!program.contains(QLatin1Char('/'))) { - const QString pathEnv = QString::fromLocal8Bit(qgetenv("PATH")); - if (!pathEnv.isEmpty()) { - QStringList pathEntries = pathEnv.split(QLatin1Char(':'), QString::SkipEmptyParts); - if (!pathEntries.isEmpty()) { - pathc = pathEntries.size(); - path = new char *[pathc + 1]; - path[pathc] = 0; - - for (int k = 0; k < pathEntries.size(); ++k) { - QByteArray tmp = QFile::encodeName(pathEntries.at(k)); - if (!tmp.endsWith('/')) tmp += '/'; - tmp += encodedProgramName; - path[k] = ::strdup(tmp.constData()); - } - } - } - } - // Start the process manager, and fork off the child process. pid_t childPid; forkfd = ::forkfd(FFD_CLOEXEC, &childPid); @@ -473,16 +459,12 @@ void QProcessPrivate::startProcess() if (forkfd != FFD_CHILD_PROCESS) { // Parent process. // Clean up duplicated memory. - free(dupProgramName); - for (int i = 1; i <= arguments.count(); ++i) + for (int i = 0; i <= arguments.count(); ++i) free(argv[i]); for (int i = 0; i < envc; ++i) free(envp[i]); - for (int i = 0; i < pathc; ++i) - free(path[i]); delete [] argv; delete [] envp; - delete [] path; } // On QNX, if spawnChild failed, childPid will be -1 but forkfd is still 0. @@ -503,7 +485,7 @@ void QProcessPrivate::startProcess() // Start the child. if (forkfd == FFD_CHILD_PROCESS) { - execChild(workingDirPtr, path, argv, envp); + execChild(workingDirPtr, argv, envp); ::_exit(-1); } @@ -550,7 +532,7 @@ struct ChildError char function[8]; }; -void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv, char **envp) +void QProcessPrivate::execChild(const char *workingDir, char **argv, char **envp) { ::signal(SIGPIPE, SIG_DFL); // reset the signal that we ignored @@ -574,7 +556,7 @@ void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv } } - // make sure this fd is closed if execvp() succeeds + // make sure this fd is closed if execv() succeeds qt_safe_close(childStartedPipe[0]); // enter the working directory @@ -589,25 +571,13 @@ void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv // execute the process if (!envp) { - qt_safe_execvp(argv[0], argv); + qt_safe_execv(argv[0], argv); strcpy(error.function, "execvp"); } else { - if (path) { - char **arg = path; - while (*arg) { - argv[0] = *arg; #if defined (QPROCESS_DEBUG) - fprintf(stderr, "QProcessPrivate::execChild() searching / starting %s\n", argv[0]); + fprintf(stderr, "QProcessPrivate::execChild() starting %s\n", argv[0]); #endif - qt_safe_execve(argv[0], argv, envp); - ++arg; - } - } else { -#if defined (QPROCESS_DEBUG) - fprintf(stderr, "QProcessPrivate::execChild() starting %s\n", argv[0]); -#endif - qt_safe_execve(argv[0], argv, envp); - } + qt_safe_execve(argv[0], argv, envp); strcpy(error.function, "execve"); } @@ -921,7 +891,7 @@ bool QProcessPrivate::waitForDeadChild() return true; } -bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid) +bool QProcessPrivate::startDetached(qint64 *pid) { QByteArray encodedWorkingDirectory = QFile::encodeName(workingDirectory); @@ -937,6 +907,17 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a return false; } + if ((stdinChannel.type == Channel::Redirect && !openChannel(stdinChannel)) + || (stdoutChannel.type == Channel::Redirect && !openChannel(stdoutChannel)) + || (stderrChannel.type == Channel::Redirect && !openChannel(stderrChannel))) { + closeChannel(&stdinChannel); + closeChannel(&stdoutChannel); + closeChannel(&stderrChannel); + qt_safe_close(startedPipe[0]); + qt_safe_close(startedPipe[1]); + return false; + } + pid_t childPid = fork(); if (childPid == 0) { struct sigaction noaction; @@ -953,6 +934,18 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a if (doubleForkPid == 0) { qt_safe_close(pidPipe[1]); + // copy the stdin socket if asked to (without closing on exec) + if (inputChannelMode != QProcess::ForwardedInputChannel) + qt_safe_dup2(stdinChannel.pipe[0], STDIN_FILENO, 0); + + // copy the stdout and stderr if asked to + if (processChannelMode != QProcess::ForwardedChannels) { + if (processChannelMode != QProcess::ForwardedOutputChannel) + qt_safe_dup2(stdoutChannel.pipe[1], STDOUT_FILENO, 0); + if (processChannelMode != QProcess::ForwardedErrorChannel) + qt_safe_dup2(stderrChannel.pipe[1], STDERR_FILENO, 0); + } + if (!encodedWorkingDirectory.isEmpty()) { if (QT_CHDIR(encodedWorkingDirectory.constData()) == -1) qWarning("QProcessPrivate::startDetached: failed to chdir to %s", encodedWorkingDirectory.constData()); @@ -963,23 +956,28 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a argv[i + 1] = ::strdup(QFile::encodeName(arguments.at(i)).constData()); argv[arguments.size() + 1] = 0; + // Duplicate the environment. + int envc = 0; + char **envp = nullptr; + if (environment.d.constData()) { + QProcessEnvironmentPrivate::MutexLocker locker(environment.d); + envp = _q_dupEnvironment(environment.d.constData()->vars, &envc); + } + + QByteArray tmp; if (!program.contains(QLatin1Char('/'))) { - const QString path = QString::fromLocal8Bit(qgetenv("PATH")); - if (!path.isEmpty()) { - QStringList pathEntries = path.split(QLatin1Char(':')); - for (int k = 0; k < pathEntries.size(); ++k) { - QByteArray tmp = QFile::encodeName(pathEntries.at(k)); - if (!tmp.endsWith('/')) tmp += '/'; - tmp += QFile::encodeName(program); - argv[0] = tmp.data(); - qt_safe_execv(argv[0], argv); - } - } - } else { - QByteArray tmp = QFile::encodeName(program); - argv[0] = tmp.data(); - qt_safe_execv(argv[0], argv); + const QString &exeFilePath = QStandardPaths::findExecutable(program); + if (!exeFilePath.isEmpty()) + tmp = QFile::encodeName(exeFilePath); } + if (tmp.isEmpty()) + tmp = QFile::encodeName(program); + argv[0] = tmp.data(); + + if (envp) + qt_safe_execve(argv[0], argv, envp); + else + qt_safe_execv(argv[0], argv); struct sigaction noaction; memset(&noaction, 0, sizeof(noaction)); @@ -1009,6 +1007,9 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a ::_exit(1); } + closeChannel(&stdinChannel); + closeChannel(&stdoutChannel); + closeChannel(&stderrChannel); qt_safe_close(startedPipe[1]); qt_safe_close(pidPipe[1]); diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp index 05c9d6594c..2bbc4eddd0 100644 --- a/src/corelib/io/qprocess_win.cpp +++ b/src/corelib/io/qprocess_win.cpp @@ -358,7 +358,8 @@ void QProcessPrivate::closeChannel(Channel *channel) destroyPipe(channel->pipe); } -static QString qt_create_commandline(const QString &program, const QStringList &arguments) +static QString qt_create_commandline(const QString &program, const QStringList &arguments, + const QString &nativeArguments) { QString args; if (!program.isEmpty()) { @@ -387,6 +388,13 @@ static QString qt_create_commandline(const QString &program, const QStringList & } args += QLatin1Char(' ') + tmp; } + + if (!nativeArguments.isEmpty()) { + if (!args.isEmpty()) + args += QLatin1Char(' '); + args += nativeArguments; + } + return args; } @@ -450,6 +458,30 @@ static QByteArray qt_create_environment(const QProcessEnvironmentPrivate::Map &e return envlist; } +bool QProcessPrivate::callCreateProcess(QProcess::CreateProcessArguments *cpargs) +{ + if (modifyCreateProcessArgs) + modifyCreateProcessArgs(cpargs); + bool success = CreateProcess(cpargs->applicationName, cpargs->arguments, + cpargs->processAttributes, cpargs->threadAttributes, + cpargs->inheritHandles, cpargs->flags, cpargs->environment, + cpargs->currentDirectory, cpargs->startupInfo, + cpargs->processInformation); + if (stdinChannel.pipe[0] != INVALID_Q_PIPE) { + CloseHandle(stdinChannel.pipe[0]); + stdinChannel.pipe[0] = INVALID_Q_PIPE; + } + if (stdoutChannel.pipe[1] != INVALID_Q_PIPE) { + CloseHandle(stdoutChannel.pipe[1]); + stdoutChannel.pipe[1] = INVALID_Q_PIPE; + } + if (stderrChannel.pipe[1] != INVALID_Q_PIPE) { + CloseHandle(stderrChannel.pipe[1]); + stderrChannel.pipe[1] = INVALID_Q_PIPE; + } + return success; +} + void QProcessPrivate::startProcess() { Q_Q(QProcess); @@ -472,15 +504,10 @@ void QProcessPrivate::startProcess() !openChannel(stderrChannel)) return; - QString args = qt_create_commandline(program, arguments); + const QString args = qt_create_commandline(program, arguments, nativeArguments); QByteArray envlist; if (environment.d.constData()) envlist = qt_create_environment(environment.d.constData()->vars); - if (!nativeArguments.isEmpty()) { - if (!args.isEmpty()) - args += QLatin1Char(' '); - args += nativeArguments; - } #if defined QPROCESS_DEBUG qDebug("Creating process"); @@ -507,18 +534,14 @@ void QProcessPrivate::startProcess() const QString nativeWorkingDirectory = QDir::toNativeSeparators(workingDirectory); QProcess::CreateProcessArguments cpargs = { - 0, (wchar_t*)args.utf16(), - 0, 0, TRUE, dwCreationFlags, - environment.isEmpty() ? 0 : envlist.data(), - nativeWorkingDirectory.isEmpty() ? Q_NULLPTR : (wchar_t*)nativeWorkingDirectory.utf16(), + nullptr, reinterpret_cast<wchar_t *>(const_cast<ushort *>(args.utf16())), + nullptr, nullptr, true, dwCreationFlags, + environment.isEmpty() ? nullptr : envlist.data(), + nativeWorkingDirectory.isEmpty() + ? nullptr : reinterpret_cast<const wchar_t *>(nativeWorkingDirectory.utf16()), &startupInfo, pid }; - if (modifyCreateProcessArgs) - modifyCreateProcessArgs(&cpargs); - success = CreateProcess(cpargs.applicationName, cpargs.arguments, cpargs.processAttributes, - cpargs.threadAttributes, cpargs.inheritHandles, cpargs.flags, - cpargs.environment, cpargs.currentDirectory, cpargs.startupInfo, - cpargs.processInformation); + success = callCreateProcess(&cpargs); QString errorString; if (!success) { @@ -526,19 +549,6 @@ void QProcessPrivate::startProcess() errorString = QProcess::tr("Process failed to start: %1").arg(qt_error_string()); } - if (stdinChannel.pipe[0] != INVALID_Q_PIPE) { - CloseHandle(stdinChannel.pipe[0]); - stdinChannel.pipe[0] = INVALID_Q_PIPE; - } - if (stdoutChannel.pipe[1] != INVALID_Q_PIPE) { - CloseHandle(stdoutChannel.pipe[1]); - stdoutChannel.pipe[1] = INVALID_Q_PIPE; - } - if (stderrChannel.pipe[1] != INVALID_Q_PIPE) { - CloseHandle(stderrChannel.pipe[1]); - stderrChannel.pipe[1] = INVALID_Q_PIPE; - } - if (!success) { cleanup(); setErrorAndEmit(QProcess::FailedToStart, errorString); @@ -826,6 +836,7 @@ bool QProcessPrivate::writeToStdin() // Use ShellExecuteEx() to trigger an UAC prompt when CreateProcess()fails // with ERROR_ELEVATION_REQUIRED. static bool startDetachedUacPrompt(const QString &programIn, const QStringList &arguments, + const QString &nativeArguments, const QString &workingDir, qint64 *pid) { typedef BOOL (WINAPI *ShellExecuteExType)(SHELLEXECUTEINFOW *); @@ -836,7 +847,8 @@ static bool startDetachedUacPrompt(const QString &programIn, const QStringList & if (!shellExecuteEx) return false; - const QString args = qt_create_commandline(QString(), arguments); // needs arguments only + const QString args = qt_create_commandline(QString(), // needs arguments only + arguments, nativeArguments); SHELLEXECUTEINFOW shellExecuteExInfo; memset(&shellExecuteExInfo, 0, sizeof(SHELLEXECUTEINFOW)); shellExecuteExInfo.cbSize = sizeof(SHELLEXECUTEINFOW); @@ -859,25 +871,52 @@ static bool startDetachedUacPrompt(const QString &programIn, const QStringList & return true; } -bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDir, qint64 *pid) +bool QProcessPrivate::startDetached(qint64 *pid) { static const DWORD errorElevationRequired = 740; - QString args = qt_create_commandline(program, arguments); + if ((stdinChannel.type == Channel::Redirect && !openChannel(stdinChannel)) + || (stdoutChannel.type == Channel::Redirect && !openChannel(stdoutChannel)) + || (stderrChannel.type == Channel::Redirect && !openChannel(stderrChannel))) { + closeChannel(&stdinChannel); + closeChannel(&stdoutChannel); + closeChannel(&stderrChannel); + return false; + } + + QString args = qt_create_commandline(program, arguments, nativeArguments); bool success = false; PROCESS_INFORMATION pinfo; + void *envPtr = nullptr; + QByteArray envlist; + if (environment.d.constData()) { + envlist = qt_create_environment(environment.d.constData()->vars); + envPtr = envlist.data(); + } + DWORD dwCreationFlags = (GetConsoleWindow() ? 0 : CREATE_NO_WINDOW); dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT; STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + 0, 0, 0, + STARTF_USESTDHANDLES, + 0, 0, 0, + stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1] }; - success = CreateProcess(0, (wchar_t*)args.utf16(), - 0, 0, FALSE, dwCreationFlags, 0, - workingDir.isEmpty() ? 0 : (wchar_t*)workingDir.utf16(), - &startupInfo, &pinfo); + + const bool inheritHandles = stdinChannel.type == Channel::Redirect + || stdoutChannel.type == Channel::Redirect + || stderrChannel.type == Channel::Redirect; + QProcess::CreateProcessArguments cpargs = { + nullptr, reinterpret_cast<wchar_t *>(const_cast<ushort *>(args.utf16())), + nullptr, nullptr, inheritHandles, dwCreationFlags, envPtr, + workingDirectory.isEmpty() + ? nullptr : reinterpret_cast<const wchar_t *>(workingDirectory.utf16()), + &startupInfo, &pinfo + }; + success = callCreateProcess(&cpargs); if (success) { CloseHandle(pinfo.hThread); @@ -885,9 +924,19 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a if (pid) *pid = pinfo.dwProcessId; } else if (GetLastError() == errorElevationRequired) { - success = startDetachedUacPrompt(program, arguments, workingDir, pid); + if (envPtr) + qWarning("QProcess: custom environment will be ignored for detached elevated process."); + if (!stdinChannel.file.isEmpty() || !stdoutChannel.file.isEmpty() + || !stderrChannel.file.isEmpty()) { + qWarning("QProcess: file redirection is unsupported for detached elevated processes."); + } + success = startDetachedUacPrompt(program, arguments, nativeArguments, + workingDirectory, pid); } + closeChannel(&stdinChannel); + closeChannel(&stdoutChannel); + closeChannel(&stderrChannel); return success; } diff --git a/src/corelib/io/qresource.cpp b/src/corelib/io/qresource.cpp index 32639759e4..ff31524c1c 100644 --- a/src/corelib/io/qresource.cpp +++ b/src/corelib/io/qresource.cpp @@ -66,10 +66,9 @@ QT_BEGIN_NAMESPACE class QStringSplitter { public: - QStringSplitter(const QString &s) - : m_string(s), m_data(m_string.constData()), m_len(s.length()), m_pos(0) + explicit QStringSplitter(QStringView sv) + : m_data(sv.data()), m_len(sv.size()) { - m_splitChar = QLatin1Char('/'); } inline bool hasNext() { @@ -78,18 +77,17 @@ public: return m_pos < m_len; } - inline QStringRef next() { + inline QStringView next() { int start = m_pos; while (m_pos < m_len && m_data[m_pos] != m_splitChar) ++m_pos; - return QStringRef(&m_string, start, m_pos - start); + return QStringView(m_data + start, m_pos - start); } - QString m_string; const QChar *m_data; - QChar m_splitChar; - int m_len; - int m_pos; + qssize_t m_len; + qssize_t m_pos = 0; + QChar m_splitChar = QLatin1Char('/'); }; @@ -678,7 +676,7 @@ int QResourceRoot::findNode(const QString &_path, const QLocale &locale) const QStringSplitter splitter(path); while (child_count && splitter.hasNext()) { - QStringRef segment = splitter.next(); + QStringView segment = splitter.next(); #ifdef DEBUG_RESOURCE_MATCH qDebug() << " CHILDREN" << segment; @@ -835,24 +833,24 @@ QStringList QResourceRoot::children(int node) const bool QResourceRoot::mappingRootSubdir(const QString &path, QString *match) const { const QString root = mappingRoot(); - if(!root.isEmpty()) { - const QVector<QStringRef> root_segments = root.splitRef(QLatin1Char('/'), QString::SkipEmptyParts), - path_segments = path.splitRef(QLatin1Char('/'), QString::SkipEmptyParts); - if(path_segments.size() <= root_segments.size()) { - int matched = 0; - for(int i = 0; i < path_segments.size(); ++i) { - if(root_segments[i] != path_segments[i]) - break; - ++matched; - } - if(matched == path_segments.size()) { - if(match && root_segments.size() > matched) - *match = root_segments.at(matched).toString(); - return true; - } + if (root.isEmpty()) + return false; + + QStringSplitter rootIt(root); + QStringSplitter pathIt(path); + while (rootIt.hasNext()) { + if (pathIt.hasNext()) { + if (rootIt.next() != pathIt.next()) // mismatch + return false; + } else { + // end of path, but not of root: + if (match) + *match = rootIt.next().toString(); + return true; } } - return false; + // end of root + return !pathIt.hasNext(); } Q_CORE_EXPORT bool qRegisterResourceData(int version, const unsigned char *tree, @@ -1459,6 +1457,13 @@ QString QResourceFileEngine::owner(FileOwner) const return QString(); } +bool QResourceFileEngine::setFileTime(const QDateTime &newDate, FileTime time) +{ + Q_UNUSED(newDate); + Q_UNUSED(time); + return false; +} + QDateTime QResourceFileEngine::fileTime(FileTime time) const { Q_D(const QResourceFileEngine); diff --git a/src/corelib/io/qresource_p.h b/src/corelib/io/qresource_p.h index e08ba64d2b..1b0f4f66e4 100644 --- a/src/corelib/io/qresource_p.h +++ b/src/corelib/io/qresource_p.h @@ -103,6 +103,7 @@ public: virtual uint ownerId(FileOwner) const Q_DECL_OVERRIDE; virtual QString owner(FileOwner) const Q_DECL_OVERRIDE; + virtual bool setFileTime(const QDateTime &newDate, FileTime time) Q_DECL_OVERRIDE; virtual QDateTime fileTime(FileTime time) const Q_DECL_OVERRIDE; virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames) Q_DECL_OVERRIDE; diff --git a/src/corelib/io/qsettings.cpp b/src/corelib/io/qsettings.cpp index d5460238ec..850e729987 100644 --- a/src/corelib/io/qsettings.cpp +++ b/src/corelib/io/qsettings.cpp @@ -1802,6 +1802,8 @@ struct QSettingsIniSection inline QSettingsIniSection() : position(-1) {} }; +Q_DECLARE_TYPEINFO(QSettingsIniSection, Q_MOVABLE_TYPE); + typedef QMap<QString, QSettingsIniSection> IniMap; /* diff --git a/src/corelib/io/qsettings_p.h b/src/corelib/io/qsettings_p.h index 639605d8c4..d8e91e48ce 100644 --- a/src/corelib/io/qsettings_p.h +++ b/src/corelib/io/qsettings_p.h @@ -109,6 +109,8 @@ private: }; #endif +Q_DECLARE_TYPEINFO(QSettingsKey, Q_MOVABLE_TYPE); + typedef QMap<QSettingsKey, QByteArray> UnparsedSettingsMap; typedef QMap<QSettingsKey, QVariant> ParsedSettingsMap; diff --git a/src/corelib/io/qstorageinfo.cpp b/src/corelib/io/qstorageinfo.cpp index 27f0552a31..e2c1f0232f 100644 --- a/src/corelib/io/qstorageinfo.cpp +++ b/src/corelib/io/qstorageinfo.cpp @@ -40,6 +40,8 @@ #include "qstorageinfo.h" #include "qstorageinfo_p.h" +#include "qdebug.h" + QT_BEGIN_NAMESPACE /*! @@ -431,4 +433,37 @@ QStorageInfo QStorageInfo::root() volume than the \a second; otherwise returns false. */ +#ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug debug, const QStorageInfo &s) +{ + QDebugStateSaver saver(debug); + debug.nospace(); + debug.noquote(); + debug << "QStorageInfo("; + if (s.isValid()) { + const QStorageInfoPrivate *d = s.d.constData(); + debug << '"' << d->rootPath << '"'; + if (!d->fileSystemType.isEmpty()) + debug << ", type=" << d->fileSystemType; + if (!d->name.isEmpty()) + debug << ", name=\"" << d->name << '"'; + if (!d->device.isEmpty()) + debug << ", device=\"" << d->device << '"'; + if (!d->subvolume.isEmpty()) + debug << ", subvolume=\"" << d->subvolume << '"'; + if (d->readOnly) + debug << " [read only]"; + debug << (d->ready ? " [ready]" : " [not ready]"); + if (d->bytesTotal > 0) { + debug << ", bytesTotal=" << d->bytesTotal << ", bytesFree=" << d->bytesFree + << ", bytesAvailable=" << d->bytesAvailable; + } + } else { + debug << "invalid"; + } + debug<< ')'; + return debug; +} +#endif // !QT_NO_DEBUG_STREAM + QT_END_NAMESPACE diff --git a/src/corelib/io/qstorageinfo.h b/src/corelib/io/qstorageinfo.h index e2d9747ceb..4ab7a353ef 100644 --- a/src/corelib/io/qstorageinfo.h +++ b/src/corelib/io/qstorageinfo.h @@ -49,6 +49,8 @@ QT_BEGIN_NAMESPACE +class QDebug; + class QStorageInfoPrivate; class Q_CORE_EXPORT QStorageInfo { @@ -94,6 +96,7 @@ public: private: friend class QStorageInfoPrivate; friend bool operator==(const QStorageInfo &first, const QStorageInfo &second); + friend Q_CORE_EXPORT QDebug operator<<(QDebug, const QStorageInfo &); QExplicitlySharedDataPointer<QStorageInfoPrivate> d; }; @@ -114,6 +117,10 @@ inline bool QStorageInfo::isRoot() const Q_DECLARE_SHARED(QStorageInfo) +#ifndef QT_NO_DEBUG_STREAM +Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QStorageInfo &); +#endif + QT_END_NAMESPACE Q_DECLARE_METATYPE(QStorageInfo) diff --git a/src/corelib/io/qtemporaryfile.cpp b/src/corelib/io/qtemporaryfile.cpp index 8a99873fee..efab2a30ff 100644 --- a/src/corelib/io/qtemporaryfile.cpp +++ b/src/corelib/io/qtemporaryfile.cpp @@ -42,6 +42,7 @@ #ifndef QT_NO_TEMPORARYFILE #include "qplatformdefs.h" +#include "qrandom.h" #include "private/qtemporaryfile_p.h" #include "private/qfile_p.h" #include "private/qsystemerror_p.h" @@ -131,15 +132,17 @@ static bool createFileFromTemplate(NativeFileHandle &file, Char *rIter = placeholderEnd; #if defined(QT_BUILD_CORE_LIB) + // don't consume more than half of the template with the PID + Char *pidStart = placeholderEnd - (placeholderEnd - placeholderStart) / 2; quint64 pid = quint64(QCoreApplication::applicationPid()); do { *--rIter = Latin1Char((pid % 10) + '0'); pid /= 10; - } while (rIter != placeholderStart && pid != 0); + } while (rIter != pidStart && pid != 0); #endif while (rIter != placeholderStart) { - char ch = char((qrand() & 0xffff) % (26 + 26)); + char ch = char(QRandomGenerator::bounded(26 + 26)); if (ch < 26) *--rIter = Latin1Char(ch + 'A'); else diff --git a/src/corelib/io/qtemporaryfile_p.h b/src/corelib/io/qtemporaryfile_p.h index 7f365f0e8a..bf40e1627a 100644 --- a/src/corelib/io/qtemporaryfile_p.h +++ b/src/corelib/io/qtemporaryfile_p.h @@ -65,7 +65,7 @@ class QTemporaryFilePrivate : public QFilePrivate { Q_DECLARE_PUBLIC(QTemporaryFile) -protected: +public: QTemporaryFilePrivate(); explicit QTemporaryFilePrivate(const QString &templateNameIn); ~QTemporaryFilePrivate(); diff --git a/src/corelib/io/qtextstream.cpp b/src/corelib/io/qtextstream.cpp index 5144ac0ec9..ee3cb4efcb 100644 --- a/src/corelib/io/qtextstream.cpp +++ b/src/corelib/io/qtextstream.cpp @@ -954,8 +954,7 @@ QTextStreamPrivate::PaddingResult QTextStreamPrivate::padding(int len) const right = padSize - padSize/2; break; } - const PaddingResult result = { left, right }; - return result; + return { left, right }; } /*! diff --git a/src/corelib/io/qtldurl.cpp b/src/corelib/io/qtldurl.cpp index 96543bbbfd..a934d19fa2 100644 --- a/src/corelib/io/qtldurl.cpp +++ b/src/corelib/io/qtldurl.cpp @@ -50,9 +50,21 @@ QT_BEGIN_NAMESPACE -static bool containsTLDEntry(const QStringRef &entry) +enum TLDMatchType { + ExactMatch, + SuffixMatch, + ExceptionMatch, +}; + +static bool containsTLDEntry(QStringView entry, TLDMatchType match) { - int index = qt_hash(entry) % tldCount; + const QStringView matchSymbols[] = { + QStringViewLiteral(""), + QStringViewLiteral("*"), + QStringViewLiteral("!"), + }; + const auto symbol = matchSymbols[match]; + int index = qt_hash(entry, qt_hash(symbol)) % tldCount; // select the right chunk from the big table short chunk = 0; @@ -65,19 +77,14 @@ static bool containsTLDEntry(const QStringRef &entry) // check all the entries from the given index while (chunkIndex < tldIndices[index+1] - offset) { - QString currentEntry = QString::fromUtf8(tldData[chunk] + chunkIndex); - if (currentEntry == entry) + const auto utf8 = tldData[chunk] + chunkIndex; + if ((symbol.isEmpty() || QLatin1Char(*utf8) == symbol) && entry == QString::fromUtf8(utf8 + symbol.size())) return true; - chunkIndex += qstrlen(tldData[chunk] + chunkIndex) + 1; // +1 for the ending \0 + chunkIndex += qstrlen(utf8) + 1; // +1 for the ending \0 } return false; } -static inline bool containsTLDEntry(const QString &entry) -{ - return containsTLDEntry(QStringRef(&entry)); -} - /*! \internal @@ -111,19 +118,16 @@ Q_CORE_EXPORT bool qIsEffectiveTLD(const QStringRef &domain) { // for domain 'foo.bar.com': // 1. return if TLD table contains 'foo.bar.com' - if (containsTLDEntry(domain)) + // 2. else if table contains '*.bar.com', + // 3. test that table does not contain '!foo.bar.com' + + if (containsTLDEntry(domain, ExactMatch)) // 1 return true; const int dot = domain.indexOf(QLatin1Char('.')); if (dot >= 0) { - int count = domain.size() - dot; - QString wildCardDomain = QLatin1Char('*') + domain.right(count); - // 2. if table contains '*.bar.com', - // test if table contains '!foo.bar.com' - if (containsTLDEntry(wildCardDomain)) { - QString exceptionDomain = QLatin1Char('!') + domain; - return (! containsTLDEntry(exceptionDomain)); - } + if (containsTLDEntry(domain.mid(dot), SuffixMatch)) // 2 + return !containsTLDEntry(domain, ExceptionMatch); // 3 } return false; } diff --git a/src/corelib/io/qwindowspipereader.cpp b/src/corelib/io/qwindowspipereader.cpp index 827ed43b63..b68e9e6d4b 100644 --- a/src/corelib/io/qwindowspipereader.cpp +++ b/src/corelib/io/qwindowspipereader.cpp @@ -129,17 +129,8 @@ qint64 QWindowsPipeReader::read(char *data, qint64 maxlen) actualReadBufferSize--; readSoFar = 1; } else { - qint64 bytesToRead = qMin(actualReadBufferSize, maxlen); - readSoFar = 0; - while (readSoFar < bytesToRead) { - const char *ptr = readBuffer.readPointer(); - qint64 bytesToReadFromThisBlock = qMin(bytesToRead - readSoFar, - readBuffer.nextDataBlockSize()); - memcpy(data + readSoFar, ptr, bytesToReadFromThisBlock); - readSoFar += bytesToReadFromThisBlock; - readBuffer.free(bytesToReadFromThisBlock); - actualReadBufferSize -= bytesToReadFromThisBlock; - } + readSoFar = readBuffer.read(data, qMin(actualReadBufferSize, maxlen)); + actualReadBufferSize -= readSoFar; } if (!pipeBroken) { diff --git a/src/corelib/io/qwindowspipewriter.cpp b/src/corelib/io/qwindowspipewriter.cpp index 3ab2c70c75..06a3572fad 100644 --- a/src/corelib/io/qwindowspipewriter.cpp +++ b/src/corelib/io/qwindowspipewriter.cpp @@ -57,7 +57,6 @@ QWindowsPipeWriter::QWindowsPipeWriter(HANDLE pipeWriteEnd, QObject *parent) : QObject(parent), handle(pipeWriteEnd), overlapped(this), - numberOfBytesToWrite(0), pendingBytesWrittenValue(0), stopped(true), writeSequenceStarted(false), @@ -97,7 +96,7 @@ bool QWindowsPipeWriter::waitForWrite(int msecs) qint64 QWindowsPipeWriter::bytesToWrite() const { - return numberOfBytesToWrite + pendingBytesWrittenValue; + return buffer.size() + pendingBytesWrittenValue; } void QWindowsPipeWriter::emitPendingBytesWrittenValue() @@ -133,7 +132,6 @@ void QWindowsPipeWriter::notified(DWORD errorCode, DWORD numberOfBytesWritten) { notifiedCalled = true; writeSequenceStarted = false; - numberOfBytesToWrite = 0; Q_ASSERT(errorCode != ERROR_SUCCESS || numberOfBytesWritten == DWORD(buffer.size())); buffer.clear(); @@ -187,13 +185,11 @@ bool QWindowsPipeWriter::write(const QByteArray &ba) overlapped.clear(); buffer = ba; - numberOfBytesToWrite = buffer.size(); stopped = false; writeSequenceStarted = true; - if (!WriteFileEx(handle, buffer.constData(), numberOfBytesToWrite, + if (!WriteFileEx(handle, buffer.constData(), buffer.size(), &overlapped, &writeFileCompleted)) { writeSequenceStarted = false; - numberOfBytesToWrite = 0; buffer.clear(); qErrnoWarning("QWindowsPipeWriter::write failed."); return false; diff --git a/src/corelib/io/qwindowspipewriter_p.h b/src/corelib/io/qwindowspipewriter_p.h index c43e986f34..a4ecfa3bf8 100644 --- a/src/corelib/io/qwindowspipewriter_p.h +++ b/src/corelib/io/qwindowspipewriter_p.h @@ -145,7 +145,6 @@ private: HANDLE handle; Overlapped overlapped; QByteArray buffer; - qint64 numberOfBytesToWrite; qint64 pendingBytesWrittenValue; bool stopped; bool writeSequenceStarted; diff --git a/src/corelib/io/qwinoverlappedionotifier.cpp b/src/corelib/io/qwinoverlappedionotifier.cpp deleted file mode 100644 index d7745ae1b6..0000000000 --- a/src/corelib/io/qwinoverlappedionotifier.cpp +++ /dev/null @@ -1,428 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** 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 The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/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 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qwinoverlappedionotifier_p.h" -#include <qdebug.h> -#include <qatomic.h> -#include <qelapsedtimer.h> -#include <qmutex.h> -#include <qpointer.h> -#include <qqueue.h> -#include <qset.h> -#include <qthread.h> -#include <qt_windows.h> -#include <private/qobject_p.h> -#include <private/qiodevice_p.h> - -QT_BEGIN_NAMESPACE - -/*! - \class QWinOverlappedIoNotifier - \inmodule QtCore - \brief The QWinOverlappedIoNotifier class provides support for overlapped I/O notifications on Windows. - \since 5.0 - \internal - - The QWinOverlappedIoNotifier class makes it possible to use efficient - overlapped (asynchronous) I/O notifications on Windows by using an - I/O completion port. - - Once you have obtained a file handle, you can use setHandle() to get - notifications for I/O operations. Whenever an I/O operation completes, - the notified() signal is emitted which will pass the number of transferred - bytes, the operation's error code and a pointer to the operation's - OVERLAPPED object to the receiver. - - Every handle that supports overlapped I/O can be used by - QWinOverlappedIoNotifier. That includes file handles, TCP sockets - and named pipes. - - Note that you must not use ReadFileEx() and WriteFileEx() together - with QWinOverlappedIoNotifier. They are not supported as they use a - different I/O notification mechanism. - - The hEvent member in the OVERLAPPED structure passed to ReadFile() - or WriteFile() is ignored and can be used for other purposes. - - \warning This class is only available on Windows. - - Due to peculiarities of the Windows I/O completion port API, users of - QWinOverlappedIoNotifier must pay attention to the following restrictions: - \list - \li File handles with a QWinOverlappedIoNotifer are assigned to an I/O - completion port until the handle is closed. It is impossible to - disassociate the file handle from the I/O completion port. - \li There can be only one QWinOverlappedIoNotifer per file handle. Creating - another QWinOverlappedIoNotifier for that file, even with a duplicated - handle, will fail. - \li Certain Windows API functions are unavailable for file handles that are - assigned to an I/O completion port. This includes the functions - \c{ReadFileEx} and \c{WriteFileEx}. - \endlist - See also the remarks in the MSDN documentation for the - \c{CreateIoCompletionPort} function. -*/ - -struct IOResult -{ - IOResult(DWORD n = 0, DWORD e = 0, OVERLAPPED *p = 0) - : numberOfBytes(n), errorCode(e), overlapped(p) - {} - - DWORD numberOfBytes; - DWORD errorCode; - OVERLAPPED *overlapped; -}; - - -class QWinIoCompletionPort; - -class QWinOverlappedIoNotifierPrivate : public QObjectPrivate -{ - Q_DECLARE_PUBLIC(QWinOverlappedIoNotifier) -public: - QWinOverlappedIoNotifierPrivate() - : hHandle(INVALID_HANDLE_VALUE) - { - } - - OVERLAPPED *waitForAnyNotified(int msecs); - void notify(DWORD numberOfBytes, DWORD errorCode, OVERLAPPED *overlapped); - void _q_notified(); - OVERLAPPED *dispatchNextIoResult(); - - static QWinIoCompletionPort *iocp; - static HANDLE iocpInstanceLock; - static unsigned int iocpInstanceRefCount; - HANDLE hHandle; - HANDLE hSemaphore; - HANDLE hResultsMutex; - QAtomicInt waiting; - QQueue<IOResult> results; -}; - -QWinIoCompletionPort *QWinOverlappedIoNotifierPrivate::iocp = 0; -HANDLE QWinOverlappedIoNotifierPrivate::iocpInstanceLock = CreateMutex(NULL, FALSE, NULL); -unsigned int QWinOverlappedIoNotifierPrivate::iocpInstanceRefCount = 0; - - -class QWinIoCompletionPort : protected QThread -{ -public: - QWinIoCompletionPort() - : finishThreadKey(reinterpret_cast<ULONG_PTR>(this)), - drainQueueKey(reinterpret_cast<ULONG_PTR>(this + 1)), - hPort(INVALID_HANDLE_VALUE) - { - setObjectName(QLatin1String("I/O completion port thread")); - HANDLE hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); - if (!hIOCP) { - qErrnoWarning("CreateIoCompletionPort failed."); - return; - } - hPort = hIOCP; - hQueueDrainedEvent = CreateEvent(NULL, TRUE, FALSE, NULL); - if (!hQueueDrainedEvent) { - qErrnoWarning("CreateEvent failed."); - return; - } - } - - ~QWinIoCompletionPort() - { - PostQueuedCompletionStatus(hPort, 0, finishThreadKey, NULL); - QThread::wait(); - CloseHandle(hPort); - CloseHandle(hQueueDrainedEvent); - } - - void registerNotifier(QWinOverlappedIoNotifierPrivate *notifier) - { - const HANDLE hHandle = notifier->hHandle; - HANDLE hIOCP = CreateIoCompletionPort(hHandle, hPort, - reinterpret_cast<ULONG_PTR>(notifier), 0); - if (!hIOCP) { - qErrnoWarning("Can't associate file handle %x with I/O completion port.", hHandle); - return; - } - mutex.lock(); - notifiers += notifier; - mutex.unlock(); - if (!QThread::isRunning()) - QThread::start(); - } - - void unregisterNotifier(QWinOverlappedIoNotifierPrivate *notifier) - { - mutex.lock(); - notifiers.remove(notifier); - mutex.unlock(); - } - - void drainQueue() - { - QMutexLocker locker(&drainQueueMutex); - ResetEvent(hQueueDrainedEvent); - PostQueuedCompletionStatus(hPort, 0, drainQueueKey, NULL); - WaitForSingleObject(hQueueDrainedEvent, INFINITE); - } - - using QThread::isRunning; - -protected: - void run() - { - DWORD dwBytesRead; - ULONG_PTR pulCompletionKey; - OVERLAPPED *overlapped; - DWORD msecs = INFINITE; - - forever { - BOOL success = GetQueuedCompletionStatus(hPort, - &dwBytesRead, - &pulCompletionKey, - &overlapped, - msecs); - - DWORD errorCode = success ? ERROR_SUCCESS : GetLastError(); - if (!success && !overlapped) { - if (!msecs) { - // Time out in drain mode. The completion status queue is empty. - msecs = INFINITE; - SetEvent(hQueueDrainedEvent); - continue; - } - qErrnoWarning(errorCode, "GetQueuedCompletionStatus failed."); - return; - } - - if (pulCompletionKey == finishThreadKey) - return; - if (pulCompletionKey == drainQueueKey) { - // Enter drain mode. - Q_ASSERT(msecs == INFINITE); - msecs = 0; - continue; - } - - QWinOverlappedIoNotifierPrivate *notifier - = reinterpret_cast<QWinOverlappedIoNotifierPrivate *>(pulCompletionKey); - mutex.lock(); - if (notifiers.contains(notifier)) - notifier->notify(dwBytesRead, errorCode, overlapped); - mutex.unlock(); - } - } - -private: - const ULONG_PTR finishThreadKey; - const ULONG_PTR drainQueueKey; - HANDLE hPort; - QSet<QWinOverlappedIoNotifierPrivate *> notifiers; - QMutex mutex; - QMutex drainQueueMutex; - HANDLE hQueueDrainedEvent; -}; - - -QWinOverlappedIoNotifier::QWinOverlappedIoNotifier(QObject *parent) - : QObject(*new QWinOverlappedIoNotifierPrivate, parent) -{ - Q_D(QWinOverlappedIoNotifier); - WaitForSingleObject(d->iocpInstanceLock, INFINITE); - if (!d->iocp) - d->iocp = new QWinIoCompletionPort; - d->iocpInstanceRefCount++; - ReleaseMutex(d->iocpInstanceLock); - - d->hSemaphore = CreateSemaphore(NULL, 0, 255, NULL); - d->hResultsMutex = CreateMutex(NULL, FALSE, NULL); - connect(this, SIGNAL(_q_notify()), this, SLOT(_q_notified()), Qt::QueuedConnection); -} - -QWinOverlappedIoNotifier::~QWinOverlappedIoNotifier() -{ - Q_D(QWinOverlappedIoNotifier); - setEnabled(false); - CloseHandle(d->hResultsMutex); - CloseHandle(d->hSemaphore); - - WaitForSingleObject(d->iocpInstanceLock, INFINITE); - if (!--d->iocpInstanceRefCount) { - delete d->iocp; - d->iocp = 0; - } - ReleaseMutex(d->iocpInstanceLock); -} - -void QWinOverlappedIoNotifier::setHandle(Qt::HANDLE h) -{ - Q_D(QWinOverlappedIoNotifier); - d->hHandle = h; -} - -Qt::HANDLE QWinOverlappedIoNotifier::handle() const -{ - Q_D(const QWinOverlappedIoNotifier); - return d->hHandle; -} - -void QWinOverlappedIoNotifier::setEnabled(bool enabled) -{ - Q_D(QWinOverlappedIoNotifier); - if (enabled) - d->iocp->registerNotifier(d); - else - d->iocp->unregisterNotifier(d); -} - -OVERLAPPED *QWinOverlappedIoNotifierPrivate::waitForAnyNotified(int msecs) -{ - if (!iocp->isRunning()) { - qWarning("Called QWinOverlappedIoNotifier::waitForAnyNotified on inactive notifier."); - return 0; - } - - if (msecs == 0) - iocp->drainQueue(); - - const DWORD wfso = WaitForSingleObject(hSemaphore, msecs == -1 ? INFINITE : DWORD(msecs)); - switch (wfso) { - case WAIT_OBJECT_0: - return dispatchNextIoResult(); - case WAIT_TIMEOUT: - return 0; - default: - qErrnoWarning("QWinOverlappedIoNotifier::waitForAnyNotified: WaitForSingleObject failed."); - return 0; - } -} - -class QScopedAtomicIntIncrementor -{ -public: - QScopedAtomicIntIncrementor(QAtomicInt &i) - : m_int(i) - { - ++m_int; - } - - ~QScopedAtomicIntIncrementor() - { - --m_int; - } - -private: - QAtomicInt &m_int; -}; - -/*! - * Wait synchronously for any notified signal. - * - * The function returns a pointer to the OVERLAPPED object corresponding to the completed I/O - * operation. In case no I/O operation was completed during the \a msec timeout, this function - * returns a null pointer. - */ -OVERLAPPED *QWinOverlappedIoNotifier::waitForAnyNotified(int msecs) -{ - Q_D(QWinOverlappedIoNotifier); - QScopedAtomicIntIncrementor saii(d->waiting); - OVERLAPPED *result = d->waitForAnyNotified(msecs); - return result; -} - -/*! - * Wait synchronously for the notified signal. - * - * The function returns true if the notified signal was emitted for - * the I/O operation that corresponds to the OVERLAPPED object. - */ -bool QWinOverlappedIoNotifier::waitForNotified(int msecs, OVERLAPPED *overlapped) -{ - Q_D(QWinOverlappedIoNotifier); - QScopedAtomicIntIncrementor saii(d->waiting); - int t = msecs; - QElapsedTimer stopWatch; - stopWatch.start(); - forever { - OVERLAPPED *triggeredOverlapped = waitForAnyNotified(t); - if (!triggeredOverlapped) - return false; - if (triggeredOverlapped == overlapped) - return true; - t = qt_subtract_from_timeout(msecs, stopWatch.elapsed()); - if (t == 0) - return false; - } -} - -/*! - * Note: This function runs in the I/O completion port thread. - */ -void QWinOverlappedIoNotifierPrivate::notify(DWORD numberOfBytes, DWORD errorCode, - OVERLAPPED *overlapped) -{ - Q_Q(QWinOverlappedIoNotifier); - WaitForSingleObject(hResultsMutex, INFINITE); - results.enqueue(IOResult(numberOfBytes, errorCode, overlapped)); - ReleaseMutex(hResultsMutex); - ReleaseSemaphore(hSemaphore, 1, NULL); - if (!waiting) - emit q->_q_notify(); -} - -void QWinOverlappedIoNotifierPrivate::_q_notified() -{ - if (WaitForSingleObject(hSemaphore, 0) == WAIT_OBJECT_0) - dispatchNextIoResult(); -} - -OVERLAPPED *QWinOverlappedIoNotifierPrivate::dispatchNextIoResult() -{ - Q_Q(QWinOverlappedIoNotifier); - WaitForSingleObject(hResultsMutex, INFINITE); - IOResult ioresult = results.dequeue(); - ReleaseMutex(hResultsMutex); - emit q->notified(ioresult.numberOfBytes, ioresult.errorCode, ioresult.overlapped); - return ioresult.overlapped; -} - -QT_END_NAMESPACE - -#include "moc_qwinoverlappedionotifier_p.cpp" diff --git a/src/corelib/io/qwinoverlappedionotifier_p.h b/src/corelib/io/qwinoverlappedionotifier_p.h deleted file mode 100644 index 276a1d861e..0000000000 --- a/src/corelib/io/qwinoverlappedionotifier_p.h +++ /dev/null @@ -1,90 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** 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 The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/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 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef QWINOVERLAPPEDIONOTIFIER_P_H -#define QWINOVERLAPPEDIONOTIFIER_P_H - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// - -#include <QtCore/private/qglobal_p.h> -#include <qobject.h> - -typedef struct _OVERLAPPED OVERLAPPED; - -QT_BEGIN_NAMESPACE - -class QWinOverlappedIoNotifierPrivate; - -class Q_CORE_EXPORT QWinOverlappedIoNotifier : public QObject -{ - Q_OBJECT - Q_DISABLE_COPY(QWinOverlappedIoNotifier) - Q_DECLARE_PRIVATE(QWinOverlappedIoNotifier) - Q_PRIVATE_SLOT(d_func(), void _q_notified()) - friend class QWinIoCompletionPort; -public: - QWinOverlappedIoNotifier(QObject *parent = 0); - ~QWinOverlappedIoNotifier(); - - void setHandle(Qt::HANDLE h); - Qt::HANDLE handle() const; - - void setEnabled(bool enabled); - OVERLAPPED *waitForAnyNotified(int msecs); - bool waitForNotified(int msecs, OVERLAPPED *overlapped); - -Q_SIGNALS: - void notified(quint32 numberOfBytes, quint32 errorCode, OVERLAPPED *overlapped); -#if !defined(Q_QDOC) - void _q_notify(); -#endif -}; - -QT_END_NAMESPACE - -#endif // QWINOVERLAPPEDIONOTIFIER_P_H |