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

**

** 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 "qplatformdefs.h"

#include "qabstractfileengine.h"

#include "private/qfsfileengine_p.h"

#include "private/qcore_unix_p.h"

#ifndef QT_NO_FSFILEENGINE

#include "qfile.h"

#include "qdir.h"

#include "qdatetime.h"

#include "qvarlengtharray.h"

#include <sys/mman.h>

#include <stdlib.h>

#include <limits.h>

#if defined(Q_OS_SYMBIAN)

# include <syslimits.h>

# include <f32file.h>

# include <pathinfo.h>

# include "private/qcore_symbian_p.h"

#endif

#include <errno.h>

#if !defined(QWS) && defined(Q_OS_MAC)

# include <private/qcore_mac_p.h>

#endif

QT_BEGIN_NAMESPACE

#if defined(Q_OS_SYMBIAN)

/*!

    \internal

    Returns true if supplied path is a relative path

*/

static bool isRelativePathSymbian(const QString& fileName)

{

    return !(fileName.startsWith(QLatin1Char('/'))

             || (fileName.length() >= 2

             && ((fileName.at(0).isLetter() && fileName.at(1) == QLatin1Char(':'))

             || (fileName.at(0) == QLatin1Char('/') && fileName.at(1) == QLatin1Char('/')))));

}

#endif

/*!

    \internal

    Returns the stdlib open string corresponding to a QIODevice::OpenMode.

*/

static inline QByteArray openModeToFopenMode(QIODevice::OpenMode flags, const QString &fileName)

{

    QByteArray mode;

    if ((flags & QIODevice::ReadOnly) && !(flags & QIODevice::Truncate)) {

        mode = "rb";

        if (flags & QIODevice::WriteOnly) {

            QT_STATBUF statBuf;

            if (!fileName.isEmpty()

                && QT_STAT(QFile::encodeName(fileName), &statBuf) == 0

                && (statBuf.st_mode & S_IFMT) == S_IFREG) {

                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)

{

    int oflags = QT_OPEN_RDONLY;

#ifdef QT_LARGEFILE_SUPPORT

    oflags |= QT_OPEN_LARGEFILE;

#endif

    if ((mode & QFile::ReadWrite) == QFile::ReadWrite) {

        oflags = QT_OPEN_RDWR | QT_OPEN_CREAT;

    } else if (mode & QFile::WriteOnly) {

        oflags = QT_OPEN_WRONLY | QT_OPEN_CREAT;

    }

    if (mode & QFile::Append) {

        oflags |= QT_OPEN_APPEND;

    } else if (mode & QFile::WriteOnly) {

        if ((mode & QFile::Truncate) || !(mode & QFile::ReadOnly))

            oflags |= QT_OPEN_TRUNC;

    }

    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;

}

/*!

    \internal

*/

void QFSFileEnginePrivate::nativeInitFileName()

{

    nativeFilePath = QFile::encodeName(filePath);

}

/*!

    \internal

*/

bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode)

{

    Q_Q(QFSFileEngine);

    if (openMode & QIODevice::Unbuffered) {

        int flags = openModeToOpenFlags(openMode);

        // Try to open the file in unbuffered mode.

        do {

            fd = QT_OPEN(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.

            QT_STATBUF statBuf;

            if (QT_FSTAT(fd, &statBuf) != -1) {

                if ((statBuf.st_mode & S_IFMT) == S_IFDIR) {

                    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, filePath);

        // Try to open the file in buffered mode.

        do {

            fh = QT_FOPEN(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.

            QT_STATBUF statBuf;

            if (QT_FSTAT(fileno(fh), &statBuf) != -1) {

                if ((statBuf.st_mode & S_IFMT) == S_IFDIR) {

                    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;

}

/*!

    \internal

*/

bool QFSFileEnginePrivate::nativeClose()

{

    return closeFdFh();

}

/*!

    \internal

*/

bool QFSFileEnginePrivate::nativeFlush()

{

    return fh ? flushFh() : fd != -1;

}

/*!

    \internal

*/

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

{

    Q_Q(QFSFileEngine);

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

}

/*!

    \internal

*/

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

{

    return readLineFdFh(data, maxlen);

}

/*!

    \internal

*/

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

{

    return writeFdFh(data, len);

}

/*!

    \internal

*/

qint64 QFSFileEnginePrivate::nativePos() const

{

    return posFdFh();

}

/*!

    \internal

*/

bool QFSFileEnginePrivate::nativeSeek(qint64 pos)

{

    return seekFdFh(pos);

}

/*!

    \internal

*/

int QFSFileEnginePrivate::nativeHandle() const

{

    return fh ? fileno(fh) : fd;

}

/*!

    \internal

*/

bool QFSFileEnginePrivate::nativeIsSequential() const

{

    return isSequentialFdFh();

}

bool QFSFileEngine::remove()

{

    Q_D(QFSFileEngine);

    bool ret = unlink(d->nativeFilePath.constData()) == 0;

    if (!ret)

        setError(QFile::RemoveError, qt_error_string(errno));

    return ret;

}

bool QFSFileEngine::copy(const QString &newName)

{

#if defined(Q_OS_SYMBIAN)

    Q_D(QFSFileEngine);

    RFs rfs = qt_s60GetRFs();

    CFileMan* fm = NULL;

    QString oldNative(QDir::toNativeSeparators(d->filePath));

    TPtrC oldPtr(qt_QString2TPtrC(oldNative));

    QFileInfo fi(newName);

    QString absoluteNewName = fi.absoluteFilePath();

    QString newNative(QDir::toNativeSeparators(absoluteNewName));

    TPtrC newPtr(qt_QString2TPtrC(newNative));

    TRAPD (err,

        fm = CFileMan::NewL(rfs);

        RFile rfile;

        err = rfile.Open(rfs, oldPtr, EFileShareReadersOrWriters);

        if (err == KErrNone) {

            err = fm->Copy(rfile, newPtr);

            rfile.Close();

        }

    ) // End TRAP

    delete fm;

#else

    Q_UNUSED(newName);

    // ### Add copy code for Unix here

    setError(QFile::UnspecifiedError, QLatin1String("Not implemented!"));

    return false;

#endif

}

bool QFSFileEngine::rename(const QString &newName)

{

    Q_D(QFSFileEngine);

    bool ret = ::rename(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;

    if (!ret)

        setError(QFile::RenameError, qt_error_string(errno));

    return ret;

}

bool QFSFileEngine::link(const QString &newName)

{

    Q_D(QFSFileEngine);

    bool ret = ::symlink(d->nativeFilePath.constData(), QFile::encodeName(newName).constData()) == 0;

    if (!ret)

        setError(QFile::RenameError, qt_error_string(errno));

    return ret;

}

qint64 QFSFileEnginePrivate::nativeSize() const

{

    return sizeFdFh();

}

bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const

{

    QString dirName = name;

    if (createParentDirectories) {

        dirName = QDir::cleanPath(dirName);

#if defined(Q_OS_SYMBIAN)

        dirName = QDir::toNativeSeparators(dirName);

#endif

        for(int oldslash = -1, slash=0; slash != -1; oldslash = slash) {

            slash = dirName.indexOf(QDir::separator(), oldslash+1);

            if (slash == -1) {

                if (oldslash == dirName.length())

                    break;

                slash = dirName.length();

            }

            if (slash) {

                QByteArray chunk = QFile::encodeName(dirName.left(slash));

                QT_STATBUF st;

                if (QT_STAT(chunk, &st) != -1) {

                    if ((st.st_mode & S_IFMT) != S_IFDIR)

                        return false;

                } else if (QT_MKDIR(chunk, 0777) != 0) {