1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtCore module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #define _POSIX_

    43 #include "qplatformdefs.h"

    44 #include "qabstractfileengine.h"

    45 #include "private/qfsfileengine_p.h"

    46 #include <qdebug.h>

    47 

    48 #include "qfile.h"

    49 #include "qdir.h"

    50 #include "private/qmutexpool_p.h"

    51 #include "qvarlengtharray.h"

    52 #include "qdatetime.h"

    53 #include "qt_windows.h"

    54 

    55 #if !defined(Q_OS_WINCE)

    56 #  include <sys/types.h>

    57 #  include <direct.h>

    58 #  include <winioctl.h>

    59 #else

    60 #  include <types.h>

    61 #endif

    62 #include <objbase.h>

    63 #include <shlobj.h>

    64 #include <initguid.h>

    65 #include <accctrl.h>

    66 #include <ctype.h>

    67 #include <limits.h>

    68 #define SECURITY_WIN32

    69 #ifdef Q_CC_MINGW

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

    71 #include <subauth.h>

    72 #endif

    73 #include <security.h>

    74 

    75 #ifndef _INTPTR_T_DEFINED

    76 #ifdef  _WIN64

    77 typedef __int64             intptr_t;

    78 #else

    79 #ifdef _W64

    80 typedef _W64 int            intptr_t;

    81 #else

    82 typedef INT_PTR intptr_t;

    83 #endif

    84 #endif

    85 #define _INTPTR_T_DEFINED

    86 #endif

    87 

    88 #ifndef INVALID_FILE_ATTRIBUTES

    89 #  define INVALID_FILE_ATTRIBUTES (DWORD (-1))

    90 #endif

    91 

    92 #if !defined(Q_OS_WINCE)

    93 #  if !defined(REPARSE_DATA_BUFFER_HEADER_SIZE)

    94 typedef struct _REPARSE_DATA_BUFFER {

    95     ULONG  ReparseTag;

    96     USHORT ReparseDataLength;

    97     USHORT Reserved;

    98     union {

    99         struct {

   100             USHORT SubstituteNameOffset;

   101             USHORT SubstituteNameLength;

   102             USHORT PrintNameOffset;

   103             USHORT PrintNameLength;

   104             ULONG  Flags;

   105             WCHAR  PathBuffer[1];

   106         } SymbolicLinkReparseBuffer;

   107         struct {

   108             USHORT SubstituteNameOffset;

   109             USHORT SubstituteNameLength;

   110             USHORT PrintNameOffset;

   111             USHORT PrintNameLength;

   112             WCHAR  PathBuffer[1];

   113         } MountPointReparseBuffer;

   114         struct {

   115             UCHAR  DataBuffer[1];

   116         } GenericReparseBuffer;

   117     };

   118 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;

   119 #    define REPARSE_DATA_BUFFER_HEADER_SIZE  FIELD_OFFSET(REPARSE_DATA_BUFFER, GenericReparseBuffer)

   120 #  endif // !defined(REPARSE_DATA_BUFFER_HEADER_SIZE)

   121 

   122 #  ifndef MAXIMUM_REPARSE_DATA_BUFFER_SIZE

   123 #    define MAXIMUM_REPARSE_DATA_BUFFER_SIZE 16384

   124 #  endif

   125 #  ifndef IO_REPARSE_TAG_SYMLINK

   126 #    define IO_REPARSE_TAG_SYMLINK (0xA000000CL)

   127 #  endif

   128 #  ifndef FSCTL_GET_REPARSE_POINT

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

   130 #  endif

   131 #endif // !defined(Q_OS_WINCE)

   132 

   133 QT_BEGIN_NAMESPACE

   134 

   135 static QString readLink(const QString &link);

   136 

   137 Q_CORE_EXPORT int qt_ntfs_permission_lookup = 0;

   138 

   139 #if defined(Q_OS_WINCE)

   140 static QString qfsPrivateCurrentDir = QLatin1String("");

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

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

   143 #define QT_NO_LIBRARY 1

   144 #endif

   145 

   146 #if !defined(QT_NO_LIBRARY)

   147 QT_BEGIN_INCLUDE_NAMESPACE

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

   149 static PtrGetNamedSecurityInfoW ptrGetNamedSecurityInfoW = 0;

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

   151 static PtrLookupAccountSidW ptrLookupAccountSidW = 0;

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

   153 static PtrBuildTrusteeWithSidW ptrBuildTrusteeWithSidW = 0;

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

   155 static PtrGetEffectiveRightsFromAclW ptrGetEffectiveRightsFromAclW = 0;

   156 static TRUSTEE_W currentUserTrusteeW;

   157 static TRUSTEE_W worldTrusteeW;

   158 

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

   160 static PtrGetUserProfileDirectoryW ptrGetUserProfileDirectoryW = 0;

   161 QT_END_INCLUDE_NAMESPACE

   162 

   163 

   164 void QFSFileEnginePrivate::resolveLibs()

   165 {

   166     static bool triedResolve = false;

   167     if (!triedResolve) {

   168         // need to resolve the security info functions

   169 

   170         // protect initialization

   171 #ifndef QT_NO_THREAD

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

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

   174         // done the initialization

   175         if (triedResolve) {

   176             // another thread did initialize the security function pointers,

   177             // so we shouldn't do it again.

   178             return;

   179         }

   180 #endif

   181 

   182         triedResolve = true;

   183 #if !defined(Q_OS_WINCE)

   184         HINSTANCE advapiHnd = LoadLibraryW(L"advapi32");

   185         if (advapiHnd) {

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

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

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

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

   190         }

   191         if (ptrBuildTrusteeWithSidW) {

   192             // Create TRUSTEE for current user

   193             HANDLE hnd = ::GetCurrentProcess();

   194             HANDLE token = 0;

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

   196                 TOKEN_USER tu;

   197                 DWORD retsize;

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

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

   200                 ::CloseHandle(token);

   201             }

   202 

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

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

   205             typedef PVOID (WINAPI *PtrFreeSid)(PSID);

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

   207             if (ptrAllocateAndInitializeSid && ptrFreeSid) {

   208                 // Create TRUSTEE for Everyone (World)

   209                 SID_IDENTIFIER_AUTHORITY worldAuth = { SECURITY_WORLD_SID_AUTHORITY };

   210                 PSID pWorld = 0;

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

   212                     ptrBuildTrusteeWithSidW(&worldTrusteeW, pWorld);

   213                 ptrFreeSid(pWorld);

   214             }

   215         }

   216         HINSTANCE userenvHnd = LoadLibraryW(L"userenv");

   217         if (userenvHnd)

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

   219 #endif

   220     }

   221 }

   222 #endif // QT_NO_LIBRARY

   223 

   224 // UNC functions NT

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

   226 static PtrNetShareEnum ptrNetShareEnum = 0;

   227 typedef DWORD (WINAPI *PtrNetApiBufferFree)(LPVOID);

   228 static PtrNetApiBufferFree ptrNetApiBufferFree = 0;

   229 typedef struct _SHARE_INFO_1 {

   230     LPWSTR shi1_netname;

   231     DWORD shi1_type;

   232     LPWSTR shi1_remark;

   233 } SHARE_INFO_1;

   234 

   235 

   236 bool QFSFileEnginePrivate::resolveUNCLibs()

   237 {

   238     static bool triedResolve = false;

   239     if (!triedResolve) {

   240 #ifndef QT_NO_THREAD

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

   242         if (triedResolve) {

   243             return ptrNetShareEnum && ptrNetApiBufferFree;

   244         }

   245 #endif

   246         triedResolve = true;

   247 #if !defined(Q_OS_WINCE)

   248         HINSTANCE hLib = LoadLibraryW(L"Netapi32");

   249         if (hLib) {

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

   251             if (ptrNetShareEnum)

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

   253         }

   254 #endif

   255     }

   256     return ptrNetShareEnum && ptrNetApiBufferFree;

   257 }

   258 

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

   260 {

   261     if (resolveUNCLibs()) {

   262         SHARE_INFO_1 *BufPtr, *p;

   263         DWORD res;

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

   265         do {

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

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

   268                 p = BufPtr;

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

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

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

   272                     p++;

   273                 }

   274             }

   275             ptrNetApiBufferFree(BufPtr);

   276         } while (res == ERROR_MORE_DATA);

   277         return res == ERROR_SUCCESS;

   278     }

   279     return false;

   280 }

   281 

   282 static bool isUncRoot(const QString &server)

   283 {

   284     QString localPath = QDir::toNativeSeparators(server);

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

   286         return false;

   287 

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

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

   290         return true;

   291 

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

   293     return localPath.isEmpty();

   294 }

   295 

   296 #if !defined(Q_OS_WINCE)

   297 static inline bool isUncPath(const QString &path)

   298 {

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

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

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

   302 }

   303 #endif

   304 

   305 static inline bool isRelativePath(const QString &path)

   306 {

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

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

   309            || (path.length() >= 2

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

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

   312 }

   313 

   314 static QString fixIfRelativeUncPath(const QString &path)

   315 {

   316     if (isRelativePath(path)) {

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

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

   319             return QString(path).prepend(currentPath);

   320     }

   321     return path;

   322 }

   323 

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

   325 static bool uncShareExists(const QString &server)

   326 {

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

   328     if (parts.count()) {

   329         QStringList shares;

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

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

   332     }

   333     return false;

   334 }

   335 

   336 static inline bool isDriveRoot(const QString &path)

   337 {

   338     return (path.length() == 3

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

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

   341 }

   342 

   343 static QString nativeAbsoluteFilePath(const QString &path)

   344 {

   345     QString absPath;

   346 #if !defined(Q_OS_WINCE)

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

   348     wchar_t *fileName = 0;

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

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

   351         buf.resize(retLen);

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

   353     }

   354     if (retLen != 0)

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

   356 #else

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

   358         absPath = QDir::toNativeSeparators(path);

   359     else

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

   361 #endif

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

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

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

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

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

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

   368         absPath.append(QLatin1Char(' '));

   369     return absPath;

   370 }

   371 

   372 /*!

   373     \internal

   374 */

   375 QString QFSFileEnginePrivate::longFileName(const QString &path)

   376 {

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

   378         return path;

   379 

   380     QString absPath = nativeAbsoluteFilePath(path);

   381 #if !defined(Q_OS_WINCE)

   382     QString prefix = QLatin1String("\\\\?\\");

   383     if (isUncPath(absPath)) {

   384         prefix.append(QLatin1String("UNC\\")); // "\\\\?\\UNC\\"

   385         absPath.remove(0, 2);

   386     }

   387     return prefix + absPath;

   388 #else

   389     return absPath;

   390 #endif

   391 }

   392 

   393 /*

   394     \internal

   395 */

   396 void QFSFileEnginePrivate::nativeInitFileName()

   397 {

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

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

   400 }

   401 

   402 /*

   403     \internal

   404 */

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

   406 {

   407     Q_Q(QFSFileEngine);

   408 

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

   410     DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;

   411 

   412     int accessRights = 0;

   413     if (openMode & QIODevice::ReadOnly)

   414         accessRights |= GENERIC_READ;

   415     if (openMode & QIODevice::WriteOnly)

   416         accessRights |= GENERIC_WRITE;

   417 

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

   419 

   420     // WriteOnly can create files, ReadOnly cannot.

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

   422 

   423     // Create the file handle.

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

   425                             accessRights,

   426                             shareMode,

   427                             &securityAtts,

   428                             creationDisp,

   429                             FILE_ATTRIBUTE_NORMAL,

   430                             NULL);

   431 

   432     // Bail out on error.

   433     if (fileHandle == INVALID_HANDLE_VALUE) {

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

   435         return false;

   436     }

   437 

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

   439     if (openMode & QIODevice::Truncate)

   440         q->setSize(0);

   441 

   442     return true;

   443 }

   444 

   445 /*

   446     \internal

   447 */

   448 bool QFSFileEnginePrivate::nativeClose()

   449 {

   450     Q_Q(QFSFileEngine);

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

   452         // stdlib / stdio mode.

   453         return closeFdFh();

   454     }

   455 

   456     // Windows native mode.

   457     bool ok = true;

   458     if ((fileHandle == INVALID_HANDLE_VALUE || !CloseHandle(fileHandle))

   459 #ifdef Q_USE_DEPRECATED_MAP_API

   460             && (fileMapHandle == INVALID_HANDLE_VALUE || !CloseHandle(fileMapHandle))

   461 #endif

   462         ) {

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

   464         ok = false;

   465     }

   466 #ifdef Q_USE_DEPRECATED_MAP_API

   467     fileMapHandle = INVALID_HANDLE_VALUE;

   468 #endif

   469     fileHandle = INVALID_HANDLE_VALUE;

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

   471 

   472     return ok;

   473 }

   474 

   475 /*

   476     \internal

   477 */

   478 bool QFSFileEnginePrivate::nativeFlush()

   479 {

   480     if (fh) {

   481         // Buffered stdlib mode.

   482         return flushFh();

   483     }

   484     if (fd != -1) {

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

   486         return true;

   487     }

   488 

   489     // Windows native mode; flushing is

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

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

   492     // don't expose an API for this.

   493     return true;

   494 }

   495 

   496 /*

   497     \internal

   498 */

   499 qint64 QFSFileEnginePrivate::nativeSize() const

   500 {

   501     Q_Q(const QFSFileEngine);

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

   503 

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

   505     thatQ->flush();

   506 

   507     // Buffered stdlib mode.

   508     if (fh) {

   509         QT_OFF_T oldPos = QT_FTELL(fh);

   510         QT_FSEEK(fh, 0, SEEK_END);

   511         QT_OFF_T fileSize = QT_FTELL(fh);

   512         QT_FSEEK(fh, oldPos, SEEK_SET);

   513         return qint64(fileSize);

   514     }

   515 

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

   517     // file system directly.

   518     if (openMode == QIODevice::NotOpen && !nativeFilePath.isEmpty()) {

   519         WIN32_FILE_ATTRIBUTE_DATA attribData;

   520         bool ok = ::GetFileAttributesEx((const wchar_t*)nativeFilePath.constData(),

   521                                         GetFileExInfoStandard, &attribData);

   522         if (!ok) {

   523             int errorCode = GetLastError();

   524             if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {

   525                 QByteArray path = nativeFilePath;

   526                 // path for the FindFirstFile should not end with a trailing slash

   527                 while (path.endsWith('\\'))

   528                     path.chop(1);

   529 

   530                 // FindFirstFile can not handle drives

   531                 if (!path.endsWith(':')) {

   532                     WIN32_FIND_DATA findData;

   533                     HANDLE hFind = ::FindFirstFile((const wchar_t*)path.constData(),

   534                                                    &findData);

   535                     if (hFind != INVALID_HANDLE_VALUE) {

   536                         ::FindClose(hFind);

   537                         ok = true;

   538                         attribData.nFileSizeHigh = findData.nFileSizeHigh;

   539                         attribData.nFileSizeLow = findData.nFileSizeLow;

   540                     }

   541                 }

   542             }

   543         }

   544         if (ok) {

   545             qint64 size = attribData.nFileSizeHigh;

   546             size <<= 32;

   547             size += attribData.nFileSizeLow;

   548             return size;

   549         }

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

   551         return 0;

   552     }

   553 

   554     // Unbuffed stdio mode.

   555     if(fd != -1) {

   556 #if !defined(Q_OS_WINCE)

   557         HANDLE handle = (HANDLE)_get_osfhandle(fd);

   558         if (handle != INVALID_HANDLE_VALUE) {

   559             BY_HANDLE_FILE_INFORMATION fileInfo;

   560             if (GetFileInformationByHandle(handle, &fileInfo)) {

   561                 qint64 size = fileInfo.nFileSizeHigh;

   562                 size <<= 32;

   563                 size += fileInfo.nFileSizeLow;

   564                 return size;

   565             }

   566         }

   567 #endif

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

   569         return 0;

   570     }

   571 

   572     // Windows native mode.

   573     if (fileHandle == INVALID_HANDLE_VALUE)

   574         return 0;

   575 

   576     BY_HANDLE_FILE_INFORMATION fileInfo;

   577     if (!GetFileInformationByHandle(fileHandle, &fileInfo)) {

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

   579         return 0;

   580     }

   581 

   582     qint64 size = fileInfo.nFileSizeHigh;

   583     size <<= 32;

   584     size += fileInfo.nFileSizeLow;

   585     return size;

   586 }

   587 

   588 /*

   589     \internal

   590 */

   591 qint64 QFSFileEnginePrivate::nativePos() const

   592 {

   593     Q_Q(const QFSFileEngine);

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

   595 

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

   597         // stdlib / stido mode.

   598         return posFdFh();

   599     }

   600 

   601     // Windows native mode.

   602     if (fileHandle == INVALID_HANDLE_VALUE)

   603         return 0;

   604 

   605 #if !defined(Q_OS_WINCE)

   606     LARGE_INTEGER currentFilePos;

   607     LARGE_INTEGER offset;

   608     offset.QuadPart = 0;

   609     if (!::SetFilePointerEx(fileHandle, offset, &currentFilePos, FILE_CURRENT)) {

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

   611         return 0;

   612     }

   613 

   614     return qint64(currentFilePos.QuadPart);

   615 #else

   616     LARGE_INTEGER filepos;

   617     filepos.HighPart = 0;

   618     DWORD newFilePointer = SetFilePointer(fileHandle, 0, &filepos.HighPart, FILE_CURRENT);

   619     if (newFilePointer == 0xFFFFFFFF && GetLastError() != NO_ERROR) {

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

   621         return 0;

   622     }

   623 

   624     filepos.LowPart = newFilePointer;

   625     return filepos.QuadPart;

   626 #endif

   627 }

   628 

   629 /*

   630     \internal

   631 */

   632 bool QFSFileEnginePrivate::nativeSeek(qint64 pos)

   633 {

   634     Q_Q(QFSFileEngine);

   635 

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

   637         // stdlib / stdio mode.

   638         return seekFdFh(pos);

   639     }

   640 

   641 #if !defined(Q_OS_WINCE)

   642     LARGE_INTEGER currentFilePos;

   643     LARGE_INTEGER offset;

   644     offset.QuadPart = pos;

   645     if (!::SetFilePointerEx(fileHandle, offset, &currentFilePos, FILE_BEGIN)) {

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

   647         return false;

   648     }

   649 

   650     return true;

   651 #else

   652     DWORD newFilePointer;

   653     LARGE_INTEGER *li = reinterpret_cast<LARGE_INTEGER*>(&pos);

   654     newFilePointer = SetFilePointer(fileHandle, li->LowPart, &li->HighPart, FILE_BEGIN);

   655     if (newFilePointer == 0xFFFFFFFF && GetLastError() != NO_ERROR) {

   656         q->setError(QFile::PositionError, qt_error_string());

   657         return false;

   658     }

   659 

   660     return true;

   661 #endif

   662 }

   663 

   664 /*

   665     \internal

   666 */

   667 qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 maxlen)

   668 {

   669     Q_Q(QFSFileEngine);

   670 

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

   672         // stdio / stdlib mode.

   673         if (fh && nativeIsSequential() && feof(fh)) {

   674             q->setError(QFile::ReadError, qt_error_string(int(errno)));

   675             return -1;

   676         }

   677 

   678         return readFdFh(data, maxlen);

   679     }

   680 

   681     // Windows native mode.

   682     if (fileHandle == INVALID_HANDLE_VALUE)

   683         return -1;

   684 

   685     DWORD bytesToRead = DWORD(maxlen); // <- lossy

   686 

   687     // Reading on Windows fails with ERROR_NO_SYSTEM_RESOURCES when

   688     // the chunks are too large, so we limit the block size to 32MB.

   689     static const DWORD maxBlockSize = 32 * 1024 * 1024;

   690 

   691     qint64 totalRead = 0;

   692     do {

   693         DWORD blockSize = qMin<DWORD>(bytesToRead, maxBlockSize);

   694         DWORD bytesRead;

   695         if (!ReadFile(fileHandle, data + totalRead, blockSize, &bytesRead, NULL)) {

   696             if (totalRead == 0) {

   697                 // Note: only return failure if the first ReadFile fails.

   698                 q->setError(QFile::ReadError, qt_error_string());

   699                 return -1;

   700             }

   701             break;

   702         }

   703         if (bytesRead == 0)

   704             break;

   705         totalRead += bytesRead;

   706         bytesToRead -= bytesRead;

   707     } while (totalRead < maxlen);

   708     return qint64(totalRead);

   709 }

   710 

   711 /*

   712     \internal

   713 */

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

   715 {

   716     Q_Q(QFSFileEngine);

   717 

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

   719         // stdio / stdlib mode.

   720         return readLineFdFh(data, maxlen);

   721     }

   722 

   723     // Windows native mode.

   724     if (fileHandle == INVALID_HANDLE_VALUE)

   725         return -1;

   726 

   727     // ### No equivalent in Win32?

   728     return q->QAbstractFileEngine::readLine(data, maxlen);

   729 }

   730 

   731 /*

   732     \internal

   733 */

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

   735 {

   736     Q_Q(QFSFileEngine);

   737 

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

   739         // stdio / stdlib mode.

   740         return writeFdFh(data, len);

   741     }

   742 

   743     // Windows native mode.

   744     if (fileHandle == INVALID_HANDLE_VALUE)

   745         return -1;

   746 

   747     qint64 bytesToWrite = DWORD(len); // <- lossy

   748 

   749     // Writing on Windows fails with ERROR_NO_SYSTEM_RESOURCES when

   750     // the chunks are too large, so we limit the block size to 32MB.

   751     static const DWORD maxBlockSize = 32 * 1024 * 1024;

   752 

   753     qint64 totalWritten = 0;

   754     do {

   755         DWORD blockSize = qMin<DWORD>(bytesToWrite, maxBlockSize);

   756         DWORD bytesWritten;

   757         if (!WriteFile(fileHandle, data + totalWritten, blockSize, &bytesWritten, NULL)) {

   758             if (totalWritten == 0) {

   759                 // Note: Only return error if the first WriteFile failed.

   760                 q->setError(QFile::WriteError, qt_error_string());

   761                 return -1;

   762             }

   763             break;

   764         }

   765         if (bytesWritten == 0)

   766             break;

   767         totalWritten += bytesWritten;

   768         bytesToWrite -= bytesWritten;

   769     } while (totalWritten < len);

   770     return qint64(totalWritten);

   771 }

   772 

   773 /*

   774     \internal

   775 */

   776 int QFSFileEnginePrivate::nativeHandle() const

   777 {

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

   779         return fh ? QT_FILENO(fh) : fd;

   780 #ifndef Q_OS_WINCE

   781     if (cachedFd != -1)

   782         return cachedFd;

   783 

   784     int flags = 0;

   785     if (openMode & QIODevice::Append)

   786         flags |= _O_APPEND;

   787     if (!(openMode & QIODevice::WriteOnly))

   788         flags |= _O_RDONLY;

   789     cachedFd = _open_osfhandle((intptr_t) fileHandle, flags);

   790     return cachedFd;

   791 #else

   792     return -1;

   793 #endif

   794 }

   795 

   796 /*

   797     \internal

   798 */

   799 bool QFSFileEnginePrivate::nativeIsSequential() const

   800 {

   801 #if !defined(Q_OS_WINCE)

   802     // stdlib / Windows native mode.

   803     if (fh || fileHandle != INVALID_HANDLE_VALUE) {

   804         if (fh == stdin || fh == stdout || fh == stderr)

   805             return true;

   806 

   807         HANDLE handle = fileHandle;

   808         if (fileHandle == INVALID_HANDLE_VALUE) {

   809             // Rare case: using QFile::open(FILE*) to open a pipe.

   810             handle = (HANDLE)_get_osfhandle(QT_FILENO(fh));

   811             return false;

   812         }

   813 

   814         DWORD fileType = GetFileType(handle);

   815         return fileType == FILE_TYPE_PIPE;

   816     }

   817 

   818     // stdio mode.

   819     if (fd != -1)

   820         return isSequentialFdFh();

   821 #endif

   822     return false;

   823 }

   824 

   825 bool QFSFileEngine::remove()

   826 {

   827     Q_D(QFSFileEngine);

   828     bool ret = ::DeleteFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16()) != 0;

   829     if (!ret)

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

   831     return ret;

   832 }

   833 

   834 bool QFSFileEngine::copy(const QString &copyName)

   835 {

   836     Q_D(QFSFileEngine);

   837     bool ret = ::CopyFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),

   838                           (wchar_t*)QFSFileEnginePrivate::longFileName(copyName).utf16(), true) != 0;

   839     if (!ret)

   840         setError(QFile::CopyError, qt_error_string());

   841     return ret;

   842 }

   843 

   844 bool QFSFileEngine::rename(const QString &newName)

   845 {

   846     Q_D(QFSFileEngine);

   847     bool ret = ::MoveFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),

   848                           (wchar_t*)QFSFileEnginePrivate::longFileName(newName).utf16()) != 0;

   849     if (!ret)

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

   851     return ret;

   852 }

   853 

   854 static inline bool mkDir(const QString &path)

   855 {

   856 #if defined(Q_OS_WINCE)

   857     // Unfortunately CreateDirectory returns true for paths longer than

   858     // 256, but does not create a directory. It starts to fail, when

   859     // path length > MAX_PATH, which is 260 usually on CE.

   860     // This only happens on a Windows Mobile device. Windows CE seems

   861     // not to be affected by this.

   862     static int platformId = 0;

   863     if (platformId == 0) {

   864         wchar_t platformString[64];

   865         if (SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(platformString)/sizeof(*platformString),platformString,0)) {

   866             if (0 == wcscmp(platformString, L"PocketPC") || 0 == wcscmp(platformString, L"Smartphone"))

   867                 platformId = 1;

   868             else

   869                 platformId = 2;

   870         }

   871     }

   872     if (platformId == 1 && QFSFileEnginePrivate::longFileName(path).size() > 256)

   873         return false;

   874 #endif

   875     return ::CreateDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16(), 0);

   876 }

   877 

   878 static inline bool rmDir(const QString &path)

   879 {

   880     return ::RemoveDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());

   881 }

   882 

   883 static bool isDirPath(const QString &dirPath, bool *existed)

   884 {

   885     QString path = dirPath;

   886     if (path.length() == 2 && path.at(1) == QLatin1Char(':'))

   887         path += QLatin1Char('\\');

   888 

   889     DWORD fileAttrib = ::GetFileAttributes((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());

   890     if (fileAttrib == INVALID_FILE_ATTRIBUTES) {

   891         int errorCode = GetLastError();

   892         if (errorCode == ERROR_ACCESS_DENIED || errorCode == ERROR_SHARING_VIOLATION) {

   893             // path for the FindFirstFile should not end with a trailing slash

   894             while (path.endsWith(QLatin1Char('\\')))

   895                 path.chop(1);

   896 

   897             // FindFirstFile can not handle drives

   898             if (!path.endsWith(QLatin1Char(':'))) {

   899                 WIN32_FIND_DATA findData;

   900                 HANDLE hFind = ::FindFirstFile((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16(),

   901                                                &findData);

   902                 if (hFind != INVALID_HANDLE_VALUE) {

   903                     ::FindClose(hFind);

   904                     fileAttrib = findData.dwFileAttributes;

   905                 }

   906             }

   907         }

   908     }

   909 

   910     if (existed)

   911         *existed = fileAttrib != INVALID_FILE_ATTRIBUTES;

   912 

   913     if (fileAttrib == INVALID_FILE_ATTRIBUTES)

   914         return false;

   915 

   916     return fileAttrib & FILE_ATTRIBUTE_DIRECTORY;

   917 }

   918 

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

   920 {

   921     QString dirName = name;

   922     if (createParentDirectories) {

   923         dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));

   924         // We spefically search for / so \ would break it..

   925         int oldslash = -1;

   926         if (dirName.startsWith(QLatin1String("\\\\"))) {

   927             // Don't try to create the root path of a UNC path;

   928             // CreateDirectory() will just return ERROR_INVALID_NAME.

   929             for (int i = 0; i < dirName.size(); ++i) {

   930                 if (dirName.at(i) != QDir::separator()) {

   931                     oldslash = i;

   932                     break;

   933                 }

   934             }

   935             if (oldslash != -1)

   936                 oldslash = dirName.indexOf(QDir::separator(), oldslash);

   937         }

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

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

   940             if (slash == -1) {

   941                 if (oldslash == dirName.length())

   942                     break;

   943                 slash = dirName.length();

   944             }

   945             if (slash) {

   946                 QString chunk = dirName.left(slash);

   947                 bool existed = false;

   948                 if (!isDirPath(chunk, &existed)) {

   949                     if (!existed) {

   950                         if (!mkDir(chunk))

   951                             return false;

   952                     } else {

   953                         return false;

   954                     }

   955                 }

   956             }

   957         }

   958         return true;

   959     }

   960     return mkDir(name);

   961 }

   962 

   963 bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const

   964 {

   965     QString dirName = name;

   966     if (recurseParentDirectories) {

   967         dirName = QDir::toNativeSeparators(QDir::cleanPath(dirName));

   968         for (int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {

   969             QString chunk = dirName.left(slash);

   970             if (chunk.length() == 2 && chunk.at(0).isLetter() && chunk.at(1) == QLatin1Char(':'))

   971                 break;

   972             if (!isDirPath(chunk, 0))

   973                 return false;

   974             if (!rmDir(chunk))

   975                 return oldslash != 0;

   976             slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);

   977         }

   978         return true;

   979     }

   980     return rmDir(name);

   981 }

   982 

   983 bool QFSFileEngine::caseSensitive() const

   984 {

   985     return false;

   986 }

   987 

   988 bool QFSFileEngine::setCurrentPath(const QString &path)

   989 {

   990     if (!QDir(path).exists())

   991         return false;

   992 

   993 #if !defined(Q_OS_WINCE)

   994     return ::SetCurrentDirectory((wchar_t*)path.utf16()) != 0;

   995 #else

   996     qfsPrivateCurrentDir = QFSFileEnginePrivate::longFileName(path);

   997     return true;

   998 #endif

   999 }

  1000 

  1001 QString QFSFileEngine::currentPath(const QString &fileName)

  1002 {

  1003 #if !defined(Q_OS_WINCE)

  1004     QString ret;

  1005     //if filename is a drive: then get the pwd of that drive

  1006     if (fileName.length() >= 2 &&

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

  1008         int drv = fileName.toUpper().at(0).toLatin1() - 'A' + 1;

  1009         if (_getdrive() != drv) {

  1010             wchar_t buf[PATH_MAX];

  1011             ::_wgetdcwd(drv, buf, PATH_MAX);

  1012             ret = QString::fromWCharArray(buf);

  1013         }

  1014     }

  1015     if (ret.isEmpty()) {

  1016         //just the pwd

  1017         DWORD size = 0;

  1018         wchar_t currentName[PATH_MAX];

  1019         size = ::GetCurrentDirectory(PATH_MAX, currentName);

  1020         if (size != 0) {

  1021             if (size > PATH_MAX) {

  1022                 wchar_t *newCurrentName = new wchar_t[size];

  1023                 if (::GetCurrentDirectory(PATH_MAX, newCurrentName) != 0)

  1024                     ret = QString::fromWCharArray(newCurrentName);

  1025                 delete [] newCurrentName;

  1026             } else {

  1027                 ret = QString::fromWCharArray(currentName);

  1028             }

  1029         }

  1030     }

  1031     if (ret.length() >= 2 && ret[1] == QLatin1Char(':'))

  1032         ret[0] = ret.at(0).toUpper(); // Force uppercase drive letters.

  1033     return QDir::fromNativeSeparators(ret);

  1034 #else

  1035     Q_UNUSED(fileName);

  1036     if (qfsPrivateCurrentDir.isEmpty())

  1037         qfsPrivateCurrentDir = QCoreApplication::applicationDirPath();

  1038 

  1039     return QDir::fromNativeSeparators(qfsPrivateCurrentDir);

  1040 #endif

  1041 }

  1042 

  1043 QString QFSFileEngine::homePath()

  1044 {

  1045     QString ret;

  1046 #if !defined(QT_NO_LIBRARY)

  1047     QFSFileEnginePrivate::resolveLibs();

  1048     if (ptrGetUserProfileDirectoryW) {

  1049         HANDLE hnd = ::GetCurrentProcess();

  1050         HANDLE token = 0;

  1051         BOOL ok = ::OpenProcessToken(hnd, TOKEN_QUERY, &token);

  1052         if (ok) {

  1053             DWORD dwBufferSize = 0;

  1054             // First call, to determine size of the strings (with '\0').

  1055             ok = ::ptrGetUserProfileDirectoryW(token, NULL, &dwBufferSize);

  1056             if (!ok && dwBufferSize != 0) {        // We got the required buffer size

  1057                 wchar_t *userDirectory = new wchar_t[dwBufferSize];

  1058                 // Second call, now we can fill the allocated buffer.

  1059                 ok = ::ptrGetUserProfileDirectoryW(token, userDirectory, &dwBufferSize);

  1060                 if (ok)

  1061                     ret = QString::fromWCharArray(userDirectory);

  1062 

  1063                 delete [] userDirectory;

  1064             }

  1065             ::CloseHandle(token);

  1066         }

  1067                 }

  1068 #endif

  1069     if (ret.isEmpty() || !QFile::exists(ret)) {

  1070         ret = QString::fromLocal8Bit(qgetenv("USERPROFILE").constData());

  1071         if (ret.isEmpty() || !QFile::exists(ret)) {

  1072             ret = QString::fromLocal8Bit(qgetenv("HOMEDRIVE").constData()) + QString::fromLocal8Bit(qgetenv("HOMEPATH").constData());

  1073             if (ret.isEmpty() || !QFile::exists(ret)) {

  1074                 ret = QString::fromLocal8Bit(qgetenv("HOME").constData());

  1075                 if (ret.isEmpty() || !QFile::exists(ret)) {

  1076 #if defined(Q_OS_WINCE)

  1077                     ret = QLatin1String("\\My Documents");

  1078                     if (!QFile::exists(ret))

  1079 #endif

  1080                     ret = rootPath();

  1081                 }

  1082             }

  1083         }

  1084     }

  1085     return QDir::fromNativeSeparators(ret);

  1086 }

  1087 

  1088 QString QFSFileEngine::rootPath()

  1089 {

  1090 #if defined(Q_OS_WINCE)

  1091     QString ret = QLatin1String("/");

  1092 #elif defined(Q_FS_FAT)

  1093     QString ret = QString::fromLatin1(qgetenv("SystemDrive").constData());

  1094     if (ret.isEmpty())

  1095         ret = QLatin1String("c:");

  1096     ret.append(QLatin1Char('/'));

  1097 #elif defined(Q_OS_OS2EMX)

  1098     char dir[4];

  1099     _abspath(dir, QLatin1String("/"), _MAX_PATH);

  1100     QString ret(dir);

  1101 #endif

  1102     return ret;

  1103 }

  1104 

  1105 QString QFSFileEngine::tempPath()

  1106 {

  1107     QString ret;

  1108     {

  1109         wchar_t tempPath[MAX_PATH];

  1110         if (GetTempPath(MAX_PATH, tempPath))

  1111             ret = QString::fromWCharArray(tempPath);

  1112         if (!ret.isEmpty()) {

  1113             while (ret.endsWith(QLatin1Char('\\')))

  1114                 ret.chop(1);

  1115             ret = QDir::fromNativeSeparators(ret);

  1116         }

  1117     }

  1118     if (ret.isEmpty()) {

  1119 #if !defined(Q_OS_WINCE)

  1120         ret = QLatin1String("c:/tmp");

  1121 #else

  1122         ret = QLatin1String("/Temp");

  1123 #endif

  1124     }

  1125     return ret;

  1126 }

  1127 

  1128 QFileInfoList QFSFileEngine::drives()

  1129 {

  1130     QFileInfoList ret;

  1131 #if !defined(Q_OS_WINCE)

  1132 #if defined(Q_OS_WIN32)

  1133     quint32 driveBits = (quint32) GetLogicalDrives() & 0x3ffffff;

  1134 #elif defined(Q_OS_OS2EMX)