stafzip.cpp

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

    // 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 "TODIRECTORY" parameter value

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

    resultPtr->result = 
            STAFString(resultPtr->result.toCurrentCodePage()->buffer());

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

    if (toDirLength <= MAXFILENAME)
    {
        util.convertSTAFStringBuffer(resultPtr->result.toCurrentCodePage(), toDir);

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

    // get "REPLACE" parameter value

    if (parsedResult->optionTimes("REPLACE"))
    {
        replace = 1;
    }

    // get "RESTOREPERMISSION" parameter value

    if (parsedResult->optionTimes("RESTOREPERMISSION"))
    {
        restorePermission = 1;
    }

    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("handleUnzip_CP1")
                     +" zipFile ["
                     + zipFile
                     + "]");

    // open the ZIP archive for reading

    if ((file = fopen(zipFile, "rb")) == NULL) 
    {
        result = STAFString("STAFZip::handleUnzip_CP1.1: ")
                 + "ZipFile [" + zipFile + "] does not exist.\n";
        rc = kSTAFDoesNotExist;

        return STAFResultPtr(new STAFResult(rc, result),
                             STAFResultPtr::INIT);
    }

    zf = new STAFZipFile(pData->fHandlePtr, file, &rc, &resultBuffer, 1);

    if (rc != kSTAFOk)
    {
        delete zf;
        fclose(file);

        return STAFResultPtr(new STAFResult(rc, resultBuffer),
                             STAFResultPtr::INIT);
    }

    unsigned int numFilesToUnzip = parsedResult->optionTimes("FILE");
    unsigned int numDirsToUnzip = parsedResult->optionTimes("DIRECTORY");

    if (numFilesToUnzip == 0 && numDirsToUnzip == 0)
    {
        if (STAFTrace::doTrace(kSTAFTraceServiceResult))
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                         STAFString("handleUnzip_CP2")
                         + " toDir ["
                         + toDir
                         + "] replace ["
                         + replace
                         + "] restorePermission ["
                         + restorePermission
                         + "]");
        }

        // if not FILE option is provided, unzip all files in the archive

        if ((rc = zf->unzipFile(toDir, replace, restorePermission,
             &resultBuffer)) != kSTAFOk)
        {
            result = resultBuffer;
        }
    }
    else if (numFilesToUnzip > 0)
    {
        // unzip the individual files one by one

        for (unsigned int i = 1; i <= numFilesToUnzip; i++)
        {
            // resolve variables

            STAFString thisFile = parsedResult->optionValue("FILE", i);
            resultPtr = resolveStr(pInfo, pData, thisFile);

            if (resultPtr->rc != 0) 
            {
                rc = resultPtr->rc;    
                result = resultPtr->result;
            
                break;
            }

            thisFile = resultPtr->result;
            fileLength = thisFile.length();

            if (fileLength != 0)
            {
                if (fileLength <= MAXFILENAME)
                {
                    util.convertSTAFStringBuffer(
                        thisFile.toCurrentCodePage(), fileName);
                }
                else
                {
                    result = STAFString("STAFZip::handleUnzip:"
                                        " FILE [")
                             + fileName
                             + "] file name length exceeds "
                             + MAXFILENAME
                             + " charactors.\n";
                    rc = kSTAFInvalidValue;

                    break;
                }
            }

            if (STAFTrace::doTrace(kSTAFTraceServiceResult))
            {
                STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("handleUnzip_CP3")
                             + " file ["
                             + fileName
                             + "] toDir ["
                             + toDir
                             + "] replace ["
                             + replace
                             + "] restorePermission ["
                             + restorePermission
                             + "]");
            }
                        
            // unzip the file entry

            if ((rc = zf->unzipFile(fileName, toDir, replace, restorePermission,
                &resultBuffer)) != kSTAFOk)
            {
                result = resultBuffer;

                // if fails, exit the loop

                break;
            }
        } //end for
    }
    else // if (numDirsToUnzip > 0)
    {
        // unzip the individual dirs one by one

        for (unsigned int i = 1; i <= numDirsToUnzip; i++)
        {
            // resolve variables

            STAFString thisDirectory = parsedResult->optionValue("DIRECTORY", i);
            resultPtr = resolveStr(pInfo, pData, thisDirectory);

            if (resultPtr->rc != 0) 
            {
                rc = resultPtr->rc;    
                result = resultPtr->result;
            
                break;
            }

            thisDirectory = resultPtr->result;
            fileLength = thisDirectory.length();

            if (fileLength != 0)
            {
                if (fileLength <= MAXFILENAME)
                {
                    util.convertSTAFStringBuffer(
                        thisDirectory.toCurrentCodePage(), fileName);
                }
                else
                {
                    result = STAFString("STAFZip::handleUnzip:"
                                        " DIRECTORY [")
                             + fileName
                             + "] dir name length exceeds "
                             + MAXFILENAME
                             + " charactors.\n";
                    rc = kSTAFInvalidValue;

                    break;
                }
            }

            if (STAFTrace::doTrace(kSTAFTraceServiceResult))
            {
                STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("handleUnzip_CP3")
                             + " dir ["
                             + fileName
                             + "] toDir ["
                             + toDir
                             + "] replace ["
                             + replace
                             + "] restorePermission ["
                             + restorePermission
                             + "]");
            }
                      
            // unzip the dir entry

            if ((rc = zf->unzipDir(fileName, toDir, replace, restorePermission,
                &resultBuffer)) != kSTAFOk)
            {
                result = resultBuffer;

                // if fails, exit the loop

                break;
            }
        } // end for
    } // end if

    delete zf;

    if (file != NULL)
    {
        fclose(file);
    }

    return STAFResultPtr(new STAFResult(rc, result),
                         STAFResultPtr::INIT);
}


// Handles Delete requests

STAFResultPtr handleDelete(STAFServiceRequestLevel30 *pInfo,
                           STAFZipServiceData *pData, STAFString *mutexName)
{
    STAFString result;
    STAFString resultBuffer;

    char zipFile[MAXFILENAME + 1] = "";
    char deleteFile[MAXFILENAME + 1] = "";
    char zipFileBackup[MAXFILENAME + 1] = "";

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

    STAFRC_t rc = kSTAFOk;

    FILE *file;       

    // Verify the requester has at least trust level 4

    VALIDATE_TRUST(4, pData->fShortName, "DELETE", pData->fLocalMachineName);

    // Parse the request

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

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

    // 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::handleDelete:"
                                            " 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);

    int fileExist = util.checkFileExist(zipFile);

    if (!fileExist)
    {

        return STAFResultPtr(new STAFResult(kSTAFDoesNotExist,
                                          STAFString("STAFZip::handleDelete:"
                                          " Zip file does not exist [")
                                          + zipFile
                                          + "].\n"),
                                          STAFResultPtr::INIT);
    }        
        
    // backup the original zip archive

    strcpy(zipFileBackup, zipFile);
    strcat(zipFileBackup, ".ZIP");

    if(util.copyFile(zipFile, zipFileBackup) != kSTAFOk)
    {

        return STAFResultPtr(new STAFResult(kZIPGeneralZipError,
                                          STAFString("STAFZip::handleDelete:"
                                          " Can't create file [")
                                          + zipFile
                                          + ".ZIP].\n"),
                                          STAFResultPtr::INIT);
    }

    // open the ZIP archive for reading and writing

    if ((file = fopen(zipFileBackup, "r+b")) == NULL) 
    {
        result = STAFString("STAFZip::handleDelete_CP0.1: ")
                 + "ZipFile [" + zipFileBackup + "] does not exist.\n";
        rc = kSTAFDoesNotExist;

        return STAFResultPtr(new STAFResult(rc, result),
                             STAFResultPtr::INIT);
    }

    // loop to delete file entries from zip archive

    long newsize = -1;
    unsigned int numFilesToDelete = parsedResult->optionTimes("FILE");

    for (unsigned int i = 1; i <= numFilesToDelete; i++)
    {
        // resolve variables

        STAFString thisFile = parsedResult->optionValue("FILE", i);
        resultPtr = resolveStr(pInfo, pData, thisFile);