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

**

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

**

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

#define _POSIX_

#include "qplatformdefs.h"

#include "qabstractfileengine.h"

#include "private/qfsfileengine_p.h"

#include <qdebug.h>

#include "qfile.h"

#include "qdir.h"

#include "private/qmutexpool_p.h"

#include "qvarlengtharray.h"

#include "qdatetime.h"

#include "qt_windows.h"

#if !defined(Q_OS_WINCE)

#  include <sys/types.h>

#  include <direct.h>

#  include <winioctl.h>

#else

#  include <types.h>

#endif

#include <objbase.h>

#include <shlobj.h>

#include <initguid.h>

#include <accctrl.h>

#include <ctype.h>

#include <limits.h>

#define SECURITY_WIN32

#ifdef Q_CC_MINGW

// A workaround for a certain version of MinGW, the define UNICODE_STRING.

#include <subauth.h>

#endif

#include <security.h>

#ifndef _INTPTR_T_DEFINED

#ifdef  _WIN64

typedef __int64             intptr_t;

#else

#ifdef _W64

typedef _W64 int            intptr_t;

#else

typedef INT_PTR intptr_t;

#endif

#endif

#define _INTPTR_T_DEFINED

#endif

#ifndef INVALID_FILE_ATTRIBUTES

#  define INVALID_FILE_ATTRIBUTES (DWORD (-1))

#endif

#if !defined(Q_OS_WINCE)

#  if !defined(REPARSE_DATA_BUFFER_HEADER_SIZE)

typedef struct _REPARSE_DATA_BUFFER {

    ULONG  ReparseTag;

    USHORT ReparseDataLength;

    USHORT Reserved;

    union {

        struct {

            USHORT SubstituteNameOffset;

            USHORT SubstituteNameLength;

            USHORT PrintNameOffset;

            USHORT PrintNameLength;

            ULONG  Flags;

            WCHAR  PathBuffer[1];

        } SymbolicLinkReparseBuffer;

        struct {

            USHORT SubstituteNameOffset;

            USHORT SubstituteNameLength;

            USHORT PrintNameOffset;

            USHORT PrintNameLength;

            WCHAR  PathBuffer[1];

        } MountPointReparseBuffer;

        struct {

            UCHAR  DataBuffer[1];

        } GenericReparseBuffer;

    };

} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;

#    define REPARSE_DATA_BUFFER_HEADER_SIZE  FIELD_OFFSET(REPARSE_DATA_BUFFER, GenericReparseBuffer)

#  endif // !defined(REPARSE_DATA_BUFFER_HEADER_SIZE)

#  ifndef MAXIMUM_REPARSE_DATA_BUFFER_SIZE

#    define MAXIMUM_REPARSE_DATA_BUFFER_SIZE 16384

#  endif

#  ifndef IO_REPARSE_TAG_SYMLINK

#    define IO_REPARSE_TAG_SYMLINK (0xA000000CL)

#  endif

#  ifndef FSCTL_GET_REPARSE_POINT

#    define FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)

#  endif

#endif // !defined(Q_OS_WINCE)

QT_BEGIN_NAMESPACE

static QString readLink(const QString &link);

Q_CORE_EXPORT int qt_ntfs_permission_lookup = 0;

#if defined(Q_OS_WINCE)

static QString qfsPrivateCurrentDir = QLatin1String("");

// As none of the functions we try to resolve do exist on Windows CE

// we use QT_NO_LIBRARY to shorten everything up a little bit.

#define QT_NO_LIBRARY 1

#endif

#if !defined(QT_NO_LIBRARY)

QT_BEGIN_INCLUDE_NAMESPACE

typedef DWORD (WINAPI *PtrGetNamedSecurityInfoW)(LPWSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION, PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);

static PtrGetNamedSecurityInfoW ptrGetNamedSecurityInfoW = 0;

typedef BOOL (WINAPI *PtrLookupAccountSidW)(LPCWSTR, PSID, LPWSTR, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE);

static PtrLookupAccountSidW ptrLookupAccountSidW = 0;

typedef VOID (WINAPI *PtrBuildTrusteeWithSidW)(PTRUSTEE_W, PSID);

static PtrBuildTrusteeWithSidW ptrBuildTrusteeWithSidW = 0;

typedef DWORD (WINAPI *PtrGetEffectiveRightsFromAclW)(PACL, PTRUSTEE_W, OUT PACCESS_MASK);

static PtrGetEffectiveRightsFromAclW ptrGetEffectiveRightsFromAclW = 0;

static TRUSTEE_W currentUserTrusteeW;

static TRUSTEE_W worldTrusteeW;

typedef BOOL (WINAPI *PtrGetUserProfileDirectoryW)(HANDLE, LPWSTR, LPDWORD);

static PtrGetUserProfileDirectoryW ptrGetUserProfileDirectoryW = 0;

QT_END_INCLUDE_NAMESPACE

void QFSFileEnginePrivate::resolveLibs()

{

    static bool triedResolve = false;

    if (!triedResolve) {

        // need to resolve the security info functions

        // protect initialization

#ifndef QT_NO_THREAD

        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));

        // check triedResolve again, since another thread may have already

        // done the initialization

        if (triedResolve) {

            // another thread did initialize the security function pointers,

            // so we shouldn't do it again.

            return;

        }

#endif

        triedResolve = true;

#if !defined(Q_OS_WINCE)

        HINSTANCE advapiHnd = LoadLibraryW(L"advapi32");

        if (advapiHnd) {

            ptrGetNamedSecurityInfoW = (PtrGetNamedSecurityInfoW)GetProcAddress(advapiHnd, "GetNamedSecurityInfoW");

            ptrLookupAccountSidW = (PtrLookupAccountSidW)GetProcAddress(advapiHnd, "LookupAccountSidW");

            ptrBuildTrusteeWithSidW = (PtrBuildTrusteeWithSidW)GetProcAddress(advapiHnd, "BuildTrusteeWithSidW");

            ptrGetEffectiveRightsFromAclW = (PtrGetEffectiveRightsFromAclW)GetProcAddress(advapiHnd, "GetEffectiveRightsFromAclW");

        }

        if (ptrBuildTrusteeWithSidW) {

            // Create TRUSTEE for current user

            HANDLE hnd = ::GetCurrentProcess();

            HANDLE token = 0;

            if (::OpenProcessToken(hnd, TOKEN_QUERY, &token)) {

                TOKEN_USER tu;

                DWORD retsize;

                if (::GetTokenInformation(token, TokenUser, &tu, sizeof(tu), &retsize))

                    ptrBuildTrusteeWithSidW(&currentUserTrusteeW, tu.User.Sid);

                ::CloseHandle(token);

            }

            typedef BOOL (WINAPI *PtrAllocateAndInitializeSid)(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);

            PtrAllocateAndInitializeSid ptrAllocateAndInitializeSid = (PtrAllocateAndInitializeSid)GetProcAddress(advapiHnd, "AllocateAndInitializeSid");

            typedef PVOID (WINAPI *PtrFreeSid)(PSID);

            PtrFreeSid ptrFreeSid = (PtrFreeSid)GetProcAddress(advapiHnd, "FreeSid");

            if (ptrAllocateAndInitializeSid && ptrFreeSid) {

                // Create TRUSTEE for Everyone (World)

                SID_IDENTIFIER_AUTHORITY worldAuth = { SECURITY_WORLD_SID_AUTHORITY };

                PSID pWorld = 0;

                if (ptrAllocateAndInitializeSid(&worldAuth, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pWorld))

                    ptrBuildTrusteeWithSidW(&worldTrusteeW, pWorld);

                ptrFreeSid(pWorld);

            }

        }

        HINSTANCE userenvHnd = LoadLibraryW(L"userenv");

        if (userenvHnd)

            ptrGetUserProfileDirectoryW = (PtrGetUserProfileDirectoryW)GetProcAddress(userenvHnd, "GetUserProfileDirectoryW");

#endif

    }

}

#endif // QT_NO_LIBRARY

// UNC functions NT

typedef DWORD (WINAPI *PtrNetShareEnum)(LPWSTR, DWORD, LPBYTE*, DWORD, LPDWORD, LPDWORD, LPDWORD);

static PtrNetShareEnum ptrNetShareEnum = 0;

typedef DWORD (WINAPI *PtrNetApiBufferFree)(LPVOID);

static PtrNetApiBufferFree ptrNetApiBufferFree = 0;

typedef struct _SHARE_INFO_1 {

    LPWSTR shi1_netname;

    DWORD shi1_type;

    LPWSTR shi1_remark;

} SHARE_INFO_1;

bool QFSFileEnginePrivate::resolveUNCLibs()

{

    static bool triedResolve = false;

    if (!triedResolve) {

#ifndef QT_NO_THREAD

        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));

        if (triedResolve) {

            return ptrNetShareEnum && ptrNetApiBufferFree;

        }

#endif

        triedResolve = true;

#if !defined(Q_OS_WINCE)

        HINSTANCE hLib = LoadLibraryW(L"Netapi32");

        if (hLib) {

            ptrNetShareEnum = (PtrNetShareEnum)GetProcAddress(hLib, "NetShareEnum");

            if (ptrNetShareEnum)

                ptrNetApiBufferFree = (PtrNetApiBufferFree)GetProcAddress(hLib, "NetApiBufferFree");

        }

#endif

    }

    return ptrNetShareEnum && ptrNetApiBufferFree;

}

bool QFSFileEnginePrivate::uncListSharesOnServer(const QString &server, QStringList *list)

{

    if (resolveUNCLibs()) {

        SHARE_INFO_1 *BufPtr, *p;

        DWORD res;

        DWORD er = 0, tr = 0, resume = 0, i;

        do {

            res = ptrNetShareEnum((wchar_t*)server.utf16(), 1, (LPBYTE *)&BufPtr, DWORD(-1), &er, &tr, &resume);

            if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA) {

                p = BufPtr;

                for (i = 1; i <= er; ++i) {

                    if (list && p->shi1_type == 0)

                        list->append(QString::fromWCharArray(p->shi1_netname));

                    p++;

                }

            }

            ptrNetApiBufferFree(BufPtr);

        } while (res == ERROR_MORE_DATA);

        return res == ERROR_SUCCESS;

    }

    return false;

}

static bool isUncRoot(const QString &server)

{

    QString localPath = QDir::toNativeSeparators(server);

    if (!localPath.startsWith(QLatin1String("\\\\")))

        return false;

    int idx = localPath.indexOf(QLatin1Char('\\'), 2);

    if (idx == -1 || idx + 1 == localPath.length())

        return true;

    localPath = localPath.right(localPath.length() - idx - 1).trimmed();

    return localPath.isEmpty();

}

#if !defined(Q_OS_WINCE)

static inline bool isUncPath(const QString &path)

{

    // Starts with \\, but not \\.

    return (path.startsWith(QLatin1String("\\\\"))

            && path.size() > 2 && path.at(2) != QLatin1Char('.'));

}

#endif

static inline bool isRelativePath(const QString &path)

{

    // drive, e.g. "a:", or UNC root, e.q. "//"

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

           || (path.length() >= 2

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

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

}

static QString fixIfRelativeUncPath(const QString &path)

{

    if (isRelativePath(path)) {

        QString currentPath = QDir::currentPath() + QLatin1Char('/');

        if (currentPath.startsWith(QLatin1String("//")))

            return QString(path).prepend(currentPath);

    }

    return path;

}

// can be //server or //server/share

static bool uncShareExists(const QString &server)

{

    QStringList parts = server.split(QLatin1Char('\\'), QString::SkipEmptyParts);

    if (parts.count()) {

        QStringList shares;

        if (QFSFileEnginePrivate::uncListSharesOnServer(QLatin1String("\\\\") + parts.at(0), &shares))

            return parts.count() >= 2 ? shares.contains(parts.at(1), Qt::CaseInsensitive) : true;

    }

    return false;

}

static inline bool isDriveRoot(const QString &path)

{

    return (path.length() == 3

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

           && path.at(2) == QLatin1Char('/'));

}

static QString nativeAbsoluteFilePath(const QString &path)

{

    QString absPath;

#if !defined(Q_OS_WINCE)

    QVarLengthArray<wchar_t, MAX_PATH> buf(qMax(MAX_PATH, path.size() + 1));

    wchar_t *fileName = 0;

    DWORD retLen = GetFullPathName((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);

    if (retLen > (DWORD)buf.size()) {

        buf.resize(retLen);

        retLen = GetFullPathName((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);

    }

    if (retLen != 0)

        absPath = QString::fromWCharArray(buf.data(), retLen);

#else

    if (path.startsWith(QLatin1Char('/')) || path.startsWith(QLatin1Char('\\')))

        absPath = QDir::toNativeSeparators(path);

    else

        absPath = QDir::toNativeSeparators(QDir::cleanPath(qfsPrivateCurrentDir + QLatin1Char('/') + path));

#endif

    // This is really ugly, but GetFullPathName strips off whitespace at the end.

    // If you for instance write ". " in the lineedit of QFileDialog,

    // (which is an invalid filename) this function will strip the space off and viola,

    // the file is later reported as existing. Therefore, we re-add the whitespace that

    // was at the end of path in order to keep the filename invalid.

    if (!path.isEmpty() && path.at(path.size() - 1) == QLatin1Char(' '))

        absPath.append(QLatin1Char(' '));

    return absPath;

}

/*!

    \internal

*/

QString QFSFileEnginePrivate::longFileName(const QString &path)

{

    if (path.startsWith(QLatin1String("\\\\.\\")))

        return path;

    QString absPath = 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

}

/*

    \internal

*/

void QFSFileEnginePrivate::nativeInitFileName()

{

    QString path = longFileName(QDir::toNativeSeparators(fixIfRelativeUncPath(filePath)));

    nativeFilePath = QByteArray((const char *)path.utf16(), path.size() * 2 + 1);

}

/*

    \internal

*/

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

{

    Q_Q(QFSFileEngine);

    // All files are opened in share mode (both read and write).

    DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;

    int accessRights = 0;

    if (openMode & QIODevice::ReadOnly)

        accessRights |= GENERIC_READ;

    if (openMode & QIODevice::WriteOnly)

        accessRights |= GENERIC_WRITE;

    SECURITY_ATTRIBUTES securityAtts = { sizeof(SECURITY_ATTRIBUTES), NULL, FALSE };

    // WriteOnly can create files, ReadOnly cannot.

    DWORD creationDisp = (openMode & QIODevice::WriteOnly) ? OPEN_ALWAYS : OPEN_EXISTING;

    // Create the file handle.

    fileHandle = CreateFile((const wchar_t*)nativeFilePath.constData(),

                            accessRights,

                            shareMode,

                            &securityAtts,

                            creationDisp,

                            FILE_ATTRIBUTE_NORMAL,

                            NULL);

    // Bail out on error.

    if (fileHandle == INVALID_HANDLE_VALUE) {

        q->setError(QFile::OpenError, qt_error_string());

        return false;

    }

    // Truncate the file after successfully opening it if Truncate is passed.

    if (openMode & QIODevice::Truncate)

        q->setSize(0);

    return true;

}

/*

    \internal

*/

bool QFSFileEnginePrivate::nativeClose()

{

    Q_Q(QFSFileEngine);

    if (fh || fd != -1) {

        // stdlib / stdio mode.

        return closeFdFh();

    }

    // Windows native mode.

    bool ok = true;

    if ((fileHandle == INVALID_HANDLE_VALUE || !::CloseHandle(fileHandle))) {

        q->setError(QFile::UnspecifiedError, qt_error_string());

        ok = false;

    }

    fileHandle = INVALID_HANDLE_VALUE;

    cachedFd = -1;              // gets closed by CloseHandle above

    return ok;

}

/*

    \internal

*/

bool QFSFileEnginePrivate::nativeFlush()

{

    if (fh) {

        // Buffered stdlib mode.

        return flushFh();

    }

    if (fd != -1) {

        // Unbuffered stdio mode; always succeeds (no buffer).

        return true;

    }

    // Windows native mode; flushing is

    // unnecessary. FlushFileBuffers(), the equivalent of sync() or

    // fsync() on Unix, does a low-level flush to the disk, and we

    // don't expose an API for this.

    return true;

}

/*

    \internal

*/

qint64 QFSFileEnginePrivate::nativeSize() const

{

    Q_Q(const QFSFileEngine);

    QFSFileEngine *thatQ = const_cast<QFSFileEngine *>(q);

    // ### Don't flush; for buffered files, we should get away with ftell.

    thatQ->flush();

#if !defined(Q_OS_WINCE)

    // stdlib/stdio mode.

    if (fh || fd != -1) {

        qint64 fileSize = _filelengthi64(fh ? QT_FILENO(fh) : fd);

        if (fileSize == -1) {

            fileSize = 0;

            thatQ->setError(QFile::UnspecifiedError, qt_error_string(errno));

        }

        return fileSize;

    }

#else // Q_OS_WINCE

    // Buffered stdlib mode.

    if (fh) {

        QT_OFF_T oldPos = QT_FTELL(fh);

        QT_FSEEK(fh, 0, SEEK_END);

        qint64 fileSize = (qint64)QT_FTELL(fh);

        QT_FSEEK(fh, oldPos, SEEK_SET);

        if (fileSize == -1) {

            fileSize = 0;

            thatQ->setError(QFile::UnspecifiedError, qt_error_string(errno));

        }

        return fileSize;

    }

#endif

    // Not-open mode, where the file name is known: We'll check the

    // file system directly.