MCL/sf/mw/qt: comparison src/corelib/io/qfsfileengine.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 #endif
 #if defined(Q_OS_UNIX)
 #include "private/qcore_unix_p.h"
 #endif
 #include <stdio.h>
+#include <stdlib.h>
 QT_BEGIN_NAMESPACE
 #ifdef Q_OS_WIN
 #  ifndef S_ISREG
 #  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
 lastFlushFailed = false;
 closeFileHandle = false;
 #ifdef Q_OS_WIN
 fileAttrib = INVALID_FILE_ATTRIBUTES;
 fileHandle = INVALID_HANDLE_VALUE;
+mapHandle = INVALID_HANDLE_VALUE;
 cachedFd = -1;
-#endif
-#ifdef Q_USE_DEPRECATED_MAP_API
-fileMapHandle = INVALID_HANDLE_VALUE;
 #endif
 }
 /*!
 \internal
 */
 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
+// Mac OS X 10.5.x doesn't support the realpath(X,0) extenstion we use here.
+#if defined(Q_OS_LINIX) || defined(Q_OS_SYMBIAN)
+char *ret = realpath(path.toLocal8Bit().constData(), (char*)0);
+if (ret) {
+QString canonicalPath = QDir::cleanPath(QString::fromLocal8Bit(ret));
+free(ret);
+return canonicalPath;
+}
+#endif
 QFileInfo fi;
 const QChar slash(QLatin1Char('/'));
 QString tmpPath = path;
 int separatorPos = 0;
 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) {
 // 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);
+} while (ret != 0 && errno == EINTR);
-if (ret == -1) {
+if (ret != 0) {
 q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
 qt_error_string(int(errno)));
 this->openMode = QIODevice::NotOpen;
 this->fh = 0;
 // 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 == -1 && errno == EINTR);
+} while (ret != 0 && errno == EINTR);
-if (ret == -1) {
+if (ret != 0) {
 q->setError(QFile::ReadError, qt_error_string(int(errno)));
 return false;
 }
 } else {
 // Unbuffered stdio mode.
-if (QT_LSEEK(fd, pos, SEEK_SET) == -1) {
+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;
 }
 }
 */
 qint64 QFSFileEnginePrivate::readFdFh(char *data, qint64 len)
 {
 Q_Q(QFSFileEngine);
-// Buffered stdlib mode.
+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) {
-qint64 readBytes = 0;
+// Buffered stdlib mode.
-qint64 read = 0;
-int retry = 0;
+size_t result;
+bool retry = true;
-// Read in blocks of 4k to avoid platform limitations (Windows
-// commonly bails out if you read or write too large blocks at once).
-qint64 bytesToRead;
 do {
-if (retry == 1)
+result = fread(data + readBytes, 1, size_t(len - readBytes), fh);
-retry = 2;
+eof = feof(fh);
+if (retry && eof && result == 0) {
-bytesToRead = qMin<qint64>(4096, len - read);
+// On Mac OS, this is needed, e.g., if a file was written to
-do {
+// through another stream since our last read. See test
-readBytes = fread(data + read, 1, size_t(bytesToRead), fh);
+// tst_QFile::appendAndRead
-} while (readBytes == 0 && !feof(fh) && errno == EINTR);
+QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET); // re-sync stream.
+retry = false;
-if (readBytes > 0) {
+continue;
-read += readBytes;
-} else if (!retry && feof(fh)) {
-// Synchronize and try again (just once though).
-if (++retry == 1)
-QT_FSEEK(fh, QT_FTELL(fh), SEEK_SET);
 }
-} while (retry == 1 || (readBytes == bytesToRead && read < len));
+readBytes += result;
+} while (!eof && (result == 0 ? errno == EINTR : readBytes < len));
-// Return the number of bytes read, or if nothing was read, return -1
-// if an error occurred, or 0 if we detected EOF.
+} else if (fd != -1) {
-if (read == 0) {
+// Unbuffered stdio mode.
-q->setError(QFile::ReadError, qt_error_string(int(errno)));
-if (!feof(fh))
+#ifdef Q_OS_WIN
-read = -1;
-}
-return read;
-}
-// Unbuffered stdio mode.
-qint64 ret = 0;
-if (len) {
 int result;
-qint64 read = 0;
+#else
-errno = 0;
+ssize_t result;
+#endif
-// Read in blocks of 4k to avoid platform limitations (Windows
-// commonly bails out if you read or write too large blocks at once).
 do {
-qint64 bytesToRead = qMin<qint64>(4096, len - read);
+result = QT_READ(fd, data + readBytes, size_t(len - readBytes));
-do {
+} while ((result == -1 && errno == EINTR)
-result = QT_READ(fd, data + read, int(bytesToRead));
+|| (result > 0 && (readBytes += result) < len));
-} while (result == -1 && errno == EINTR);
-if (result > 0)
+eof = !(result == -1);
-read += result;
+}
-} while (result > 0 && read < len);
+if (!eof && readBytes == 0) {
-// Return the number of bytes read, or if nothing was read, return -1
+readBytes = -1;
-// if an error occurred.
+q->setError(QFile::ReadError, qt_error_string(errno));
-if (read > 0) {
+}
-ret += read;
-} else if (read == 0 && result < 0) {
+return readBytes;
-ret = -1;
-q->setError(QFile::ReadError, qt_error_string(errno));
-}
-}
-return ret;
 }
 /*!
 \reimp
 */
 \internal
 */
 qint64 QFSFileEnginePrivate::writeFdFh(const char *data, qint64 len)
 {
 Q_Q(QFSFileEngine);
-qint64 result;
-qint64 written = 0;
+if (len < 0 || len != qint64(size_t(len))) {
+q->setError(QFile::WriteError, qt_error_string(EINVAL));
-do {
+return -1;
-// Write blocks of 4k to avoid platform limitations (Windows commonly
+}
-// bails out if you read or write too large blocks at once).
-qint64 bytesToWrite = qMin<qint64>(4096, len - written);
+qint64 writtenBytes = 0;
-if (fh) {
-do {
+if (fh) {
 // Buffered stdlib mode.
-result = qint64(fwrite(data + written, 1, size_t(bytesToWrite), fh));
-} while (result == 0 && errno == EINTR);
+size_t result;
-if (bytesToWrite > 0 && result == 0)
+do {
-result = -1;
+result = fwrite(data + writtenBytes, 1, size_t(len - writtenBytes), fh);
-} else {
+writtenBytes += result;
-do {
+} while (result == 0 ? errno == EINTR : writtenBytes < len);
-// Unbuffered stdio mode.
-result = QT_WRITE(fd, data + written, bytesToWrite);
+} else if (fd != -1) {
-} while (result == -1 && errno == EINTR);
+// Unbuffered stdio mode.
-}
-if (result > 0)
+#ifdef Q_OS_WIN
-written += qint64(result);
+int result;
-} while (written < len && result > 0);
+#else
+ssize_t result;
-// If we read anything, return that with success. Otherwise, set an error,
+#endif
-// and return the last return value.
+do {
-if (result > 0)
+result = QT_WRITE(fd, data + writtenBytes, size_t(len - writtenBytes));
-return written;
+} while ((result == -1 && errno == EINTR)
-q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
+|| (result > 0 && (writtenBytes += result) < len));
-return result;
+}
+if (len &&  writtenBytes == 0) {
+writtenBytes = -1;
+q->setError(errno == ENOSPC ? QFile::ResourceError : QFile::WriteError, qt_error_string(errno));
+}
+return writtenBytes;
 }
 /*!
 \internal
 */
 */
 /*! \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:).

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7