extracting file inside of directory with miniz

Question

Is there someone that can explain me how i can get files from directories inside a zipfile. I use c++ and miniz(code.google.com/p/miniz/). thank you in advance. here my code i have that i use right now:

size_t uncomp_size;
mz_bool status;
mz_zip_archive zip_archive;

memset(&zip_archive, 0, sizeof(zip_archive));
status = mz_zip_reader_init_file(&zip_archive, "data.zip", 0);
if (!status){
    puts("failed to open zip file\n");
    return 0;
}
try{
    void* p = NULL;
    std::string file_to_extract = "data//test.txt";
    int file_index = mz_zip_reader_locate_file(&zip_archive, file_to_extract.c_str(), NULL, MZ_ZIP_FLAG_IGNORE_PATH);
    if (file_index < 0)
    {
        mz_bool is_dir = mz_zip_reader_is_file_a_directory(&zip_archive,file_index);
        if(is_dir){
            throw std::exception("file_index = folder");
        }else{
            throw std::exception("cannot find file in zip(0)");
        }
    }

    p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, &uncomp_size, NULL);
    if(!p){
        throw std::exception("cannot find file in zip(1)");
    }
    std::fstream fp1("test.txt",ios::binary|ios::out);
    fp1.write(reinterpret_cast<char*>(p),uncomp_size);
    fp1.close();
    delete p;
}catch(std::exception ex){
    cout << ex.what() << endl; 
}
mz_zip_reader_end(&zip_archive);

Answer 1

I came up with a solution for this.

Lets we have;

In your C directory:

+-- ZipFile /
    +-- folder1 /
    +-- file1         
    +-- folder2 /
        +--file2.1
        +--file2.2
        +--file2.3

bool decompress_folders_inside_zip()
{
    const std::string archive_name = "ZipFile.zip";
    const std::string decompress_path = "C:\\";

    mz_zip_archive archive {};

    boost::filesystem::path dec_path { decompress_path + archive_name };

    if (!mz_zip_reader_init_file(&archive, dec_path.string().c_str(), 0))
    {
        return false;
    }

    const int file_cnt = (int)mz_zip_reader_get_num_files(&archive);

    if (0 == file_cnt)
    {
        return false;
    }

    mz_zip_archive_file_stat file_stat;

    if (!mz_zip_reader_file_stat(&archive, 0, &file_stat))
    {
        mz_zip_reader_end(&archive);
        return false;
    }

    for (int i = 0; i < file_cnt; ++i)
    {
        mz_zip_reader_file_stat(&archive, i, &file_stat);

        if (mz_zip_reader_is_file_a_directory(&archive, i))
        {
            boost::filesystem::path dir(decompress_path + file_stat.m_filename);
            boost::filesystem::create_directories(dir.parent_path());
            continue;
        }

        boost::filesystem::path file_out(decompress_path + file_stat.m_filename);

        boost::filesystem::path out_file(file_out.parent_path().generic_string() + "/" + file_out.filename().string());

        if (!mz_zip_reader_extract_to_file(&archive, i, out_file.string().c_str(), 0))
        {
            mz_zip_reader_end(&archive);
            return false;
        }
    }

    if (!mz_zip_reader_end(&archive))
    {
        return false;
    }

    std::cout << "Completed" << std::endl;
    return true;
}

Answer 2

This code is working for me using miniz from here.

string str_zip;    // The zip archive in string form.
string str_unzip;  // The uncompressed contents of the first file in the zip archive.

// Read in or assign zip contents to the string.
// In my case I receive the zip file via a web service.  
// The processing all takes place in memory.  
// But you can easily read a file's contents into the zipfile string, as well.

typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint;

mz_zip_archive zip_archive;
mz_bool status;

// Now try to open the archive.
memset(&zip_archive, 0, sizeof(zip_archive));

// You can provide the zip data in memory as I did...
status = mz_zip_reader_init_mem(&zip_archive, str_zip.c_str(), str_zip.size(), 0);

// Or you can just give a filename...
// status = mz_zip_reader_init_file(&zip_archive, "myfile.zip", 0);

if (!status)
{
    cout << "zip file appears invalid..." << endl;
    return;
}

// Get the first file in the archive.
if (mz_zip_reader_get_num_files(&zip_archive) != 1)
{
    cout << "zip file does not contain our 1 file..." << endl;
    return;
}

mz_zip_archive_file_stat file_stat;
if (!mz_zip_reader_file_stat(&zip_archive, 0, &file_stat))
{
    cout << "zip file read error..." << endl;
    mz_zip_reader_end(&zip_archive);
    return;
}

// Unzip the file to heap.
size_t uncompressed_size = file_stat.m_uncomp_size;
void* p = mz_zip_reader_extract_file_to_heap(&zip_archive, file_stat.m_filename, &uncompressed_size, 0);
if (!p)
{
    cout << "mz_zip_reader_extract_file_to_heap() failed..." << endl;
    mz_zip_reader_end(&zip_archive);
    return;
}

str_unzip.assign((const char*)p,uncompressed_size);

// Close the archive, freeing any resources it was using
mz_free(p);
mz_zip_reader_end(&zip_archive);