staffilesystem.cpp

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

{
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

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

    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;

    try
    {
        *linkTargetString = entry->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) || entry->isLink)
        {
            if (unlink(filename.toCurrentCodePage()->buffer()) != 0)
            {
                if (osRC) *osRC = errno;
                retCode = kSTAFBaseOSError;
            }
        }
        else
        {
            if (rmdir(filename.toCurrentCodePage()->buffer()) != 0)
            {
                if (errno == ENOTEMPTY)
                {
                    retCode = kSTAFDirectoryNotEmpty;
                }
                else
                {
                    // Solaris returns a EEXIST instead of ENOTEMPTY like other
                    // Unix OS's if the directory is not empty.

                    #ifdef STAF_OS_NAME_SOLARIS
                        if (errno == EEXIST) retCode = kSTAFDirectoryNotEmpty;
                    #endif

                    if (retCode == kSTAFOk)
                    {
                        if (osRC) *osRC = errno;
                        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 (rename(fromname.toCurrentCodePage()->buffer(),
                   STAFString(toName).toCurrentCodePage()->buffer()) != 0)
        {
            if (osRC) *osRC = errno;
            retCode = kSTAFBaseOSError;
        }
    }
    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;
        
        // Check if the toName entry already exists and if so, return an
        // already exists error.

        unsigned int doesExist = 0;
        rc = STAFFSExists(toName, &doesExist, osRC);
        
        if (rc) return rc;

        if (doesExist) return kSTAFAlreadyExists;
        
        // Rename the entry to its new name.

        STAFString fromname(fromNameT);
            
        if (rename(fromname.toCurrentCodePage()->buffer(),
                   STAFString(toName).toCurrentCodePage()->buffer()) != 0)
        {
            if (osRC) *osRC = errno;
            retCode = kSTAFBaseOSError;
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSOSGetExclusiveFileLock(STAFStringConst_t path,
                                      STAFFSOSFileLock_t *lock,
                                      unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;
    if (lock == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFString filename(path);
        struct flock theLock = { 0 };
        int theFile = 0;

        theLock.l_type = F_WRLCK;

        if ((theFile = open(filename.toCurrentCodePage()->buffer(),
                            O_RDWR)) < 0)
        {
            if (osRC) *osRC = errno;
            return kSTAFBaseOSError;
        }

        int rc2 = 0;

        do
        {
            rc2 = fcntl(theFile, F_SETLKW, &theLock);
        } while ((rc2 != 0) && (errno == EINTR));

        if (rc2 != 0)
        {
            if (osRC) *osRC = errno;
            close(theFile);
            return kSTAFBaseOSError;
        }

        *lock = new STAFFSOSFileLockImpl(theFile);
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSOSReleaseExclusiveFileLock(STAFFSOSFileLock_t *lock,
                                          unsigned int *osRC)
{
    if (lock == 0) return kSTAFInvalidParm;
    if (*lock == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        int rc = 0;
        struct flock theLock = { 0 };

        theLock.l_type = F_UNLCK;

        do
        {
            rc = fcntl((**lock).fileDes, F_SETLKW, &theLock);
        } while ((rc != 0) && (errno == EINTR));

        if (rc != 0)
        {
            // Note: We fall through here so that we can close the file and
            //       free the lock

            if (osRC) *osRC = errno;
            retCode = kSTAFBaseOSError;
        }

        close((**lock).fileDes);

        delete *lock;

        *lock = 0;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSFreeEntry(STAFFSEntry_t *entry)
{
    if (entry == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        delete *entry;
        *entry = 0;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


/*****************************************************************************/
/*                             Directory APIs                                */
/*****************************************************************************/

STAFRC_t STAFFSCreateDirectory(STAFStringConst_t path,
                               STAFFSDirectoryCreateMode_t flags,
                               unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFString directory(path);
        struct stat data = { 0 };
        int rc = stat(directory.toCurrentCodePage()->buffer(), &data);

        if (rc == 0) return kSTAFAlreadyExists;
        else if (errno != ENOENT)
        {
            if (osRC) *osRC = errno;
            retCode = kSTAFBaseOSError;
        }

        if (flags == kSTAFFSCreateDirOnly)
        {
            int rc = mkdir(directory.toCurrentCodePage()->buffer(),
                           S_IRWXU | S_IRWXG | S_IRWXO);

            if (rc < 0)
            {
                if (osRC) *osRC = errno;
                return kSTAFBaseOSError;
            }
        }
        else  // Create entire path
        {
            STAFFSPath fsPath(path);
            STAFFSPath currPath;

            currPath.setRoot(fsPath.root());

            for (unsigned int i = 0; i < fsPath.numDirs(); ++i)
            {
                currPath.addDir(fsPath.dir(i));

                mkdir(currPath.asString().toCurrentCodePage()->buffer(),
                      S_IRWXU | S_IRWXG | S_IRWXO);
            }

            if (mkdir(fsPath.asString().toCurrentCodePage()->buffer(),
                      S_IRWXU | S_IRWXG | S_IRWXO) < 0)
            {
                if (osRC) *osRC = errno;
                return kSTAFBaseOSError;
            }
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSGetCurrentDirectory(STAFString_t *path, unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


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

    STAFRC_t retCode = kSTAFOk;

    try
    {
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEnumOpen(STAFFSEnumHandle_t *enumHandle, STAFFSEntry_t entry,
                        STAFStringConst_t namePattern,
                        STAFStringConst_t extPattern,
                        STAFFSCaseSensitive_t caseSensitive,
                        STAFFSEntryType_t entryTypes,
                        STAFFSSortBy_t sortBy, unsigned int *osRC)
{
    if (enumHandle == 0) return kSTAFInvalidParm;
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    if (caseSensitive == kSTAFFSCaseDefault)
        STAFFSInfo(&caseSensitive, kSTAFFSCaseSensitivity);

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

        if (rc) return rc;

        STAFFSEnumHandleImpl data;

        STAFString theRootName(rootName);
        STAFString theNamePattern(namePattern);
        STAFString theExtPattern(extPattern);

        if (theNamePattern.length() == 0) theNamePattern = kUTF8_STAR;
        if (theExtPattern.length() == 0) theExtPattern = kUTF8_STAR;

	// We need to get the enumeration semaphore so that no other enum
	// operation can mess us up

	STAFMutexSemLock lock(sEnumSem);
        DIR *rootDir = opendir(theRootName.toCurrentCodePage()->buffer());

        // If we get an error other than this isn't a directory, then
        // return the error

        if (!rootDir && (errno != ENOTDIR))
        {
            if (osRC) *osRC = errno;
            return kSTAFBaseOSError;
        }
        else if (rootDir)
        {
            // Loop through all the entries in the directory and see if they
            // match the name and extension patterns

            for (struct dirent *anEntry = readdir(rootDir); anEntry != 0;
                 anEntry = readdir(rootDir))
            {
                // Ignore . and .. unless the user specifically requests them

                if (!(entryTypes & kSTAFFSSpecialDirectory) &&
                    ((STAFString(anEntry->d_name) == sPeriod) ||
                     (STAFString(anEntry->d_name) == sDoublePeriod)))
                {
                    continue;
                }

                STAFString pathName(theRootName);

                pathName += STAFString(kUTF8_SLASH);
                pathName += anEntry->d_name;

                STAFFSPath path(pathName);

                if ((STAFFileSystem::matchesWildcards(path.name(),
                                                      theNamePattern,
                                                      caseSensitive)) &&
                    (STAFFileSystem::matchesWildcards(path.extension(),
                                                      theExtPattern,
                                                      caseSensitive)))
                {
                    // Now, make sure that we can get the associated entry and
                    // that it matches the requested types

                    STAFFSEntry_t goodEntry = 0;
                    STAFFSEntryType_t entryType = kSTAFFSOther;

                    rc = STAFFSGetEntry(path.asString().getImpl(),
                                        &goodEntry, 0);

                    if (rc != 0) continue;

                    rc = STAFFSEntryGetType(goodEntry, &entryType, 0);

                    if ((rc == 0) && (entryType & entryTypes))
                        data.entries.push_back(goodEntry);
                    else
                        STAFFSFreeEntry(&goodEntry);
                }
            }

            closedir(rootDir);
        }

        switch (sortBy)
        {
            case kSTAFFSSortByName:
            {
                std::sort(data.entries.begin(), data.entries.end(),
                          STAFSortEnumByName(caseSensitive));
                break;
            }

            case kSTAFFSSortBySize:
            {
                std::sort(data.entries.begin(), data.entries.end(),
                          sortEnumBySize);
                break;
            }

            case kSTAFFSSortByModTime:
            {
                std::sort(data.entries.begin(), data.entries.end(),
                          sortEnumByModTime);
                break;
            }

            default: break;
        }

        *enumHandle = new STAFFSEnumHandleImpl(data);
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEnumNext(STAFFSEnumHandle_t enumHandle, STAFFSEntry_t *entry,
                        unsigned int *osRC)
{
    if (enumHandle == 0) return kSTAFInvalidObject;
    if (entry == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        if (enumHandle->entries.size() == 0)
        {
            *entry = 0;
        }
        else
        {
            *entry = enumHandle->entries.front();
            enumHandle->entries.pop_front();
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEnumClose(STAFFSEnumHandle_t *enumHandle, unsigned int *osRC)
{
    if (enumHandle == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        for (STAFFSEntryList::iterator iter = (*enumHandle)->entries.begin();
             iter != (*enumHandle)->entries.end(); ++iter)
        {
            STAFFSEntry_t entry = *iter;

            STAFFSFreeEntry(&entry);
        }

        delete *enumHandle;

        *enumHandle = 0;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }
    
    return retCode;
}