/****************************************************************************

**

** Copyright (C) 2010 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$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, 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.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $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>

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;

    cachedFd = -1;

#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

    // Mac OS X 10.5.x doesn't support the realpath(X,0) extenstion we use here.

#if defined(Q_OS_LINUX) || 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;

    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;