zip.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "io-precomp.h"  // Precompiled headers
 
#include "zlib.h"
 
// For named pipes:
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
 
#include <mrpt/io/zip.h>
#include <mrpt/core/exceptions.h>
#include <mrpt/io/vector_loadsave.h>
 
#include <mrpt/io/CFileGZOutputStream.h>
#include <mrpt/io/CFileGZInputStream.h>
#include <mrpt/io/CFileInputStream.h>
#include <mrpt/system/filesystem.h>
#include <chrono>
#include <iostream>
 
using namespace mrpt;
using namespace mrpt::io;
using namespace mrpt::io::zip;
 
void mrpt::io::zip::compress(
        void* inData, size_t inDataSize, std::vector<unsigned char>& outData)
{
        int ret = 0;
        MRPT_START
 
        unsigned long resSize;
 
        outData.resize(inDataSize + inDataSize / 1000 + 50);
        resSize = (unsigned long)outData.size();
        ret = ::compress(
                &outData[0], &resSize, (unsigned char*)inData,
                (unsigned long)inDataSize);
        ASSERT_(ret == Z_OK);
 
        outData.resize(resSize);
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                                compress
---------------------------------------------------------------*/
void mrpt::io::zip::compress(
        const std::vector<unsigned char>& inData,
        std::vector<unsigned char>& outData)
{
        int ret = 0;
        MRPT_START
 
        unsigned long resSize;
 
        outData.resize(inData.size() + inData.size() / 1000 + 50);
        resSize = (unsigned long)outData.size();
        ret = ::compress(
                &outData[0], &resSize, &inData[0], (unsigned long)inData.size());
        ASSERT_(ret == Z_OK);
 
        outData.resize(resSize);
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                                compress
---------------------------------------------------------------*/
void mrpt::io::zip::compress(void* inData, size_t inDataSize, CStream& out)
{
        int ret = 0;
        MRPT_START
 
        unsigned long resSize;
        std::vector<unsigned char> outData;
 
        outData.resize(inDataSize + inDataSize / 1000 + 50);
        resSize = (unsigned long)outData.size();
 
        ret = ::compress(
                &outData[0], &resSize, (unsigned char*)inData,
                (unsigned long)inDataSize);
        ASSERT_(ret == Z_OK);
 
        outData.resize(resSize);
 
        // Write to stream:
        out.Write(&outData[0], resSize);
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                                compress
---------------------------------------------------------------*/
void mrpt::io::zip::compress(
        const std::vector<unsigned char>& inData, CStream& out)
{
        int ret = 0;
        MRPT_START
 
        unsigned long resSize;
        std::vector<unsigned char> outData;
        outData.resize(inData.size() + inData.size() / 1000 + 50);
        resSize = (unsigned long)outData.size();
 
        ret = ::compress(
                &outData[0], &resSize, &inData[0], (unsigned long)inData.size());
 
        ASSERT_(ret == Z_OK);
 
        outData.resize(resSize);
 
        // Write to stream:
        out.Write(&outData[0], resSize);
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                                decompress
---------------------------------------------------------------*/
void mrpt::io::zip::decompress(
        void* inData, size_t inDataSize, std::vector<unsigned char>& outData,
        size_t outDataEstimatedSize)
{
        int ret = 0;
        MRPT_START
 
        outData.resize(outDataEstimatedSize);
        unsigned long actualOutSize;
 
        ret = ::uncompress(
                &outData[0], &actualOutSize, (unsigned char*)inData,
                (unsigned long)inDataSize);
 
        ASSERT_(ret == Z_OK);
 
        outData.resize(actualOutSize);
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                                decompress
---------------------------------------------------------------*/
void mrpt::io::zip::decompress(
        void* inData, size_t inDataSize, void* outData, size_t outDataBufferSize,
        size_t& outDataActualSize)
{
        int ret = 0;
        MRPT_START
 
        unsigned long actualOutSize = (unsigned long)outDataBufferSize;
 
        ret = ::uncompress(
                (unsigned char*)outData, &actualOutSize, (unsigned char*)inData,
                (unsigned long)inDataSize);
 
        ASSERT_(ret == Z_OK);
 
        outDataActualSize = actualOutSize;
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                                decompress
---------------------------------------------------------------*/
void mrpt::io::zip::decompress(
        CStream& inStream, size_t inDataSize, void* outData,
        size_t outDataBufferSize, size_t& outDataActualSize)
{
        int ret = 0;
        MRPT_START
 
        unsigned long actualOutSize = (unsigned long)outDataBufferSize;
        std::vector<unsigned char> inData;
 
        inData.resize(inDataSize);
        inStream.Read(&inData[0], inDataSize);
 
        ret = ::uncompress(
                (unsigned char*)outData, &actualOutSize, &inData[0],
                (unsigned long)inDataSize);
 
        ASSERT_(ret == Z_OK);
 
        outDataActualSize = actualOutSize;
 
        MRPT_END_WITH_CLEAN_UP(printf("[zlib] Error code=%i\n", ret););
}
 
/*---------------------------------------------------------------
                                        decompress_gz_file
---------------------------------------------------------------*/
bool mrpt::io::zip::decompress_gz_file(
        const std::string& file_path, std::vector<uint8_t>& buffer)
{
        CFileGZInputStream iss(file_path);
        if (!iss.fileOpenCorrectly()) return false;
 
        buffer.clear();
 
        const int bytes2read = 1 << 20;
        int act_read;
        size_t total_bytes = 0;
 
        buffer.reserve(iss.getTotalBytesCount());
 
        do
        {
                buffer.resize(1000 + bytes2read + buffer.size());
                act_read = iss.Read(&buffer[total_bytes], bytes2read);
                total_bytes += act_read;
        } while (act_read == bytes2read);
 
        buffer.resize(total_bytes);
        return true;
}
 
bool mrpt::io::zip::compress_gz_file(
        const std::string& file_path, const std::vector<uint8_t>& buffer,
        const int compress_level)
{
        CFileGZOutputStream oss;
        oss.open(file_path, compress_level);
        if (!oss.fileOpenCorrectly()) return false;
 
        if (!buffer.empty())
        {
                try
                {
                        oss.Write(&buffer[0], buffer.size());
                        return true;
                }
                catch (...)
                {
                        return false;
                }
        }
        else
        {
                return true;
        }
}
 
bool mrpt::io::zip::compress_gz_data_block(
        const std::vector<uint8_t>& in_data, std::vector<uint8_t>& out_gz_data,
        const int compress_level)
{
        out_gz_data.clear();
        if (in_data.empty()) return true;
 
        const unsigned int nPipeName =
                std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
        std::string pipe_file_name;
 
// Create an anonymous pipe for writing the data to:
#ifdef _WIN32
        // Windows:
        pipe_file_name =
                format("\\\\.\\pipe\\mrpt_compress_gz_data_block_%u", nPipeName);
 
        HANDLE hPipe = CreateNamedPipeA(
                pipe_file_name.c_str(),
                PIPE_ACCESS_DUPLEX | 0x00080000 /* FILE_FLAG_FIRST_PIPE_INSTANCE */,
                PIPE_TYPE_BYTE, PIPE_UNLIMITED_INSTANCES, in_data.size() + 1000,
                in_data.size() + 1000, 0, nullptr);
        if (hPipe == INVALID_HANDLE_VALUE)
                THROW_EXCEPTION("Error creating named pipe for gz-file compression");
#else
        // Unix:
        pipe_file_name = format("/tmp/mrpt_compress_gz_data_block_%u", nPipeName);
#endif
 
        bool retVal = false;
        try
        {
                // Write as gz
                {
                        gzFile f = gzopen(
                                pipe_file_name.c_str(), format("wb%i", compress_level).c_str());
                        if (f)
                        {
                                retVal = (int)in_data.size() ==
                                                 gzwrite(f, &in_data[0], in_data.size());
                                gzclose(f);
                        }
                        else
                        {
                                std::cerr << "[compress_gz_data_block] Error writing to pipe: "
                                                  << pipe_file_name << std::endl;
                        }
                }
                // Read it all:
                if (retVal)
                {
#ifdef _WIN32
                        // Read (windows)
                        const size_t N = GetFileSize(hPipe, nullptr);
                        if (N)
                        {
                                out_gz_data.resize(N);
                                DWORD nRead;
                                SetFilePointer(hPipe, 0, nullptr, FILE_BEGIN);
                                if (N)
                                {
                                        ReadFile(hPipe, &out_gz_data[0], N, &nRead, nullptr);
                                        retVal = nRead == N;
                                }
                        }
                        else
                        {
                                retVal = false;
                        }
#else
                        // Read (Unix)
                        {
                                CFileInputStream iss;
                                if (iss.open(pipe_file_name))
                                {
                                        const size_t M = iss.getTotalBytesCount();
                                        out_gz_data.resize(M);
                                        if (M) retVal = M == iss.Read(&out_gz_data[0], M);
                                }
                        }
#endif
                }
        }
        catch (...)
        {
                retVal = false;
        }
 
// Close the pipe:
#ifdef _WIN32
        CloseHandle(hPipe);
#else
        remove(pipe_file_name.c_str());
#endif
 
        return retVal;
}
 
bool mrpt::io::zip::decompress_gz_data_block(
        const std::vector<uint8_t>& in_gz_data, std::vector<uint8_t>& out_data)
{
        out_data.clear();
        if (in_gz_data.empty()) return true;
 
        // JL: I tried to do this with pipes but had no luck... :-(
        const std::string tmp_file_name = mrpt::system::getTempFileName();
        if (!mrpt::io::vectorToBinaryFile(in_gz_data, tmp_file_name)) return false;
        bool retVal = mrpt::io::zip::decompress_gz_file(tmp_file_name, out_data);
 
        remove(tmp_file_name.c_str());  // Delete tmp file
 
        return retVal;
}