/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the QtCore module of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** 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, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia 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. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include "qfsfileengine_p.h" | |
#include "qfsfileengine_iterator_p.h" | |
#include "qdatetime.h" | |
#include "qdiriterator.h" | |
#include "qset.h" | |
#include <QtCore/qdebug.h> | |
#ifndef QT_NO_FSFILEENGINE | |
#if !defined(Q_OS_WINCE) | |
#include <errno.h> | |
#endif | |
#if defined(Q_OS_UNIX) | |
#include "private/qcore_unix_p.h" | |
#endif | |
#include <stdio.h> | |
#include <stdlib.h> | |
#if defined(Q_OS_MAC) | |
# include <private/qcore_mac_p.h> | |
#endif | |
QT_BEGIN_NAMESPACE | |
#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 | |
\brief The QFSFileEngine class implements Qt's default file engine. | |
\since 4.1 | |
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 = INVALID_HANDLE_VALUE; | |
#ifndef Q_OS_WINCE | |
cachedFd = -1; | |
#endif | |
#endif | |
} | |
/*! | |
\internal | |
Returns the canonicalized form of \a path (i.e., with all symlinks | |
resolved, and all redundant path elements removed. | |
*/ | |
QString QFSFileEnginePrivate::canonicalized(const QString &path) | |
{ | |
if (path.isEmpty()) | |
return path; | |
// FIXME let's see if this stuff works, then we might be able to remove some of the other code. | |
#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN) | |
if (path.size() == 1 && path.at(0) == QLatin1Char('/')) | |
return path; | |
#endif | |
#if defined(Q_OS_LINUX) || defined(Q_OS_SYMBIAN) || defined(Q_OS_MAC) | |
// ... but Linux with uClibc does not have it | |
#if !defined(__UCLIBC__) | |
char *ret = 0; | |
#if defined(Q_OS_MAC) | |
// Mac OS X 10.5.x doesn't support the realpath(X,0) extension we use here. | |
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) { | |
ret = realpath(path.toLocal8Bit().constData(), (char*)0); | |
} else { | |
// on 10.5 we can use FSRef to resolve the file path. | |
FSRef fsref; | |
if (FSPathMakeRef((const UInt8 *)QDir::cleanPath(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 ret; | |
} | |
} | |
#else | |
ret = realpath(path.toLocal8Bit().constData(), (char*)0); | |
#endif | |
if (ret) { | |
QString canonicalPath = QDir::cleanPath(QString::fromLocal8Bit(ret)); | |
free(ret); | |
return canonicalPath; | |
} | |
#endif | |
#endif | |
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 | |
// UNC, skip past the first two elements | |
if (separatorPos == 0 && tmpPath.startsWith(QLatin1String("//"))) | |
separatorPos = tmpPath.indexOf(slash, 2); | |
if (separatorPos != -1) | |
#endif | |
separatorPos = tmpPath.indexOf(slash, separatorPos + 1); | |
QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos); | |
if ( | |
#ifdef Q_OS_SYMBIAN | |
// Symbian doesn't support directory symlinks, so do not check for link unless we | |
// are handling the last path element. This not only slightly improves performance, | |
// but also saves us from lot of unnecessary platform security check failures | |
// when dealing with files under *:/private directories. | |
separatorPos == -1 && | |
#endif | |
!nonSymlinks.contains(prefix)) { | |
fi.setFile(prefix); | |
if (fi.isSymLink()) { | |
QString target = fi.symLinkTarget(); | |
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); | |
} | |
/*! | |
Constructs a QFSFileEngine for the file name \a file. | |
*/ | |
QFSFileEngine::QFSFileEngine(const QString &file) : QAbstractFileEngine(*new QFSFileEnginePrivate) | |
{ | |
Q_D(QFSFileEngine); | |
d->filePath = QDir::fromNativeSeparators(file); | |
d->nativeInitFileName(); | |
} | |
/*! | |
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->filePath = QDir::fromNativeSeparators(file); | |
d->nativeInitFileName(); | |
} | |
/*! | |
\reimp | |
*/ | |
bool QFSFileEngine::open(QIODevice::OpenMode openMode) | |
{ | |
Q_D(QFSFileEngine); | |
if (d->filePath.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 true on | |
success; otherwise returns false. | |
*/ | |
bool QFSFileEngine::open(QIODevice::OpenMode openMode, FILE *fh) | |
{ | |
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 = false; | |
d->nativeFilePath.clear(); | |
d->filePath.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 true | |
on success; otherwise returns false. | |
*/ | |
bool QFSFileEngine::open(QIODevice::OpenMode openMode, int fd) | |
{ | |
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 = false; | |
d->nativeFilePath.clear(); | |
d->filePath.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(); | |
} | |
/*! | |
\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(); | |
} | |
/*! | |
\internal | |
*/ | |
qint64 QFSFileEnginePrivate::sizeFdFh() const | |
{ | |
Q_Q(const QFSFileEngine); | |
// ### Fix this function, it should not stat unless the file is closed. | |
QT_STATBUF st; | |
int ret = 0; | |
const_cast<QFSFileEngine *>(q)->flush(); | |
if (fh && nativeFilePath.isEmpty()) { | |
// Buffered stdlib mode. | |
// ### This should really be an ftell | |
ret = QT_FSTAT(QT_FILENO(fh), &st); | |
} else if (fd == -1) { | |
// Stateless stat. | |
ret = QT_STAT(nativeFilePath.constData(), &st); | |
} else { | |
// Unbuffered stdio mode. | |
ret = QT_FSTAT(fd, &st); | |
} | |
if (ret == -1) | |
return 0; | |
return st.st_size; | |
} | |
/*! | |
\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; | |
} | |
/*! | |
\internal | |
*/ | |
QAbstractFileEngine::Iterator *QFSFileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames) | |
{ | |
return new QFSFileEngineIterator(filters, filterNames); | |
} | |
/*! | |
\internal | |
*/ | |
QAbstractFileEngine::Iterator *QFSFileEngine::endEntryList() | |
{ | |
return 0; | |
} | |
/*! | |
\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 | |
*/ | |
bool QFSFileEnginePrivate::isSequentialFdFh() const | |
{ | |
if (!tried_stat) | |
doStat(); | |
if (could_stat) { | |
#ifdef Q_OS_UNIX | |
return (st.st_mode & S_IFMT) != S_IFREG; | |
// ### WINDOWS! | |
#endif | |
} | |
return true; | |
} | |
/*! | |
\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 true for Windows, false for Unix. | |
*/ | |
/*! \fn bool QFSFileEngine::copy(const QString ©Name) | |
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 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::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 true if the | |
new path exists; otherwise this function does nothing, and returns 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 | |
*/ | |
QT_END_NAMESPACE | |
#endif // QT_NO_FSFILEENGINE |