QFileSystemEngine Class Reference

#include <qfilesystemengine_p.h>

Static Public Functions
static QFileSystemEntry	absoluteName (const QFileSystemEntry &entry)
static QString	bundleName (const QFileSystemEntry &entry)
static QFileSystemEntry	canonicalName (const QFileSystemEntry &entry, QFileSystemMetaData &data)
static bool	copyFile (const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error)
static bool	createDirectory (const QFileSystemEntry &entry, bool createParents)
static bool	createLink (const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error)
static QFileSystemEntry	currentPath ()
static bool	fillMetaData (const QFileSystemEntry &entry, QFileSystemMetaData &data, QFileSystemMetaData::MetaDataFlags what)
static bool	fillMetaData (int fd, QFileSystemMetaData &data)
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 QFileSystemEntry	getLinkTarget (const QFileSystemEntry &link, QFileSystemMetaData &data)
static QString	homePath ()
static bool	isCaseSensitive ()
static QString	nativeAbsoluteFilePath (const QString &path)
static QString	owner (const QFileSystemEntry &entry, QAbstractFileEngine::FileOwner own)
static bool	removeDirectory (const QFileSystemEntry &entry, bool removeEmptyParents)
static bool	removeFile (const QFileSystemEntry &entry, QSystemError &error)
static bool	renameFile (const QFileSystemEntry &source, const QFileSystemEntry &target, QSystemError &error)
static QAbstractFileEngine *	resolveEntryAndCreateLegacyEngine (QFileSystemEntry &entry, QFileSystemMetaData &data)
	Resolves the entry (see QDir::searchPaths) and returns an engine for it, but never a QFSFileEngine. More...
static QString	resolveGroupName (const QFileSystemEntry &entry, QFileSystemMetaData &data)
static QString	resolveGroupName (uint groupId)
static QString	resolveUserName (const QFileSystemEntry &entry, QFileSystemMetaData &data)
static QString	resolveUserName (uint userId)
static QString	rootPath ()
static bool	setCurrentPath (const QFileSystemEntry &entry)
static bool	setPermissions (const QFileSystemEntry &entry, QFile::Permissions permissions, QSystemError &error, QFileSystemMetaData *data=0)
static QString	tempPath ()
static bool	uncListSharesOnServer (const QString &server, QStringList *list)

Static Private Functions
static void	clearWinStatData (QFileSystemMetaData &data)
static QString	slowCanonicalized (const QString &path)
	Returns the canonicalized form of path (i. More...

Detailed Description

Definition at line 63 of file qfilesystemengine_p.h.

Functions

absoluteName()

QFileSystemEntry QFileSystemEngine::absoluteName ( const QFileSystemEntry &  entry )

static

Definition at line 236 of file qfilesystemengine_unix.cpp.

Referenced by canonicalName(), QFSFileEngine::fileName(), QFileInfoPrivate::getFileName(), QFSFileEnginePrivate::map(), nativeAbsoluteFilePath(), QTemporaryFileEngine::open(), QDirPrivate::resolveAbsoluteEntry(), and setCloseOnExec().

{
    if (entry.isAbsolute() && entry.isClean())
        return entry;

    QByteArray orig = entry.nativeFilePath();
    QByteArray result;
    if (orig.isEmpty() || !orig.startsWith('/')) {
        QFileSystemEntry cur(currentPath());
        result = cur.nativeFilePath();
    }
    if (!orig.isEmpty() && !(orig.length() == 1 && orig[0] == '.')) {
        if (!result.isEmpty() && !result.endsWith('/'))
            result.append('/');
        result.append(orig);
    }

    if (result.length() == 1 && result[0] == '/')
        return QFileSystemEntry(result, QFileSystemEntry::FromNativePath());
    const bool isDir = result.endsWith('/');

    /* as long as QDir::cleanPath() operates on a QString we have to convert to a string here.
     * ideally we never convert to a string since that loses information. Please fix after
     * we get a QByteArray version of QDir::cleanPath()
     */
    QFileSystemEntry resultingEntry(result, QFileSystemEntry::FromNativePath());
    QString stringVersion = QDir::cleanPath(resultingEntry.filePath());
    if (isDir)
        stringVersion.append(QLatin1Char('/'));
    return QFileSystemEntry(stringVersion);
}

bundleName()

QString QFileSystemEngine::bundleName ( const QFileSystemEntry &  entry )

static

Definition at line 331 of file qfilesystemengine_unix.cpp.

Referenced by QFSFileEngine::fileName(), and QFileInfoPrivate::getFileName().

{
    QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(entry.filePath()),
            kCFURLPOSIXPathStyle, true);
    if (QCFType<CFDictionaryRef> dict = CFBundleCopyInfoDictionaryForURL(url)) {
        if (CFTypeRef name = (CFTypeRef)CFDictionaryGetValue(dict, kCFBundleNameKey)) {
            if (CFGetTypeID(name) == CFStringGetTypeID())
                return QCFString::toQString((CFStringRef)name);
        }
    }
    return QString();
}

canonicalName()

QFileSystemEntry QFileSystemEngine::canonicalName ( const QFileSystemEntry &  entry, QFileSystemMetaData &  data  )

static

Definition at line 172 of file qfilesystemengine_unix.cpp.

Referenced by QDir::canonicalPath(), clearWinStatData(), QFSFileEngine::fileName(), QFileInfoPrivate::getFileName(), and QFSFileEnginePrivate::longFileName().

{
    if (entry.isEmpty() || entry.isRoot())
        return entry;

#if !defined(Q_OS_MAC) && !defined(Q_OS_QNX) && _POSIX_VERSION < 200809L
    // realpath(X,0) is not supported
    Q_UNUSED(data);
    return QFileSystemEntry(slowCanonicalized(absoluteName(entry).filePath()));
#else
    char *ret = 0;
# if defined(Q_OS_MAC) && !defined(Q_OS_IOS)
    // When using -mmacosx-version-min=10.4, we get the legacy realpath implementation,
    // which does not work properly with the realpath(X,0) form. See QTBUG-28282.
    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) {
        ret = (char*)malloc(PATH_MAX + 1);
        if (ret && realpath(entry.nativeFilePath().constData(), (char*)ret) == 0) {
            const int savedErrno = errno; // errno is checked below, and free() might change it
            free(ret);
            errno = savedErrno;
            ret = 0;
        }
    } else {
        // on 10.5 we can use FSRef to resolve the file path.
        QString path = QDir::cleanPath(entry.filePath());
        FSRef fsref;
        if (FSPathMakeRef((const UInt8 *)path.toUtf8().data(), &fsref, 0) == noErr) {
            CFURLRef urlref = CFURLCreateFromFSRef(NULL, &fsref);
            CFStringRef canonicalPath = CFURLCopyFileSystemPath(urlref, kCFURLPOSIXPathStyle);
            QString ret = QCFString::toQString(canonicalPath);
            CFRelease(canonicalPath);
            CFRelease(urlref);
            return QFileSystemEntry(ret);
        }
    }
# else
#  if _POSIX_VERSION >= 200801L
    ret = realpath(entry.nativeFilePath().constData(), (char*)0);
#  else
    ret = (char*)malloc(PATH_MAX + 1);
    if (realpath(entry.nativeFilePath().constData(), (char*)ret) == 0) {
        const int savedErrno = errno; // errno is checked below, and free() might change it
        free(ret);
        errno = savedErrno;
        ret = 0;
    }
#  endif
# endif
    if (ret) {
        data.knownFlagsMask |= QFileSystemMetaData::ExistsAttribute;
        data.entryFlags |= QFileSystemMetaData::ExistsAttribute;
        QString canonicalPath = QDir::cleanPath(QString::fromLocal8Bit(ret));
        free(ret);
        return QFileSystemEntry(canonicalPath);
    } else if (errno == ENOENT) { // file doesn't exist
        data.knownFlagsMask |= QFileSystemMetaData::ExistsAttribute;
        data.entryFlags &= ~(QFileSystemMetaData::ExistsAttribute);
        return QFileSystemEntry();
    }
    return entry;
#endif
}

clearWinStatData()

void QFileSystemEngine::clearWinStatData ( QFileSystemMetaData &  data )

staticprivate

Definition at line 468 of file qfilesystemengine_win.cpp.

{
    data.size_ = 0;
    data.fileAttribute_ =  0;
    data.creationTime_ = FILETIME();
    data.lastAccessTime_ = FILETIME();
    data.lastWriteTime_ = FILETIME();
}

copyFile()

bool QFileSystemEngine::copyFile ( const QFileSystemEntry &  source, const QFileSystemEntry &  target, QSystemError &  error  )

static

Definition at line 556 of file qfilesystemengine_unix.cpp.

Referenced by QFSFileEngine::copy(), isDirPath(), and QFSFileEnginePrivate::longFileName().

{
    Q_UNUSED(source);
    Q_UNUSED(target);
    error = QSystemError(ENOSYS, QSystemError::StandardLibraryError); //Function not implemented
    return false;
}

createDirectory()

bool QFileSystemEngine::createDirectory ( const QFileSystemEntry &  entry, bool  createParents  )

static

Definition at line 491 of file qfilesystemengine_unix.cpp.

Referenced by QCoreApplication::init(), isDirPath(), QFSFileEnginePrivate::longFileName(), QFSFileEngine::mkdir(), QDir::mkdir(), and QDir::mkpath().

{
    QString dirName = entry.filePath();
    if (createParents) {
        dirName = QDir::cleanPath(dirName);
        for (int oldslash = -1, slash=0; slash != -1; oldslash = slash) {
            slash = dirName.indexOf(QDir::separator(), oldslash+1);
            if (slash == -1) {
                if (oldslash == dirName.length())
                    break;
                slash = dirName.length();
            }
            if (slash) {
                QByteArray chunk = QFile::encodeName(dirName.left(slash));
                QT_STATBUF st;
                if (QT_STAT(chunk, &st) != -1) {
                    if ((st.st_mode & S_IFMT) != S_IFDIR)
                        return false;
                } else if (QT_MKDIR(chunk, 0777) != 0) {
                    return false;
                }
            }
        }
        return true;
    }
#if defined(Q_OS_DARWIN)  // Mac X doesn't support trailing /'s
    if (dirName.endsWith(QLatin1Char('/')))
        dirName.chop(1);
#endif
    return (QT_MKDIR(QFile::encodeName(dirName), 0777) == 0);
}

createLink()

bool QFileSystemEngine::createLink ( const QFileSystemEntry &  source, const QFileSystemEntry &  target, QSystemError &  error  )

static

Definition at line 547 of file qfilesystemengine_unix.cpp.

Referenced by isDirPath(), and QFSFileEngine::link().

{
    if (::symlink(source.nativeFilePath().constData(), target.nativeFilePath().constData()) == 0)
        return true;
    error = QSystemError(errno, QSystemError::StandardLibraryError);
    return false;
}

currentPath()

QFileSystemEntry QFileSystemEngine::currentPath ( )

static

Definition at line 665 of file qfilesystemengine_unix.cpp.

Referenced by absoluteName(), QFSFileEngine::currentPath(), QDir::currentPath(), QCoreApplication::init(), isDirPath(), and QFSFileEnginePrivate::longFileName().

{
    QFileSystemEntry result;
    QT_STATBUF st;
    if (QT_STAT(".", &st) == 0) {
#if defined(__GLIBC__) && !defined(PATH_MAX)
        char *currentName = ::get_current_dir_name();
        if (currentName) {
            result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
            ::free(currentName);
        }
#else
        char currentName[PATH_MAX+1];
        if (::getcwd(currentName, PATH_MAX)) {
#if defined(Q_OS_VXWORKS) && defined(VXWORKS_VXSIM)
            QByteArray dir(currentName);
            if (dir.indexOf(':') < dir.indexOf('/'))
                dir.remove(0, dir.indexOf(':')+1);

            qstrncpy(currentName, dir.constData(), PATH_MAX);
#endif
            result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
        }
# if defined(QT_DEBUG)
        if (result.isEmpty())
            qWarning("QFSFileEngine::currentPath: getcwd() failed");
# endif
#endif
    } else {
# if defined(QT_DEBUG)
        qWarning("QFSFileEngine::currentPath: stat(\".\") failed");
# endif
    }
    return result;
}

fillMetaData() [1/4]

bool QFileSystemEngine::fillMetaData ( const QFileSystemEntry &  entry, QFileSystemMetaData &  data, QFileSystemMetaData::MetaDataFlags  what  )

static

Definition at line 346 of file qfilesystemengine_unix.cpp.

Referenced by _q_checkEntry(), clearWinStatData(), QFileInfo::created(), QFSFileEnginePrivate::doStat(), QDirPrivate::exists(), QFileInfo::exists(), fillMetaData(), getLinkTarget(), QFileInfo::groupId(), QFileInfo::isBundle(), QFileInfo::isDir(), QFileInfo::isExecutable(), QFileInfo::isFile(), QFileInfo::isHidden(), QFileInfo::isReadable(), QDir::isReadable(), QFileInfo::isRoot(), QFileInfo::isSymLink(), QFSFileEnginePrivate::isSymlink(), QFileInfo::isWritable(), QFileInfo::lastModified(), QFileInfo::lastRead(), QFSFileEnginePrivate::longFileName(), QFSFileEnginePrivate::nativeOpen(), openModeToFopenMode(), QFileInfo::ownerId(), QFileInfo::permission(), QFileInfo::permissions(), resolveGroupName(), resolveUserName(), QFileInfo::size(), and tryFindFallback().

{
#if !defined(QWS) && !defined(Q_WS_QPA) && defined(Q_OS_MAC)
    if (what & QFileSystemMetaData::BundleType) {
        if (!data.hasFlags(QFileSystemMetaData::DirectoryType))
            what |= QFileSystemMetaData::DirectoryType;
    }
#endif

#if !defined(QWS) && !defined(Q_WS_QPA) && defined(Q_OS_MAC) \
        && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
    if (what & QFileSystemMetaData::HiddenAttribute) {
        // Mac OS >= 10.5: st_flags & UF_HIDDEN
        what |= QFileSystemMetaData::PosixStatFlags;
    }
#endif

    if (what & QFileSystemMetaData::PosixStatFlags)
        what |= QFileSystemMetaData::PosixStatFlags;

    if (what & QFileSystemMetaData::ExistsAttribute) {
        //  FIXME:  Would other queries being performed provide this bit?
        what |= QFileSystemMetaData::PosixStatFlags;
    }

    data.entryFlags &= ~what;

    const char * nativeFilePath;
    int nativeFilePathLength;
    {
        const QByteArray &path = entry.nativeFilePath();
        nativeFilePath = path.constData();
        nativeFilePathLength = path.size();
        Q_UNUSED(nativeFilePathLength);
    }

    bool entryExists = true; // innocent until proven otherwise

    QT_STATBUF statBuffer;
    bool statBufferValid = false;
    if (what & QFileSystemMetaData::LinkType) {
        if (QT_LSTAT(nativeFilePath, &statBuffer) == 0) {
            if (S_ISLNK(statBuffer.st_mode)) {
                data.entryFlags |= QFileSystemMetaData::LinkType;
            } else {
                statBufferValid = true;
                data.entryFlags &= ~QFileSystemMetaData::PosixStatFlags;
            }
        } else {
            entryExists = false;
        }

        data.knownFlagsMask |= QFileSystemMetaData::LinkType;
    }

    if (statBufferValid || (what & QFileSystemMetaData::PosixStatFlags)) {
        if (entryExists && !statBufferValid)
            statBufferValid = (QT_STAT(nativeFilePath, &statBuffer) == 0);

        if (statBufferValid)
            data.fillFromStatBuf(statBuffer);
        else {
            entryExists = false;
            data.creationTime_ = 0;
            data.modificationTime_ = 0;
            data.accessTime_ = 0;
            data.size_ = 0;
            data.userId_ = (uint) -2;
            data.groupId_ = (uint) -2;
        }

        // reset the mask
        data.knownFlagsMask |= QFileSystemMetaData::PosixStatFlags
            | QFileSystemMetaData::ExistsAttribute;
    }

#if !defined(QWS) && !defined(Q_WS_QPA) && defined(Q_OS_MAC)
    if (what & QFileSystemMetaData::AliasType)
    {
        if (entryExists) {
            FSRef fref;
            if (FSPathMakeRef((const UInt8 *)nativeFilePath, &fref, NULL) == noErr) {
                Boolean isAlias, isFolder;
                if (FSIsAliasFile(&fref, &isAlias, &isFolder) == noErr) {
                    if (isAlias)
                        data.entryFlags |= QFileSystemMetaData::AliasType;
                }
            }
        }
        data.knownFlagsMask |= QFileSystemMetaData::AliasType;
    }
#endif

    if (what & QFileSystemMetaData::UserPermissions) {
        // calculate user permissions

        if (entryExists) {
            if (what & QFileSystemMetaData::UserReadPermission) {
                if (QT_ACCESS(nativeFilePath, R_OK) == 0)
                    data.entryFlags |= QFileSystemMetaData::UserReadPermission;
            }
            if (what & QFileSystemMetaData::UserWritePermission) {
                if (QT_ACCESS(nativeFilePath, W_OK) == 0)
                    data.entryFlags |= QFileSystemMetaData::UserWritePermission;
            }
            if (what & QFileSystemMetaData::UserExecutePermission) {
                if (QT_ACCESS(nativeFilePath, X_OK) == 0)
                    data.entryFlags |= QFileSystemMetaData::UserExecutePermission;
            }
        }
        data.knownFlagsMask |= (what & QFileSystemMetaData::UserPermissions);
    }

    if (what & QFileSystemMetaData::HiddenAttribute
            && !data.isHidden()) {
        QString fileName = entry.fileName();
        if ((fileName.size() > 0 && fileName.at(0) == QLatin1Char('.'))
                || (entryExists && _q_isMacHidden(nativeFilePath)))
            data.entryFlags |= QFileSystemMetaData::HiddenAttribute;
        data.knownFlagsMask |= QFileSystemMetaData::HiddenAttribute;
    }

#if !defined(QWS) && !defined(Q_WS_QPA) && defined(Q_OS_MAC)
    if (what & QFileSystemMetaData::BundleType) {
        if (entryExists && data.isDirectory()) {
            QCFType<CFStringRef> path = CFStringCreateWithBytes(0,
                    (const UInt8*)nativeFilePath, nativeFilePathLength,
                    kCFStringEncodingUTF8, false);
            QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, path,
                    kCFURLPOSIXPathStyle, true);

            UInt32 type, creator;
            if (CFBundleGetPackageInfoInDirectory(url, &type, &creator))
                data.entryFlags |= QFileSystemMetaData::BundleType;
        }

        data.knownFlagsMask |= QFileSystemMetaData::BundleType;
    }
#endif

    return data.hasFlags(what);
}

fillMetaData() [2/4]

bool QFileSystemEngine::fillMetaData ( int  fd, QFileSystemMetaData &  data  )

static

Definition at line 227 of file qfilesystemengine.cpp.

{
    data.entryFlags &= ~QFileSystemMetaData::PosixStatFlags;
    data.knownFlagsMask |= QFileSystemMetaData::PosixStatFlags;

    QT_STATBUF statBuffer;
    if (QT_FSTAT(fd, &statBuffer) == 0) {
        data.fillFromStatBuf(statBuffer);
        return true;
    }

    return false;
}

fillMetaData() [3/4]

static bool QFileSystemEngine::fillMetaData ( int  fd, QFileSystemMetaData &  data, QFileSystemMetaData::MetaDataFlags  what  )

static

fillMetaData() [4/4]

bool QFileSystemEngine::fillMetaData ( HANDLE  fHandle, QFileSystemMetaData &  data, QFileSystemMetaData::MetaDataFlags  what  )

static

Definition at line 819 of file qfilesystemengine_win.cpp.

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

fillPermissions()

bool QFileSystemEngine::fillPermissions ( const QFileSystemEntry &  entry, QFileSystemMetaData &  data, QFileSystemMetaData::MetaDataFlags  what  )

static

Definition at line 625 of file qfilesystemengine_win.cpp.

{
#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::UserWritePermission;
        }
    }

    return data.hasFlags(what);
}

getLinkTarget()

QFileSystemEntry QFileSystemEngine::getLinkTarget ( const QFileSystemEntry &  link, QFileSystemMetaData &  data  )

static

Definition at line 96 of file qfilesystemengine_unix.cpp.

Referenced by clearWinStatData(), QFSFileEngine::fileName(), QFileInfoPrivate::getFileName(), and QFSFileEnginePrivate::longFileName().

{
#if defined(__GLIBC__) && !defined(PATH_MAX)
#define PATH_CHUNK_SIZE 256
    char *s = 0;
    int len = -1;
    int size = PATH_CHUNK_SIZE;

    while (1) {
        s = (char *) ::realloc(s, size);
        Q_CHECK_PTR(s);
        len = ::readlink(link.nativeFilePath().constData(), s, size);
        if (len < 0) {
            ::free(s);
            break;
        }
        if (len < size) {
            break;
        }
        size *= 2;
    }
#else
    char s[PATH_MAX+1];
    int len = readlink(link.nativeFilePath().constData(), s, PATH_MAX);
#endif
    if (len > 0) {
        QString ret;
        if (!data.hasFlags(QFileSystemMetaData::DirectoryType))
            fillMetaData(link, data, QFileSystemMetaData::DirectoryType);
        if (data.isDirectory() && s[0] != '/') {
            QDir parent(link.filePath());
            parent.cdUp();
            ret = parent.path();
            if (!ret.isEmpty() && !ret.endsWith(QLatin1Char('/')))
                ret += QLatin1Char('/');
        }
        s[len] = '\0';
        ret += QFile::decodeName(QByteArray(s));
#if defined(__GLIBC__) && !defined(PATH_MAX)
        ::free(s);
#endif

        if (!ret.startsWith(QLatin1Char('/'))) {
            if (link.filePath().startsWith(QLatin1Char('/'))) {
                ret.prepend(link.filePath().left(link.filePath().lastIndexOf(QLatin1Char('/')))
                            + QLatin1Char('/'));
            } else {
                ret.prepend(QDir::currentPath() + QLatin1Char('/'));
            }
        }
        ret = QDir::cleanPath(ret);
        if (ret.size() > 1 && ret.endsWith(QLatin1Char('/')))
            ret.chop(1);
        return QFileSystemEntry(ret);
    }
#if !defined(QWS) && !defined(Q_WS_QPA) && defined(Q_OS_MAC)
    {
        FSRef fref;
        if (FSPathMakeRef((const UInt8 *)QFile::encodeName(QDir::cleanPath(link.filePath())).data(), &fref, 0) == noErr) {
            // TODO get the meta data info from the QFileSystemMetaData object
            Boolean isAlias, isFolder;
            if (FSResolveAliasFile(&fref, true, &isFolder, &isAlias) == noErr && isAlias) {
                AliasHandle alias;
                if (FSNewAlias(0, &fref, &alias) == noErr && alias) {
                    QCFString cfstr;
                    if (FSCopyAliasInfo(alias, 0, 0, &cfstr, 0, 0) == noErr)
                        return QFileSystemEntry(QCFString::toQString(cfstr));
                }
            }
        }
    }
#endif
    return QFileSystemEntry();
}

homePath()

QString QFileSystemEngine::homePath ( )

static

Definition at line 623 of file qfilesystemengine_unix.cpp.

Referenced by QFSFileEngine::homePath(), QDir::homePath(), isDirPath(), and QFSFileEnginePrivate::longFileName().

{
    QString home = QFile::decodeName(qgetenv("HOME"));
    if (home.isEmpty())
        home = rootPath();
    return QDir::cleanPath(home);
}

isCaseSensitive()

bool QFileSystemEngine::isCaseSensitive ( )

static

Definition at line 90 of file qfilesystemengine_unix.cpp.

Referenced by clearWinStatData(), QFileInfo::operator==(), and QDir::operator==().

{
    return true;
}

nativeAbsoluteFilePath()

QString QFileSystemEngine::nativeAbsoluteFilePath ( const QString &  path )

static

Definition at line 510 of file qfilesystemengine_win.cpp.

Referenced by QFSFileEnginePrivate::longFileName().

{
    // 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;
}

owner()

QString QFileSystemEngine::owner ( const QFileSystemEntry &  entry, QAbstractFileEngine::FileOwner  own  )

static

Definition at line 575 of file qfilesystemengine_win.cpp.

Referenced by QFSFileEnginePrivate::longFileName(), resolveGroupName(), and resolveUserName().

{
    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(entry);
    Q_UNUSED(own);
#endif
    return name;
}

removeDirectory()

bool QFileSystemEngine::removeDirectory ( const QFileSystemEntry &  entry, bool  removeEmptyParents  )

static

Definition at line 524 of file qfilesystemengine_unix.cpp.

Referenced by isDirPath(), QFSFileEnginePrivate::longFileName(), QFSFileEngine::rmdir(), QDir::rmdir(), and QDir::rmpath().

{
    if (removeEmptyParents) {
        QString dirName = QDir::cleanPath(entry.filePath());
        for (int oldslash = 0, slash=dirName.length(); slash > 0; oldslash = slash) {
            QByteArray chunk = QFile::encodeName(dirName.left(slash));
            QT_STATBUF st;
            if (QT_STAT(chunk, &st) != -1) {
                if ((st.st_mode & S_IFMT) != S_IFDIR)
                    return false;
                if (::rmdir(chunk) != 0)
                    return oldslash != 0;
            } else {
                return false;
            }
            slash = dirName.lastIndexOf(QDir::separator(), oldslash-1);
        }
        return true;
    }
    return rmdir(QFile::encodeName(entry.filePath())) == 0;
}

removeFile()

bool QFileSystemEngine::removeFile ( const QFileSystemEntry &  entry, QSystemError &  error  )

static

Definition at line 574 of file qfilesystemengine_unix.cpp.

Referenced by isDirPath(), QFSFileEnginePrivate::longFileName(), and QFSFileEngine::remove().

{
    if (unlink(entry.nativeFilePath().constData()) == 0)
        return true;
    error = QSystemError(errno, QSystemError::StandardLibraryError);
    return false;

}

renameFile()

bool QFileSystemEngine::renameFile ( const QFileSystemEntry &  source, const QFileSystemEntry &  target, QSystemError &  error  )

static

Definition at line 565 of file qfilesystemengine_unix.cpp.

Referenced by isDirPath(), QFSFileEnginePrivate::longFileName(), and QFSFileEngine::rename().

{
    if (::rename(source.nativeFilePath().constData(), target.nativeFilePath().constData()) == 0)
        return true;
    error = QSystemError(errno, QSystemError::StandardLibraryError);
    return false;
}

resolveEntryAndCreateLegacyEngine()

QAbstractFileEngine * QFileSystemEngine::resolveEntryAndCreateLegacyEngine ( QFileSystemEntry &  entry, QFileSystemMetaData &  data  )

static

Resolves the entry (see QDir::searchPaths) and returns an engine for it, but never a QFSFileEngine.

Warning

This function is not part of the public interface.

Returns a file engine that can be used to access the entry. Returns 0 if QFileSystemEngine API should be used to query and interact with the file system object.

Definition at line 209 of file qfilesystemengine.cpp.

Referenced by QAbstractFileEngine::create(), QDirPrivate::initFileEngine(), and QDirIteratorPrivate::QDirIteratorPrivate().

                                                            {
    QFileSystemEntry copy = entry;
    QAbstractFileEngine *engine = 0;

    if (_q_resolveEntryAndCreateLegacyEngine_recursive(copy, data, engine))
        // Reset entry to resolved copy.
        entry = copy;
    else
        data.clear();

    return engine;
}

resolveGroupName() [1/2]

QString QFileSystemEngine::resolveGroupName ( const QFileSystemEntry &  entry, QFileSystemMetaData &  data  )

static

Definition at line 435 of file qfilesystemengine.cpp.

Referenced by QFileInfoPrivate::getFileOwner(), and QFSFileEngine::owner().

{
#if defined (Q_OS_SYMBIAN)
    Q_UNUSED(entry);
    Q_UNUSED(metaData);
    return QString();
#elif defined(Q_OS_WIN)
    Q_UNUSED(metaData);
    return QFileSystemEngine::owner(entry, QAbstractFileEngine::OwnerGroup);
#else //(Q_OS_UNIX)
    if (!metaData.hasFlags(QFileSystemMetaData::GroupId))
        QFileSystemEngine::fillMetaData(entry, metaData, QFileSystemMetaData::GroupId);
    return resolveGroupName(metaData.groupId());
#endif
}

resolveGroupName() [2/2]

QString QFileSystemEngine::resolveGroupName ( uint  groupId )

static

Definition at line 293 of file qfilesystemengine_unix.cpp.

{
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
    int size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
    if (size_max == -1)
        size_max = 1024;
    QVarLengthArray<char, 1024> buf(size_max);
#endif

    struct group *gr = 0;
#if !defined(Q_OS_INTEGRITY)
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD) && !defined(Q_OS_VXWORKS)
    size_max = sysconf(_SC_GETGR_R_SIZE_MAX);
    if (size_max == -1)
        size_max = 1024;
    buf.resize(size_max);
    struct group entry;
    // Some large systems have more members than the POSIX max size
    // Loop over by doubling the buffer size (upper limit 250k)
    for (unsigned size = size_max; size < 256000; size += size)
    {
        buf.resize(size);
        // ERANGE indicates that the buffer was too small
        if (!getgrgid_r(groupId, &entry, buf.data(), buf.size(), &gr)
            || errno != ERANGE)
            break;
    }
#else
    gr = getgrgid(groupId);
#endif
#endif
    if (gr)
        return QFile::decodeName(QByteArray(gr->gr_name));
    return QString();
}

resolveUserName() [1/2]

QString QFileSystemEngine::resolveUserName ( const QFileSystemEntry &  entry, QFileSystemMetaData &  data  )

static

Definition at line 418 of file qfilesystemengine.cpp.

Referenced by QFileInfoPrivate::getFileOwner(), and QFSFileEngine::owner().

{
#if defined (Q_OS_SYMBIAN)
    Q_UNUSED(entry);
    Q_UNUSED(metaData);
    return QString();
#elif defined(Q_OS_WIN)
    Q_UNUSED(metaData);
    return QFileSystemEngine::owner(entry, QAbstractFileEngine::OwnerUser);
#else //(Q_OS_UNIX)
    if (!metaData.hasFlags(QFileSystemMetaData::UserId))
        QFileSystemEngine::fillMetaData(entry, metaData, QFileSystemMetaData::UserId);
    return resolveUserName(metaData.userId());
#endif
}

resolveUserName() [2/2]

QString QFileSystemEngine::resolveUserName ( uint  userId )

static

Definition at line 269 of file qfilesystemengine_unix.cpp.

{
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
    int size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
    if (size_max == -1)
        size_max = 1024;
    QVarLengthArray<char, 1024> buf(size_max);
#endif

    struct passwd *pw = 0;
#if !defined(Q_OS_INTEGRITY)
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD) && !defined(Q_OS_VXWORKS)
    struct passwd entry;
    getpwuid_r(userId, &entry, buf.data(), buf.size(), &pw);
#else
    pw = getpwuid(userId);
#endif
#endif
    if (pw)
        return QFile::decodeName(QByteArray(pw->pw_name));
    return QString();
}

rootPath()

QString QFileSystemEngine::rootPath ( )

static

Definition at line 631 of file qfilesystemengine_unix.cpp.

Referenced by homePath(), isDirPath(), QFSFileEnginePrivate::longFileName(), QFSFileEngine::rootPath(), and QDir::rootPath().

{
    return QLatin1String("/");
}

setCurrentPath()

bool QFileSystemEngine::setCurrentPath ( const QFileSystemEntry &  entry )

static

Definition at line 658 of file qfilesystemengine_unix.cpp.

Referenced by isDirPath(), QFSFileEnginePrivate::longFileName(), QDir::setCurrent(), and QFSFileEngine::setCurrentPath().

{
    int r;
    r = QT_CHDIR(path.nativeFilePath());
    return r >= 0;
}

setPermissions()

bool QFileSystemEngine::setPermissions ( const QFileSystemEntry &  entry, QFile::Permissions  permissions, QSystemError &  error, QFileSystemMetaData *  data = 0  )

static

Definition at line 584 of file qfilesystemengine_unix.cpp.

Referenced by isDirPath(), QFSFileEnginePrivate::longFileName(), and QFSFileEngine::setPermissions().

{
    mode_t mode = 0;
    if (permissions & QFile::ReadOwner)
        mode |= S_IRUSR;
    if (permissions & QFile::WriteOwner)
        mode |= S_IWUSR;
    if (permissions & QFile::ExeOwner)
        mode |= S_IXUSR;
    if (permissions & QFile::ReadUser)
        mode |= S_IRUSR;
    if (permissions & QFile::WriteUser)
        mode |= S_IWUSR;
    if (permissions & QFile::ExeUser)
        mode |= S_IXUSR;
    if (permissions & QFile::ReadGroup)
        mode |= S_IRGRP;
    if (permissions & QFile::WriteGroup)
        mode |= S_IWGRP;
    if (permissions & QFile::ExeGroup)
        mode |= S_IXGRP;
    if (permissions & QFile::ReadOther)
        mode |= S_IROTH;
    if (permissions & QFile::WriteOther)
        mode |= S_IWOTH;
    if (permissions & QFile::ExeOther)
        mode |= S_IXOTH;

    bool success = ::chmod(entry.nativeFilePath().constData(), mode) == 0;
    if (success && data) {
        data->entryFlags &= ~QFileSystemMetaData::Permissions;
        data->entryFlags |= QFileSystemMetaData::MetaDataFlag(uint(permissions));
        data->knownFlagsMask |= QFileSystemMetaData::Permissions;
    }
    if (!success)
        error = QSystemError(errno, QSystemError::StandardLibraryError);
    return success;
}

slowCanonicalized()

QString QFileSystemEngine::slowCanonicalized ( const QString &  path )

staticprivate

Returns the canonicalized form of path (i.

Warning

This function is not part of the public interface.

e., with all symlinks resolved, and all redundant path elements removed.

Definition at line 62 of file qfilesystemengine.cpp.

Referenced by canonicalName().

{
    if (path.isEmpty())
        return path;

    QFileInfo fi;
    const QChar slash(QLatin1Char('/'));
    QString tmpPath = path;
    int separatorPos = 0;
    QSet<QString> nonSymlinks;
    QSet<QString> known;

    known.insert(path);
    do {
#ifdef Q_OS_WIN
        if (separatorPos == 0) {
            if (tmpPath.size() >= 2 && tmpPath.at(0) == slash && tmpPath.at(1) == slash) {
                // UNC, skip past the first two elements
                separatorPos = tmpPath.indexOf(slash, 2);
            } else if (tmpPath.size() >= 3 && tmpPath.at(1) == QLatin1Char(':') && tmpPath.at(2) == slash) {
                // volume root, skip since it can not be a symlink
                separatorPos = 2;
            }
        }
        if (separatorPos != -1)
#endif
        separatorPos = tmpPath.indexOf(slash, separatorPos + 1);
        QString prefix = separatorPos == -1 ? tmpPath : tmpPath.left(separatorPos);
        if (
#ifdef Q_OS_SYMBIAN
            // Symbian doesn't support directory symlinks, so do not check for link unless we
            // are handling the last path element. This not only slightly improves performance,
            // but also saves us from lot of unnecessary platform security check failures
            // when dealing with files under *:/private directories.
            separatorPos == -1 &&
#endif
            !nonSymlinks.contains(prefix)) {
            fi.setFile(prefix);
            if (fi.isSymLink()) {
                QString target = fi.symLinkTarget();
                if(QFileInfo(target).isRelative())
                    target = fi.absolutePath() + slash + target;
                if (separatorPos != -1) {
                    if (fi.isDir() && !target.endsWith(slash))
                        target.append(slash);
                    target.append(tmpPath.mid(separatorPos));
                }
                tmpPath = QDir::cleanPath(target);
                separatorPos = 0;

                if (known.contains(tmpPath))
                    return QString();
                known.insert(tmpPath);
            } else {
                nonSymlinks.insert(prefix);
            }
        }
    } while (separatorPos != -1);

    return QDir::cleanPath(tmpPath);
}

tempPath()

QString QFileSystemEngine::tempPath ( )

static

Definition at line 636 of file qfilesystemengine_unix.cpp.

Referenced by QCoreApplication::init(), isDirPath(), QFSFileEnginePrivate::longFileName(), QFSFileEngine::tempPath(), and QDir::tempPath().

{
#ifdef QT_UNIX_TEMP_PATH_OVERRIDE
    return QLatin1String(QT_UNIX_TEMP_PATH_OVERRIDE);
#elif defined(Q_OS_BLACKBERRY)
    QString temp = QFile::decodeName(qgetenv("TEMP"));
    if (temp.isEmpty())
        temp = QFile::decodeName(qgetenv("TMPDIR"));

    if (temp.isEmpty()) {
        qWarning("Neither the TEMP nor the TMPDIR environment variable is set, falling back to /tmp.");
        temp = QLatin1String("/tmp/");
    }
    return QDir::cleanPath(temp);
#else
    QString temp = QFile::decodeName(qgetenv("TMPDIR"));
    if (temp.isEmpty())
        temp = QLatin1String("/tmp/");
    return QDir::cleanPath(temp);
#endif
}

uncListSharesOnServer()

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

static

Definition at line 445 of file qfilesystemengine_win.cpp.

Referenced by uncShareExists().

{
    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;
}

---

The documentation for this class was generated from the following files:

• /src/corelib/io/qfilesystemengine_p.h
• /src/corelib/io/qfilesystemengine.cpp
• /src/corelib/io/qfilesystemengine_unix.cpp
• /src/corelib/io/qfilesystemengine_win.cpp