Создание ZIP архива

#ifndef __ZIP_HPP__
#define __ZIP_HPP__
 
#include <boost/shared_ptr.hpp>
 
#include "zip_impl.hpp"
 
class Zip
{
public:
   Zip(const std::string& filename):impl(new ZipImpl(filename))
   {
   }
   void insert(const std::string& filename, const std::string& content)
   {
      impl->insert(filename, content);
   }
   void close()
   {
      impl->close();
   }
private:
   boost::shared_ptr<ZipImpl> impl;
};
 
#endif

#ifndef __ZIP_IMPL_HPP__
#define __ZIP_IMPL_HPP__
 
#include <fstream>
#include <sstream>
#include <string>
 
#include <zlib.h>
 
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
 
#include <boost/filesystem.hpp>
#include <arpa/inet.h>
 
bool is_littleendian()
{
   unsigned short x = 1;
   if (*((unsigned char*)(&x)) != 0)
   {
      return true;
   }
   return false;
}
 
bool need_convert_endian(char endian)
{
   return ((endian == '<' && !is_littleendian()) ||
   (endian == '>' || endian == '!') && is_littleendian);
}
 
template<class T>
std::string pack(char endian, const T& value);
 
template<class T>
std::string pack_internal(const T& value)
{
   std::stringstream ss;
   ss.write((char*)&value, sizeof(T));
   return ss.str();
}
 
template<>
std::string pack_internal(const std::string& value)
{
   std::stringstream ss;
   ss.write(value.data(), value.length());
   return ss.str();
}
 
template<>
std::string pack(char endian, const unsigned int& value)
{
   bool need_conv = need_convert_endian(endian);
   unsigned int val = value;
   if (need_conv)
   {
      val = htonl(value);
   }
   return pack_internal(val);
}
 
template<> 
std::string pack(char endian, const unsigned short& value)
{
   bool need_conv = need_convert_endian(endian);
   unsigned short val = value;
   if (need_conv)
   {
      val = htons(val);
   }
   return pack_internal(val);
}
 
template<>
std::string pack(char endian, const std::string& value)
{
   return pack_internal(value);
}
 
template<>
std::string pack(char endian, const unsigned char& value)
{
   return pack_internal(value);
}
 
template<> 
std::string pack(char endian, const unsigned long& value)
{
   return pack(endian, static_cast<const unsigned int&>(value));
}
 
template<class T>
std::string pack(const T& value)
{
   return pack('<', value);
}
 
const unsigned long ZIP64_LIMIT = (1U << 31) - 1;
const size_t ZIP_FILECOUNT_LIMIT = 1 << 16;
const size_t FLAG = 0x08;
 
struct ZipInfo
{
public:
   ZipInfo(const std::string& fn, const boost::posix_time::ptime& time = boost::posix_time::ptime()):
      filename(fn), reversed(0), flag_bits(0), create_version(20),
      extract_version(20), filesize(0), compress_size(0), CRC(0),
      internal_attr(0), external_attr(0), create_system(3)
   {
      boost::posix_time::ptime now = time;
      if (now.is_special())
      {
         now = boost::posix_time::second_clock::local_time();
      }
      const boost::gregorian::date& dt = now.date();
      date[0] = dt.year();
      date[1] = dt.month();
      date[2] = dt.day();
      const boost::posix_time::time_duration& tm = now.time_of_day();
      date[3] = tm.hours();
      date[4] = tm.minutes();
      date[5] = tm.seconds();
   }
   std::string file_header()
   {
      const std::string string_file_header("PK\3\4");
      const unsigned char feature_version = 45;
 
      unsigned short dosdate = ((date[0] - 1980) << 9) | (date[1] << 5) | date[2];
      unsigned short dostime = date[3] << 11 | date[4] << 5 | (date[5] / 2);
      unsigned int crc = 0, compress = 0, file_size = 0;
      if (!(flag_bits & FLAG))
      {
         crc = CRC;
         compress = compress_size;
         file_size = filesize;
      }
      std::string ext = extra;
      if (file_size > ZIP64_LIMIT || compress > ZIP64_LIMIT)
      {
         // File is larger than what fits into a 4 byte integer,
         // fall back to the ZIP64 extension.
         // TODO: extra = extra + pack(params).
         file_size = std::numeric_limits<unsigned int>::max();
         compress = std::numeric_limits<unsigned int>::max();
         extract_version = std::max(feature_version, extract_version);
         create_version = std::max(feature_version, create_version);
      }
      // TODO: Function that encode and set flags.
      std::string header;
      header += pack(string_file_header);
      header += pack(extract_version);
      header += pack(reversed);
      header += pack(flag_bits);
      header += pack(compress_type);
      header += pack(dostime);
      header += pack(dosdate);
      header += pack(crc);
      header += pack(compress);
      header += pack(file_size);
      header += pack((unsigned short)filename.length());
      header += pack((unsigned short)ext.length());
      // TODO: header = pack(params).
      return header + filename + ext;
   }
   const std::string get_filename() const
   {
      return filename;
   }
 
   std::string filename;
   std::string comment;
   std::string extra;
   unsigned char reversed;
   unsigned short flag_bits;
   long date[6];
   unsigned char create_version;
   unsigned char extract_version;
   unsigned long long filesize;
   unsigned long long compress_size;
   std::streampos header_offset;
   unsigned long CRC;
   unsigned short internal_attr;
   unsigned long external_attr;
   unsigned char create_system;
   static const unsigned short compress_type = Z_DEFLATED;
};
 
const unsigned short ZipInfo::compress_type;
 
namespace fs = boost::filesystem;
 
class ZlibError : public std::logic_error
{
public:
   ZlibError(const std::string& msg, int error):std::logic_error(msg), error_code(get_error(error))
   {
   }
   ~ZlibError() throw()
   {
   }
   const char* what() const throw()
   {
      return (std::string(std::logic_error::what()) + error_code).c_str();
   }
private:
   std::string get_error(const int err)
   {
      std::string result;
      switch (err)
      {
      case Z_MEM_ERROR:
         result = "No memory";
         break;
      case Z_STREAM_ERROR:
         result = "Inconsistent stream state";
         break;
      case Z_DATA_ERROR:
         result = "Invalid input data";
         break;
      case Z_BUF_ERROR:
         result = "Buffer error";
         break;
      default:
         break;
      }
      return result;
   }
   std::string error_code;
};
 
class ZipImpl
{
public:
   ZipImpl(const std::string& arch_name)
   {
      file_stream.open(arch_name.c_str());
   }
   ~ZipImpl()
   {
      close();
   }
   void insert(const std::string& f_name, const std::string& content)
   {
      // TODO: utf-8 encode content.
      ZipInfo zinfo(f_name);
      zinfo.filesize = content.length();
      zinfo.header_offset = file_stream.tellp();
      zinfo.CRC = crc(content) & std::numeric_limits<unsigned int>::max();
      std::string compressed = compress(content);
      zinfo.compress_size = compressed.length();
      file_stream << zinfo.file_header() << compressed;
      file_stream.flush();
      if (zinfo.flag_bits & FLAG)
      {
         // Write CRC and file sizes after the file data
         std::string temp;
         temp += pack((unsigned int)zinfo.CRC);
         temp += pack((unsigned int)zinfo.compress_size);
         temp += pack((unsigned int)zinfo.filesize);
         file_stream << temp;
         file_stream.flush();
         // TODO: file_stream << pack(params).
      }
      files_info.push_back(zinfo);
   }
   void close()
   {
      if (!file_stream.is_open())
      {
         return;
      }
      std::streampos pos1 = file_stream.tellp();
      for (std::vector<ZipInfo>::iterator iter = files_info.begin(); iter != files_info.end(); ++iter)
      {
         const ZipInfo& cur_info = *iter;
         const unsigned char feature_version = 45;
         const std::string cent_dir_header("PK\1\2");
 
         unsigned short dosdate = (cur_info.date[0] - 1980) << 9 | cur_info.date[1] << 5 | cur_info.date[2];
         unsigned short dostime = cur_info.date[3] << 11 | cur_info.date[4] << 5 | (cur_info.date[5] / 2);
         std::vector<unsigned long long> extra;
         unsigned long file_size = cur_info.filesize;
         unsigned long compress_size = cur_info.compress_size;
         if (file_size > ZIP64_LIMIT || compress_size > ZIP64_LIMIT)
         {
            extra.push_back(file_size);
            extra.push_back(compress_size);
            file_size = std::numeric_limits<unsigned int>::max();
            compress_size = std::numeric_limits<unsigned int>::max();
         }
         std::streampos header_offset = cur_info.header_offset;
         if (header_offset > ZIP64_LIMIT)
         {
            extra.push_back(header_offset);
            header_offset = std::numeric_limits<unsigned int>::max();
         }
         std::string extra_data = cur_info.extra;
         unsigned char extract_version = cur_info.extract_version;
         unsigned char create_version = cur_info.create_version;
         if (!extra.empty())
         {
            // Append a ZIP64 field to extra`s.
            // TODO: extra_data = pack(params) + extra_data.
            extract_version = std::max(feature_version, extract_version);
            create_version = std::max(feature_version, create_version);
         }
         // TODO: encode data and set flag_bits.
         std::string centDir;
         centDir += pack(cent_dir_header);
         centDir += pack(create_version);
         centDir += pack(cur_info.create_system);
         centDir += pack(extract_version);
         centDir += pack(cur_info.reversed);
         centDir += pack(cur_info.flag_bits);
         centDir += pack(cur_info.compress_type);
         centDir += pack(dostime);
         centDir += pack(dosdate);
         centDir += pack(static_cast<unsigned int>(cur_info.CRC));
         centDir += pack(compress_size);
         centDir += pack(file_size);
         centDir += pack(static_cast<unsigned short>(cur_info.filename.length()));
         centDir += pack(static_cast<unsigned short>(extra_data.length()));
         centDir += pack(static_cast<unsigned short>(0));
         centDir += pack(static_cast<unsigned short>(0));
         centDir += pack(cur_info.internal_attr);
         centDir += pack(cur_info.external_attr);
         centDir += pack(static_cast<unsigned int>(header_offset));
         // TODO: centdir = pack(params).
         file_stream << centDir << cur_info.filename << extra_data;
         file_stream.flush();
      }
      
      const std::string end_record_header("PK\5\6");
 
      std::streampos pos2 = file_stream.tellp();
      unsigned short centDirCount = files_info.size();
      unsigned long long centDirSize = pos2 - pos1;
      unsigned long long centDirOffset = pos1;
      if (centDirCount > ZIP_FILECOUNT_LIMIT || centDirOffset > ZIP64_LIMIT || centDirSize > ZIP64_LIMIT)
      {
         // Need to write ZIP64 end-of-archive records.
         std::string zip64_endrec;
         // TODO: zip_64_endrec = pack(params).
         file_stream << zip64_endrec;
         std::string zip64_locrec;
         // TODO: zip64_locrec = pack(params).
         file_stream << zip64_locrec;
         centDirCount = std::min(centDirCount, std::numeric_limits<unsigned short>::max());
         centDirSize = std::min(centDirSize, static_cast<unsigned long long>(std::numeric_limits<unsigned int>::max()));
         centDirOffset = std::min(centDirOffset, static_cast<unsigned long long>(std::numeric_limits<unsigned int>::max()));
      }
      // check for valid comment length. no comments now.
      std::string endrec;
      endrec += pack(end_record_header);
      endrec += pack(static_cast<unsigned short>(0));
      endrec += pack(static_cast<unsigned short>(0));
      endrec += pack(centDirCount);
      endrec += pack(centDirCount);
      endrec += pack(static_cast<unsigned int>(centDirSize));
      endrec += pack(static_cast<unsigned int>(centDirOffset));
      endrec += pack(static_cast<unsigned short>(0));
      // TODO: endrec = pack(params).
      file_stream << endrec;
      file_stream.flush();
      file_stream.close();
   }
private:
   unsigned long crc(const std::string& data) const
   {
      const size_t maxlen = 1024 * 5;
      Bytef* buffer = reinterpret_cast<Bytef*>(const_cast<char*>(data.data()));
      size_t len = data.length();
      unsigned long crc32_val = 0;
      unsigned long result = 0;
      if (len > maxlen)
      {
         const size_t uint_max = static_cast<size_t>(std::numeric_limits<unsigned int>::max());
         while (len > uint_max)
         {
            crc32_val = crc32(crc32_val, (Bytef*)buffer, uint_max);
            buffer += uint_max;
            len -= uint_max;
         }
         result = crc32(crc32_val, (Bytef*)buffer, len);
      }
      else
      {
         result = crc32(0, (Bytef*)buffer, len);
      }
      return result;
   }
   std::string compress(const std::string& data)
   {
      const std::string& comp_st = compress_begin(data);
      return comp_st + compress_end();
   }
   std::string compress_begin(const std::string& data)
   {
      const size_t start_buffer_size = 10000;
      const int default_memory_level = 8;
      const int unspecified_in_documentation_magic = -15;
 
      std::stringstream error_stream;
      std::vector<char> buffer(start_buffer_size);
      c_stream.zalloc = Z_NULL;
      c_stream.zfree = Z_NULL;
      c_stream.opaque = Z_NULL;
      c_stream.next_in = 0;
      c_stream.avail_in = 0;
 
      int err = deflateInit2(&c_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
      unspecified_in_documentation_magic, default_memory_level, Z_DEFAULT_STRATEGY);
      if (err != Z_OK)
      {
         error_stream << "deflateInit() failed: ";
         throw ZlibError(error_stream.str(), err);
      }
 
      unsigned long start_total_out = c_stream.total_out;
      c_stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(data.data()));
      c_stream.avail_in = data.size();
      c_stream.avail_out = buffer.size();
      c_stream.next_out = reinterpret_cast<Bytef*>(&buffer[0]);
      err = deflate(&c_stream, Z_NO_FLUSH);
      while (err == Z_OK && c_stream.avail_out == 0)
      {
         size_t old_buf_size = buffer.size();
         buffer.resize(buffer.size() + start_buffer_size);
         c_stream.avail_out = old_buf_size;
         c_stream.next_out = reinterpret_cast<Bytef*>(&buffer[0] + old_buf_size);
         err = deflate(&c_stream, Z_NO_FLUSH);
      }
      if (err != Z_OK && err != Z_BUF_ERROR)
      {
         error_stream << "deflate() failed: ";
         deflateEnd(&c_stream);
         throw ZlibError(error_stream.str(), err);
      }
      buffer.resize(c_stream.total_out - start_total_out);
      return std::string(buffer.begin(), buffer.end());
   }
   std::string compress_end()
   {
      const size_t start_buffer_size = 10000;
 
      std::stringstream error_stream;
      std::vector<char> buffer(start_buffer_size);
      unsigned long start_total_out = c_stream.total_out;
      c_stream.total_in = 0;
      c_stream.avail_out = buffer.size();
      c_stream.next_out = reinterpret_cast<Bytef*>(&buffer[0]);
 
      int err = deflate(&c_stream, Z_FINISH);
      while (err == Z_OK && c_stream.avail_out == 0)
      {
         size_t old_buf_size = buffer.size();
         buffer.resize(buffer.size() + start_buffer_size);
         c_stream.avail_out = old_buf_size;
         c_stream.next_out = reinterpret_cast<Bytef*>(&buffer[0] + old_buf_size);
         err = deflate(&c_stream, Z_FINISH);
      }
      if (err != Z_STREAM_END && err != Z_OK && err != Z_BUF_ERROR)
      {
         error_stream << "deflate() failed: ",
         deflateEnd(&c_stream);
         throw ZlibError(error_stream.str(), err);
      }
 
      buffer.resize(c_stream.total_out - start_total_out);
      err = deflateEnd(&c_stream);
      if (err != Z_OK)
      {
         error_stream << "deflateEnd() failed: ";
         throw ZlibError(error_stream.str(), err);
      }
      return std::string(buffer.begin(), buffer.end());
   }
 
   z_stream c_stream;
   std::ofstream file_stream;
   std::vector<ZipInfo> files_info;
};
 
#endif