Make QFSFileEngine & QFileInfo use the new filesystemengine on Windows

QFSFileEngine now uses the QFileSystemEngine static functions to
implement most of the file system related quries. All the Win32 specific
code is now moved from the QFSFileEngine to QFileSystemEngine. This
implements all the fillMetaData and filename query functions. These new
functions behave exactly like their previous implementations in
QFSFileEngine. Following optimizations are done with this.

* GetFileAttributesEx() instead of GetFileAttibutes().
* GetFileInformationByHandle() instead of POSIX  functions.

Reviewed-by: Joao

6 files changed, 1211 insertions, 1002 deletions

diff --git a/src/corelib/io/qfilesystemengine_p.h b/src/corelib/io/qfilesystemengine_p.h
index 94a8175..1068e76 100644
--- a/src/corelib/io/qfilesystemengine_p.h
+++ b/src/corelib/io/qfilesystemengine_p.h
@@ -75,10 +75,24 @@ public:
     static QString bundleName(const QFileSystemEntry &entry);
 
     static bool fillMetaData(const QFileSystemEntry &entry, QFileSystemMetaData &data,
-            QFileSystemMetaData::MetaDataFlags what);
+                             QFileSystemMetaData::MetaDataFlags what);
 #if defined(Q_OS_UNIX)
     static bool fillMetaData(int fd, QFileSystemMetaData &data); // what = PosixStatFlags
 #endif
+#if defined(Q_OS_WIN)
+
+    static bool uncListSharesOnServer(const QString &server, QStringList *list); //Used also by QFSFileEngineIterator::hasNext()
+    static bool fillMetaData(int fd, QFileSystemMetaData &data,
+                             QFileSystemMetaData::MetaDataFlags what);
+    static bool fillMetaData(HANDLE fHandle, QFileSystemMetaData &data,
+                             QFileSystemMetaData::MetaDataFlags what);
+    static bool fillPermissions(const QFileSystemEntry &entry, QFileSystemMetaData &data,
+                                QFileSystemMetaData::MetaDataFlags what);
+    static QString homePath();
+    static QString rootPath();
+    static QString owner(const QFileSystemEntry &entry, QAbstractFileEngine::FileOwner own);
+    static QString nativeAbsoluteFilePath(const QString &path);
+#endif
 
     static bool createDirectory(const QFileSystemEntry &entry, bool createParents);
     static bool removeDirectory(const QFileSystemEntry &entry, bool removeEmptyParents);
@@ -90,12 +104,15 @@ public:
     static bool removeFile(const QFileSystemEntry &entry);
 
     static bool setPermissions(const QFileSystemEntry &entry, QFile::Permissions permissions,
-            QFileSystemMetaData *data = 0);
+                               QFileSystemMetaData *data = 0);
 
     static QAbstractFileEngine *resolveEntryAndCreateLegacyEngine(QFileSystemEntry &entry,
-            QFileSystemMetaData &data);
+                                                                  QFileSystemMetaData &data);
 private:
     static QString slowCanonicalized(const QString &path);
+#if defined(Q_OS_WIN)
+    static void clearWinStatData(QFileSystemMetaData &data);
+#endif
 };
 
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qfilesystemengine_win.cpp b/src/corelib/io/qfilesystemengine_win.cpp
index 28d5db4..550b522 100644
--- a/src/corelib/io/qfilesystemengine_win.cpp
+++ b/src/corelib/io/qfilesystemengine_win.cpp
@@ -41,29 +41,531 @@
 
 #include "qfilesystemengine_p.h"
 
+#define _POSIX_
+#include "qplatformdefs.h"
+#include "qabstractfileengine.h"
+#include "private/qfsfileengine_p.h"
+#include "qfilesystemengine_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
+#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
 
+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;
+typedef BOOL (WINAPI *PtrGetVolumePathNamesForVolumeNameW)(LPCWSTR,LPWSTR,DWORD,PDWORD);
+static PtrGetVolumePathNamesForVolumeNameW ptrGetVolumePathNamesForVolumeNameW = 0;
+QT_END_INCLUDE_NAMESPACE
+
+
+static void 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 = LoadLibrary(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 = LoadLibrary(L"userenv");
+        if (userenvHnd)
+            ptrGetUserProfileDirectoryW = (PtrGetUserProfileDirectoryW)GetProcAddress(userenvHnd, "GetUserProfileDirectoryW");
+        HINSTANCE kernel32 = LoadLibrary(L"kernel32");
+        if(kernel32)
+            ptrGetVolumePathNamesForVolumeNameW = (PtrGetVolumePathNamesForVolumeNameW)GetProcAddress(kernel32, "GetVolumePathNamesForVolumeNameW");
+#endif
+    }
+}
+#endif // QT_NO_LIBRARY
+
+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;
+
+
+static bool 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 = LoadLibrary(L"netapi32");
+        if (hLib) {
+            ptrNetShareEnum = (PtrNetShareEnum)GetProcAddress(hLib, "NetShareEnum");
+            if (ptrNetShareEnum)
+                ptrNetApiBufferFree = (PtrNetApiBufferFree)GetProcAddress(hLib, "NetApiBufferFree");
+        }
+#endif
+    }
+    return ptrNetShareEnum && ptrNetApiBufferFree;
+}
+
+static QString readSymLink(const QFileSystemEntry &link)
+{
+    QString result;
+#if !defined(Q_OS_WINCE)
+    HANDLE handle = CreateFile((wchar_t*)link.nativeFilePath().utf16(),
+                               FILE_READ_EA,
+                               FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                               0,
+                               OPEN_EXISTING,
+                               FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+                               0);
+    if (handle != INVALID_HANDLE_VALUE) {
+        DWORD bufsize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
+        REPARSE_DATA_BUFFER *rdb = (REPARSE_DATA_BUFFER*)qMalloc(bufsize);
+        DWORD retsize = 0;
+        if (::DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, 0, 0, rdb, bufsize, &retsize, 0)) {
+            if (rdb->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) {
+                int length = rdb->MountPointReparseBuffer.SubstituteNameLength / sizeof(wchar_t);
+                int offset = rdb->MountPointReparseBuffer.SubstituteNameOffset / sizeof(wchar_t);
+                const wchar_t* PathBuffer = &rdb->MountPointReparseBuffer.PathBuffer[offset];
+                result = QString::fromWCharArray(PathBuffer, length);
+            } else if (rdb->ReparseTag == IO_REPARSE_TAG_SYMLINK) {
+                int length = rdb->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(wchar_t);
+                int offset = rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t);
+                const wchar_t* PathBuffer = &rdb->SymbolicLinkReparseBuffer.PathBuffer[offset];
+                result = QString::fromWCharArray(PathBuffer, length);
+            }
+            // cut-off "//?/" and "/??/"
+            if (result.size() > 4 && result.at(0) == QLatin1Char('\\') && result.at(2) == QLatin1Char('?') && result.at(3) == QLatin1Char('\\'))
+                result = result.mid(4);
+        }
+        qFree(rdb);
+        CloseHandle(handle);
+
+#if !defined(QT_NO_LIBRARY)
+        resolveLibs();
+        if (ptrGetVolumePathNamesForVolumeNameW) {
+            QRegExp matchVolName(QLatin1String("^Volume\\{([a-z]|[0-9]|-)+\\}\\\\"), Qt::CaseInsensitive);
+            if(matchVolName.indexIn(result) == 0) {
+                DWORD len;
+                wchar_t buffer[MAX_PATH];
+                QString volumeName = result.mid(0, matchVolName.matchedLength()).prepend(QLatin1String("\\\\?\\"));
+                if(ptrGetVolumePathNamesForVolumeNameW((wchar_t*)volumeName.utf16(), buffer, MAX_PATH, &len) != 0)
+                    result.replace(0,matchVolName.matchedLength(), QString::fromWCharArray(buffer));
+            }
+        }
+#endif
+    }
+#else
+    Q_UNUSED(link);
+#endif // Q_OS_WINCE
+    return result;
+}
+
+static QString readLink(const QFileSystemEntry &link)
+{
+#if !defined(Q_OS_WINCE)
+#if !defined(QT_NO_LIBRARY) && !defined(Q_CC_MWERKS)
+    QString ret;
+
+    bool neededCoInit = false;
+    IShellLink *psl;                            // pointer to IShellLink i/f
+    WIN32_FIND_DATA wfd;
+    wchar_t szGotPath[MAX_PATH];
+
+    // Get pointer to the IShellLink interface.
+    HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID *)&psl);
+
+    if (hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+        neededCoInit = true;
+        CoInitialize(NULL);
+        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                                    IID_IShellLink, (LPVOID *)&psl);
+    }
+    if (SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
+        IPersistFile *ppf;
+        hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
+        if (SUCCEEDED(hres))  {
+            hres = ppf->Load((LPOLESTR)link.nativeFilePath().utf16(), STGM_READ);
+            //The original path of the link is retrieved. If the file/folder
+            //was moved, the return value still have the old path.
+            if (SUCCEEDED(hres)) {
+                if (psl->GetPath(szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
+                    ret = QString::fromWCharArray(szGotPath);
+            }
+            ppf->Release();
+        }
+        psl->Release();
+    }
+    if (neededCoInit)
+        CoUninitialize();
+
+    return ret;
+#else
+    Q_UNUSED(link);
+    return QString();
+#endif // QT_NO_LIBRARY
+#else
+    wchar_t target[MAX_PATH];
+    QString result;
+    if (SHGetShortcutTarget((wchar_t*)QFileInfo(link.filePath()).absoluteFilePath().replace(QLatin1Char('/'),QLatin1Char('\\')).utf16(), target, MAX_PATH)) {
+        result = QString::fromWCharArray(target);
+        if (result.startsWith(QLatin1Char('"')))
+            result.remove(0,1);
+        if (result.endsWith(QLatin1Char('"')))
+            result.remove(result.size()-1,1);
+    }
+    return result;
+#endif // Q_OS_WINCE
+}
+
+static bool uncShareExists(const QString &server)
+{
+    // This code asumes the UNC path is always like \\?\UNC\server...
+    QStringList parts = server.split(QLatin1Char('\\'), QString::SkipEmptyParts);
+    if (parts.count() >= 3) {
+        QStringList shares;
+        if (QFileSystemEngine::uncListSharesOnServer(QLatin1String("\\\\") + parts.at(2), &shares))
+            return parts.count() >= 4 ? shares.contains(parts.at(3), Qt::CaseInsensitive) : true;
+    }
+    return false;
+}
+
+static inline bool getFindData(QString path, WIN32_FIND_DATA &findData)
+{
+    // path should not end with a trailing slash
+    while (path.endsWith(QLatin1Char('\\')))
+        path.chop(1);
+
+    // can't handle drives
+    if (!path.endsWith(QLatin1Char(':'))) {
+        HANDLE hFind = ::FindFirstFile((wchar_t*)path.utf16(), &findData);
+        if (hFind != INVALID_HANDLE_VALUE) {
+            ::FindClose(hFind);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool QFileSystemEngine::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;
+}
+
+void QFileSystemMetaData::fillFromFileAttribute(DWORD fileAttribute,bool isDriveRoot)
+{
+    fileAttribute_ = fileAttribute;
+    // Ignore the hidden attribute for drives.
+    if (!isDriveRoot && (fileAttribute_ & FILE_ATTRIBUTE_HIDDEN))
+        entryFlags |= HiddenAttribute;
+    entryFlags |= ((fileAttribute & FILE_ATTRIBUTE_DIRECTORY) ? DirectoryType: FileType);
+    entryFlags |= ExistsAttribute;
+    knownFlagsMask |= FileType | DirectoryType | HiddenAttribute | ExistsAttribute;
+}
+
+void QFileSystemMetaData::fillFromFindData(WIN32_FIND_DATA &findData, bool setLinkType, bool isDriveRoot)
+{
+    fillFromFileAttribute(findData.dwFileAttributes, isDriveRoot);
+    creationTime_ = findData.ftCreationTime;
+    lastAccessTime_ = findData.ftLastAccessTime;
+    lastWriteTime_ = findData.ftLastWriteTime;
+    size_ = findData.nFileSizeHigh;
+    size_ <<= 32;
+    size_ += findData.nFileSizeLow;
+    knownFlagsMask |=  Times | SizeAttribute;
+    if (setLinkType) {
+        knownFlagsMask |=  LinkType;
+        entryFlags &= ~LinkType;
+        if ((fileAttribute_ & FILE_ATTRIBUTE_REPARSE_POINT)
+            && (findData.dwReserved0 == IO_REPARSE_TAG_SYMLINK
+                || findData.dwReserved0 == IO_REPARSE_TAG_MOUNT_POINT)) {
+            entryFlags |= LinkType;
+        }
+
+    }
+}
+
+void QFileSystemMetaData::fillFromFindInfo(BY_HANDLE_FILE_INFORMATION &fileInfo)
+{
+    fillFromFileAttribute(fileInfo.dwFileAttributes);
+    creationTime_ = fileInfo.ftCreationTime;
+    lastAccessTime_ = fileInfo.ftLastAccessTime;
+    lastWriteTime_ = fileInfo.ftLastWriteTime;
+    size_ = fileInfo.nFileSizeHigh;
+    size_ <<= 32;
+    size_ += fileInfo.nFileSizeLow;
+    knownFlagsMask |=  Times | SizeAttribute;
+}
+
+void QFileSystemEngine::clearWinStatData(QFileSystemMetaData &data)
+{
+    data.size_ = -1;
+    data.fileAttribute_ =  0;
+}
+
 bool QFileSystemEngine::isCaseSensitive()
 {
     return false;
 }
 
 //static
-QFileSystemEntry QFileSystemEngine::getLinkTarget(const QFileSystemEntry &link, QFileSystemMetaData &data)
+QFileSystemEntry QFileSystemEngine::getLinkTarget(const QFileSystemEntry &link,
+                                                  QFileSystemMetaData &data)
 {
-    return link; // TODO implement
+   if (data.missingFlags(QFileSystemMetaData::LinkType))
+       QFileSystemEngine::fillMetaData(link, data, QFileSystemMetaData::LinkType);
+
+    QString ret;
+    if (data.isLnkFile())
+        ret = readLink(link);
+    else if (data.isLink())
+        ret = readSymLink(link);
+    return QFileSystemEntry(QDir::fromNativeSeparators(ret));
 }
 
 //static
 QFileSystemEntry QFileSystemEngine::canonicalName(const QFileSystemEntry &entry)
 {
-    return QFileSystemEntry(slowCanonicalized(entry.filePath()));
+    // The caller has to verify whether the file exists or not.
+    return QFileSystemEntry(slowCanonicalized(absoluteName(entry).filePath()));
+}
+
+//static
+QString QFileSystemEngine::nativeAbsoluteFilePath(const QString &path)
+{
+    // can be //server or //server/share
+    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;
 }
 
 //static
 QFileSystemEntry QFileSystemEngine::absoluteName(const QFileSystemEntry &entry)
 {
-    return entry; // TODO implement;
+    QString ret;
+
+    if (!entry.isRelative()) {
+#if !defined(Q_OS_WINCE)
+        if (entry.filePath().startsWith(QLatin1Char('/')) || // It's a absolute path to the current drive, so \a.txt -> Z:\a.txt
+            entry.filePath().size() == 2 ||                  // It's a drive letter that needs to get a working dir appended
+            (entry.filePath().size() > 2 && entry.filePath().at(2) != QLatin1Char('/')) || // It's a drive-relative path, so Z:a.txt -> Z:\currentpath\a.txt
+            entry.filePath().contains(QLatin1String("/../")) || entry.filePath().contains(QLatin1String("/./")) ||
+            entry.filePath().endsWith(QLatin1String("/..")) || entry.filePath().endsWith(QLatin1String("/.")))
+        {
+            ret = QDir::fromNativeSeparators(nativeAbsoluteFilePath(entry.filePath()));
+        } else
+#endif
+        {
+            ret = entry.filePath();
+        }
+    } else {
+        ret = QDir::cleanPath(QDir::currentPath() + QLatin1Char('/') + entry.filePath());
+    }
+
+    // The path should be absolute at this point.
+    // From the docs :
+    // Absolute paths begin with the directory separator "/"
+    // (optionally preceded by a drive specification under Windows).
+    if (ret.at(0) != QLatin1Char('/')) {
+        Q_ASSERT(ret.length() >= 2);
+        Q_ASSERT(ret.at(0).isLetter());
+        Q_ASSERT(ret.at(1) == QLatin1Char(':'));
+
+        // Force uppercase drive letters.
+        ret[0] = ret.at(0).toUpper();
+    }
+    return QFileSystemEntry(ret);
 }
 
 //static
@@ -81,25 +583,506 @@ QString QFileSystemEngine::resolveGroupName(uint groupId)
 //static
 QString QFileSystemEngine::bundleName(const QFileSystemEntry &entry)
 {
+    Q_UNUSED(entry);
     return QString();
 }
 
 //static
-bool QFileSystemEngine::fillMetaData(const QFileSystemEntry &entry, QFileSystemMetaData &data, QFileSystemMetaData::MetaDataFlags what)
+QString QFileSystemEngine::owner(const QFileSystemEntry &entry, QAbstractFileEngine::FileOwner own)
 {
-    return false; // TODO implement;
+    QString name;
+#if !defined(QT_NO_LIBRARY)
+    extern int qt_ntfs_permission_lookup;
+    if((qt_ntfs_permission_lookup > 0) && (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)) {
+        resolveLibs();
+        if (ptrGetNamedSecurityInfoW && ptrLookupAccountSidW) {
+            PSID pOwner = 0;
+            PSECURITY_DESCRIPTOR pSD;
+            if (ptrGetNamedSecurityInfoW((wchar_t*)entry.nativeFilePath().utf16(), SE_FILE_OBJECT,
+                                         own == QAbstractFileEngine::OwnerGroup ? GROUP_SECURITY_INFORMATION : OWNER_SECURITY_INFORMATION,
+                                         own == QAbstractFileEngine::OwnerUser ? &pOwner : 0, own == QAbstractFileEngine::OwnerGroup ? &pOwner : 0,
+                                         0, 0, &pSD) == ERROR_SUCCESS) {
+                DWORD lowner = 64;
+                DWORD ldomain = 64;
+                QVarLengthArray<wchar_t, 64> owner(lowner);
+                QVarLengthArray<wchar_t, 64> domain(ldomain);
+                SID_NAME_USE use = SidTypeUnknown;
+                // First call, to determine size of the strings (with '\0').
+                if (!ptrLookupAccountSidW(NULL, pOwner, (LPWSTR)owner.data(), &lowner,
+                                          (LPWSTR)domain.data(), &ldomain, (SID_NAME_USE*)&use)) {
+                    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                        if (lowner > (DWORD)owner.size())
+                            owner.resize(lowner);
+                        if (ldomain > (DWORD)domain.size())
+                            domain.resize(ldomain);
+                        // Second call, try on resized buf-s
+                        if (!ptrLookupAccountSidW(NULL, pOwner, (LPWSTR)owner.data(), &lowner,
+                                                  (LPWSTR)domain.data(), &ldomain, (SID_NAME_USE*)&use)) {
+                            lowner = 0;
+                        }
+                    } else {
+                        lowner = 0;
+                    }
+                }
+                if (lowner != 0)
+                    name = QString::fromWCharArray(owner.data());
+                LocalFree(pSD);
+            }
+        }
+    }
+#else
+    Q_UNUSED(own);
+#endif
+    return name;
+}
+
+//static
+bool QFileSystemEngine::fillPermissions(const QFileSystemEntry &entry, QFileSystemMetaData &data,
+                                        QFileSystemMetaData::MetaDataFlags what)
+{
+    QAbstractFileEngine::FileFlags ret = 0;
+
+#if !defined(QT_NO_LIBRARY)
+    if((qt_ntfs_permission_lookup > 0) && (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)) {
+        resolveLibs();
+        if(ptrGetNamedSecurityInfoW && ptrBuildTrusteeWithSidW && ptrGetEffectiveRightsFromAclW) {
+            enum { ReadMask = 0x00000001, WriteMask = 0x00000002, ExecMask = 0x00000020 };
+
+            QString fname = entry.filePath();
+            PSID pOwner = 0;
+            PSID pGroup = 0;
+            PACL pDacl;
+            PSECURITY_DESCRIPTOR pSD;
+            DWORD res = ptrGetNamedSecurityInfoW((wchar_t*)fname.utf16(), SE_FILE_OBJECT,
+                                                 OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
+                                                 &pOwner, &pGroup, &pDacl, 0, &pSD);
+            if(res == ERROR_SUCCESS) {
+                ACCESS_MASK access_mask;
+                TRUSTEE_W trustee;
+                if (what & QFileSystemMetaData::UserPermissions) { // user
+                    data.knownFlagsMask |= QFileSystemMetaData::UserPermissions;
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &currentUserTrusteeW, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1;
+                    if(access_mask & ReadMask)
+                        data.entryFlags |= QFileSystemMetaData::UserReadPermission;
+                    if(access_mask & WriteMask)
+                        data.entryFlags|= QFileSystemMetaData::UserWritePermission;
+                    if(access_mask & ExecMask)
+                        data.entryFlags|= QFileSystemMetaData::UserExecutePermission;
+                }
+                if (what & QFileSystemMetaData::OwnerPermissions) { // owner
+                    data.knownFlagsMask |= QFileSystemMetaData::OwnerPermissions;
+                    ptrBuildTrusteeWithSidW(&trustee, pOwner);
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1;
+                    if(access_mask & ReadMask)
+                        data.entryFlags |= QFileSystemMetaData::OwnerReadPermission;
+                    if(access_mask & WriteMask)
+                        data.entryFlags |= QFileSystemMetaData::OwnerWritePermission;
+                    if(access_mask & ExecMask)
+                        data.entryFlags |= QFileSystemMetaData::OwnerExecutePermission;
+                }
+                if (what & QFileSystemMetaData::GroupPermissions) { // group
+                    data.knownFlagsMask |= QFileSystemMetaData::GroupPermissions;
+                    ptrBuildTrusteeWithSidW(&trustee, pGroup);
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1;
+                    if(access_mask & ReadMask)
+                        data.entryFlags |= QFileSystemMetaData::GroupReadPermission;
+                    if(access_mask & WriteMask)
+                        data.entryFlags |= QFileSystemMetaData::GroupWritePermission;
+                    if(access_mask & ExecMask)
+                        data.entryFlags |= QFileSystemMetaData::GroupExecutePermission;
+                }
+                if (what & QFileSystemMetaData::OtherPermissions) { // other (world)
+                    data.knownFlagsMask |= QFileSystemMetaData::OtherPermissions;
+                    if(ptrGetEffectiveRightsFromAclW(pDacl, &worldTrusteeW, &access_mask) != ERROR_SUCCESS)
+                        access_mask = (ACCESS_MASK)-1; // ###
+                    if(access_mask & ReadMask)
+                        data.entryFlags |= QFileSystemMetaData::OtherReadPermission;
+                    if(access_mask & WriteMask)
+                        data.entryFlags |= QFileSystemMetaData::OtherWritePermission;
+                    if(access_mask & ExecMask)
+                        data.entryFlags |= QFileSystemMetaData::OwnerExecutePermission;
+                }
+                LocalFree(pSD);
+            }
+        }
+    } else
+#endif
+    {
+        //### what to do with permissions if we don't use NTFS
+        // for now just add all permissions and what about exe missions ??
+        // also qt_ntfs_permission_lookup is now not set by default ... should it ?
+        data.entryFlags |= QFileSystemMetaData::OwnerReadPermission
+                           | QFileSystemMetaData::GroupReadPermission
+                           | QFileSystemMetaData::OtherReadPermission;
+
+        if (!(data.fileAttribute_ & FILE_ATTRIBUTE_READONLY)) {
+            data.entryFlags |= QFileSystemMetaData::OwnerWritePermission
+                   | QFileSystemMetaData::GroupWritePermission
+                   | QFileSystemMetaData::OtherWritePermission;
+        }
+
+        QString fname = entry.filePath();
+        QString ext = fname.right(4).toLower();
+        if (data.isDirectory() ||
+            ext == QLatin1String(".exe") || ext == QLatin1String(".com") || ext == QLatin1String(".bat") ||
+            ext == QLatin1String(".pif") || ext == QLatin1String(".cmd")) {
+            data.entryFlags |= QFileSystemMetaData::OwnerExecutePermission | QFileSystemMetaData::GroupExecutePermission
+                               | QFileSystemMetaData::OtherExecutePermission | QFileSystemMetaData::UserExecutePermission;
+        }
+        data.knownFlagsMask |= QFileSystemMetaData::OwnerPermissions | QFileSystemMetaData::GroupPermissions
+                                | QFileSystemMetaData::OtherPermissions | QFileSystemMetaData::UserExecutePermission;
+        // calculate user permissions
+        if (what & QFileSystemMetaData::UserReadPermission) {
+            if (::_waccess((wchar_t*)entry.nativeFilePath().utf16(), R_OK) == 0)
+                data.entryFlags |= QFileSystemMetaData::UserReadPermission;
+            data.knownFlagsMask |= QFileSystemMetaData::UserReadPermission;
+        }
+        if (what & QFileSystemMetaData::UserWritePermission) {
+            if (::_waccess((wchar_t*)entry.nativeFilePath().utf16(), W_OK) == 0)
+                data.entryFlags |= QFileSystemMetaData::UserWritePermission;
+            data.knownFlagsMask |= QFileSystemMetaData::UserReadPermission;
+        }
+    }
+
+    return data.hasFlags(what);
+}
+
+static bool tryDriveUNCFallback(const QFileSystemEntry &fname, QFileSystemMetaData &data)
+{
+    bool entryExists = false;
+    DWORD fileAttrib = 0;
+#if !defined(Q_OS_WINCE)
+    if (fname.isDriveRoot()) {
+        // a valid drive ??
+        DWORD drivesBitmask = ::GetLogicalDrives();
+        int drivebit = 1 << (fname.filePath().at(0).toUpper().unicode() - QLatin1Char('A').unicode());
+        if (drivesBitmask & drivebit) {
+            fileAttrib = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM;
+            entryExists = true;
+        }
+    } else {
+#endif
+        const QString &path = fname.nativeFilePath();
+        bool is_dir = false;
+        if (path.startsWith(QLatin1String("\\\\?\\UNC"))) {
+            // UNC - stat doesn't work for all cases (Windows bug)
+            int s = path.indexOf(path.at(0),7);
+            if (s > 0) {
+                // "\\?\UNC\server\..."
+                s = path.indexOf(path.at(0),s+1);
+                if (s > 0) {
+                    // "\\?\UNC\server\share\..."
+                    if (s == path.size() - 1) {
+                        // "\\?\UNC\server\share\"
+                        is_dir = true;
+                    } else {
+                        // "\\?\UNC\server\share\notfound"
+                    }
+                } else {
+                    // "\\?\UNC\server\share"
+                    is_dir = true;
+                }
+            } else {
+                // "\\?\UNC\server"
+                is_dir = true;
+            }
+        }
+        if (is_dir && uncShareExists(path)) {
+            // looks like a UNC dir, is a dir.
+            fileAttrib = FILE_ATTRIBUTE_DIRECTORY;
+            entryExists = true;
+        }
+#if !defined(Q_OS_WINCE)
+    }
+#endif
+    if (entryExists)
+        data.fillFromFileAttribute(fileAttrib);
+    return entryExists;
+}
+
+static bool tryFindFallback(const QFileSystemEntry &fname, QFileSystemMetaData &data)
+{
+    bool filledData = false;
+    // This assumes the last call to a Windows API failed.
+    int errorCode = GetLastError();
+    if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {
+        WIN32_FIND_DATA findData;
+        if (getFindData(fname.nativeFilePath(), findData)
+            && findData.dwFileAttributes != INVALID_FILE_ATTRIBUTES) {
+            data.fillFromFindData(findData, true, fname.isDriveRoot());
+            filledData = true;
+        }
+    }
+    return filledData;
+}
+
+#if !defined(Q_OS_WINCE)
+//static
+bool QFileSystemEngine::fillMetaData(int fd, QFileSystemMetaData &data,
+                                     QFileSystemMetaData::MetaDataFlags what)
+{
+    HANDLE fHandle = (HANDLE)_get_osfhandle(fd);
+    if (fHandle  != INVALID_HANDLE_VALUE) {
+        return fillMetaData(fHandle, data, what);
+    }
+    return false;
+}
+#endif
+
+//static
+bool QFileSystemEngine::fillMetaData(HANDLE fHandle, QFileSystemMetaData &data,
+                                     QFileSystemMetaData::MetaDataFlags what)
+{
+    data.entryFlags &= ~what;
+    clearWinStatData(data);
+    BY_HANDLE_FILE_INFORMATION fileInfo;
+    UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
+    if (GetFileInformationByHandle(fHandle , &fileInfo)) {
+        data.fillFromFindInfo(fileInfo);
+    }
+    SetErrorMode(oldmode);
+    return data.hasFlags(what);
+}
+
+//static
+bool QFileSystemEngine::fillMetaData(const QFileSystemEntry &entry, QFileSystemMetaData &data,
+                                     QFileSystemMetaData::MetaDataFlags what)
+{
+    what |= QFileSystemMetaData::WinLnkType | QFileSystemMetaData::WinStatFlags;
+    data.entryFlags &= ~what;
+
+    QFileSystemEntry fname;
+    data.knownFlagsMask |= QFileSystemMetaData::WinLnkType;
+    if(entry.filePath().endsWith(QLatin1String(".lnk"))) {
+        data.entryFlags |= QFileSystemMetaData::WinLnkType;
+        fname = QFileSystemEntry(readLink(entry));
+    } else {
+        fname = entry;
+    }
+
+    if (fname.isEmpty()) {
+        data.knownFlagsMask |= what;
+        clearWinStatData(data);
+        return false;
+    }
+
+    if (what & QFileSystemMetaData::WinStatFlags) {
+        UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
+        clearWinStatData(data);
+        WIN32_FIND_DATA findData;
+        // The memory structure for WIN32_FIND_DATA is same as WIN32_FILE_ATTRIBUTE_DATA
+        // for all members used by fillFindData().
+        bool ok = ::GetFileAttributesEx((wchar_t*)fname.nativeFilePath().utf16(), GetFileExInfoStandard,
+                                        reinterpret_cast<WIN32_FILE_ATTRIBUTE_DATA *>(&findData));
+        if (ok) {
+            data.fillFromFindData(findData, false, fname.isDriveRoot());
+        } else {
+            if (!tryFindFallback(fname, data))
+                tryDriveUNCFallback(fname, data);
+        }
+        SetErrorMode(oldmode);
+    }
+
+    if (what & QFileSystemMetaData::Permissions)
+        fillPermissions(fname, data, what);
+    if ((what & QFileSystemMetaData::LinkType)
+        && data.missingFlags(QFileSystemMetaData::LinkType)) {
+        data.knownFlagsMask |= QFileSystemMetaData::LinkType;
+        if (data.fileAttribute_ & FILE_ATTRIBUTE_REPARSE_POINT) {
+            WIN32_FIND_DATA findData;
+            if (getFindData(fname.nativeFilePath(), findData))
+                data.fillFromFindData(findData, true);
+        }
+    }
+    data.knownFlagsMask |= what;
+    return data.hasFlags(what);
+}
+
+static inline bool mkDir(const QString &path)
+{
+#if defined(Q_OS_WINCE)
+    // Unfortunately CreateDirectory returns true for paths longer than
+    // 256, but does not create a directory. It starts to fail, when
+    // path length > MAX_PATH, which is 260 usually on CE.
+    // This only happens on a Windows Mobile device. Windows CE seems
+    // not to be affected by this.
+    static int platformId = 0;
+    if (platformId == 0) {
+        wchar_t platformString[64];
+        if (SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(platformString)/sizeof(*platformString),platformString,0)) {
+            if (0 == wcscmp(platformString, L"PocketPC") || 0 == wcscmp(platformString, L"Smartphone"))
+                platformId = 1;
+            else
+                platformId = 2;
+        }
+    }
+    if (platformId == 1 && QFSFileEnginePrivate::longFileName(path).size() > 256)
+        return false;
+#endif
+    return ::CreateDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16(), 0);
+}
+
+static inline bool rmDir(const QString &path)
+{
+    return ::RemoveDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());
+}
+
+static bool isDirPath(const QString &dirPath, bool *existed)
+{
+    QString path = dirPath;
+    if (path.length() == 2 && path.at(1) == QLatin1Char(':'))
+        path += QLatin1Char('\\');
+
+    DWORD fileAttrib = ::GetFileAttributes((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());
+    if (fileAttrib == INVALID_FILE_ATTRIBUTES) {
+        int errorCode = GetLastError();
+        if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {
+            WIN32_FIND_DATA findData;
+            if (getFindData(QFSFileEnginePrivate::longFileName(path), findData))
+                fileAttrib = findData.dwFileAttributes;
+        }
+    }
+
+    if (existed)
+        *existed = fileAttrib != INVALID_FILE_ATTRIBUTES;
+
+    if (fileAttrib == INVALID_FILE_ATTRIBUTES)
+        return false;
+
+    return fileAttrib & FILE_ATTRIBUTE_DIRECTORY;
 }
 
 //static
 bool QFileSystemEngine::createDirectory(const QFileSystemEntry &entry, bool createParents)
 {
-    return false; // TODO implement;
+    QString dirName = entry.filePath();
+    if (createParents) {
+        dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));
+        // We spefically search for / so \ would break it..
+        int oldslash = -1;
+        if (dirName.startsWith(QLatin1String("\\\\"))) {
+            // Don't try to create the root path of a UNC path;
+            // CreateDirectory() will just return ERROR_INVALID_NAME.
+            for (int i = 0; i < dirName.size(); ++i) {
+                if (dirName.at(i) != QDir::separator()) {
+                    oldslash = i;
+                    break;
+                }
+            }
+            if (oldslash != -1)
+                oldslash = dirName.indexOf(QDir::separator(), oldslash);
+        }
+        for (int 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) {
+                QString chunk = dirName.left(slash);
+                bool existed = false;
+                if (!isDirPath(chunk, &existed)) {
+                    if (!existed) {
+                        if (!mkDir(chunk))
+                            return false;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    return mkDir(entry.filePath());
 }
 
 //static
 bool QFileSystemEngine::removeDirectory(const QFileSystemEntry &entry, bool removeEmptyParents)
 {
-    return false; // TODO implement;
+    QString dirName = entry.filePath();
+    if (removeEmptyParents) {
+        dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));
+        for (int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {
+            QString chunk = dirName.left(slash);
+            if (chunk.length() == 2 && chunk.at(0).isLetter() && chunk.at(1) == QLatin1Char(':'))
+                break;
+            if (!isDirPath(chunk, 0))
+                return false;
+            if (!rmDir(chunk))
+                return oldslash != 0;
+            slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);
+        }
+        return true;
+    }
+    return rmDir(entry.filePath());
+}
+
+//static
+QString QFileSystemEngine::rootPath()
+{
+#if defined(Q_OS_WINCE)
+    QString ret = QLatin1String("/");
+#elif defined(Q_FS_FAT)
+    QString ret = QString::fromLatin1(qgetenv("SystemDrive").constData());
+    if (ret.isEmpty())
+        ret = QLatin1String("c:");
+    ret.append(QLatin1Char('/'));
+#elif defined(Q_OS_OS2EMX)
+    char dir[4];
+    _abspath(dir, QLatin1String("/"), _MAX_PATH);
+    QString ret(dir);
+#endif
+    return ret;
+}
+
+//static
+QString QFileSystemEngine::homePath()
+{
+    QString ret;
+#if !defined(QT_NO_LIBRARY)
+    resolveLibs();
+    if (ptrGetUserProfileDirectoryW) {
+        HANDLE hnd = ::GetCurrentProcess();
+        HANDLE token = 0;
+        BOOL ok = ::OpenProcessToken(hnd, TOKEN_QUERY, &token);
+        if (ok) {
+            DWORD dwBufferSize = 0;
+            // First call, to determine size of the strings (with '\0').
+            ok = ptrGetUserProfileDirectoryW(token, NULL, &dwBufferSize);
+            if (!ok && dwBufferSize != 0) {        // We got the required buffer size
+                wchar_t *userDirectory = new wchar_t[dwBufferSize];
+                // Second call, now we can fill the allocated buffer.
+                ok = ptrGetUserProfileDirectoryW(token, userDirectory, &dwBufferSize);
+                if (ok)
+                    ret = QString::fromWCharArray(userDirectory);
+                delete [] userDirectory;
+            }
+            ::CloseHandle(token);
+        }
+    }
+#endif
+    if (ret.isEmpty() || !QFile::exists(ret)) {
+        ret = QString::fromLocal8Bit(qgetenv("USERPROFILE").constData());
+        if (ret.isEmpty() || !QFile::exists(ret)) {
+            ret = QString::fromLocal8Bit(qgetenv("HOMEDRIVE").constData())
+                  + QString::fromLocal8Bit(qgetenv("HOMEPATH").constData());
+            if (ret.isEmpty() || !QFile::exists(ret)) {
+                ret = QString::fromLocal8Bit(qgetenv("HOME").constData());
+                if (ret.isEmpty() || !QFile::exists(ret)) {
+#if defined(Q_OS_WINCE)
+                    ret = QLatin1String("\\My Documents");
+                    if (!QFile::exists(ret))
+#endif
+                        ret = rootPath();
+                }
+            }
+        }
+    }
+    return QDir::fromNativeSeparators(ret);
 }
 
 //static
@@ -111,25 +1094,90 @@ bool QFileSystemEngine::createLink(const QFileSystemEntry &source, const QFileSy
 //static
 bool QFileSystemEngine::copyFile(const QFileSystemEntry &source, const QFileSystemEntry &target)
 {
-    return false; // TODO implement;
+    bool ret = ::CopyFile((wchar_t*)source.nativeFilePath().utf16(),
+                          (wchar_t*)target.nativeFilePath().utf16(), true) != 0;
+    return ret;
 }
 
 //static
 bool QFileSystemEngine::renameFile(const QFileSystemEntry &source, const QFileSystemEntry &target)
 {
-    return false; // TODO implement;
+    bool ret = ::MoveFile((wchar_t*)source.nativeFilePath().utf16(),
+                          (wchar_t*)target.nativeFilePath().utf16()) != 0;
+    return ret;
 }
 
 //static
 bool QFileSystemEngine::removeFile(const QFileSystemEntry &entry)
 {
-    return false; // TODO implement;
+    bool ret = ::DeleteFile((wchar_t*)entry.nativeFilePath().utf16()) != 0;
+    return ret;
 }
 
 //static
-bool QFileSystemEngine::setPermissions(const QFileSystemEntry &entry, QFile::Permissions permissions, QFileSystemMetaData *data)
+bool QFileSystemEngine::setPermissions(const QFileSystemEntry &entry, QFile::Permissions permissions,
+                                       QFileSystemMetaData *data)
 {
-    return false; // TODO implement;
+    Q_UNUSED(data);
+    int mode = 0;
+
+    if (permissions & QFile::ReadOwner || permissions & QFile::ReadUser
+        || permissions & QFile::ReadGroup || permissions & QFile::ReadOther)
+        mode |= _S_IREAD;
+    if (permissions & QFile::WriteOwner || permissions & QFile::WriteUser
+        || permissions & QFile::WriteGroup || permissions & QFile::WriteOther)
+        mode |= _S_IWRITE;
+
+    if (mode == 0) // not supported
+        return false;
+
+    return ::_wchmod((wchar_t*)entry.nativeFilePath().utf16(), mode) == 0;
+}
+
+static inline QDateTime fileTimeToQDateTime(const FILETIME *time)
+{
+    QDateTime ret;
+
+#if defined(Q_OS_WINCE)
+    SYSTEMTIME systime;
+    FILETIME ftime;
+    systime.wYear = 1970;
+    systime.wMonth = 1;
+    systime.wDay = 1;
+    systime.wHour = 0;
+    systime.wMinute = 0;
+    systime.wSecond = 0;
+    systime.wMilliseconds = 0;
+    systime.wDayOfWeek = 4;
+    SystemTimeToFileTime(&systime, &ftime);
+    unsigned __int64 acttime = (unsigned __int64)time->dwHighDateTime << 32 | time->dwLowDateTime;
+    FileTimeToSystemTime(time, &systime);
+    unsigned __int64 time1970 = (unsigned __int64)ftime.dwHighDateTime << 32 | ftime.dwLowDateTime;
+    unsigned __int64 difftime = acttime - time1970;
+    difftime /= 10000000;
+    ret.setTime_t((unsigned int)difftime);
+#else
+    SYSTEMTIME sTime, lTime;
+    FileTimeToSystemTime(time, &sTime);
+    SystemTimeToTzSpecificLocalTime(0, &sTime, &lTime);
+    ret.setDate(QDate(lTime.wYear, lTime.wMonth, lTime.wDay));
+    ret.setTime(QTime(lTime.wHour, lTime.wMinute, lTime.wSecond, lTime.wMilliseconds));
+#endif
+
+    return ret;
+}
+
+QDateTime QFileSystemMetaData::creationTime() const
+{
+    return fileTimeToQDateTime(&creationTime_);
+}
+QDateTime QFileSystemMetaData::modificationTime() const
+{
+    return fileTimeToQDateTime(&lastWriteTime_);
+}
+QDateTime QFileSystemMetaData::accessTime() const
+{
+    return fileTimeToQDateTime(&lastAccessTime_);
 }
 
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qfilesystemmetadata_p.h b/src/corelib/io/qfilesystemmetadata_p.h
index e45c5dc..29ef987 100644
--- a/src/corelib/io/qfilesystemmetadata_p.h
+++ b/src/corelib/io/qfilesystemmetadata_p.h
@@ -111,9 +111,14 @@ public:
         BundleType          =        0x0,
         AliasType           =        0x0,
 #endif
+#if defined(Q_OS_WIN)
+        WinLnkType          = 0x08000000,   // Note: Uses the same position for AliasType on Mac
+#else
+        WinLnkType          =        0x0,
+#endif
         SequentialType      = 0x00800000,   // Note: overlaps with QAbstractFileEngine::RootFlag
 
-        LegacyLinkType      = LinkType | AliasType,
+        LegacyLinkType      = LinkType | AliasType | WinLnkType,
 
         Type                = LinkType | FileType | DirectoryType | BundleType | SequentialType | AliasType,
 
@@ -153,6 +158,14 @@ public:
                             | QFileSystemMetaData::SequentialType
                             | QFileSystemMetaData::Attributes
                             | QFileSystemMetaData::Times,
+#if defined(Q_OS_WIN)
+        WinStatFlags        = QFileSystemMetaData::FileType
+                            | QFileSystemMetaData::DirectoryType
+                            | QFileSystemMetaData::HiddenAttribute
+                            | QFileSystemMetaData::ExistsAttribute
+                            | QFileSystemMetaData::SizeAttribute
+                            | QFileSystemMetaData::Times,
+#endif
 
         AllMetaDataFlags    = 0xFFFFFFFF
 
@@ -181,7 +194,7 @@ public:
 
     bool exists() const                     { return (entryFlags & ExistsAttribute); }
 
-    bool isLink() const                     { return (entryFlags & LinkType); }
+    bool isLink() const                     { return  (entryFlags & LinkType); }
     bool isFile() const                     { return (entryFlags & FileType); }
     bool isDirectory() const                { return (entryFlags & DirectoryType); }
     bool isBundle() const;
@@ -189,6 +202,11 @@ public:
     bool isLegacyLink() const               { return (entryFlags & LegacyLinkType); }
     bool isSequential() const               { return (entryFlags & SequentialType); }
     bool isHidden() const                   { return (entryFlags & HiddenAttribute); }
+#if defined(Q_OS_WIN)
+    bool isLnkFile() const                  { return (entryFlags & WinLnkType); }
+#else
+    bool isLnkFile() const                  { return false; }
+#endif
 
     qint64 size() const                     { return size_; }
 
@@ -212,6 +230,11 @@ public:
     void fillFromVolumeInfo(const TVolumeInfo& info);
 #endif
 
+#if defined(Q_OS_WIN)
+    inline void fillFromFileAttribute(DWORD fileAttribute, bool isDriveRoot = false);
+    inline void fillFromFindData(WIN32_FIND_DATA &findData, bool setLinkType = false, bool isDriveRoot = false);
+    inline void fillFromFindInfo(BY_HANDLE_FILE_INFORMATION &fileInfo);
+#endif
 private:
     friend class QFileSystemEngine;
 
@@ -222,6 +245,10 @@ private:
 
     // Platform-specific data goes here:
 #if defined(Q_OS_WIN)
+    DWORD fileAttribute_;
+    FILETIME creationTime_;
+    FILETIME lastAccessTime_;
+    FILETIME lastWriteTime_;
 #elif defined(Q_OS_SYMBIAN)
     TTime modificationTime_;
 #else
@@ -245,11 +272,7 @@ inline bool QFileSystemMetaData::isBundle() const                   { return fal
 inline bool QFileSystemMetaData::isAlias() const                    { return false; }
 #endif
 
-#if defined(Q_OS_UNIX) && !defined (Q_OS_SYMBIAN)
-inline QDateTime QFileSystemMetaData::creationTime() const          { return QDateTime::fromTime_t(creationTime_); }
-inline QDateTime QFileSystemMetaData::modificationTime() const      { return QDateTime::fromTime_t(modificationTime_); }
-inline QDateTime QFileSystemMetaData::accessTime() const            { return QDateTime::fromTime_t(accessTime_); }
-
+#if (defined(Q_OS_UNIX) && !defined (Q_OS_SYMBIAN)) || defined (Q_OS_WIN)
 inline QDateTime QFileSystemMetaData::fileTime(QAbstractFileEngine::FileTime time) const
 {
     switch (time) {
@@ -265,6 +288,12 @@ inline QDateTime QFileSystemMetaData::fileTime(QAbstractFileEngine::FileTime tim
 
     return QDateTime();
 }
+#endif
+
+#if defined(Q_OS_UNIX) && !defined (Q_OS_SYMBIAN)
+inline QDateTime QFileSystemMetaData::creationTime() const          { return QDateTime::fromTime_t(creationTime_); }
+inline QDateTime QFileSystemMetaData::modificationTime() const      { return QDateTime::fromTime_t(modificationTime_); }
+inline QDateTime QFileSystemMetaData::accessTime() const            { return QDateTime::fromTime_t(accessTime_); }
 
 inline uint QFileSystemMetaData::userId() const                     { return userId_; }
 inline uint QFileSystemMetaData::groupId() const                    { return groupId_; }
@@ -297,6 +326,18 @@ inline uint QFileSystemMetaData::ownerId(QAbstractFileEngine::FileOwner owner) c
 }
 #endif
 
+#if defined(Q_OS_WIN)
+inline uint QFileSystemMetaData::userId() const                     { return (uint) -2; }
+inline uint QFileSystemMetaData::groupId() const                    { return (uint) -2; }
+inline uint QFileSystemMetaData::ownerId(QAbstractFileEngine::FileOwner owner) const
+{
+    if (owner == QAbstractFileEngine::OwnerUser)
+        return userId();
+    else
+        return groupId();
+}
+#endif
+
 QT_END_NAMESPACE
 
 #endif // include guard
diff --git a/src/corelib/io/qfsfileengine_iterator_win.cpp b/src/corelib/io/qfsfileengine_iterator_win.cpp
index 7181025..d4e6f5a 100644
--- a/src/corelib/io/qfsfileengine_iterator_win.cpp
+++ b/src/corelib/io/qfsfileengine_iterator_win.cpp
@@ -41,6 +41,7 @@
 
 #include "qfsfileengine_iterator_p.h"
 #include "qfsfileengine_p.h"
+#include "qfilesystemengine_p.h"
 #include "qplatformdefs.h"
 
 #include <QtCore/qvariant.h>
@@ -135,7 +136,7 @@ bool QFSFileEngineIterator::hasNext() const
                 // UNC
                 QStringList parts = QDir::toNativeSeparators(path).split(QLatin1Char('\\'), QString::SkipEmptyParts);
 
-                if (parts.count() == 1 && QFSFileEnginePrivate::uncListSharesOnServer(QLatin1String("\\\\") + parts.at(0),
+                if (parts.count() == 1 && QFileSystemEngine::uncListSharesOnServer(QLatin1String("\\\\") + parts.at(0),
                                                                                       &platform->uncShares)) {
                     if (platform->uncShares.isEmpty()) {
                         platform->done = true;
diff --git a/src/corelib/io/qfsfileengine_p.h b/src/corelib/io/qfsfileengine_p.h
index a3733d8..14a8938 100644
--- a/src/corelib/io/qfsfileengine_p.h
+++ b/src/corelib/io/qfsfileengine_p.h
@@ -114,9 +114,7 @@ public:
     uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
     bool unmap(uchar *ptr);
 
-#if defined(Q_OS_UNIX)
     mutable QFileSystemMetaData metaData;
-#endif
 
     FILE *fh;
 #ifdef Q_OS_SYMBIAN
@@ -177,7 +175,7 @@ public:
 #endif
 
 #if defined(Q_OS_WIN)
-    bool doStat() const;
+    bool doStat(QFileSystemMetaData::MetaDataFlags flags) const;
 #else
     bool doStat(QFileSystemMetaData::MetaDataFlags flags = QFileSystemMetaData::PosixStatFlags) const;
 #endif
@@ -187,12 +185,6 @@ public:
     int sysOpen(const QString &, int flags);
 #endif
 
-#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
-    static void resolveLibs();
-    static bool resolveUNCLibs();
-    static bool uncListSharesOnServer(const QString &server, QStringList *list);
-#endif
-
 #ifdef Q_OS_SYMBIAN
     void setSymbianError(int symbianError, QFile::FileError defaultError, QString defaultString);
 #endif
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
index 7262129..976207a 100644
--- a/src/corelib/io/qfsfileengine_win.cpp
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -69,69 +69,9 @@
 #define SECURITY_WIN32
 #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 QFileSystemEntry &link);
 
-Q_CORE_EXPORT int qt_ntfs_permission_lookup = 0;
 
 #if defined(Q_OS_WINCE)
 static QString qfsPrivateCurrentDir = QLatin1String("");
@@ -140,146 +80,6 @@ static QString qfsPrivateCurrentDir = QLatin1String("");
 #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;
-typedef BOOL (WINAPI *PtrGetVolumePathNamesForVolumeNameW)(LPCWSTR,LPWSTR,DWORD,PDWORD);
-static PtrGetVolumePathNamesForVolumeNameW ptrGetVolumePathNamesForVolumeNameW = 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 = LoadLibrary(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 = LoadLibrary(L"userenv");
-        if (userenvHnd)
-            ptrGetUserProfileDirectoryW = (PtrGetUserProfileDirectoryW)GetProcAddress(userenvHnd, "GetUserProfileDirectoryW");
-        HINSTANCE kernel32 = LoadLibrary(L"kernel32");
-        if(kernel32)
-            ptrGetVolumePathNamesForVolumeNameW = (PtrGetVolumePathNamesForVolumeNameW)GetProcAddress(kernel32, "GetVolumePathNamesForVolumeNameW");
-#endif
-    }
-}
-#endif // QT_NO_LIBRARY
-
-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 = LoadLibrary(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;
-}
-
 #if !defined(Q_OS_WINCE)
 static inline bool isUncPath(const QString &path)
 {
@@ -289,47 +89,6 @@ static inline bool isUncPath(const QString &path)
 }
 #endif
 
-// 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 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
 */
@@ -338,7 +97,7 @@ QString QFSFileEnginePrivate::longFileName(const QString &path)
     if (path.startsWith(QLatin1String("\\\\.\\")))
         return path;
 
-    QString absPath = nativeAbsoluteFilePath(path);
+    QString absPath = QFileSystemEngine::nativeAbsoluteFilePath(path);
 #if !defined(Q_OS_WINCE)
     QString prefix = QLatin1String("\\\\?\\");
     if (isUncPath(absPath)) {
@@ -389,7 +148,6 @@ bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode)
 
     // WriteOnly can create files, ReadOnly cannot.
     DWORD creationDisp = (openMode & QIODevice::WriteOnly) ? OPEN_ALWAYS : OPEN_EXISTING;
-
     // Create the file handle.
     fileHandle = CreateFile((const wchar_t*)fileEntry.nativeFilePath().utf16(),
                             accessRights,
@@ -481,17 +239,9 @@ qint64 QFSFileEnginePrivate::nativeSize() const
     // ### 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
+    // Always retrive the current information
+    metaData.clearFlags(QFileSystemMetaData::SizeAttribute);
+#if defined(Q_OS_WINCE)
     // Buffered stdlib mode.
     if (fh) {
         QT_OFF_T oldPos = QT_FTELL(fh);
@@ -504,57 +254,23 @@ qint64 QFSFileEnginePrivate::nativeSize() const
         }
         return fileSize;
     }
-#endif
-
-    // Not-open mode, where the file name is known: We'll check the
-    // file system directly.
-    if (openMode == QIODevice::NotOpen && !fileEntry.isEmpty()) {
-        WIN32_FILE_ATTRIBUTE_DATA attribData;
-        bool ok = ::GetFileAttributesEx((const wchar_t*)fileEntry.nativeFilePath().utf16(),
-                                        GetFileExInfoStandard, &attribData);
-        if (!ok) {
-            int errorCode = GetLastError();
-            if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {
-                WIN32_FIND_DATA findData;
-                if (getFindData(fileEntry.nativeFilePath(), findData)) {
-                    ok = true;
-                    attribData.nFileSizeHigh = findData.nFileSizeHigh;
-                    attribData.nFileSizeLow = findData.nFileSizeLow;
-                }
-            }
-        }
-        if (ok) {
-            qint64 size = attribData.nFileSizeHigh;
-            size <<= 32;
-            size += attribData.nFileSizeLow;
-            return size;
-        }
-        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
-        return 0;
-    }
-
-#if defined(Q_OS_WINCE)
-    // Unbuffed stdio mode
     if (fd != -1) {
         thatQ->setError(QFile::UnspecifiedError, QLatin1String("Not implemented!"));
         return 0;
     }
 #endif
+    bool filled = false;
+    if (fileHandle != INVALID_HANDLE_VALUE && openMode != QIODevice::NotOpen )
+        filled = QFileSystemEngine::fillMetaData(fileHandle, metaData,
+                                                 QFileSystemMetaData::SizeAttribute);
+    else
+        filled = doStat(QFileSystemMetaData::SizeAttribute);
 
-    // Windows native mode.
-    if (fileHandle == INVALID_HANDLE_VALUE)
-        return 0;
-
-    BY_HANDLE_FILE_INFORMATION fileInfo;
-    if (!GetFileInformationByHandle(fileHandle, &fileInfo)) {
-        thatQ->setError(QFile::UnspecifiedError, qt_error_string());
+    if (!filled || metaData.size() == -1) {
+        thatQ->setError(QFile::UnspecifiedError, qt_error_string(errno));
         return 0;
     }
-
-    qint64 size = fileInfo.nFileSizeHigh;
-    size <<= 32;
-    size += fileInfo.nFileSizeLow;
-    return size;
+    return metaData.size();
 }
 
 /*
@@ -788,7 +504,7 @@ bool QFSFileEnginePrivate::nativeIsSequential() const
 bool QFSFileEngine::remove()
 {
     Q_D(QFSFileEngine);
-    bool ret = ::DeleteFile((wchar_t*)d->fileEntry.nativeFilePath().utf16()) != 0;
+    bool ret = QFileSystemEngine::removeFile(d->fileEntry);
     if (!ret)
         setError(QFile::RemoveError, qt_error_string());
     return ret;
@@ -797,10 +513,7 @@ bool QFSFileEngine::remove()
 bool QFSFileEngine::copy(const QString &copyName)
 {
     Q_D(QFSFileEngine);
-
-    QFileSystemEntry target(copyName);
-    bool ret = ::CopyFile((wchar_t*)d->fileEntry.nativeFilePath().utf16(),
-                          (wchar_t*)target.nativeFilePath().utf16(), true) != 0;
+    bool ret = QFileSystemEngine::copyFile(d->fileEntry, QFileSystemEntry(copyName));
     if (!ret)
         setError(QFile::CopyError, qt_error_string());
     return ret;
@@ -809,130 +522,20 @@ bool QFSFileEngine::copy(const QString &copyName)
 bool QFSFileEngine::rename(const QString &newName)
 {
     Q_D(QFSFileEngine);
-    QFileSystemEntry target(newName);
-    bool ret = ::MoveFile((wchar_t*)d->fileEntry.nativeFilePath().utf16(),
-                          (wchar_t*)target.nativeFilePath().utf16()) != 0;
+    bool ret = QFileSystemEngine::renameFile(d->fileEntry, QFileSystemEntry(newName));
     if (!ret)
         setError(QFile::RenameError, qt_error_string());
     return ret;
 }
 
-static inline bool mkDir(const QString &path)
-{
-#if defined(Q_OS_WINCE)
-    // Unfortunately CreateDirectory returns true for paths longer than
-    // 256, but does not create a directory. It starts to fail, when
-    // path length > MAX_PATH, which is 260 usually on CE.
-    // This only happens on a Windows Mobile device. Windows CE seems
-    // not to be affected by this.
-    static int platformId = 0;
-    if (platformId == 0) {
-        wchar_t platformString[64];
-        if (SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(platformString)/sizeof(*platformString),platformString,0)) {
-            if (0 == wcscmp(platformString, L"PocketPC") || 0 == wcscmp(platformString, L"Smartphone"))
-                platformId = 1;
-            else
-                platformId = 2;
-        }
-    }
-    if (platformId == 1 && QFSFileEnginePrivate::longFileName(path).size() > 256)
-        return false;
-#endif
-    return ::CreateDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16(), 0);
-}
-
-static inline bool rmDir(const QString &path)
-{
-    return ::RemoveDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());
-}
-
-static bool isDirPath(const QString &dirPath, bool *existed)
-{
-    QString path = dirPath;
-    if (path.length() == 2 && path.at(1) == QLatin1Char(':'))
-        path += QLatin1Char('\\');
-
-    DWORD fileAttrib = ::GetFileAttributes((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());
-    if (fileAttrib == INVALID_FILE_ATTRIBUTES) {
-        int errorCode = GetLastError();
-        if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {
-            WIN32_FIND_DATA findData;
-            if (getFindData(QFSFileEnginePrivate::longFileName(path), findData))
-                fileAttrib = findData.dwFileAttributes;
-        }
-    }
-
-    if (existed)
-        *existed = fileAttrib != INVALID_FILE_ATTRIBUTES;
-
-    if (fileAttrib == INVALID_FILE_ATTRIBUTES)
-        return false;
-
-    return fileAttrib & FILE_ATTRIBUTE_DIRECTORY;
-}
-
 bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
 {
-    QString dirName = name;
-    if (createParentDirectories) {
-        dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));
-        // We spefically search for / so \ would break it..
-        int oldslash = -1;
-        if (dirName.startsWith(QLatin1String("\\\\"))) {
-            // Don't try to create the root path of a UNC path;
-            // CreateDirectory() will just return ERROR_INVALID_NAME.
-            for (int i = 0; i < dirName.size(); ++i) {
-                if (dirName.at(i) != QDir::separator()) {
-                    oldslash = i;
-                    break;
-                }
-            }
-            if (oldslash != -1)
-                oldslash = dirName.indexOf(QDir::separator(), oldslash);
-        }
-        for (int 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) {
-                QString chunk = dirName.left(slash);
-                bool existed = false;
-                if (!isDirPath(chunk, &existed)) {
-                    if (!existed) {
-                        if (!mkDir(chunk))
-                            return false;
-                    } else {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    return mkDir(name);
+    return QFileSystemEngine::createDirectory(QFileSystemEntry(name), createParentDirectories);
 }
 
 bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
 {
-    QString dirName = name;
-    if (recurseParentDirectories) {
-        dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));
-        for (int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {
-            QString chunk = dirName.left(slash);
-            if (chunk.length() == 2 && chunk.at(0).isLetter() && chunk.at(1) == QLatin1Char(':'))
-                break;
-            if (!isDirPath(chunk, 0))
-                return false;
-            if (!rmDir(chunk))
-                return oldslash != 0;
-            slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);
-        }
-        return true;
-    }
-    return rmDir(name);
+    return QFileSystemEngine::removeDirectory(QFileSystemEntry(name), recurseParentDirectories);
 }
 
 bool QFSFileEngine::caseSensitive() const
@@ -997,64 +600,12 @@ QString QFSFileEngine::currentPath(const QString &fileName)
 
 QString QFSFileEngine::homePath()
 {
-    QString ret;
-#if !defined(QT_NO_LIBRARY)
-    QFSFileEnginePrivate::resolveLibs();
-    if (ptrGetUserProfileDirectoryW) {
-        HANDLE hnd = ::GetCurrentProcess();
-        HANDLE token = 0;
-        BOOL ok = ::OpenProcessToken(hnd, TOKEN_QUERY, &token);
-        if (ok) {
-            DWORD dwBufferSize = 0;
-            // First call, to determine size of the strings (with '\0').
-            ok = ptrGetUserProfileDirectoryW(token, NULL, &dwBufferSize);
-            if (!ok && dwBufferSize != 0) {        // We got the required buffer size
-                wchar_t *userDirectory = new wchar_t[dwBufferSize];
-                // Second call, now we can fill the allocated buffer.
-                ok = ptrGetUserProfileDirectoryW(token, userDirectory, &dwBufferSize);
-                if (ok)
-                    ret = QString::fromWCharArray(userDirectory);
-
-                delete [] userDirectory;
-            }
-            ::CloseHandle(token);
-        }
-                }
-#endif
-    if (ret.isEmpty() || !QFile::exists(ret)) {
-        ret = QString::fromLocal8Bit(qgetenv("USERPROFILE").constData());
-        if (ret.isEmpty() || !QFile::exists(ret)) {
-            ret = QString::fromLocal8Bit(qgetenv("HOMEDRIVE").constData()) + QString::fromLocal8Bit(qgetenv("HOMEPATH").constData());
-            if (ret.isEmpty() || !QFile::exists(ret)) {
-                ret = QString::fromLocal8Bit(qgetenv("HOME").constData());
-                if (ret.isEmpty() || !QFile::exists(ret)) {
-#if defined(Q_OS_WINCE)
-                    ret = QLatin1String("\\My Documents");
-                    if (!QFile::exists(ret))
-#endif
-                    ret = rootPath();
-                }
-            }
-        }
-    }
-    return QDir::fromNativeSeparators(ret);
+    return QFileSystemEngine::homePath();
 }
 
 QString QFSFileEngine::rootPath()
 {
-#if defined(Q_OS_WINCE)
-    QString ret = QLatin1String("/");
-#elif defined(Q_FS_FAT)
-    QString ret = QString::fromLatin1(qgetenv("SystemDrive").constData());
-    if (ret.isEmpty())
-        ret = QLatin1String("c:");
-    ret.append(QLatin1Char('/'));
-#elif defined(Q_OS_OS2EMX)
-    char dir[4];
-    _abspath(dir, QLatin1String("/"), _MAX_PATH);
-    QString ret(dir);
-#endif
-    return ret;
+    return QFileSystemEngine::rootPath();
 }
 
 QString QFSFileEngine::tempPath()
@@ -1107,219 +658,25 @@ QFileInfoList QFSFileEngine::drives()
 #endif
 }
 
-bool QFSFileEnginePrivate::doStat() const
+bool QFSFileEnginePrivate::doStat(QFileSystemMetaData::MetaDataFlags flags) const
 {
-    if (!tried_stat) {
+    if (!tried_stat || !metaData.hasFlags(flags)) {
         tried_stat = true;
-        could_stat = false;
-
-        if (fileEntry.isEmpty())
-            return could_stat;
-
-        QFileSystemEntry fname;
-        if(fileEntry.filePath().endsWith(QLatin1String(".lnk"))) {
-            fname = QFileSystemEntry(readLink(fileEntry));
-            if(fname.isEmpty())
-                return could_stat;
-        }
-        else
-            fname = fileEntry;
-
-        UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
 
-        if (fd != -1) {
 #if !defined(Q_OS_WINCE)
-            HANDLE fh = (HANDLE)_get_osfhandle(fd);
-            if (fh != INVALID_HANDLE_VALUE) {
-                BY_HANDLE_FILE_INFORMATION fileInfo;
-                if (GetFileInformationByHandle(fh, &fileInfo)) {
-                    could_stat = true;
-                    fileAttrib = fileInfo.dwFileAttributes;
-                }
-            }
-#else
-            DWORD tmpAttributes = GetFileAttributes((wchar_t*)fname.nativeFilePath().utf16());
-            if (tmpAttributes != -1) {
-                fileAttrib = tmpAttributes;
-                could_stat = true;
-            }
-#endif
-        } else {
-            fileAttrib = GetFileAttributes((wchar_t*)fname.nativeFilePath().utf16());
-            if (fileAttrib == INVALID_FILE_ATTRIBUTES) {
-                int errorCode = GetLastError();
-                if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {
-                    WIN32_FIND_DATA findData;
-                    if (getFindData(fname.nativeFilePath(), findData)) {
-                        fileAttrib = findData.dwFileAttributes;
-                    }
-                }
-            }
-            could_stat = fileAttrib != INVALID_FILE_ATTRIBUTES;
-            if (!could_stat) {
-#if !defined(Q_OS_WINCE)
-                if (fname.isDriveRoot()) {
-                    // a valid drive ??
-                    DWORD drivesBitmask = ::GetLogicalDrives();
-                    int drivebit = 1 << (fname.filePath().at(0).toUpper().unicode() - QLatin1Char('A').unicode());
-                    if (drivesBitmask & drivebit) {
-                        fileAttrib = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM;
-                        could_stat = true;
-                    }
-                } else {
-#endif
-                    const QString &path = fname.nativeFilePath();
-                    bool is_dir = false;
-                    if (path.startsWith(QLatin1String("\\\\"))) {
-                        // UNC - stat doesn't work for all cases (Windows bug)
-                        int s = path.indexOf(path.at(0),2);
-                        if (s > 0) {
-                            // "\\server\..."
-                            s = path.indexOf(path.at(0),s+1);
-                            if (s > 0) {
-                                // "\\server\share\..."
-                                if (s == path.size() - 1) {
-                                    // "\\server\share\"
-                                    is_dir = true;
-                                } else {
-                                    // "\\server\share\notfound"
-                                }
-                            } else {
-                                // "\\server\share"
-                                is_dir = true;
-                            }
-                        } else {
-                            // "\\server"
-                            is_dir = true;
-                        }
-                    }
-                    if (is_dir && uncShareExists(path)) {
-                        // looks like a UNC dir, is a dir.
-                        fileAttrib = FILE_ATTRIBUTE_DIRECTORY;
-                        could_stat = true;
-                    }
-#if !defined(Q_OS_WINCE)
-                }
+        int localFd = fd;
+        if (fh && fileEntry.isEmpty())
+            localFd = QT_FILENO(fh);
+        if (localFd != -1)
+            QFileSystemEngine::fillMetaData(localFd, metaData, flags);
 #endif
-            }
-        }
-
-        SetErrorMode(oldmode);
+        if (metaData.missingFlags(flags) && !fileEntry.isEmpty())
+            QFileSystemEngine::fillMetaData(fileEntry, metaData, metaData.missingFlags(flags));
     }
-    return could_stat;
-}
 
-
-static QString readSymLink(const QFileSystemEntry &link)
-{
-    QString result;
-#if !defined(Q_OS_WINCE)
-    HANDLE handle = CreateFile((wchar_t*)link.nativeFilePath().utf16(),
-                               FILE_READ_EA,
-                               FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                               0,
-                               OPEN_EXISTING,
-                               FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
-                               0);
-    if (handle != INVALID_HANDLE_VALUE) {
-        DWORD bufsize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
-        REPARSE_DATA_BUFFER *rdb = (REPARSE_DATA_BUFFER*)qMalloc(bufsize);
-        DWORD retsize = 0;
-        if (::DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, 0, 0, rdb, bufsize, &retsize, 0)) {
-            if (rdb->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) {
-                int length = rdb->MountPointReparseBuffer.SubstituteNameLength / sizeof(wchar_t);
-                int offset = rdb->MountPointReparseBuffer.SubstituteNameOffset / sizeof(wchar_t);
-                const wchar_t* PathBuffer = &rdb->MountPointReparseBuffer.PathBuffer[offset];
-                result = QString::fromWCharArray(PathBuffer, length);
-            } else if (rdb->ReparseTag == IO_REPARSE_TAG_SYMLINK) {
-                int length = rdb->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(wchar_t);
-                int offset = rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t);
-                const wchar_t* PathBuffer = &rdb->SymbolicLinkReparseBuffer.PathBuffer[offset];
-                result = QString::fromWCharArray(PathBuffer, length);
-            }
-            // cut-off "//?/" and "/??/"
-            if (result.size() > 4 && result.at(0) == QLatin1Char('\\') && result.at(2) == QLatin1Char('?') && result.at(3) == QLatin1Char('\\'))
-                result = result.mid(4);
-        }
-        qFree(rdb);
-        CloseHandle(handle);
-
-#if !defined(QT_NO_LIBRARY)
-        QFSFileEnginePrivate::resolveLibs();
-        if (ptrGetVolumePathNamesForVolumeNameW) {
-            QRegExp matchVolName(QLatin1String("^Volume\\{([a-z]|[0-9]|-)+\\}\\\\"), Qt::CaseInsensitive);
-            if(matchVolName.indexIn(result) == 0) {
-                DWORD len;
-                wchar_t buffer[MAX_PATH];
-                QString volumeName = result.mid(0, matchVolName.matchedLength()).prepend(QLatin1String("\\\\?\\"));
-                if(ptrGetVolumePathNamesForVolumeNameW((wchar_t*)volumeName.utf16(), buffer, MAX_PATH, &len) != 0)
-                    result.replace(0,matchVolName.matchedLength(), QString::fromWCharArray(buffer));
-            }
-        }
-#endif
-    }
-#else
-    Q_UNUSED(link);
-#endif // Q_OS_WINCE
-    return result;
+    return metaData.exists();
 }
 
-static QString readLink(const QFileSystemEntry &link)
-{
-#if !defined(Q_OS_WINCE)
-#if !defined(QT_NO_LIBRARY) && !defined(Q_CC_MWERKS)
-    QString ret;
-
-    bool neededCoInit = false;
-    IShellLink *psl;                            // pointer to IShellLink i/f
-    WIN32_FIND_DATA wfd;
-    wchar_t szGotPath[MAX_PATH];
-
-    // Get pointer to the IShellLink interface.
-    HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID *)&psl);
-
-    if (hres == CO_E_NOTINITIALIZED) { // COM was not initialized
-        neededCoInit = true;
-        CoInitialize(NULL);
-        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-                                    IID_IShellLink, (LPVOID *)&psl);
-    }
-    if (SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
-        IPersistFile *ppf;
-        hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
-        if (SUCCEEDED(hres))  {
-            hres = ppf->Load((LPOLESTR)link.nativeFilePath().utf16(), STGM_READ);
-            //The original path of the link is retrieved. If the file/folder
-            //was moved, the return value still have the old path.
-            if (SUCCEEDED(hres)) {
-                if (psl->GetPath(szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
-                    ret = QString::fromWCharArray(szGotPath);
-            }
-            ppf->Release();
-        }
-        psl->Release();
-    }
-    if (neededCoInit)
-        CoUninitialize();
-
-    return ret;
-#else
-    Q_UNUSED(link);
-    return QString();
-#endif // QT_NO_LIBRARY
-#else
-    wchar_t target[MAX_PATH];
-    QString result;
-    if (SHGetShortcutTarget((wchar_t*)QFileInfo(link.filePath()).absoluteFilePath().replace(QLatin1Char('/'),QLatin1Char('\\')).utf16(), target, MAX_PATH)) {
-        result = QString::fromWCharArray(target);
-        if (result.startsWith(QLatin1Char('"')))
-            result.remove(0,1);
-        if (result.endsWith(QLatin1Char('"')))
-            result.remove(result.size()-1,1);
-    }
-    return result;
-#endif // Q_OS_WINCE
-}
 
 bool QFSFileEngine::link(const QString &newName)
 {
@@ -1384,183 +741,63 @@ bool QFSFileEngine::link(const QString &newName)
 #endif // Q_OS_WINCE
 }
 
-QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions(QAbstractFileEngine::FileFlags type) const
+/*!
+    \reimp
+*/
+QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(QAbstractFileEngine::FileFlags type) const
 {
+    Q_D(const QFSFileEngine);
+
+    if (type & Refresh)
+        d->metaData.clear();
+
     QAbstractFileEngine::FileFlags ret = 0;
 
-#if !defined(QT_NO_LIBRARY)
-    if((qt_ntfs_permission_lookup > 0) && (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)) {
-        resolveLibs();
-        if(ptrGetNamedSecurityInfoW && ptrBuildTrusteeWithSidW && ptrGetEffectiveRightsFromAclW) {
-            enum { ReadMask = 0x00000001, WriteMask = 0x00000002, ExecMask = 0x00000020 };
-
-            QString fname = fileEntry.filePath().endsWith(QLatin1String(".lnk")) ? readLink(fileEntry) : fileEntry.filePath();
-            PSID pOwner = 0;
-            PSID pGroup = 0;
-            PACL pDacl;
-            PSECURITY_DESCRIPTOR pSD;
-            DWORD res = ptrGetNamedSecurityInfoW((wchar_t*)fname.utf16(), SE_FILE_OBJECT,
-                                                 OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
-                                                 &pOwner, &pGroup, &pDacl, 0, &pSD);
-            if(res == ERROR_SUCCESS) {
-                ACCESS_MASK access_mask;
-                TRUSTEE_W trustee;
-                if (type & 0x0700) { // user
-                    if(ptrGetEffectiveRightsFromAclW(pDacl, &currentUserTrusteeW, &access_mask) != ERROR_SUCCESS)
-                        access_mask = (ACCESS_MASK)-1;
-                    if(access_mask & ReadMask)
-                        ret |= QAbstractFileEngine::ReadUserPerm;
-                    if(access_mask & WriteMask)
-                        ret |= QAbstractFileEngine::WriteUserPerm;
-                    if(access_mask & ExecMask)
-                        ret |= QAbstractFileEngine::ExeUserPerm;
-                }
-                if (type & 0x7000) { // owner
-                    ptrBuildTrusteeWithSidW(&trustee, pOwner);
-                    if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
-                        access_mask = (ACCESS_MASK)-1;
-                    if(access_mask & ReadMask)
-                        ret |= QAbstractFileEngine::ReadOwnerPerm;
-                    if(access_mask & WriteMask)
-                        ret |= QAbstractFileEngine::WriteOwnerPerm;
-                    if(access_mask & ExecMask)
-                        ret |= QAbstractFileEngine::ExeOwnerPerm;
-                }
-                if (type & 0x0070) { // group
-                    ptrBuildTrusteeWithSidW(&trustee, pGroup);
-                    if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
-                        access_mask = (ACCESS_MASK)-1;
-                    if(access_mask & ReadMask)
-                        ret |= QAbstractFileEngine::ReadGroupPerm;
-                    if(access_mask & WriteMask)
-                        ret |= QAbstractFileEngine::WriteGroupPerm;
-                    if(access_mask & ExecMask)
-                        ret |= QAbstractFileEngine::ExeGroupPerm;
-                }
-                if (type & 0x0007) { // other (world)
-                    if(ptrGetEffectiveRightsFromAclW(pDacl, &worldTrusteeW, &access_mask) != ERROR_SUCCESS)
-                        access_mask = (ACCESS_MASK)-1; // ###
-                    if(access_mask & ReadMask)
-                        ret |= QAbstractFileEngine::ReadOtherPerm;
-                    if(access_mask & WriteMask)
-                        ret |= QAbstractFileEngine::WriteOtherPerm;
-                    if(access_mask & ExecMask)
-                        ret |= QAbstractFileEngine::ExeOtherPerm;
-                }
-                LocalFree(pSD);
-            }
-        }
-    } else
-#endif
+    if (type & FlagsMask)
+        ret |= LocalDiskFlag;
+
+    bool exists;
     {
-        //### what to do with permissions if we don't use NTFS
-        // for now just add all permissions and what about exe missions ??
-        // also qt_ntfs_permission_lookup is now not set by default ... should it ?
-        ret |= QAbstractFileEngine::ReadOwnerPerm | QAbstractFileEngine::ReadGroupPerm
-             | QAbstractFileEngine::ReadOtherPerm;
-
-        if (!(fileAttrib & FILE_ATTRIBUTE_READONLY)) {
-            ret |= QAbstractFileEngine::WriteOwnerPerm | QAbstractFileEngine::WriteGroupPerm
-                 | QAbstractFileEngine::WriteOtherPerm;
-        }
+        QFileSystemMetaData::MetaDataFlags queryFlags = 0;
 
-        QString fname = fileEntry.filePath().endsWith(QLatin1String(".lnk")) ? readLink(fileEntry) : fileEntry.filePath();
-        QString ext = fname.right(4).toLower();
-        if ((fileAttrib & FILE_ATTRIBUTE_DIRECTORY) ||
-            ext == QLatin1String(".exe") || ext == QLatin1String(".com") || ext == QLatin1String(".bat") ||
-            ext == QLatin1String(".pif") || ext == QLatin1String(".cmd")) {
-            ret |= QAbstractFileEngine::ExeOwnerPerm | QAbstractFileEngine::ExeGroupPerm
-                 | QAbstractFileEngine::ExeOtherPerm | QAbstractFileEngine::ExeUserPerm;
-        }
+        queryFlags |= QFileSystemMetaData::MetaDataFlags(uint(type))
+                & QFileSystemMetaData::Permissions;
 
-        // calculate user permissions
-        if (type & QAbstractFileEngine::ReadUserPerm) {
-            if (::_waccess((wchar_t*)longFileName(fname).utf16(), R_OK) == 0)
-                ret |= QAbstractFileEngine::ReadUserPerm;
-        }
-        if (type & QAbstractFileEngine::WriteUserPerm) {
-            if (::_waccess((wchar_t*)longFileName(fname).utf16(), W_OK) == 0)
-                ret |= QAbstractFileEngine::WriteUserPerm;
-        }
-    }
-    return ret;
-}
+        // AliasType and BundleType are 0x0
+        if (type & TypesMask)
+            queryFlags |= QFileSystemMetaData::AliasType
+                    | QFileSystemMetaData::LinkType
+                    | QFileSystemMetaData::FileType
+                    | QFileSystemMetaData::DirectoryType
+                    | QFileSystemMetaData::BundleType;
 
-/*!
-    \internal
-*/
-bool QFSFileEnginePrivate::isSymlink() const
-{
-#if !defined(Q_OS_WINCE)
-    if (need_lstat) {
-        need_lstat = false;
-        is_link = false;
-
-        if (fileAttrib & FILE_ATTRIBUTE_REPARSE_POINT) {
-            WIN32_FIND_DATA findData;
-            if (getFindData(fileEntry.nativeFilePath(), findData)) {
-                if ((findData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
-                    && (findData.dwReserved0 == IO_REPARSE_TAG_SYMLINK || findData.dwReserved0 == IO_REPARSE_TAG_MOUNT_POINT)) {
-                    is_link = true;
-                }
-            }
-        }
-    }
-    return is_link;
-#else
-    return false;
-#endif // Q_OS_WINCE
-}
+        if (type & FlagsMask)
+            queryFlags |= QFileSystemMetaData::HiddenAttribute
+                    | QFileSystemMetaData::ExistsAttribute;
 
-/*!
-    \reimp
-*/
-QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(QAbstractFileEngine::FileFlags type) const
-{
-    Q_D(const QFSFileEngine);
-    QAbstractFileEngine::FileFlags ret = 0;
-    // Force a stat, so that we're guaranteed to get up-to-date results
-    if (type & Refresh) {
-        d->tried_stat = 0;
-#if !defined(Q_OS_WINCE)
-        d->need_lstat = 1;
-#endif
-    }
+        queryFlags |= QFileSystemMetaData::LinkType;
 
-    if (type & PermsMask) {
-        if (d->doStat()) {
-            ret |= ExistsFlag;
-            ret |= d->getPermissions(type);
-        }
+        exists = d->doStat(queryFlags);
     }
+
+    if (exists && (type & PermsMask))
+        ret |= FileFlags(uint(d->metaData.permissions()));
+
     if (type & TypesMask) {
-        if (d->fileEntry.filePath().endsWith(QLatin1String(".lnk"))) {
+        if ((type & LinkType) && d->metaData.isLegacyLink())
             ret |= LinkType;
-            QString l = readLink(d->fileEntry);
-            if (!l.isEmpty()) {
-                bool existed = false;
-                if (isDirPath(l, &existed) && existed)
-                    ret |= DirectoryType;
-                else if (existed)
-                    ret |= FileType;
-            }
-        } else if (d->doStat()) {
-            if ((type & LinkType) && d->isSymlink())
-                ret |= LinkType;
-            if (d->fileAttrib & FILE_ATTRIBUTE_DIRECTORY) {
-                ret |= DirectoryType;
-            } else {
-                ret |= FileType;
-            }
+        if (d->metaData.isDirectory()) {
+            ret |= DirectoryType;
+        } else {
+            ret |= FileType;
         }
     }
     if (type & FlagsMask) {
-        ret |= LocalDiskFlag;
-        if (d->doStat()) {
+        if (d->metaData.exists()) {
             ret |= ExistsFlag;
             if (d->fileEntry.isRoot())
                 ret |= RootFlag;
-            else if (d->fileAttrib & FILE_ATTRIBUTE_HIDDEN)
+            else if (d->metaData.isHidden())
                 ret |= HiddenFlag;
         }
     }
@@ -1585,7 +822,7 @@ QString QFSFileEngine::fileName(FileName file) const
                 d->fileEntry.filePath().contains(QLatin1String("/../")) || d->fileEntry.filePath().contains(QLatin1String("/./")) ||
                 d->fileEntry.filePath().endsWith(QLatin1String("/..")) || d->fileEntry.filePath().endsWith(QLatin1String("/.")))
             {
-                ret = QDir::fromNativeSeparators(nativeAbsoluteFilePath(d->fileEntry.filePath()));
+                ret = QDir::fromNativeSeparators(QFileSystemEngine::nativeAbsoluteFilePath(d->fileEntry.filePath()));
             } else
 #endif
             {
@@ -1621,18 +858,13 @@ QString QFSFileEngine::fileName(FileName file) const
     } else if (file == CanonicalName || file == CanonicalPathName) {
         if (!(fileFlags(ExistsFlag) & ExistsFlag))
             return QString();
-        QFileSystemEntry entry(QFileSystemEngine::canonicalName(d->fileEntry));
+        QFileSystemEntry entry(QFileSystemEngine::canonicalName(QFileSystemEntry(fileName(AbsoluteName))));
 
         if (file == CanonicalPathName)
             return entry.path();
         return entry.filePath();
     } else if (file == LinkName) {
-        QString ret;
-        if (d->fileEntry.filePath().endsWith(QLatin1String(".lnk")))
-            ret = readLink(d->fileEntry);
-        else if (d->doStat() && d->isSymlink())
-            ret = readSymLink(d->fileEntry);
-        return QDir::fromNativeSeparators(ret);
+        QFileSystemEngine::getLinkTarget(d->fileEntry, d->metaData).filePath();
     } else if (file == BundleName) {
         return QString();
     }
@@ -1654,67 +886,14 @@ uint QFSFileEngine::ownerId(FileOwner /*own*/) const
 
 QString QFSFileEngine::owner(FileOwner own) const
 {
-    QString name;
-#if !defined(QT_NO_LIBRARY)
     Q_D(const QFSFileEngine);
-    if((qt_ntfs_permission_lookup > 0) && (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)) {
-        QFSFileEnginePrivate::resolveLibs();
-        if (ptrGetNamedSecurityInfoW && ptrLookupAccountSidW) {
-            PSID pOwner = 0;
-            PSECURITY_DESCRIPTOR pSD;
-            if (ptrGetNamedSecurityInfoW((wchar_t*)d->fileEntry.nativeFilePath().utf16(), SE_FILE_OBJECT,
-                                         own == OwnerGroup ? GROUP_SECURITY_INFORMATION : OWNER_SECURITY_INFORMATION,
-                                         own == OwnerUser ? &pOwner : 0, own == OwnerGroup ? &pOwner : 0,
-                                         0, 0, &pSD) == ERROR_SUCCESS) {
-                DWORD lowner = 64;
-                DWORD ldomain = 64;
-                QVarLengthArray<wchar_t, 64> owner(lowner);
-                QVarLengthArray<wchar_t, 64> domain(ldomain);
-                SID_NAME_USE use = SidTypeUnknown;
-                // First call, to determine size of the strings (with '\0').
-                if (!ptrLookupAccountSidW(NULL, pOwner, (LPWSTR)owner.data(), &lowner,
-                                          (LPWSTR)domain.data(), &ldomain, (SID_NAME_USE*)&use)) {
-                    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
-                        if (lowner > (DWORD)owner.size())
-                            owner.resize(lowner);
-                        if (ldomain > (DWORD)domain.size())
-                            domain.resize(ldomain);
-                        // Second call, try on resized buf-s
-                        if (!ptrLookupAccountSidW(NULL, pOwner, (LPWSTR)owner.data(), &lowner,
-                                                  (LPWSTR)domain.data(), &ldomain, (SID_NAME_USE*)&use)) {
-                            lowner = 0;
-                        }
-                    } else {
-                        lowner = 0;
-                    }
-                }
-                if (lowner != 0)
-                    name = QString::fromWCharArray(owner.data());
-                LocalFree(pSD);
-            }
-        }
-    }
-#else
-    Q_UNUSED(own);
-#endif
-    return name;
+    return QFileSystemEngine::owner(d->fileEntry, own);
 }
 
 bool QFSFileEngine::setPermissions(uint perms)
 {
     Q_D(QFSFileEngine);
-    bool ret = false;
-    int mode = 0;
-
-    if (perms & QFile::ReadOwner || perms & QFile::ReadUser || perms & QFile::ReadGroup || perms & QFile::ReadOther)
-        mode |= _S_IREAD;
-    if (perms & QFile::WriteOwner || perms & QFile::WriteUser || perms & QFile::WriteGroup || perms & QFile::WriteOther)
-        mode |= _S_IWRITE;
-
-    if (mode == 0) // not supported
-        return false;
-
-    ret = ::_wchmod((wchar_t*)d->fileEntry.nativeFilePath().utf16(), mode) == 0;
+    bool ret = QFileSystemEngine::setPermissions(d->fileEntry, QFile::Permissions(perms));
     if (!ret)
         setError(QFile::PermissionsError, qt_error_string(errno));
     return ret;
@@ -1758,83 +937,14 @@ bool QFSFileEngine::setSize(qint64 size)
 }
 
 
-static inline QDateTime fileTimeToQDateTime(const FILETIME *time)
-{
-    QDateTime ret;
-
-#if defined(Q_OS_WINCE)
-    SYSTEMTIME systime;
-    FILETIME ftime;
-    systime.wYear = 1970;
-    systime.wMonth = 1;
-    systime.wDay = 1;
-    systime.wHour = 0;
-    systime.wMinute = 0;
-    systime.wSecond = 0;
-    systime.wMilliseconds = 0;
-    systime.wDayOfWeek = 4;
-    SystemTimeToFileTime(&systime, &ftime);
-    unsigned __int64 acttime = (unsigned __int64)time->dwHighDateTime << 32 | time->dwLowDateTime;
-    FileTimeToSystemTime(time, &systime);
-    unsigned __int64 time1970 = (unsigned __int64)ftime.dwHighDateTime << 32 | ftime.dwLowDateTime;
-    unsigned __int64 difftime = acttime - time1970;
-    difftime /= 10000000;
-    ret.setTime_t((unsigned int)difftime);
-#else
-    SYSTEMTIME sTime, lTime;
-    FileTimeToSystemTime(time, &sTime);
-    SystemTimeToTzSpecificLocalTime(0, &sTime, &lTime);
-    ret.setDate(QDate(lTime.wYear, lTime.wMonth, lTime.wDay));
-    ret.setTime(QTime(lTime.wHour, lTime.wMinute, lTime.wSecond, lTime.wMilliseconds));
-#endif
-
-    return ret;
-}
-
 QDateTime QFSFileEngine::fileTime(FileTime time) const
 {
     Q_D(const QFSFileEngine);
-    QDateTime ret;
-    if (d->fd != -1) {
-#if !defined(Q_OS_WINCE)
-        HANDLE fh = (HANDLE)_get_osfhandle(d->fd);
-        if (fh != INVALID_HANDLE_VALUE) {
-            FILETIME creationTime, lastAccessTime, lastWriteTime;
-            if (GetFileTime(fh, &creationTime, &lastAccessTime, &lastWriteTime)) {
-                if(time == CreationTime)
-                    ret = fileTimeToQDateTime(&creationTime);
-                else if(time == ModificationTime)
-                    ret = fileTimeToQDateTime(&lastWriteTime);
-                else if(time == AccessTime)
-                    ret = fileTimeToQDateTime(&lastAccessTime);
-            }
-        }
-#endif
-    } else {
-        WIN32_FILE_ATTRIBUTE_DATA attribData;
-        bool ok = ::GetFileAttributesEx((wchar_t*)QFSFileEnginePrivate::longFileName(d->fileEntry.filePath()).utf16(), GetFileExInfoStandard, &attribData);
-        if (!ok) {
-            int errorCode = GetLastError();
-            if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {
-                WIN32_FIND_DATA findData;
-                if (getFindData(d->fileEntry.nativeFilePath(), findData)) {
-                    ok = true;
-                    attribData.ftCreationTime = findData.ftCreationTime;
-                    attribData.ftLastWriteTime = findData.ftLastWriteTime;
-                    attribData.ftLastAccessTime = findData.ftLastAccessTime;
-                }
-            }
-        }
-        if (ok) {
-            if(time == CreationTime)
-                ret = fileTimeToQDateTime(&attribData.ftCreationTime);
-            else if(time == ModificationTime)
-                ret = fileTimeToQDateTime(&attribData.ftLastWriteTime);
-            else if(time == AccessTime)
-                ret = fileTimeToQDateTime(&attribData.ftLastAccessTime);
-        }
-    }
-    return ret;
+
+    if (d->doStat(QFileSystemMetaData::Times))
+        return d->metaData.fileTime(time);
+
+    return QDateTime();
 }
 
 uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,