ext/CrashServer/CommonLibs/Zlib/ZipUnzip.cpp

   1 // Copyright 2014 Idol Software, Inc.
   2 //
   3 // This file is part of Doctor Dump SDK.
   4 //
   5 // Doctor Dump SDK is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU Lesser General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public License
  16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 #include <atlstr.h>
  19 #include <atlfile.h>
  20 #include <stdexcept>
  21 #include "ZipUnzip.h"
  22 #include "contrib\minizip\zip.h"
  23 #include "contrib\minizip\unzip.h"
  24 #include "contrib\minizip\iowin32.h"
  25
  26 using namespace std;
  27
  28 extern "C" voidpf ZCALLBACK win32_open64_file_funcW(voidpf opaque,const void* filename,int mode);
  29
  30 Zip::Zip(LPCWSTR pszFilename, bool append)
  31 {
  32     zlib_filefunc_def ffunc;
  33     fill_win32_filefunc(&ffunc);
  34 #if ZLIB128
  35     // Hack used to force Unicode version of CreateFile in ANSI zipOpen2 function
  36     ffunc.zopen_file = (open_file_func) win32_open64_file_funcW;
  37     m_zf = zipOpen2((const char*)pszFilename, append ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE, NULL, &ffunc);
  38 #else
  39     m_zf = zipOpen2((const char*)CW2A(pszFilename), append ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE, NULL, &ffunc);
  40 #endif
  41
  42     if (!m_zf)
  43         throw runtime_error(append ? "failed to append zip file" : "failed to create zip file");
  44 }
  45
  46 Zip::~Zip(void)
  47 {
  48     zipClose(m_zf, NULL);
  49 }
  50
  51 void Zip::AddFile(LPCWSTR pszFilename, LPCWSTR pszFilenameInZip, bool* cancel)
  52 {
  53     zip_fileinfo zi = {};
  54
  55     WIN32_FIND_DATAW ff;
  56     HANDLE hFind = FindFirstFileW(pszFilename, &ff);
  57     if (hFind == INVALID_HANDLE_VALUE)
  58         throw runtime_error("file to add to zip not found");
  59
  60     if (!pszFilenameInZip)
  61     {
  62         LPCWSTR slashPos = wcsrchr(pszFilename, L'\\');
  63         if (!slashPos)
  64             slashPos = wcsrchr(pszFilename, L'/');
  65         pszFilenameInZip = slashPos ? slashPos + 1 : pszFilename;
  66     }
  67
  68     FILETIME ftLocal;
  69     FileTimeToLocalFileTime(&(ff.ftLastWriteTime), &ftLocal);
  70     FileTimeToDosDateTime(&ftLocal, ((LPWORD)&zi.dosDate)+1, ((LPWORD)&zi.dosDate)+0);
  71     FindClose(hFind);
  72
  73     int err = zipOpenNewFileInZip3(m_zf, CW2A(pszFilenameInZip), &zi,
  74         NULL, 0, NULL, 0, NULL /* comment*/,
  75         Z_DEFLATED, Z_BEST_COMPRESSION, 0,
  76         -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
  77         NULL, 0);
  78
  79     if (err != ZIP_OK)
  80         throw runtime_error("failed to create file in zip");
  81
  82
  83     CAtlFile hFile(CreateFileW(pszFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
  84     if (hFile == INVALID_HANDLE_VALUE)
  85         throw runtime_error("file to add to zip not found");
  86
  87     BYTE buf[1024*8];
  88     DWORD dwReaded;
  89     while (SUCCEEDED(hFile.Read(buf, _countof(buf), dwReaded)) && dwReaded != 0)
  90     {
  91         err = zipWriteInFileInZip(m_zf, buf, dwReaded);
  92         if (err != ZIP_OK)
  93             throw runtime_error("failed to write to zip");
  94         if (cancel && *cancel)
  95             throw std::runtime_error("canceled");
  96     }
  97
  98     if (ZIP_OK != zipCloseFileInZip(m_zf))
  99         throw runtime_error("failed to finalize file in zip");
 100 }
 101
 102 static unzFile Unzip_Open(LPCWSTR pszFilename)
 103 {
 104     zlib_filefunc_def ffunc;
 105     fill_win32_filefunc(&ffunc);
 106     unzFile uf = unzOpen2(CW2CT(pszFilename), &ffunc);
 107     if (!uf)
 108         throw runtime_error("failed to open zip file");
 109     return uf;
 110 }
 111
 112 static CStringW Unzip_GetCurentFilePath(unzFile uf, FILETIME& ftLocal)
 113 {
 114     unz_file_info file_info;
 115     CStringA pathA;
 116     const int pathLen = 256;
 117     if (UNZ_OK != unzGetCurrentFileInfo(uf, &file_info, pathA.GetBuffer(pathLen), pathLen, NULL, 0, NULL, 0))
 118         throw runtime_error("failed to unzGetCurrentFileInfo");
 119     pathA.ReleaseBuffer(-1);
 120     DosDateTimeToFileTime((WORD)(file_info.dosDate>>16), (WORD)file_info.dosDate, &ftLocal);
 121     return CStringW(pathA);
 122 }
 123
 124 static void Unzip_ExtractFile(unzFile uf, const CStringW& path, DWORD flagsAndAttributes, FILETIME ftLocal)
 125 {
 126     try
 127     {
 128         if (UNZ_OK != unzOpenCurrentFilePassword(uf, NULL))
 129             throw runtime_error("failed to unzOpenCurrentFilePassword");
 130
 131         CAtlFile file(CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, flagsAndAttributes, NULL));
 132         if (file == INVALID_HANDLE_VALUE)
 133             throw runtime_error("failed to CreateFile");
 134
 135         vector<BYTE> buf(8192);
 136         while (1)
 137         {
 138             int size = unzReadCurrentFile(uf, &buf[0], (unsigned int)buf.size());
 139             if (size < 0)
 140                 throw runtime_error("failed to unzReadCurrentFile");
 141             if (size == 0)
 142                 break;
 143
 144             if (FAILED(file.Write(&buf[0], size)))
 145                 throw runtime_error("failed to WriteFile");
 146         }
 147
 148         FILETIME ftm, ftCreate, ftLastAcc, ftLastWrite;
 149         GetFileTime(file, &ftCreate, &ftLastAcc, &ftLastWrite);
 150         LocalFileTimeToFileTime(&ftLocal, &ftm);
 151         SetFileTime(file, &ftm, &ftLastAcc, &ftm);
 152
 153         if (UNZ_OK != unzCloseCurrentFile(uf))
 154             throw runtime_error("failed to unzCloseCurrentFile");
 155     }
 156     catch (...)
 157     {
 158         DeleteFileW(path);
 159     }
 160 }
 161
 162 std::vector<CStringW> Unzip::Extract(LPCWSTR pszFilename, LPCWSTR pszFolder, std::function<bool(LPCWSTR filePath, DWORD& flagsAndAttributes)> predicate)
 163 {
 164     std::vector<CStringW> result;
 165
 166     unzFile uf = NULL;
 167     try
 168     {
 169         uf = Unzip_Open(pszFilename);
 170
 171         unz_global_info gi;
 172         if (UNZ_OK != unzGetGlobalInfo(uf, &gi))
 173             throw runtime_error("failed to unzGetGlobalInfo");
 174
 175         for (uLong i = 0; i < gi.number_entry; ++i)
 176         {
 177             FILETIME ftLocal;
 178             CStringW path = CStringW(pszFolder) + L'\\' + Unzip_GetCurentFilePath(uf, ftLocal);
 179
 180             CStringW filename = path.Mid(path.ReverseFind(L'\\') + 1);
 181             if (filename.IsEmpty())
 182             {
 183                 if (!CreateDirectoryW(path, NULL))
 184                     throw runtime_error("failed to CreateDirectory");
 185                 continue;
 186             }
 187
 188             DWORD flagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
 189             if (predicate(path, flagsAndAttributes))
 190             {
 191                 Unzip_ExtractFile(uf, path, flagsAndAttributes, ftLocal);
 192                 result.push_back(path);
 193             }
 194
 195             if (i + 1 < gi.number_entry && UNZ_OK != unzGoToNextFile(uf))
 196                 throw runtime_error("failed to unzGoToNextFile");
 197         }
 198         unzClose(uf);
 199
 200         return result;
 201     }
 202     catch (...)
 203     {
 204         if (uf != NULL)
 205             unzClose(uf);
 206         for each (auto file in result)
 207             DeleteFileW(file);
 208         throw;
 209     }
 210 }
 211
 212 std::vector<CStringW> Unzip::Extract(LPCWSTR pszFilename, LPCWSTR pszFolder)
 213 {
 214     return Extract(pszFilename, pszFolder, [](LPCWSTR filePath, DWORD& flagsAndAttributes) { return true; });
 215 }
 216
 217 bool DeflateBuffer(const BYTE* buffer, size_t bufferLen, std::vector<BYTE>& outBuffer, const char* dictionary)
 218 {
 219     z_stream stream = {};
 220     deflateInit(&stream, Z_BEST_COMPRESSION);
 221     outBuffer.resize(deflateBound(&stream, static_cast<uLong>(bufferLen)));
 222     if (dictionary)
 223         deflateSetDictionary(&stream, (const Bytef*)dictionary, static_cast<uInt>(strlen(dictionary)));
 224     stream.next_in = (Bytef*)buffer;
 225     stream.avail_in = static_cast<uInt>(bufferLen);
 226     stream.next_out = &outBuffer[0];
 227     stream.avail_out = static_cast<uInt>(outBuffer.size());
 228     while (1)
 229     {
 230         switch (deflate(&stream, Z_FINISH))
 231         {
 232         case Z_STREAM_END:
 233             outBuffer.resize(outBuffer.size() - stream.avail_out);
 234             deflateEnd(&stream);
 235             return true;
 236         case Z_OK:
 237             stream.avail_out += static_cast<uInt>(outBuffer.size());
 238             outBuffer.resize(outBuffer.size() * 2);
 239             stream.next_out = &outBuffer[outBuffer.size() - stream.avail_out];
 240             break;
 241         default:
 242             deflateEnd(&stream);
 243             return false;
 244         }
 245     }
 246 }
 247
 248 bool InflateBuffer(const BYTE* buffer, size_t bufferLen, std::vector<BYTE>& outBuffer, const char* dictionary)
 249 {
 250     z_stream stream = {};
 251     stream.next_in = (Bytef*)buffer;
 252     stream.avail_in = static_cast<uInt>(bufferLen);
 253     inflateInit(&stream);
 254     outBuffer.resize(2*bufferLen);
 255     stream.next_out = &outBuffer[0];
 256     stream.avail_out = static_cast<uInt>(outBuffer.size());
 257     while (1)
 258     {
 259         switch (inflate(&stream, 0))
 260         {
 261         case Z_NEED_DICT:
 262             if (!dictionary || Z_OK != inflateSetDictionary(&stream, (const Bytef*)dictionary, static_cast<uInt>(strlen(dictionary))))
 263             {
 264                 inflateEnd(&stream);
 265                 return false;
 266             }
 267             break;
 268         case Z_STREAM_END:
 269             outBuffer.resize(outBuffer.size() - stream.avail_out);
 270             inflateEnd(&stream);
 271             return true;
 272         case Z_OK:
 273             stream.avail_out += static_cast<uInt>(outBuffer.size());
 274             outBuffer.resize(outBuffer.size() * 2);
 275             stream.next_out = &outBuffer[outBuffer.size() - stream.avail_out];
 276             break;
 277         default:
 278             inflateEnd(&stream);
 279             return false;
 280         }
 281     }
 282 }