staffilesystem.cpp

Software Testing Automation Framework (STAF)的开发代码

            if (extension) *extension = theExtension.adoptImpl();

            // We are now left with the name

            if (name) *name = thePath.adoptImpl();
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError;}

    return retCode;
}


STAFRC_t STAFFSFreePathDirs(STAFString_t *dirs)
{
    delete [] dirs;

    return kSTAFOk;
}


/*****************************************************************************/
/*                          File System Entry APIs                           */
/*****************************************************************************/

STAFRC_t STAFFSExists(STAFStringConst_t path, unsigned int *exists,
                      unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;
    if (exists == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    // Remove any trailing slashes (that are not also leading slashes)

    STAFString thePath = removeTrailingSlashes(path);

    try
    {
        DWORD rc = GetFileAttributes(
                   thePath.toCurrentCodePage()->buffer());

        if (rc == INVALID_FILE_ATTRIBUTES)
            *exists = 0;
        else
            *exists = 1;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSGetEntry(STAFStringConst_t path, STAFFSEntry_t *entry,
                        unsigned int *osRC)
{
    if ((path == 0) || (entry == 0)) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFString thePath(path);

        // We have to see if we have a path like <alpha>:[/\].  If so, we have
        // to handle it specially, as Win32 doesn't like a call to
        // FindFirstFile() with a path like that.
        //
        // Note: The number '7' was chosen to catch various weird possibilities
        //       such as "c:\\\\" without having to check every path.

        if (thePath.length() < 7)
        {
            STAFFSPath tempPath(thePath);

            tempPath.setExtension(tempPath.extension());

            STAFString tempPathString(tempPath.asString());
            
            if ((tempPathString.length() == 2) &&
                (tempPathString.subString(1, 1) == kUTF8_COLON))
            {
                *entry = new STAFFSEntryImpl(thePath, kSTAFFSDirectory, 0, 0,
                                             STAFTimestamp::now().getImpl());
                return kSTAFOk;
            }
        }

        // Remove any trailing slashes (that are not also leading slashes)

        thePath = removeTrailingSlashes(thePath);

        WIN32_FIND_DATA data = { 0 };
        HANDLE findHandle = FindFirstFile(
                            thePath.toCurrentCodePage()->buffer(), &data);

        if (findHandle == INVALID_HANDLE_VALUE)
        {
            // Save error information for FindFirstFile()

            unsigned int savedRC = 0;
            if (osRC) savedRC = GetLastError();

            // Since FindFirstFile() failed, try GetFileAttributes() in case
            // thePath points to a root directory of a network share
            // (e.g. \\server\service") because FindFirstFile() cannot handle
            // the root directory of a network share, but GetFileAttributes()
            // can handle the root directory of a network share.

            data.dwFileAttributes = GetFileAttributes(
                thePath.toCurrentCodePage()->buffer());

            // Validate that the entry type is a directory

            if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
                // The high and low size for a directory is always 0
                // Don't know the mod time, so just use the current time

                *entry = new STAFFSEntryImpl(thePath, kSTAFFSDirectory, 0, 0,
                                             STAFTimestamp::now().getImpl());

                return kSTAFOk;
            }
            else
            {
                // Return the saved error information from FindFirstFile()
                *osRC = savedRC;
                return kSTAFBaseOSError;
            }
        }

        FindClose(findHandle);

        STAFFSEntryType_t theType = kSTAFFSFile;

        if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            theType = kSTAFFSDirectory;

        FILETIME localFileTime = { 0 };
        SYSTEMTIME sysWriteTime = { 0 };
        
        if (FileTimeToLocalFileTime(&data.ftLastWriteTime, &localFileTime) == 
                FALSE)
        {
            if (osRC) *osRC = GetLastError();
            return kSTAFBaseOSError;
        }
        
        if (FileTimeToSystemTime(&localFileTime, &sysWriteTime) == FALSE)
        {
            if (osRC) *osRC = GetLastError();
            return kSTAFBaseOSError;
        }       

        STAFTimestamp writeTime(sysWriteTime.wYear, sysWriteTime.wMonth,
                                sysWriteTime.wDay, sysWriteTime.wHour,
                                sysWriteTime.wMinute, sysWriteTime.wSecond);
        
        *entry = new STAFFSEntryImpl(thePath, theType, data.nFileSizeHigh,
                                     data.nFileSizeLow, writeTime.getImpl());
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEntryGetPathString(STAFFSEntry_t entry,
                                  STAFStringConst_t *pathString,
                                  unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;
    if (pathString == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        *pathString = entry->pathString.getImpl();
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEntryGetType(STAFFSEntry_t entry, STAFFSEntryType_t *type,
                            unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;
    if (type == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        *type = entry->type;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEntryGetSize(STAFFSEntry_t entry, unsigned int *upperSize,
                            unsigned int *lowerSize, unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        *upperSize = entry->highSize;
        *lowerSize = entry->lowSize;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEntryGetModTime(STAFFSEntry_t entry, time_t *modTime,
                               unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        *modTime = entry->modTime;                
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEntryGetIsLink(STAFFSEntry_t entry, unsigned int *isLink,
                              unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    *isLink = 0;

    return retCode;
}


STAFRC_t STAFFSEntryGetLinkTarget(STAFFSEntry_t entry,
                                  STAFString_t *linkTargetString,
                                  unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;
    if (linkTargetString == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;
    STAFString linkTarget = STAFString("");

    try
    {
        *linkTargetString = linkTarget.getImpl();
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSDeleteEntry(STAFFSEntry_t entry, unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFStringConst_t filenameT = 0;
        STAFRC_t rc = STAFFSEntryGetPathString(entry, &filenameT, osRC);

        if (rc) return rc;

        STAFString filename(filenameT);

        if (entry->type == kSTAFFSFile)
        {
            if (DeleteFile(filename.toCurrentCodePage()->buffer()) == FALSE)
            {
                if (osRC) *osRC = GetLastError();
                retCode = kSTAFBaseOSError;
            }
        }
        else
        {
            if (RemoveDirectory(filename.toCurrentCodePage()->buffer()) == FALSE)
            {
                if (GetLastError() == ERROR_DIR_NOT_EMPTY)
                {
                    retCode = kSTAFDirectoryNotEmpty;
                }
                else
                {
                    unsigned int saveLastError = GetLastError();

                    if (!isWinNT())
                    {
                        // Windows 95 returns a ERROR_ACCESS_DENIED instead of
                        // ERROR_DIR_NOT_EMPTY if the directory is not empty.
                        // So, enumerate the directory to check if it's really
                        // non-empty.

                        STAFFSPath entryPath(filename);

                        if (entryPath.getEntry()->enumerate(
                                kUTF8_STAR, kUTF8_STAR, kSTAFFSAll)->isValid())
                        {
                            retCode = kSTAFDirectoryNotEmpty;
                        }
                    }

                    if (retCode == kSTAFOk)
                    {
                        if (osRC) *osRC = saveLastError;
                        retCode = kSTAFBaseOSError;
                    }
                }
            }
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSCopyEntry(STAFFSEntry_t source, STAFStringConst_t target,
                         unsigned int *osRC)
{
    return STAFFSCopyEntryCommon(source, target, osRC);
}


STAFRC_t STAFFSMoveEntry(STAFFSEntry_t entry, STAFStringConst_t toName,
                         unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;
    if (toName == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFStringConst_t fromNameT = 0;
        STAFRC_t rc = STAFFSEntryGetPathString(entry, &fromNameT, osRC);

        if (rc) return rc;

        STAFString fromname(fromNameT);
            
        if (isWinNT())
        {
            if (MoveFileEx(fromname.toCurrentCodePage()->buffer(),
                           STAFString(toName).toCurrentCodePage()->buffer(),
                           MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH |
                           MOVEFILE_COPY_ALLOWED) == FALSE)
            {
                if (osRC) *osRC = GetLastError();
                retCode = kSTAFBaseOSError;
            }
        }
        else
        {
            // Since MoveFileEx is only supported on WinNT and later, copy
            // the file and then delete the file on Win95/98/ME.

            rc = STAFFSCopyEntry(entry, toName, osRC);
            if (rc) return rc;
            
            rc = STAFFSDeleteEntry(entry, osRC);
            if (rc) return rc;
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSRenameEntry(STAFFSEntry_t entry, STAFStringConst_t toName,
                           unsigned int *osRC)
{
    if (entry == 0) return kSTAFInvalidObject;
    if (toName == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFStringConst_t fromNameT = 0;
        STAFRC_t rc = STAFFSEntryGetPathString(entry, &fromNameT, osRC);

        if (rc) return rc;