QFSFileEnginePrivate Class Reference

#include <qfsfileengine_p.h>

Inheritance diagram for QFSFileEnginePrivate:

Public Types
enum	LastIOCommand { IOFlushCommand, IOReadCommand, IOWriteCommand }

Public Functions
bool	closeFdFh ()
bool	doStat (QFileSystemMetaData::MetaDataFlags flags) const
bool	flushFh ()
bool	isSymlink () const
uchar *	map (qint64 offset, qint64 size, QFile::MemoryMapFlags flags)
bool	nativeClose ()
bool	nativeFlush ()
int	nativeHandle () const
bool	nativeIsSequential () const
bool	nativeOpen (QIODevice::OpenMode openMode)
qint64	nativePos () const
qint64	nativeRead (char *data, qint64 maxlen)
qint64	nativeReadLine (char *data, qint64 maxlen)
bool	nativeSeek (qint64)
qint64	nativeSize () const
qint64	nativeWrite (const char *data, qint64 len)
bool	openFd (QIODevice::OpenMode flags, int fd)
	Opens the file descriptor fd to the file engine, using the open mode flags. More...
bool	openFh (QIODevice::OpenMode flags, FILE *fh)
	Opens the file handle fh using the open mode flags. More...
qint64	posFdFh () const
qint64	readFdFh (char *data, qint64 maxlen)
qint64	readLineFdFh (char *data, qint64 maxlen)
bool	seekFdFh (qint64)
bool	unmap (uchar *ptr)
qint64	writeFdFh (const char *data, qint64 len)
Public Functions inherited from QAbstractFileEnginePrivate
	QAbstractFileEnginePrivate ()
virtual	~QAbstractFileEnginePrivate ()

Static Public Functions
static QString	longFileName (const QString &path)

Public Variables
bool	closeFileHandle
uint	could_stat: 1
int	fd
FILE *	fh
DWORD	fileAttrib
QFileSystemEntry	fileEntry
HANDLE	fileHandle
uint	is_sequential: 2
bool	lastFlushFailed
LastIOCommand	lastIOCommand
HANDLE	mapHandle
QHash< uchar *, DWORD >	maps
QFileSystemMetaData	metaData
QIODevice::OpenMode	openMode
uint	tried_stat: 1
Public Variables inherited from QAbstractFileEnginePrivate
QString	errorString
QFile::FileError	fileError
QAbstractFileEngine *	q_ptr

Protected Functions
QAbstractFileEngine::FileFlags	getPermissions (QAbstractFileEngine::FileFlags type) const
void	init ()
	QFSFileEnginePrivate ()

Detailed Description

Definition at line 81 of file qfsfileengine_p.h.

Enumerations

LastIOCommand

enum QFSFileEnginePrivate::LastIOCommand

Enumerator
IOFlushCommand
IOReadCommand
IOWriteCommand

Definition at line 171 of file qfsfileengine_p.h.

    {
        IOFlushCommand,
        IOReadCommand,
        IOWriteCommand
    };

Constructors and Destructors

QFSFileEnginePrivate()

QFSFileEnginePrivate::QFSFileEnginePrivate ( )

protected

Definition at line 107 of file qfsfileengine.cpp.

                                           : QAbstractFileEnginePrivate()
{
    init();
}

Functions

closeFdFh()

bool QFSFileEnginePrivate::closeFdFh

(

)

Warning

This function is not part of the public interface.

Definition at line 387 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativeClose().

{
    Q_Q(QFSFileEngine);
    if (fd == -1 && !fh
#ifdef Q_OS_SYMBIAN
        && !symbianFile.SubSessionHandle()
#ifndef QT_SYMBIAN_USE_NATIVE_FILEMAP
        && fileHandleForMaps == -1
#endif
#endif
        )
        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;

#if defined(Q_OS_SYMBIAN) && !defined(QT_SYMBIAN_USE_NATIVE_FILEMAP)
    // Map handle is always owned by us so always close it
    if (fileHandleForMaps >= 0) {
        QT_CLOSE(fileHandleForMaps);
        fileHandleForMaps = -1;
    }
#endif

    // Close the file if we created the handle.
    if (closeFileHandle) {
        int ret;
        do {
#ifdef Q_OS_SYMBIAN
            if (symbianFile.SubSessionHandle()) {
                symbianFile.Close();
                ret = 0;
            } else
#endif
            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;
}

doStat()

bool QFSFileEnginePrivate::doStat

(

QFileSystemMetaData::MetaDataFlags

flags

)

const

Definition at line 784 of file qfsfileengine_unix.cpp.

Referenced by longFileName(), and map().

{
    if (!tried_stat || !metaData.hasFlags(flags)) {
        tried_stat = 1;

        int localFd = fd;
        if (fh && fileEntry.isEmpty())
            localFd = QT_FILENO(fh);
        if (localFd != -1)
            QFileSystemEngine::fillMetaData(localFd, metaData);

        if (metaData.missingFlags(flags) && !fileEntry.isEmpty())
            QFileSystemEngine::fillMetaData(fileEntry, metaData, metaData.missingFlags(flags));
    }

    return metaData.exists();
}

flushFh()

bool QFSFileEnginePrivate::flushFh

(

)

Warning

This function is not part of the public interface.

Definition at line 468 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativeFlush().

{
    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;
}

getPermissions()

QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions ( QAbstractFileEngine::FileFlags  type ) const

protected

Warning

This function is not part of the public interface.

init()

void QFSFileEnginePrivate::init ( )

protected

Warning

This function is not part of the public interface.

Definition at line 115 of file qfsfileengine.cpp.

Referenced by QFSFileEnginePrivate().

{
    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;
#if defined (Q_OS_SYMBIAN)
    symbianFilePos = 0;
#if !defined(QT_SYMBIAN_USE_NATIVE_FILEMAP)
    fileHandleForMaps = -1;
#endif
#endif
    lastIOCommand = IOFlushCommand;
    lastFlushFailed = false;
    closeFileHandle = false;
#ifdef Q_OS_WIN
    fileAttrib = INVALID_FILE_ATTRIBUTES;
    fileHandle = INVALID_HANDLE_VALUE;
    mapHandle = NULL;
#ifndef Q_OS_WINCE
    cachedFd = -1;
#endif
#endif
}

isSymlink()

bool QFSFileEnginePrivate::isSymlink

(

)

const

Definition at line 802 of file qfsfileengine_unix.cpp.

{
    if (!metaData.hasFlags(QFileSystemMetaData::LinkType))
        QFileSystemEngine::fillMetaData(fileEntry, metaData, QFileSystemMetaData::LinkType);

    return metaData.isLink();
}

longFileName()

QString QFSFileEnginePrivate::longFileName ( const QString &  path )

static

Warning

This function is not part of the public interface.

Definition at line 90 of file qfsfileengine_win.cpp.

Referenced by isDirPath(), mkDir(), qt_create_pipe(), QFileSystemEntry::resolveNativeFilePath(), and rmDir().

{
    if (path.startsWith(QLatin1String("\\\\.\\")))
        return path;

    QString absPath = QFileSystemEngine::nativeAbsoluteFilePath(path);
#if !defined(Q_OS_WINCE)
    QString prefix = QLatin1String("\\\\?\\");
    if (isUncPath(absPath)) {
        prefix.append(QLatin1String("UNC\\")); // "\\\\?\\UNC\\"
        absPath.remove(0, 2);
    }
    return prefix + absPath;
#else
    return absPath;
#endif
}

map()

uchar * QFSFileEnginePrivate::map	(	qint64	offset,
		qint64	size,
		QFile::MemoryMapFlags	flags
	)

Definition at line 1022 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
    Q_Q(QFSFileEngine);
    Q_UNUSED(flags);
    if (openMode == QIODevice::NotOpen) {
        q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
        return 0;
    }

    if (offset < 0 || offset != qint64(QT_OFF_T(offset))
            || size < 0 || quint64(size) > quint64(size_t(-1))) {
        q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
        return 0;
    }

    // If we know the mapping will extend beyond EOF, fail early to avoid
    // undefined behavior. Otherwise, let mmap have its say.
    if (doStat(QFileSystemMetaData::SizeAttribute)
            && (QT_OFF_T(size) > metaData.size() - QT_OFF_T(offset)))
        qWarning("QFSFileEngine::map: Mapping a file beyond its size is not portable");

    int access = 0;
    if (openMode & QIODevice::ReadOnly) access |= PROT_READ;
    if (openMode & QIODevice::WriteOnly) access |= PROT_WRITE;

#if defined(Q_OS_INTEGRITY)
    int pageSize = sysconf(_SC_PAGESIZE);
#else
    int pageSize = getpagesize();
#endif
    int extra = offset % pageSize;

    if (quint64(size + extra) > quint64((size_t)-1)) {
        q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
        return 0;
    }

    size_t realSize = (size_t)size + extra;
    QT_OFF_T realOffset = QT_OFF_T(offset);
    realOffset &= ~(QT_OFF_T(pageSize - 1));

#ifdef QT_SYMBIAN_USE_NATIVE_FILEMAP
    TInt nativeMapError = KErrNone;
    RFileMap mapping;
    TUint mode(EFileMapRemovableMedia);
    TUint64 nativeOffset = offset & ~(mapping.PageSizeInBytes() - 1);

    //If the file was opened for write or read/write, then open the map for read/write
    if (openMode & QIODevice::WriteOnly)
        mode |= EFileMapWrite;
    if (symbianFile.SubSessionHandle()) {
        nativeMapError = mapping.Open(symbianFile, nativeOffset, size, mode);
    } else {
        //map file by name if we don't have a native handle
        QString fn = QFileSystemEngine::absoluteName(fileEntry).nativeFilePath();
        TUint filemode = EFileShareReadersOrWriters | EFileRead;
        if (openMode & QIODevice::WriteOnly)
            filemode |= EFileWrite;
        nativeMapError = mapping.Open(qt_s60GetRFs(), qt_QString2TPtrC(fn), filemode, nativeOffset, size, mode);
    }
    if (nativeMapError == KErrNone) {
        QScopedResource<RFileMap> ptr(mapping); //will call Close if adding to mapping throws an exception
        uchar *address = mapping.Base() + (offset - nativeOffset);
        maps[address] = mapping;
        ptr.take();
        return address;
    }
    QFile::FileError reportedError = QFile::UnspecifiedError;
    switch (nativeMapError) {
    case KErrAccessDenied:
    case KErrPermissionDenied:
        reportedError = QFile::PermissionsError;
        break;
    case KErrNoMemory:
        reportedError = QFile::ResourceError;
        break;
    }
    q->setError(reportedError, QSystemError(nativeMapError, QSystemError::NativeError).toString());
    return 0;
#else
#ifdef Q_OS_SYMBIAN
    //older phones & emulator don't support native mapping, so need to keep the open C way around for those.
    void *mapAddress;
    TRAPD(err, mapAddress = QT_MMAP((void*)0, realSize,
                   access, MAP_SHARED, getMapHandle(), realOffset));
    if (err != KErrNone) {
        qWarning("OpenC bug: leave from mmap %d", err);
        mapAddress = MAP_FAILED;
        errno = EINVAL;
    }
#else
    void *mapAddress = QT_MMAP((void*)0, realSize,
                   access, MAP_SHARED, nativeHandle(), realOffset);
#endif
    if (MAP_FAILED != mapAddress) {
        uchar *address = extra + static_cast<uchar*>(mapAddress);
        maps[address] = QPair<int,size_t>(extra, realSize);
        return address;
    }

    switch(errno) {
    case EBADF:
        q->setError(QFile::PermissionsError, qt_error_string(int(EACCES)));
        break;
    case ENFILE:
    case ENOMEM:
        q->setError(QFile::ResourceError, qt_error_string(int(errno)));
        break;
    case EINVAL:
        // size are out of bounds
    default:
        q->setError(QFile::UnspecifiedError, qt_error_string(int(errno)));
        break;
    }
    return 0;
#endif
}

nativeClose()

bool QFSFileEnginePrivate::nativeClose

(

)

Warning

This function is not part of the public interface.

Definition at line 429 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
    return closeFdFh();
}

nativeFlush()

bool QFSFileEnginePrivate::nativeFlush

(

)

Warning

This function is not part of the public interface.

Definition at line 438 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
#ifdef Q_OS_SYMBIAN
    if (symbianFile.SubSessionHandle())
        return (KErrNone == symbianFile.Flush());
#endif
    return fh ? flushFh() : fd != -1;
}

nativeHandle()

int QFSFileEnginePrivate::nativeHandle

(

)

const

Warning

This function is not part of the public interface.

Definition at line 614 of file qfsfileengine_unix.cpp.

Referenced by longFileName(), and map().

{
    return fh ? fileno(fh) : fd;
}

nativeIsSequential()

bool QFSFileEnginePrivate::nativeIsSequential

(

)

const

Warning

This function is not part of the public interface.

Definition at line 638 of file qfsfileengine_unix.cpp.

Referenced by longFileName(), and nativeRead().

{
#ifdef Q_OS_SYMBIAN
    if (symbianFile.SubSessionHandle())
        return false;
#endif
    return isSequentialFdFh();
}

nativeOpen()

bool QFSFileEnginePrivate::nativeOpen

(

QIODevice::OpenMode

openMode

)

Warning

This function is not part of the public interface.

Definition at line 331 of file qfsfileengine_unix.cpp.

Referenced by longFileName(), and setCloseOnExec().

{
    Q_Q(QFSFileEngine);

    if (openMode & QIODevice::Unbuffered) {
        int flags = openModeToOpenFlags(openMode);

        // Try to open the file in unbuffered mode.
        do {
            fd = QT_OPEN(fileEntry.nativeFilePath().constData(), flags, 0666);
        } while (fd == -1 && errno == EINTR);

        // On failure, return and report the error.
        if (fd == -1) {
            q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
                        qt_error_string(errno));
            return false;
        }

        if (!(openMode & QIODevice::WriteOnly)) {
            // we don't need this check if we tried to open for writing because then
            // we had received EISDIR anyway.
            if (QFileSystemEngine::fillMetaData(fd, metaData)
                    && metaData.isDirectory()) {
                q->setError(QFile::OpenError, QLatin1String("file to open is a directory"));
                QT_CLOSE(fd);
                return false;
            }
        }

        // Seek to the end when in Append mode.
        if (flags & QFile::Append) {
            int ret;
            do {
                ret = QT_LSEEK(fd, 0, SEEK_END);
            } while (ret == -1 && errno == EINTR);

            if (ret == -1) {
                q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
                            qt_error_string(int(errno)));
                return false;
            }
        }

        fh = 0;
    } else {
        QByteArray fopenMode = openModeToFopenMode(openMode, fileEntry, metaData);

        // Try to open the file in buffered mode.
        do {
            fh = QT_FOPEN(fileEntry.nativeFilePath().constData(), fopenMode.constData());
        } while (!fh && errno == EINTR);

        // On failure, return and report the error.
        if (!fh) {
            q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
                        qt_error_string(int(errno)));
            return false;
        }

        if (!(openMode & QIODevice::WriteOnly)) {
            // we don't need this check if we tried to open for writing because then
            // we had received EISDIR anyway.
            if (QFileSystemEngine::fillMetaData(QT_FILENO(fh), metaData)
                    && metaData.isDirectory()) {
                q->setError(QFile::OpenError, QLatin1String("file to open is a directory"));
                fclose(fh);
                return false;
            }
        }

        setCloseOnExec(fileno(fh)); // ignore failure

        // Seek to the end when in Append mode.
        if (openMode & QIODevice::Append) {
            int ret;
            do {
                ret = QT_FSEEK(fh, 0, SEEK_END);
            } while (ret == -1 && errno == EINTR);

            if (ret == -1) {
                q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
                            qt_error_string(int(errno)));
                return false;
            }
        }

        fd = -1;
    }

    closeFileHandle = true;
    return true;
}

nativePos()

qint64 QFSFileEnginePrivate::nativePos

(

)

const

Warning

This function is not part of the public interface.

Definition at line 579 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
#ifdef Q_OS_SYMBIAN
    const Q_Q(QFSFileEngine);
    if (symbianFile.SubSessionHandle()) {
        return symbianFilePos;
    }
#endif
    return posFdFh();
}

nativeRead()

qint64 QFSFileEnginePrivate::nativeRead	(	char *	data,
		qint64	len
	)

Warning

This function is not part of the public interface.

Definition at line 450 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
    Q_Q(QFSFileEngine);

#ifdef Q_OS_SYMBIAN
    if (symbianFile.SubSessionHandle()) {
        if(len > KMaxTInt) {
            //this check is more likely to catch a corrupt length, since it isn't possible to allocate 2GB buffers (yet..)
            q->setError(QFile::ReadError, QLatin1String("Maximum 2GB in single read on this platform"));
            return -1;
        }
        TPtr8 ptr(reinterpret_cast<TUint8*>(data), static_cast<TInt>(len));
        TInt r = symbianFile.Read(symbianFilePos, ptr);
        if (r != KErrNone)
        {
            q->setError(QFile::ReadError, QSystemError(r, QSystemError::NativeError).toString());
            return -1;
        }
        symbianFilePos += ptr.Length();
        return qint64(ptr.Length());
    }
#endif
    if (fh && nativeIsSequential()) {
        size_t readBytes = 0;
        int oldFlags = fcntl(QT_FILENO(fh), F_GETFL);
        for (int i = 0; i < 2; ++i) {
            // Unix: Make the underlying file descriptor non-blocking
            if ((oldFlags & O_NONBLOCK) == 0)
                fcntl(QT_FILENO(fh), F_SETFL, oldFlags | O_NONBLOCK);

            // Cross platform stdlib read
            size_t read = 0;
            do {
                read = fread(data + readBytes, 1, size_t(len - readBytes), fh);
            } while (read == 0 && !feof(fh) && errno == EINTR);
            if (read > 0) {
                readBytes += read;
                break;
            } else {
                if (readBytes)
                    break;
                readBytes = read;
            }

            // Unix: Restore the blocking state of the underlying socket
            if ((oldFlags & O_NONBLOCK) == 0) {
                fcntl(QT_FILENO(fh), F_SETFL, oldFlags);
                if (readBytes == 0) {
                    int readByte = 0;
                    do {
                        readByte = fgetc(fh);
                    } while (readByte == -1 && errno == EINTR);
                    if (readByte != -1) {
                        *data = uchar(readByte);
                        readBytes += 1;
                    } else {
                        break;
                    }
                }
            }
        }
        // Unix: Restore the blocking state of the underlying socket
        if ((oldFlags & O_NONBLOCK) == 0) {
            fcntl(QT_FILENO(fh), F_SETFL, oldFlags);
        }
        if (readBytes == 0 && !feof(fh)) {
            // if we didn't read anything and we're not at EOF, it must be an error
            q->setError(QFile::ReadError, qt_error_string(int(errno)));
            return -1;
        }
        return readBytes;
    }

    return readFdFh(data, len);
}

nativeReadLine()

qint64 QFSFileEnginePrivate::nativeReadLine	(	char *	data,
		qint64	maxlen
	)

Warning

This function is not part of the public interface.

Definition at line 529 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
    return readLineFdFh(data, maxlen);
}

nativeSeek()

bool QFSFileEnginePrivate::nativeSeek

(

qint64

pos

)

Warning

This function is not part of the public interface.

Definition at line 593 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
#ifdef Q_OS_SYMBIAN
    Q_Q(QFSFileEngine);
    if (symbianFile.SubSessionHandle()) {
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
        if(pos > KMaxTInt) {
            q->setError(QFile::PositionError, QLatin1String("Maximum 2GB file position on this platform"));
            return false;
        }
#endif
        symbianFilePos = pos;
        return true;
    }
#endif
    return seekFdFh(pos);
}

nativeSize()

qint64 QFSFileEnginePrivate::nativeSize

(

)

const

Definition at line 694 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
#ifdef Q_OS_SYMBIAN
    const Q_Q(QFSFileEngine);
    if (symbianFile.SubSessionHandle()) {
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
        qint64 size;
#else
        TInt size;
#endif
        TInt err = symbianFile.Size(size);
        if(err != KErrNone) {
            const_cast<QFSFileEngine*>(q)->setError(QFile::PositionError, QSystemError(err, QSystemError::NativeError).toString());
            return 0;
        }
        return size;
    }
#endif
    return sizeFdFh();
}

nativeWrite()

qint64 QFSFileEnginePrivate::nativeWrite	(	const char *	data,
		qint64	len
	)

Warning

This function is not part of the public interface.

Definition at line 537 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
#ifdef Q_OS_SYMBIAN
    Q_Q(QFSFileEngine);
    if (symbianFile.SubSessionHandle()) {
        if(len > KMaxTInt) {
            //this check is more likely to catch a corrupt length, since it isn't possible to allocate 2GB buffers (yet..)
            q->setError(QFile::WriteError, QLatin1String("Maximum 2GB in single write on this platform"));
            return -1;
        }
        const TPtrC8 ptr(reinterpret_cast<const TUint8*>(data), static_cast<TInt>(len));
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
        TInt64 eofpos = 0;
#else
        TInt eofpos = 0;
#endif
        //The end of file position is not cached because QFile is read/write sharable, therefore another
        //process may have altered the file size.
        TInt r = symbianFile.Seek(ESeekEnd, eofpos);
        if (r == KErrNone && symbianFilePos > eofpos) {
            //seek position is beyond end of file so file needs to be extended before write.
            //note that SetSize does not zero-initialise (c.f. posix lseek)
            r = symbianFile.SetSize(symbianFilePos);
        }
        if (r == KErrNone) {
            //write to specific position in the file (i.e. use our own cursor rather than calling seek)
            r = symbianFile.Write(symbianFilePos, ptr);
        }
        if (r != KErrNone) {
            q->setError(QFile::WriteError, QSystemError(r, QSystemError::NativeError).toString());
            return -1;
        }
        symbianFilePos += len;
        return len;
    }
#endif
    return writeFdFh(data, len);
}

openFd()

bool QFSFileEnginePrivate::openFd	(	QIODevice::OpenMode	flags,
		int	fd
	)

Opens the file descriptor fd to the file engine, using the open mode flags.

Definition at line 347 of file qfsfileengine.cpp.

{
    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;
}

openFh()

bool QFSFileEnginePrivate::openFh	(	QIODevice::OpenMode	flags,
		FILE *	fh
	)

Opens the file handle fh using the open mode flags.

Definition at line 275 of file qfsfileengine.cpp.

{
    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;
}

posFdFh()

qint64 QFSFileEnginePrivate::posFdFh

(

)

const

Warning

This function is not part of the public interface.

Definition at line 528 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativePos().

{
    if (fh)
        return qint64(QT_FTELL(fh));
    return QT_LSEEK(fd, 0, SEEK_CUR);
}

readFdFh()

qint64 QFSFileEnginePrivate::readFdFh	(	char *	data,
		qint64	len
	)

Warning

This function is not part of the public interface.

Definition at line 612 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativeRead().

{
    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;
}

readLineFdFh()

qint64 QFSFileEnginePrivate::readLineFdFh	(	char *	data,
		qint64	maxlen
	)

Warning

This function is not part of the public interface.

Definition at line 688 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativeReadLine().

{
    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);
}

seekFdFh()

bool QFSFileEnginePrivate::seekFdFh

(

qint64

pos

)

Warning

This function is not part of the public interface.

Definition at line 547 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativeSeek().

{
    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;
}

unmap()

bool QFSFileEnginePrivate::unmap

(

uchar *

ptr

)

Definition at line 1140 of file qfsfileengine_unix.cpp.

Referenced by longFileName().

{
#if !defined(Q_OS_INTEGRITY)
    Q_Q(QFSFileEngine);
    if (!maps.contains(ptr)) {
        q->setError(QFile::PermissionsError, qt_error_string(EACCES));
        return false;
    }

#ifdef QT_SYMBIAN_USE_NATIVE_FILEMAP
    RFileMap mapping = maps.value(ptr);
    TInt err = mapping.Flush();
    mapping.Close();
    maps.remove(ptr);
    if (err) {
        q->setError(QFile::WriteError, QSystemError(err, QSystemError::NativeError).toString());
        return false;
    }
    return true;
#else
    uchar *start = ptr - maps[ptr].first;
    size_t len = maps[ptr].second;
    if (-1 == munmap(start, len)) {
        q->setError(QFile::UnspecifiedError, qt_error_string(errno));
        return false;
    }
    maps.remove(ptr);
    return true;
#endif
#else
    return false;
#endif
}

writeFdFh()

qint64 QFSFileEnginePrivate::writeFdFh	(	const char *	data,
		qint64	len
	)

Warning

This function is not part of the public interface.

Definition at line 741 of file qfsfileengine.cpp.

Referenced by longFileName(), and nativeWrite().

{
    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;
}

Properties

closeFileHandle

bool QFSFileEnginePrivate::closeFileHandle

Definition at line 179 of file qfsfileengine_p.h.

Referenced by init(), nativeOpen(), and setCloseOnExec().

could_stat

uint QFSFileEnginePrivate::could_stat

mutable

Definition at line 182 of file qfsfileengine_p.h.

fd

int QFSFileEnginePrivate::fd

Definition at line 169 of file qfsfileengine_p.h.

Referenced by doStat(), init(), longFileName(), nativeFlush(), nativeHandle(), nativeOpen(), and setCloseOnExec().

fh

FILE* QFSFileEnginePrivate::fh

Definition at line 125 of file qfsfileengine_p.h.

Referenced by doStat(), init(), longFileName(), nativeFlush(), nativeHandle(), nativeOpen(), nativeRead(), and setCloseOnExec().

fileAttrib

DWORD QFSFileEnginePrivate::fileAttrib

mutable

Definition at line 163 of file qfsfileengine_p.h.

Referenced by init().

fileEntry

QFileSystemEntry QFSFileEnginePrivate::fileEntry

Definition at line 90 of file qfsfileengine_p.h.

Referenced by doStat(), isSymlink(), longFileName(), map(), nativeHandle(), nativeOpen(), and setCloseOnExec().

fileHandle

HANDLE QFSFileEnginePrivate::fileHandle

Definition at line 155 of file qfsfileengine_p.h.

Referenced by init(), and longFileName().

is_sequential

uint QFSFileEnginePrivate::is_sequential

mutable

Definition at line 181 of file qfsfileengine_p.h.

Referenced by init().

lastFlushFailed

bool QFSFileEnginePrivate::lastFlushFailed

Definition at line 178 of file qfsfileengine_p.h.

Referenced by init().

lastIOCommand

LastIOCommand QFSFileEnginePrivate::lastIOCommand

Definition at line 177 of file qfsfileengine_p.h.

Referenced by init().

mapHandle

HANDLE QFSFileEnginePrivate::mapHandle

Definition at line 156 of file qfsfileengine_p.h.

Referenced by init(), and longFileName().

maps

QHash<uchar *, DWORD > QFSFileEnginePrivate::maps

Definition at line 157 of file qfsfileengine_p.h.

Referenced by longFileName(), map(), and unmap().

metaData

QFileSystemMetaData QFSFileEnginePrivate::metaData

mutable

Definition at line 123 of file qfsfileengine_p.h.

Referenced by doStat(), isSymlink(), longFileName(), map(), and nativeOpen().

openMode

QIODevice::OpenMode QFSFileEnginePrivate::openMode

Definition at line 91 of file qfsfileengine_p.h.

Referenced by init(), longFileName(), and setCloseOnExec().

tried_stat

uint QFSFileEnginePrivate::tried_stat

mutable

Definition at line 183 of file qfsfileengine_p.h.

Referenced by doStat(), init(), and longFileName().

---

The documentation for this class was generated from the following files:

• /src/corelib/io/qfsfileengine_p.h
• /src/corelib/io/qfsfileengine.cpp
• /src/corelib/io/qfsfileengine_unix.cpp
• /src/corelib/io/qfsfileengine_win.cpp