stafzipcentraldirextension.cpp

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

STAFRC_t STAFZipCentralDirExtension::flush(FILE *zf, STAFString *result)
{

    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDirExtension::flush_CP1")
                     + " size ["
                     + size
                     + "]");

    if (size == 0)
    {
        return kSTAFOk;
    }

    STAFRC_t rc = kSTAFOk;

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

    STAFZipUtil util = STAFZipUtil();


    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString("STAFZipCentralDirExtension::flush_CP2")
                     + " signature ["
                     + signature
                     + "]");

    // signature
    rc = util.putValue(zf, (uLong)signature, 4);


    // write file attribute record into zip archive
    for (i = falist.begin(); i != falist.end(); i++)
    {

        // filenamelength
        if (rc == kSTAFOk)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDirExtension::flush_CP3")
                             + " (*i)->filename_length ["
                             + (*i)->filename_length
                             + "]");

            rc = util.putValue(zf, (uLong)(*i)->filename_length, 2);
        }


        // file name
        if (rc == kSTAFOk && (*i)->filename_length > 0)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDirExtension::flush_CP4")
                             + " (*i)->filename ["
                             + (*i)->filename
                             + "]");

            if (fwrite((*i)->filename, (uInt)(*i)->filename_length, 1, zf) != 1)
            {
                *result = STAFString("STAFZipCentralDirExtension::flush: ")
                          + "Error writing filename ["
                          + (*i)->filename
                          + "].\n";

                rc = kSTAFFileWriteError;
            }
        }


        // mode
        if (rc == kSTAFOk)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDirExtension::flush_CP6")
                             + " (*i)->mode ["
                             + (*i)->mode
                             + "]");

            rc = util.putValue(zf, (uLong)(*i)->mode, 4);
        }


        // owner
        if (rc == kSTAFOk)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDirExtension::flush_CP7")
                             + " (*i)->owner ["
                             + (*i)->owner
                             + "]");

            rc = util.putValue(zf, (uLong)(*i)->owner, 4);
        }


        // group
        if (rc == kSTAFOk)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                             STAFString("STAFZipCentralDirExtension::flush_CP8")
                             + " (*i)->group ["
                             + (*i)->group
                             + "]");

            rc = util.putValue(zf, (uLong)(*i)->group, 4);
        }


        if (rc != kSTAFOk)
        {
            if ((*result).length() == 0)
            {
                *result = STAFString("STAFZipCentralDirExtension::flush: ")
                          + "Error writing data.\n";
            }

            break;
        }
    }

    return rc;
}


// add a file attribute record into central dir extension
STAFRC_t STAFZipCentralDirExtension::addFileAttribute(const char *fullname,
                                             int prefix_len, STAFString *result)
{
    char *buffer ;
    char *p;
    int len = strlen(fullname);
    STAFRC_t rc;

    int err;


    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString(
                     "STAFZipCentralDirExtension::addFileAttribute_CP1")
                     + " len ["
                     + len
                     + " fullname ["
                     + fullname
                     + " prefix_len ["
                     + prefix_len
                     + "]");

    if (len <= 0)
    {
        return kSTAFOk;
    }

    // allocate buffer to make a copy of fullname
    if ((buffer = (char*)calloc(len + 1, 1)) == NULL)
    {
        *result = STAFString("STAFZipCentralDirExtension::addFileAttribute: ")
                          + "Error allocating memory for fullname ["
                          + (len + 1)
                          + "].\n";

        return kZIPNotEnoughMemory;
    }

    strcpy(buffer, fullname);


    // if this fullname is a directory, remove the ending slash
    if (buffer[len - 1] == '/' || buffer[len - 1] == '\\')
    {
        buffer[len-1] = '\0';
    }

    STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString(
                     "STAFZipCentralDirExtension::addFileAttribute_CP3")
                     + " buffer ["
                     + buffer
                     + "]");

    // setup a pointer to point to the first char after prefix
    // i.e. given full name: /opt/staf/mydata.dat,
    // prefix /opt/
    // we will start processing from staf/mydata.dat
    p = buffer + prefix_len + 1;

    while (1)
    {
        char hold;

        // get the first level of directory
        while(*p && *p != '\\' && *p != '/')
        {
          p++;
        }

        hold = *p;

        *p = 0;

        STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString(
                     "STAFZipCentralDirExtension::addFileAttribute_CP4")
                     + " buffer ["
                     + buffer
                     + "] hold ["
                     + hold
                     + "]");

        struct stat s;

        if ((err = lstat(buffer, &s)) != 0)
        {
            *result =
                STAFString("STAFZipCentralDirExtension::addFileAttribute: ")
                + "Error getting file status ["
                + buffer
                + "] err ["
                + err
                + "].\n";

            return kZIPGeneralZipError;
        }


        STAFZipFileAttribute *fa;


        // seach the current central dir extension for existing file attribute
        if ((fa = find(buffer + prefix_len)) == NULL)
        {
            // if not found, create a new file attribute entry

            STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString(
                     "STAFZipCentralDirExtension::addFileAttribute_CP6")
                     + " buffer+prefix_len ["
                     + (buffer + prefix_len)
                     + "]");

            fa = new STAFZipFileAttribute(buffer + prefix_len, &s);

            falist.push_back(fa);
            falistSorted[STAFString(fa->filename)] = fa;

            size += fa->filename_length + sizeof(unsigned short) + sizeof(mode_t) +
            sizeof(uid_t) + sizeof(gid_t);

        }
        else
        {
            // if found, replace the existing entry with new value

            fa->mode = s.st_mode;

            fa->owner = s.st_uid;

            fa->group = s.st_gid;

            STAFTrace::trace(kSTAFTraceServiceResult,
                     STAFString(
                     "STAFZipCentralDirExtension::addFileAttribute_CP7")
                     + " buffer+prefix_len ["
                     + (buffer + prefix_len)
                     + "] fa->mode ["
                     + fa->mode
                     + "] fa->owner ["
                     + fa->owner
                     + "] fa->group ["
                     + fa->group
                     + "]");
        }



        if (hold == 0)
        {
            STAFTrace::trace(kSTAFTraceServiceResult,
                    STAFString(
                    "STAFZipCentralDirExtension::addFileAttribute_CP8"));

            // if it is the end of the fullname
            break;
        }

        // retore the char
        *p++ = hold;
    }


    return kSTAFOk;
}


// find filename in the central dir extension section
STAFZipFileAttribute* STAFZipCentralDirExtension::find(char *filename)
{
    STAFTrace::trace(kSTAFTraceServiceResult,
                    STAFString("STAFZipCentralDirExtension::find_CP1")
                    + " filename ["
                    + filename
                    + "]");

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

    i = falistSorted.find(
        STAFString(filename).replace(kUTF8_BSLASH, kUTF8_SLASH));

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


// destructor
STAFZipCentralDirExtension::~STAFZipCentralDirExtension()
{

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

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

}