stafzipcentraldir.cpp

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

                          + "Error reading central dir data.\n";
            }

            break;
        }


        fileHeaderList.push_back(fh);

        fileHeaderListSorted[STAFString(fh->fileName)] = fh;        
    }

    return rc;

}

// Add file header
void STAFZipCentralDir::addFileHeader(STAFZipLocalFileHeader *lfh)
{

    STAFZipFileHeader *fh = new STAFZipFileHeader(lfh);

    fileHeaderList.push_back(fh);
    fileHeaderListSorted[STAFString(fh->fileName)] = fh;        

    cder->numberEntry++;

    cder->numberEntryWithCentralDir = cder->numberEntry;

    cder->centralDirSize += fh->size;

    cder->centralDirOffset += lfh->size;

    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDir::addFileHeader_CP1")
                     + " cder->numberEntry ["
                     + STAFString(cder->numberEntry)
                     + "] cder->numberEntryWithCentralDir ["
                     + STAFString(cder->numberEntryWithCentralDir)
                     + "] cder->centralDirSize ["
                     + cder->centralDirSize
                     + "] cder->centralDirOffset ["
                     + cder->centralDirOffset
                     + "]");
}


// get central dir offset
uLong STAFZipCentralDir::getOffset()
{
    return cder->centralDirOffset;
}


// get number of entries in central dir
unsigned short STAFZipCentralDir::getNumberEntry()
{
    return cder->numberEntry;
}


// get central dir size
uLong STAFZipCentralDir::getSize()
{
    return cder->centralDirSize;
}


// get central dir end record
STAFZipCentralDirEndRecord* STAFZipCentralDir::getCentralDirEndRecord()
{
    return cder;
}


static const STAFString sZipInfoClassName = "STAF/Service/Zip/ZipInfo";


// list the content of Zip archive
STAFRC_t STAFZipCentralDir::list(STAFString *buf, STAFString *result)
{
    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDir::list_CP1"));

    // Construct map class for the marshalled  zip information

    STAFMapClassDefinitionPtr zipInfoClass;
 
    zipInfoClass = STAFMapClassDefinition::create("STAF/Service/Zip/ZipInfo");
 
    zipInfoClass->addKey("length", "Length");
    zipInfoClass->addKey("method", "Method");
    zipInfoClass->addKey("size", "Size");
    zipInfoClass->addKey("ratio", "Ratio");
    zipInfoClass->addKey("date", "Date");
    zipInfoClass->addKey("time", "Time");
    zipInfoClass->addKey("crc-32", "CRC-32");
    zipInfoClass->addKey("name", "Name");

    // Create a marshalled list of maps containing zip file information

    STAFObjectPtr mc = STAFObject::createMarshallingContext();
    mc->setMapClassDefinition(zipInfoClass->reference());
    STAFObjectPtr outputList = STAFObject::createList();
    
    char fieldBuf[MAXMESSAGE] = "";
    std::vector<STAFZipFileHeader*>::iterator i;

    for (i = fileHeaderList.begin(); i != fileHeaderList.end(); i++)
    {
        uLong ratio = 0;

        const char *string_method;

        struct tm filedate;

        STAFZipUtil util = STAFZipUtil();


        util.fileTime((*i)->lastModifiedTimeDate, &filedate);


        if ((*i)->uncompressedSize > 0)
        {
            ratio = ((*i)->compressedSize * 100) / (*i)->uncompressedSize;
        }

        if ((*i)->compressionMethod == 0)
        {
            string_method="Stored";
        }
        else
        {
            if ((*i)->compressionMethod == Z_DEFLATED)
            {
                uInt iLevel = (uInt)(((*i)->generalPurposeBitFlag & 0x6)
                                      / 2);
                if (iLevel == 0)
                {
                    string_method = "Defl:N";
                }
                else if (iLevel == 1)
                {
                    string_method = "Defl:X";
                }
                else if ((iLevel == 2) || (iLevel == 3))
                {
                    string_method = "Defl:F"; /* 2:fast , 3 : extra fast*/
                }
            }
            else
            {
                string_method = "Unkn. ";
            }
        }


        STAFObjectPtr zipInfoMap = zipInfoClass->createInstance();

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%7lu", (*i)->uncompressedSize);
        zipInfoMap->put("length", STAFString(fieldBuf));

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%6s", string_method);
        zipInfoMap->put("method", STAFString(fieldBuf));

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%7lu", (*i)->compressedSize);
        zipInfoMap->put("size", STAFString(fieldBuf));

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%3lu%%", ratio);
        zipInfoMap->put("ratio", STAFString(fieldBuf));

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%2.2lu-%2.2lu-%2.2lu", 
                (uLong)filedate.tm_mon + 1,
                (uLong)filedate.tm_mday,
                (uLong)filedate.tm_year % 100);
        zipInfoMap->put("date", STAFString(fieldBuf));

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%2.2lu:%2.2lu", 
                (uLong)filedate.tm_hour,
                (uLong)filedate.tm_min);
        zipInfoMap->put("time", STAFString(fieldBuf));

        memset(fieldBuf, 0, MAXMESSAGE);
        sprintf(fieldBuf, "%8.8lx", (uLong)(*i)->crc);
        zipInfoMap->put("crc-32", STAFString(fieldBuf));

        zipInfoMap->put("name", STAFString((*i)->fileName));

        outputList->append(zipInfoMap);
    }
    
    mc->setRootObject(outputList);
    *buf = mc->marshall();

    return kSTAFOk;
}


// remove a file entry from central dir
STAFZipFileHeader* STAFZipCentralDir::remove(const char *fileName,
                                             STAFZipLocalFileHeader *lfh)
{

    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDir::remove_CP1"));

    STAFZipFileHeader *fh = NULL;

    STAFZipUtil util = STAFZipUtil();

    std::vector<STAFZipFileHeader*>::iterator i;


    // search for file entry in the central dir
    for (i = fileHeaderList.begin(); i != fileHeaderList.end(); i++)
    {
        STAFTrace::trace(kSTAFTraceServiceResult,
                         STAFString("STAFZipCentralDir::remove_CP2")
                         + " fileName ["
                         + fileName
                         + "] (*i)->fileName ["
                         + (*i)->fileName
                         + "]");

        if (util.myStrCmp((*i)->fileName, fileName) == 0)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDir::remove_CP3")
                             + " fileName ["
                             + fileName
                             + "] (*i)->fileName ["
                             + (*i)->fileName
                             + "]");

            // store file header
            fh = (*i);

            // remove the file header from central dir
            fileHeaderList.erase(i);
            fileHeaderListSorted.erase(STAFString(fh->fileName));

            break;
        }
    }

    // if file header is found
    if (fh != NULL)
    {
        STAFTrace::trace(kSTAFTraceServiceResult,
                         STAFString("STAFZipCentralDir::remove_CP4"));

        // change local file header offset to the new offset in central dir
        for (i = fileHeaderList.begin(); i != fileHeaderList.end(); i++)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDir::remove_CP5")
                             + " (*i)->localFileHeaderOffset ["
                             + (*i)->localFileHeaderOffset
                             + "] fh->localFileHeaderOffset ["
                             + fh->localFileHeaderOffset
                             + "]");


            // if local file header is after the removed file header
            if ((*i)->localFileHeaderOffset > fh->localFileHeaderOffset)
            {
                // change local file header offset to the new offset
                (*i)->localFileHeaderOffset -= lfh->size;

                STAFTrace::trace(kSTAFTraceServiceResult,
                                 STAFString("STAFZipCentralDir::remove_CP6")
                                 + " (*i)->localFileHeaderOffset ["
                                 + (*i)->localFileHeaderOffset
                                 + "] fh->localFileHeaderOffset ["
                                 + fh->localFileHeaderOffset
                                 + "] lfh->size ["
                                 + lfh->size
                                 + "]");
            }
        }

        STAFTrace::trace(kSTAFTraceServiceResult,
                         STAFString("STAFZipCentralDir::remove_CP7")
                         + " cder->centralDirOffset ["
                         + cder->centralDirOffset
                         + "] cder->centralDirSize ["
                         + cder->centralDirSize
                         + "] cder->numberEntry ["
                         + STAFString(cder->numberEntry)
                         + "] cder->numberEntryWithCentralDir ["
                         + STAFString(cder->numberEntryWithCentralDir)
                         + "] lfh->size ["
                         + lfh->size
                         + "]");

        // change central dir offset
        cder->centralDirOffset -= lfh->size;

        // change central dir size
        cder->centralDirSize -= fh->size;

        // reduce number of entries in central dir by 1
        cder->numberEntry--;

        // reduce number of entries with central dir by 1
        cder->numberEntryWithCentralDir--;

        STAFTrace::trace(kSTAFTraceServiceResult,
                         STAFString("STAFZipCentralDir::remove_CP8")
                         + " cder->centralDirOffset ["
                         + cder->centralDirOffset
                         + "] cder->centralDirSize ["
                         + cder->centralDirSize
                         + "] cder->numberEntry ["
                         + STAFString(cder->numberEntry)
                         + "] cder->numberEntryWithCentralDir ["
                         + STAFString(cder->numberEntryWithCentralDir)
                         + "] lfh->size ["
                         + lfh->size
                         + "]");

    }

    return fh;
}

// find a file name in central dir
STAFZipFileHeader* STAFZipCentralDir::find(const char *fileName)
{
    STAFTrace::trace(kSTAFTraceServiceResult,
                         STAFString("STAFZipCentralDir::find_CP1")
                         + " fileName ["
                         + fileName
                         + "]");

    std::map<STAFString, STAFZipFileHeader*>::iterator i;

    i = fileHeaderListSorted.find(
        STAFString(fileName).replace(kUTF8_BSLASH, kUTF8_SLASH));

    if (i != fileHeaderListSorted.end())
        return i->second;
    else
        return NULL;
}


// find the last file header
STAFZipFileHeader* STAFZipCentralDir::findLastFileHeader()
{
    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDir::findLastFileHeader_CP1"));

    STAFZipFileHeader *fh = *fileHeaderList.begin();


    std::vector<STAFZipFileHeader*>::iterator i;

    for (i = fileHeaderList.begin(); i != fileHeaderList.end(); i++)
    {

        if ((*i)->localFileHeaderOffset > fh->localFileHeaderOffset)
        {
            fh = *i;
        }

    }

    return fh;

}


// destructor
STAFZipCentralDir::~STAFZipCentralDir()
{
    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDir::destructor_CP1"));

    std::vector<STAFZipFileHeader*>::iterator i;

    for (i = fileHeaderList.begin(); i != fileHeaderList.end(); i++)
    {
        delete *i;
    }

    delete cder;

}