stafzip.cpp

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

            STAFString("The Zip archive has an invalid format "));

        registerHelpData(pData, kZIPBadCRC,
            STAFString("Bad CRC"),
            STAFString("Bad CRC in the Zip archive "));

        registerHelpData(pData, kZIPInvalidOwnerGroup,
            STAFString("Invalid Owner Group"),
            STAFString("Owner or Group does not exist in system "));

        registerHelpData(pData, kZIPInvalidFileMode,
            STAFString("Invalid File Mode"),
            STAFString("Cannot set the file's mode (permission) in system "));

    }
    catch (STAFException &e)
    {
        STAFString result;

        result += STAFString("In STAFZip.cpp: STAFServiceInit")
            + kUTF8_SCOLON;

        result += STAFString("Name: ") + e.getName() + kUTF8_SCOLON;
        result += STAFString("Location: ") + e.getLocation() + kUTF8_SCOLON;
        result += STAFString("Text: ") + e.getText() + kUTF8_SCOLON;
        result += STAFString("Error code: ") + e.getErrorCode() + kUTF8_SCOLON;

        *pErrorBuffer = result.adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFZip.cpp: STAFServiceInit: Caught unknown "
                    "exception in STAFServiceServiceInit()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


STAFRC_t STAFServiceAcceptRequest(STAFServiceHandle_t serviceHandle,
                                  void *pRequestInfo, unsigned int reqLevel,
                                  STAFString_t *pResultBuffer)
{
    if (reqLevel != 30) return kSTAFInvalidAPILevel;

    STAFRC_t retCode = kSTAFUnknownError;

    STAFString mutexName("STAFZIPMUTEX:");

    try
    {
        STAFResultPtr result(new STAFResult(),
                             STAFResultPtr::INIT);

        STAFServiceRequestLevel30 *pInfo =
            reinterpret_cast<STAFServiceRequestLevel30 *>(pRequestInfo);

        STAFZipServiceData *pData =
            reinterpret_cast<STAFZipServiceData *>(serviceHandle);

        STAFString request(pInfo->request);
        STAFString action = request.subWord(0, 1).toLowerCase();

        // Call functions for the request

        if (action == "add" || action == "zip")
            result = handleAdd(pInfo, pData, &mutexName);
        else if (action == "unzip")
            result = handleUnzip(pInfo, pData, &mutexName);
        else if (action == "list")
            result = handleList(pInfo, pData, &mutexName);
        else if (action == "delete")
            result = handleDelete(pInfo, pData, &mutexName);
        else if (action == "help")
            result = handleHelp(pInfo, pData);
        else if (action == "version")
            result = handleVersion(pInfo, pData);
        else
        {
            result = STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                                   request.subWord(0, 1)),
                                   STAFResultPtr::INIT);
        }

        *pResultBuffer = result->result.adoptImpl();
        retCode = result->rc;
    }
    catch (STAFException &e)
    {
        STAFString result;

        result += STAFString("In STAFZip.cpp: STAFServiceAcceptRequest")
            + kUTF8_SCOLON;

        result += STAFString("Name: ") + e.getName() + kUTF8_SCOLON;
        result += STAFString("Location: ") + e.getLocation() + kUTF8_SCOLON;
        result += STAFString("Text: ") + e.getText() + kUTF8_SCOLON;
        result += STAFString("Error code: ") + e.getErrorCode() + kUTF8_SCOLON;

        *pResultBuffer = result.adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFZip.cpp: STAFServiceAcceptRequest: Caught "
                    "unknown exception in STAFServiceAcceptRequest()");
        *pResultBuffer = error.adoptImpl();
    }

    if (mutexName.length() > STAFString("STAFZIPMUTEX:").length())
    {
        // release the mutex
        zipLock.release(mutexName);
    }        

    return retCode;
}


STAFRC_t STAFServiceTerm(STAFServiceHandle_t serviceHandle,
                         void *pTermInfo, unsigned int termLevel,
                         STAFString_t *pErrorBuffer)
{
    if (termLevel != 0) return kSTAFInvalidAPILevel;

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        retCode = kSTAFOk;

        STAFZipServiceData *pData =
            reinterpret_cast<STAFZipServiceData *>(serviceHandle);

        // Unregister help data

        unregisterHelpData(pData, kZIPGeneralZipError);
        unregisterHelpData(pData, kZIPNotEnoughMemory);
        unregisterHelpData(pData, kZIPChangeFileSizeError);
        unregisterHelpData(pData, kZIPErrorCreatingDir);
        unregisterHelpData(pData, kZIPInvalidZipFile);
        unregisterHelpData(pData, kZIPBadCRC);
        unregisterHelpData(pData, kZIPInvalidOwnerGroup);
        unregisterHelpData(pData, kZIPInvalidFileMode);

    }
    catch (STAFException &e)
    {
        STAFString result;

        result += STAFString("In STAFZip.cpp: STAFServiceTerm")
            + kUTF8_SCOLON;

        result += STAFString("Name: ") + e.getName() + kUTF8_SCOLON;
        result += STAFString("Location: ") + e.getLocation() + kUTF8_SCOLON;
        result += STAFString("Text: ") + e.getText() + kUTF8_SCOLON;
        result += STAFString("Error code: ") + e.getErrorCode() + kUTF8_SCOLON;

        *pErrorBuffer = result.adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFZip.cpp: STAFServiceTerm: Caught unknown "
                    "exception in STAFServiceTerm()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


STAFRC_t STAFServiceDestruct(STAFServiceHandle_t *serviceHandle,
                             void *pDestructInfo, unsigned int destructLevel,
                             STAFString_t *pErrorBuffer)
{
    if (destructLevel != 0) return kSTAFInvalidAPILevel;

    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        STAFZipServiceData *pData =
            reinterpret_cast<STAFZipServiceData *>(*serviceHandle);

        delete pData;
        *serviceHandle = 0;

        retCode = kSTAFOk;
    }
    catch (STAFException &e)
    {
        STAFString result;

        result += STAFString("In STAFZip.cpp: STAFServiceDestruct")
            + kUTF8_SCOLON;

        result += STAFString("Name: ") + e.getName() + kUTF8_SCOLON;
        result += STAFString("Location: ") + e.getLocation() + kUTF8_SCOLON;
        result += STAFString("Text: ") + e.getText() + kUTF8_SCOLON;
        result += STAFString("Error code: ") + e.getErrorCode() + kUTF8_SCOLON;

        *pErrorBuffer = result.adoptImpl();
    }
    catch (...)
    {
        STAFString error(
                    "STAFZip.cpp: STAFServiceDestruct: Caught "
                    "unknown exception in STAFServiceDestruct()");
        *pErrorBuffer = error.adoptImpl();
    }

    return retCode;
}


// Handles Add (and Zip Add) requests

STAFResultPtr handleAdd(STAFServiceRequestLevel30 *pInfo,
                        STAFZipServiceData *pData, STAFString *mutexName)
{
    STAFString result;
    STAFString resultBuffer;
    
    char zipFile[MAXFILENAME + 1] = "";
    char entry[MAXFILENAME + 1] = "";
    char excludePrefix[MAXFILENAME + 1] = "";
    char zipFileBackup[MAXFILENAME + 1] = "";

    unsigned int entryLength = 0;
    unsigned int prefixLength = 0;

    int replace = 0, recursive = 0;

    STAFZipFile *zf;
    STAFZipUtil util = STAFZipUtil(pData->fHandlePtr);

    FILE *file;       

    STAFRC_t rc = kSTAFOk;

    // An ADD request is equivalent to a ZIP ADD request (except for
    // slightly different parsers).  The ADD request syntax is preferred
    // over the ZIP ADD request syntax, since ZIP ADD has been deprecated.
    
    // Check if the deprecated ZIP ADD command was specified

    STAFString requestType = "ADD";
    STAFString request = STAFString(pInfo->request);

    if (request.subWord(0, 1).toLowerCase() == "zip")
        requestType = "ZIP";

    // Verify the requester has at least trust level 4

    VALIDATE_TRUST(4, pData->fShortName, requestType, pData->fLocalMachineName);

    // Parse the request

    STAFCommandParseResultPtr parsedResult = pData->fAddParser->
        parse(pInfo->request);

    if (parsedResult->rc != kSTAFOk)
    {
        return STAFResultPtr(new STAFResult(kSTAFInvalidRequestString,
                             parsedResult->errorBuffer), STAFResultPtr::INIT);
    }

    if (requestType == "ZIP")
    {
        // Log a deprecated tracepoint message

        STAFString errorBuffer = STAFString(
            "STAFZip::handleAdd() - The ZIP service has deprecated the "
            "ZIP ADD request.  Use the ADD request instead.");

        STAFTrace::trace(kSTAFTraceDeprecated, errorBuffer);
    }

    // get "ZIPFILE" parameter value

    STAFResultPtr resultPtr = resolveOp(pInfo, pData, parsedResult, "ZIPFILE");
    if (resultPtr->rc != 0) return resultPtr;

    if (resultPtr->result.length() <= MAXFILENAME)
    {
        util.convertSTAFStringBuffer(resultPtr->result.toCurrentCodePage(), zipFile);
    }
    else
    {
        return STAFResultPtr(new STAFResult(kSTAFInvalidValue,
                                 STAFString("STAFZip::handleAdd: ZIPFILE [")
                                 + zipFile
                                 + "] file name length exceeds "
                                 + MAXFILENAME
                                 + " charactors.\n"),
                                 STAFResultPtr::INIT);
    }

    resultPtr->result = resultPtr->result.replace(kUTF8_BSLASH, kUTF8_SLASH);

    // use zip file name to construct the mutex name

    *mutexName += resultPtr->result;  
    *mutexName = (*mutexName).toUpperCase();
    
    // obtain mutex semphore on the zipfile

    zipLock.request(*mutexName);
    
    // get "RELATIVETO" parameter value

    resultPtr = resolveOp(pInfo, pData, parsedResult, "RELATIVETO");
    if (resultPtr->rc != 0) return resultPtr;

    resultPtr->result = resultPtr->result.replace(kUTF8_BSLASH, kUTF8_SLASH);
    prefixLength = resultPtr->result.length();

    if (prefixLength > 0)
    {
        if (prefixLength <= MAXFILENAME)
        {
            util.convertSTAFStringBuffer(resultPtr->result.toCurrentCodePage(), excludePrefix);

            if (excludePrefix[prefixLength - 1] != '/')
            {
                excludePrefix[prefixLength] = '/';                
                excludePrefix[prefixLength + 1] = kUTF8_NULL;
                
                prefixLength++;
            }
        }
        else
        {
            return STAFResultPtr(new STAFResult(kSTAFInvalidValue,
                                     STAFString("STAFZip::handleAdd:"
                                     " RELATIVETO [")
                                     + excludePrefix
                                     + "] file name length exceeds "
                                     + MAXFILENAME
                                     + " charactors.\n"),
                                     STAFResultPtr::INIT);
        }
    }

    // get "RECURSE" parameter value

    if (parsedResult->optionTimes("RECURSE"))
    {
        recursive = 1;
    }

    // make a backup copy of the current zip file

    int fileExist = util.checkFileExist(zipFile);

    if (fileExist)
    {
        strcpy(zipFileBackup, zipFile);
        strcat(zipFileBackup, ".ZIP");

        if(util.copyFile(zipFile, zipFileBackup) != kSTAFOk)
        {
            return STAFResultPtr(new STAFResult(kZIPGeneralZipError,
                                     STAFString("STAFZip::handleAdd:"
                                     " Can't create file [")
                                     + zipFile
                                     + ".ZIP].\n"),
                                     STAFResultPtr::INIT);
        }

        // open the file for reading and writing

        if ((file = fopen(zipFileBackup, "r+b")) == NULL) 
        {
            result = STAFString("STAFZip::handleAdd_CP1.1: ")
                     + "ZipFile [" + zipFileBackup + "] does not exist.\n";
            rc = kSTAFDoesNotExist;
        }
    }
    else
    {
        // create a new file

        if ((file = fopen(zipFile, "wb")) == NULL)