zipFile FileUtils::mzOpenOutputFile(const std::string &path) { #if defined(MINIZIP_WIN32) zlib_filefunc64_def zFunc; memset(&zFunc, 0, sizeof(zFunc)); fill_win32_filefunc64W(&zFunc); return zipOpen2_64(utf8::utf8ToUtf16(path).c_str(), 0, nullptr, &zFunc); #elif defined(MINIZIP_ANDROID) zlib_filefunc64_def zFunc; memset(&zFunc, 0, sizeof(zFunc)); fill_android_filefunc64(&zFunc); return zipOpen2_64(path.c_str(), 0, nullptr, &zFunc); #else return zipOpen64(path.c_str(), 0); #endif }
ZipCtx * MinizipUtils::open_output_file(std::string path) { ZipCtx *ctx = new(std::nothrow) ZipCtx(); if (!ctx) { return nullptr; } #if defined(MINIZIP_WIN32) auto converted = utf8_to_wcs(path); if (!converted) { delete ctx; return nullptr; } ctx->path = std::move(converted.value()); fill_win32_filefunc64W(&ctx->buf.filefunc64); #elif defined(MINIZIP_ANDROID) fill_android_filefunc64(&ctx->buf.filefunc64); ctx->path = std::move(path); #else fill_fopen64_filefunc(&ctx->buf.filefunc64); ctx->path = std::move(path); #endif fill_buffer_filefunc64(&ctx->z_func, &ctx->buf); ctx->zf = zipOpen2_64(ctx->path.c_str(), 0, nullptr, &ctx->z_func); if (!ctx->zf) { delete ctx; return nullptr; } return ctx; }
// TODO: using this for XPS files results in documents that Microsoft XPS Viewer can't read IStream *OpenDirAsZipStream(const WCHAR *dirPath, bool recursive) { if (!dir::Exists(dirPath)) return NULL; ScopedComPtr<IStream> stream; if (FAILED(CreateStreamOnHGlobal(NULL, TRUE, &stream))) return NULL; zlib_filefunc64_def ffunc; fill_win32s_filefunc64(&ffunc); zipFile zf = zipOpen2_64(stream, 0, NULL, &ffunc); if (!zf) return NULL; size_t dirLen = str::Len(dirPath); if (!path::IsSep(dirPath[dirLen - 1])) dirLen++; bool ok = true; DirIter di(dirPath, recursive); for (const WCHAR *filePath = di.First(); filePath && ok; filePath = di.Next()) { CrashIf(!str::StartsWith(filePath, dirPath)); const WCHAR *nameInZip = filePath + dirLen; size_t fileSize; ScopedMem<char> fileData(file::ReadAll(filePath, &fileSize)); ok = fileData && AppendFileToZip(zf, nameInZip, fileData, fileSize); } int err = zipClose(zf, NULL); if (!ok || err != ZIP_OK) return NULL; stream->AddRef(); return stream; }
FileUtils::MzZipCtx * FileUtils::mzOpenOutputFile(std::string path) { MzZipCtx *ctx = new(std::nothrow) MzZipCtx(); if (!ctx) { return nullptr; } #if defined(MINIZIP_WIN32) fill_win32_filefunc64W(&ctx->buf.filefunc64); ctx->path = utf8::utf8ToUtf16(path); #elif defined(MINIZIP_ANDROID) fill_android_filefunc64(&ctx->buf.filefunc64); ctx->path = std::move(path); #else fill_fopen64_filefunc(&ctx->buf.filefunc64); ctx->path = std::move(path); #endif fill_buffer_filefunc64(&ctx->zFunc, &ctx->buf); ctx->zf = zipOpen2_64(ctx->path.c_str(), 0, nullptr, &ctx->zFunc); if (!ctx->zf) { free(ctx); return nullptr; } return ctx; }
bool ZipArchiveWriter::Open(const std::string& zipFileName, bool bZipExist) { if (zipFileName.empty()) return false; Close(); m_errCode = Z_OK; m_zipFilePath = zipFileName; #ifdef USEWIN32IOAPI zlib_filefunc64_def ffunc; fill_win32_filefunc64W(&ffunc); m_hZip = zipOpen2_64(TUtf8Util::UTF8StrToUniStr(m_zipFilePath).c_str(), bZipExist ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE, nullptr, &ffunc); #else m_hZip = zipOpen64(m_zipFilePath.c_str(), bZipExist ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE); #endif if (!m_hZip) { m_errCode = Z_ZIP_OPEN_ERROR; return false; } return true; }
extern "C" HZIP CreateArchiveW(WCHAR *lpstrZipFile,char *lpPassword,int dwPasswordLen,int dwCompLevel) { void *r=NULL; if (lpstrZipFile) { ZIPCOMPRESSION *p=(ZIPCOMPRESSION *)_alloc(sizeof(ZIPCOMPRESSION)); if (p) { p->bHandleType=HT_COMPRESSOR; bool bPassword=((lpPassword) && (dwPasswordLen > 0)); if (bPassword) { memcpy(p->szPassword,lpPassword,dwPasswordLen); p->bEncrypted=true; } p->dwCompLevel=dwCompLevel; zlib_filefunc64_def ffunc; fill_fopen64_filefunc(&ffunc); p->hZip=zipOpen2_64(lpstrZipFile,0,NULL,&ffunc); if (p->hZip) r=p; } if (!r) MemFree(p); } else ArchSetLastError(ARCH_INVALID_PARAMETER); return r; }
bool ZipCreator::SaveAs(const WCHAR *zipFilePath) { if (d->pathsAndZipNames.Count() == 0) return false; zlib_filefunc64_def ffunc; fill_win32_filefunc64(&ffunc); zipFile zf = zipOpen2_64(zipFilePath, 0, NULL, &ffunc); if (!zf) return false; bool result = true; for (size_t i = 0; i < d->pathsAndZipNames.Count(); i += 2) { const WCHAR *fileName = d->pathsAndZipNames.At(i); const WCHAR *nameInZip = d->pathsAndZipNames.At(i + 1); size_t fileSize; ScopedMem<char> fileData(file::ReadAll(fileName, &fileSize)); if (!fileData) { result = false; break; } result = AppendFileToZip(zf, nameInZip, fileData, fileSize); if (!result) break; } int err = zipClose(zf, NULL); if (err != ZIP_OK) result = false; return result; }
bool ZipArchive::open() { if (isOpen()) return true; auto zip = zipOpen2_64(nullptr, APPEND_STATUS_CREATE, nullptr, &d->fileFuncs); d->zip = zip; return zip; }
// //////////////////////////////////////////////////////////////////////////////// // @public @static 将指定文件名打包成指定 zip // bool ZipTools::Zip(LPCWSTR wzDirPath, LPCWSTR wzDestName) { // // 检查指定路径是否存在 // if ( !FileTools::Exist(wzDirPath) ) { DebugTools::OutputDebugPrintfW(L"[ZipTools] [Zip] Path Not Exist. [%s]\r\n", wzDirPath); return false; } WCHAR wzDestDir[MAX_PATH] = {0}; FileTools::GetFileDir(wzDestName, wzDestDir, L'\\'); if ( !FileTools::Exist(wzDestDir) ) { DebugTools::OutputDebugPrintfW(L"[ZipTools] [Zip] Path Not Exist. [%s]\r\n", wzDestDir); return false; } // 设置当前工作目录 SetCurrentDirectoryW(wzDirPath); WCHAR wzParentDir[MAX_PATH] = {0}; wcscpy_s(wzParentDir, wzDirPath); //FileTools::GetFileDir(wzDirPath, wzParentDir, L'\\'); wcscat_s(wzParentDir, L"\\"); // // 创建 zip 文件 // zlib_filefunc64_def ffunc; fill_win32_filefunc64W(&ffunc); zipFile zf; zf = zipOpen2_64(wzDestName, 0, NULL, &ffunc); if ( NULL == zf ) { DebugTools::OutputDebugPrintfW( L"[ZipTools] [Zip] Create Zip File Failed. [%s] \r\n", wzDestName); return false; } unsigned long size_read = 0; unsigned long size_buf = WRITEBUFFERSIZE; PBYTE buf = new BYTE [size_buf]; // // 将文件夹下所有文件添加进 zip // AddFileToZip(zf, wzDirPath, wzParentDir, buf); zipClose(zf,NULL); delete [] buf; return true; }
zipFile FileUtils::mzOpenOutputFile(const std::string &path) { #ifdef USEWIN32IOAPI zlib_filefunc64_def zFunc; memset(&zFunc, 0, sizeof(zFunc)); fill_win32_filefunc64A(&zFunc); return zipOpen2_64(path.c_str(), 0, nullptr, &zFunc); #else return zipOpen64(path.c_str(), 0); #endif }
int main(int argc, char *argv[]) { zipFile zf = NULL; #ifdef USEWIN32IOAPI zlib_filefunc64_def ffunc = {0}; #endif char *zipfilename = NULL; const char* password = NULL; void* buf = NULL; int size_buf = WRITEBUFFERSIZE; int zipfilenamearg = 0; int errclose = 0; int err = 0; int i = 0; int opt_overwrite = APPEND_STATUS_CREATE; int opt_compress_level = Z_DEFAULT_COMPRESSION; int opt_exclude_path = 0; do_banner(); if (argc == 1) { do_help(); return 0; } /* Parse command line options */ for (i = 1; i < argc; i++) { if ((*argv[i]) == '-') { const char *p = argv[i]+1; while ((*p) != '\0') { char c = *(p++);; if ((c == 'o') || (c == 'O')) opt_overwrite = APPEND_STATUS_CREATEAFTER; if ((c == 'a') || (c == 'A')) opt_overwrite = APPEND_STATUS_ADDINZIP; if ((c >= '0') && (c <= '9')) opt_compress_level = (c - '0'); if ((c == 'j') || (c == 'J')) opt_exclude_path = 1; if (((c == 'p') || (c == 'P')) && (i+1 < argc)) { password=argv[i+1]; i++; } } } else { if (zipfilenamearg == 0) zipfilenamearg = i; } } if (zipfilenamearg == 0) { do_help(); return 0; } zipfilename = argv[zipfilenamearg]; buf = (void*)malloc(size_buf); if (buf == NULL) { printf("Error allocating memory\n"); return ZIP_INTERNALERROR; } if (opt_overwrite == 2) { /* If the file don't exist, we not append file */ if (check_file_exists(zipfilename) == 0) opt_overwrite = 1; } else if (opt_overwrite == 0) { /* If ask the user what to do because append and overwrite args not set */ //if (check_file_exists(zipfilename) != 0) //{ // char rep = 0; // do // { // char answer[128]; // printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ", zipfilename); // if (scanf("%1s", answer) != 1) // exit(EXIT_FAILURE); // rep = answer[0]; // if ((rep >= 'a') && (rep <= 'z')) // rep -= 0x20; // } // while ((rep != 'Y') && (rep != 'N') && (rep != 'A')); // if (rep == 'A') // opt_overwrite = 2; // else if (rep == 'N') // { // do_help(); // free(buf); // return 0; // } //} } #ifdef USEWIN32IOAPI fill_win32_filefunc64A(&ffunc); zf = zipOpen2_64(zipfilename, opt_overwrite, NULL, &ffunc); #else zf = zipOpen64(zipfilename, opt_overwrite); #endif if (zf == NULL) { printf("error opening %s\n", zipfilename); err = ZIP_ERRNO; } else printf("creating %s\n", zipfilename); /* Go through command line args looking for files to add to zip */ for (i = zipfilenamearg + 1; (i < argc) && (err == ZIP_OK); i++) { FILE *fin = NULL; int size_read = 0; const char* filenameinzip = argv[i]; const char *savefilenameinzip; zip_fileinfo zi = {0}; unsigned long crcFile = 0; int zip64 = 0; /* Skip command line options */ if ((((*(argv[i])) == '-') || ((*(argv[i])) == '/')) && (strlen(argv[i]) == 2) && ((argv[i][1] == 'o') || (argv[i][1] == 'O') || (argv[i][1] == 'a') || (argv[i][1] == 'A') || (argv[i][1] == 'p') || (argv[i][1] == 'P') || ((argv[i][1] >= '0') && (argv[i][1] <= '9')))) continue; /* Get information about the file on disk so we can store it in zip */ filetime(filenameinzip, &zi.tmz_date, &zi.dosDate); if ((password != NULL) && (err == ZIP_OK)) err = get_file_crc(filenameinzip, buf, size_buf, &crcFile); zip64 = is_large_file(filenameinzip); /* Construct the filename that our file will be stored in the zip as. The path name saved, should not include a leading slash. If it did, windows/xp and dynazip couldn't read the zip file. */ savefilenameinzip = filenameinzip; while (savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/') savefilenameinzip++; /* Should the file be stored with any path info at all? */ if (opt_exclude_path) { const char *tmpptr = NULL; const char *lastslash = 0; for (tmpptr = savefilenameinzip; *tmpptr; tmpptr++) { if (*tmpptr == '\\' || *tmpptr == '/') lastslash = tmpptr; } if (lastslash != NULL) savefilenameinzip = lastslash + 1; /* base filename follows last slash. */ } /* Add to zip file */ err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &zi, NULL, 0, NULL, 0, NULL /* comment*/, (opt_compress_level != 0) ? Z_DEFLATED : 0, opt_compress_level,0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password, crcFile, zip64); if (err != ZIP_OK) printf("error in opening %s in zipfile (%d)\n", filenameinzip, err); else { fin = FOPEN_FUNC(filenameinzip, "rb"); if (fin == NULL) { err = ZIP_ERRNO; printf("error in opening %s for reading\n", filenameinzip); } } if (err == ZIP_OK) { /* Read contents of file and write it to zip */ do { size_read = (int)fread(buf, 1, size_buf, fin); if ((size_read < size_buf) && (feof(fin) == 0)) { printf("error in reading %s\n",filenameinzip); err = ZIP_ERRNO; } if (size_read > 0) { err = zipWriteInFileInZip(zf, buf, size_read); if (err < 0) printf("error in writing %s in the zipfile (%d)\n", filenameinzip, err); } } while ((err == ZIP_OK) && (size_read > 0)); } if (fin) fclose(fin); if (err < 0) err = ZIP_ERRNO; else { err = zipCloseFileInZip(zf); if (err != ZIP_OK) printf("error in closing %s in the zipfile (%d)\n", filenameinzip, err); } } errclose = zipClose(zf, NULL); if (errclose != ZIP_OK) printf("error in closing %s (%d)\n", zipfilename, errclose); free(buf); return err; }
int TRI_ZipFile (const char* filename, const char* dir, TRI_vector_string_t const* files, const char* password) { void* buffer; size_t bufferSize; zipFile zf; #ifdef USEWIN32IOAPI zlib_filefunc64_def ffunc; #endif size_t i, n; int res; if (TRI_ExistsFile(filename)) { return TRI_ERROR_CANNOT_OVERWRITE_FILE; } bufferSize = 16384; buffer = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, bufferSize, false); if (buffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } #ifdef USEWIN32IOAPI fill_win32_filefunc64A(&ffunc); zf = zipOpen2_64(filename, 0, NULL, &ffunc); #else zf = zipOpen64(filename, 0); #endif if (zf == NULL) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer); return ZIP_ERRNO; } res = TRI_ERROR_NO_ERROR; n = files->_length; for (i = 0; i < n; ++i) { FILE* fin; char* file; char* fullfile; char* saveName; zip_fileinfo zi; uint32_t crc; int isLarge; file = TRI_AtVectorString(files, i); if (*dir == '\0') { fullfile = TRI_DuplicateString(file); } else { fullfile = TRI_Concatenate2File(dir, file); } memset(&zi, 0, sizeof(zi)); res = TRI_Crc32File(fullfile, &crc); if (res != TRI_ERROR_NO_ERROR) { break; } isLarge = (TRI_SizeFile(file) > 0xFFFFFFFFLL); saveName = file; while (*saveName == '\\' || *saveName == '/') { ++saveName; } if (zipOpenNewFileInZip3_64(zf, saveName, &zi, NULL, 0, NULL, 0, NULL, /* comment*/ Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password, (unsigned long) crc, isLarge) != ZIP_OK) { } fin = fopen(fullfile, "rb"); TRI_FreeString(TRI_CORE_MEM_ZONE, fullfile); if (fin == NULL) { break; } while (true) { int sizeRead; sizeRead = (int) fread(buffer, 1, bufferSize, fin); if (sizeRead < bufferSize) { if (feof(fin) == 0) { res = TRI_set_errno(TRI_ERROR_SYS_ERROR); break; } } if (sizeRead > 0) { res = zipWriteInFileInZip(zf, buffer, sizeRead); if (res != 0) { break; } } else if (sizeRead <= 0) { break; } } fclose(fin); zipCloseFileInZip(zf); if (res != TRI_ERROR_NO_ERROR) { break; } } zipClose(zf, NULL); TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer); return res; }
void ExportEPUB::SaveFolderAsEpubToLocation(const QString &fullfolderpath, const QString &fullfilepath) { QString tempFile = fullfolderpath + "-tmp.epub"; QDateTime timeNow = QDateTime::currentDateTime(); zip_fileinfo fileInfo; #ifdef Q_OS_WIN32 zlib_filefunc64_def ffunc; fill_win32_filefunc64W(&ffunc); zipFile zfile = zipOpen2_64(Utility::QStringToStdWString(QDir::toNativeSeparators(tempFile)).c_str(), APPEND_STATUS_CREATE, NULL, &ffunc); #else zipFile zfile = zipOpen64(QDir::toNativeSeparators(tempFile).toUtf8().constData(), APPEND_STATUS_CREATE); #endif if (zfile == NULL) { boost_throw(CannotOpenFile() << errinfo_file_fullpath(tempFile.toStdString())); } memset(&fileInfo, 0, sizeof(fileInfo)); fileInfo.tmz_date.tm_sec = timeNow.time().second(); fileInfo.tmz_date.tm_min = timeNow.time().minute(); fileInfo.tmz_date.tm_hour = timeNow.time().hour(); fileInfo.tmz_date.tm_mday = timeNow.date().day(); fileInfo.tmz_date.tm_mon = timeNow.date().month() - 1; fileInfo.tmz_date.tm_year = timeNow.date().year(); // Write the mimetype. This must be uncompressed and the first entry in the archive. if (zipOpenNewFileInZip64(zfile, "mimetype", &fileInfo, NULL, 0, NULL, 0, NULL, Z_NO_COMPRESSION, 0, 0) != Z_OK) { zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotStoreFile() << errinfo_file_fullpath("mimetype")); } if (zipWriteInFileInZip(zfile, EPUB_MIME_DATA, (unsigned int)strlen(EPUB_MIME_DATA)) != Z_OK) { zipCloseFileInZip(zfile); zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotStoreFile() << errinfo_file_fullpath("mimetype")); } zipCloseFileInZip(zfile); // Write all the files in our directory path to the archive. QDirIterator it(fullfolderpath, QDir::Files | QDir::NoDotAndDotDot | QDir::Readable | QDir::Hidden, QDirIterator::Subdirectories); while (it.hasNext()) { it.next(); QString relpath = it.filePath().remove(fullfolderpath); while (relpath.startsWith("/")) { relpath = relpath.remove(0, 1); } // Add the file entry to the archive. // We should check the uncompressed file size. If it's over >= 0xffffffff the last parameter (zip64) should be 1. if (zipOpenNewFileInZip4_64(zfile, relpath.toUtf8().constData(), &fileInfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, 8, 0, 15, 8, Z_DEFAULT_STRATEGY, NULL, 0, 0x0b00, 1<<11, 0) != Z_OK) { zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotStoreFile() << errinfo_file_fullpath(relpath.toStdString())); } // Open the file on disk. We will read this and write what we read into // the archive. QFile dfile(it.filePath()); if (!dfile.open(QIODevice::ReadOnly)) { zipCloseFileInZip(zfile); zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotOpenFile() << errinfo_file_fullpath(it.fileName().toStdString())); } // Write the data from the file on disk into the archive. char buff[BUFF_SIZE] = {0}; qint64 read = 0; while ((read = dfile.read(buff, BUFF_SIZE)) > 0) { if (zipWriteInFileInZip(zfile, buff, read) != Z_OK) { dfile.close(); zipCloseFileInZip(zfile); zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotStoreFile() << errinfo_file_fullpath(relpath.toStdString())); } } dfile.close(); // There was an error reading the file on disk. if (read < 0) { zipCloseFileInZip(zfile); zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotStoreFile() << errinfo_file_fullpath(relpath.toStdString())); } if (zipCloseFileInZip(zfile) != Z_OK) { zipClose(zfile, NULL); QFile::remove(tempFile); boost_throw(CannotStoreFile() << errinfo_file_fullpath(relpath.toStdString())); } } zipClose(zfile, NULL); // Overwrite the contents of the real file with the contents from the temp // file we saved the data do. We do this instead of simply copying the file // because a file copy will lose extended attributes such as labels on OS X. QFile temp_epub(tempFile); if (!temp_epub.open(QFile::ReadOnly)) { boost_throw(CannotOpenFile() << errinfo_file_fullpath(tempFile.toStdString())); } QFile real_epub(fullfilepath); if (!real_epub.open(QFile::WriteOnly | QFile::Truncate)) { temp_epub.close(); boost_throw(CannotWriteFile() << errinfo_file_fullpath(fullfilepath.toStdString())); } // Copy the contents from the temp file to the real file. char buff[BUFF_SIZE] = {0}; qint64 read = 0; qint64 written = 0; while ((read = temp_epub.read(buff, BUFF_SIZE)) > 0) { written = real_epub.write(buff, read); if (written != read) { temp_epub.close(); real_epub.close(); QFile::remove(tempFile); boost_throw(CannotCopyFile() << errinfo_file_fullpath(fullfilepath.toStdString())); } } if (read == -1) { temp_epub.close(); real_epub.close(); QFile::remove(tempFile); boost_throw(CannotCopyFile() << errinfo_file_fullpath(fullfilepath.toStdString())); } temp_epub.close(); real_epub.close(); QFile::remove(tempFile); }
bool DialogPackage::CreatePackage() { // Create options file WCHAR tempFile[MAX_PATH]; GetTempPath(MAX_PATH, tempFile); GetTempFileName(tempFile, L"ini", 0, tempFile); WritePrivateProfileString(L"rmskin", L"Name", m_Name.c_str(), tempFile); WritePrivateProfileString(L"rmskin", L"Author", m_Author.c_str(), tempFile); WritePrivateProfileString(L"rmskin", L"Version", m_Version.c_str(), tempFile); if (!c_Dialog->m_Load.empty()) { WritePrivateProfileString(L"rmskin", L"LoadType", c_Dialog->m_LoadLayout ? L"Layout" : L"Skin", tempFile); WritePrivateProfileString(L"rmskin", L"Load", c_Dialog->m_Load.c_str(), tempFile); } if (!c_Dialog->m_VariableFiles.empty()) { WritePrivateProfileString(L"rmskin", L"VariableFiles", m_VariableFiles.c_str(), tempFile); } if (c_Dialog->m_MergeSkins) { WritePrivateProfileString(L"rmskin", L"MergeSkins", L"1", tempFile); } WritePrivateProfileString(L"rmskin", L"MinimumRainmeter", m_MinimumRainmeter.c_str(), tempFile); WritePrivateProfileString(L"rmskin", L"MinimumWindows", m_MinimumWindows.c_str(), tempFile); // Only Skin Installer in Rainmeter 3.0.1 support UTF-8 filenames. m_AllowNonAsciiFilenames = DialogInstall::CompareVersions(m_MinimumRainmeter, L"3.0.1") != -1; // Create archive and add options file and header bitmap zlib_filefunc64_def zlibFileFunc; fill_win32_filefunc64W(&zlibFileFunc); m_ZipFile = zipOpen2_64(m_TargetFile.c_str(), APPEND_STATUS_CREATE, nullptr, &zlibFileFunc); auto cleanup = [&]()->bool { zipClose(m_ZipFile, nullptr); DeleteFile(m_TargetFile.c_str()); return false; }; if (!m_ZipFile || (!c_Dialog->m_HeaderFile.empty() && !AddFileToPackage(c_Dialog->m_HeaderFile.c_str(), L"RMSKIN.bmp")) || !AddFileToPackage(tempFile, L"RMSKIN.ini")) { std::wstring error = L"Unable to create package."; error += L"\n\nClick OK to close Packager."; MessageBox(m_Window, error.c_str(), L"Rainmeter Skin Packager", MB_OK | MB_ICONERROR); DeleteFile(tempFile); return cleanup(); } // Add skin { std::wstring zipPrefix = L"Skins\\" + m_SkinFolder.first; zipPrefix += L'\\'; if (!AddFolderToPackage(m_SkinFolder.second, L"", zipPrefix.c_str())) { return cleanup(); } } // Add layouts for (auto iter = m_LayoutFolders.cbegin(); iter != m_LayoutFolders.cend(); ++iter) { std::wstring realPath = (*iter).second + L"Rainmeter.ini"; std::wstring zipPath = L"Layouts\\" + (*iter).first; zipPath += L"\\Rainmeter.ini"; if (!AddFileToPackage(realPath.c_str(), zipPath.c_str())) { std::wstring error = L"Error adding layout '"; error += (*iter).first; error += L"'."; error += L"\n\nClick OK to close Packager."; MessageBox(m_Window, error.c_str(), L"Rainmeter Skin Packager", MB_OK | MB_ICONERROR); return cleanup(); } } // Add plugins for (auto iter = m_PluginFolders.cbegin(); iter != m_PluginFolders.cend(); ++iter) { // Add 32bit and 64bit versions for (int i = 0; i < 2; ++i) { const std::wstring& realPath = (i == 0) ? (*iter).second.first : (*iter).second.second; std::wstring zipPath = ((i == 0) ? L"Plugins\\32bit\\" : L"Plugins\\64bit\\") + (*iter).first; if (!AddFileToPackage(realPath.c_str(), zipPath.c_str())) { std::wstring error = L"Error adding plugin '"; error += (*iter).first; error += L"'."; error += L"\n\nClick OK to close Packager."; MessageBox(m_Window, error.c_str(), L"Rainmeter Skin Packager", MB_OK | MB_ICONERROR); return cleanup(); } } } // Add footer FILE* file; if (zipClose(m_ZipFile, nullptr) == ZIP_OK && (file = _wfopen(m_TargetFile.c_str(), L"r+b")) != nullptr) { fseek(file, 0, SEEK_END); DialogInstall::PackageFooter footer = { _ftelli64(file), 0, "RMSKIN" }; fwrite(&footer, sizeof(footer), 1, file); fclose(file); } else { std::wstring error = L"Unable to create package."; error += L"\n\nClick OK to close Packager."; MessageBox(m_Window, error.c_str(), L"Rainmeter Skin Packager", MB_OK | MB_ICONERROR); return false; } return true; }
int _compress(const char** srcs, int src_num, const char** srcspath, int srcpath_num, const char* dst, int level, const char* password, int exclude_path, PyObject* progress) { zipFile zf = NULL; int size_buf = WRITEBUFFERSIZE; int opt_overwrite = APPEND_STATUS_CREATE; int err = ZIP_OK; int errclose = 0; int i; #ifdef USEWIN32IOAPI zlib_filefunc64_def ffunc = {0}; #endif void* buf = NULL; buf = (void*)malloc(size_buf); if (buf == NULL) { pyerr_msg = PyErr_Format(PyExc_MemoryError, "could not allocate memory"); return ZIP_ERRNO; } if (srcpath_num > 0) assert(src_num == srcpath_num); #ifdef USEWIN32IOAPI fill_win32_filefunc64A(&ffunc); zf = zipOpen2_64(dst, opt_overwrite, NULL, &ffunc); #else zf = zipOpen64(dst, opt_overwrite); #endif if (zf == NULL) { pyerr_msg = PyErr_Format(PyExc_IOError, "error opening %s", dst); err = ZIP_ERRNO; } for (i = 0; i < src_num && (err == ZIP_OK); i++) { FILE *fin = NULL; int size_read = 0; const char* filenameinzip = srcs[i]; const char* filepathnameinzip; const char *savefilenameinzip; const char *savefilepathnameinzip = NULL; char *fullpathfileinzip = NULL; unsigned long crcFile = 0; int zip64 = 0; zip_fileinfo zi; memset(&zi, 0, sizeof(zip_fileinfo)); if (srcpath_num > 0) filepathnameinzip = srcspath[i]; /* Get information about the file on disk so we can store it in zip */ filetime(filenameinzip, &zi.tmz_date, &zi.dosDate); if ((password != NULL) && (err == ZIP_OK)) err = get_file_crc(filenameinzip, buf, size_buf, &crcFile); zip64 = is_large_file(filenameinzip); /* Construct the filename that our file will be stored in the zip as. The path name saved, should not include a leading slash. If it did, windows/xp and dynazip couldn't read the zip file. */ savefilenameinzip = filenameinzip; while (savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/') savefilenameinzip++; if (srcpath_num > 0) { savefilepathnameinzip = filepathnameinzip; while (savefilepathnameinzip[0] == '\\' || savefilepathnameinzip[0] == '/') savefilepathnameinzip++; } /* Should the file be stored with any path info at all? */ if (exclude_path) { const char *tmpptr = NULL; const char *lastslash = NULL; for (tmpptr = savefilenameinzip; *tmpptr; tmpptr++) { if (*tmpptr == '\\' || *tmpptr == '/') lastslash = tmpptr; } if (lastslash != NULL) savefilenameinzip = lastslash + 1; // base filename follows last slash. if (srcpath_num > 0) { /* prepend savefilepathnameinzip for each savefilenameinzip */ const char * slash; #if (defined(_WIN32)) const char default_slash = '\\'; #else const char default_slash = '/'; #endif size_t extra_len = 0; size_t filename_len = strlen(savefilenameinzip); size_t filepathname_len = strlen(savefilepathnameinzip); /* look for slash used in filepath */ slash = strchr(savefilepathnameinzip, '/'); if (slash == NULL) { slash = strchr(savefilepathnameinzip, '\\'); if (slash == NULL) { // no slash found.. use default slash = &default_slash; } } if (savefilepathnameinzip[filepathname_len-1] != *slash) extra_len = 1; /* allocate buffer */ fullpathfileinzip = (char *)malloc(filename_len + filepathname_len + extra_len + 1); if (fullpathfileinzip == NULL) { free(buf); pyerr_msg = PyErr_Format(PyExc_MemoryError, "error allocating memory on minizip compress"); return ZIP_INTERNALERROR; } strncpy(fullpathfileinzip, savefilepathnameinzip, filepathname_len); if (extra_len) fullpathfileinzip[filepathname_len] = *slash; strncpy(fullpathfileinzip + filepathname_len + extra_len, savefilenameinzip, filename_len); /* terminate string */ fullpathfileinzip[filename_len + filepathname_len + extra_len] = '\0'; /* set pointer */ savefilenameinzip = fullpathfileinzip; } } /* Add to zip file */ err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &zi, NULL, 0, NULL, 0, NULL /* comment*/, (level != 0) ? Z_DEFLATED : 0, level, 0, /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password, crcFile, zip64); if (err != ZIP_OK) { pyerr_msg = PyErr_Format(PyExc_IOError, "error in opening %s in zipfile (%d)", filenameinzip, err); err = ZIP_ERRNO; } else { fin = FOPEN_FUNC(filenameinzip, "rb"); if (fin == NULL) { pyerr_msg = PyErr_Format(PyExc_IOError, "error in opening %s for reading", filenameinzip); err = ZIP_ERRNO; } } if (err == ZIP_OK) { /* Read contents of file and write it to zip */ do { size_read = (int)fread(buf, 1, size_buf, fin); if ((size_read < size_buf) && (feof(fin) == 0)) { pyerr_msg = PyErr_Format(PyExc_IOError, "error in reading %s", filenameinzip); err = ZIP_ERRNO; } if (0 < size_read) { err = zipWriteInFileInZip(zf, buf, size_read); if (err < 0) { pyerr_msg = PyErr_Format(PyExc_IOError, "error in writing %s in the zipfile (%d)", filenameinzip, err); err = ZIP_ERRNO; } } } while ((err == ZIP_OK) && (size_read > 0)); } if (fin) fclose(fin); if (err == ZIP_OK) { err = zipCloseFileInZip(zf); if (err != ZIP_OK) { pyerr_msg = PyErr_Format(PyExc_IOError, "error in closing %s in the zipfile (%d)", filenameinzip, err); err = ZIP_ERRNO; } } if (progress != NULL) { PyObject* args = Py_BuildValue("(I)", i + 1); PyObject* result = PyObject_CallObject(progress, args); if (PyErr_Occurred()) // Ignore errors in the callback, don't want them to crash this c module { PyErr_Clear(); } Py_XDECREF(result); Py_XDECREF(args); } if(srcpath_num > 0 && fullpathfileinzip) free(fullpathfileinzip); } errclose = zipClose(zf, NULL); if (errclose != ZIP_OK) { pyerr_msg = PyErr_Format(PyExc_IOError, "error in closing %s (%d)", dst, errclose); err = ZIP_ERRNO; } free(buf); return err; }
int main( int argc, char *argv[]) { int i; int opt_overwrite=0; int opt_compress_level=Z_DEFAULT_COMPRESSION; int opt_exclude_path=0; int zipfilenamearg = 0; char filename_try[MAXFILENAME+16]; int zipok; int err=0; int size_buf=0; void* buf=NULL; const char* password=NULL; do_banner(); if (argc==1) { do_help(); return 0; } else { for (i=1;i<argc;i++) { if ((*argv[i])=='-') { const char *p=argv[i]+1; while ((*p)!='\0') { char c=*(p++);; if ((c=='o') || (c=='O')) opt_overwrite = 1; if ((c=='a') || (c=='A')) opt_overwrite = 2; if ((c>='0') && (c<='9')) opt_compress_level = c-'0'; if ((c=='j') || (c=='J')) opt_exclude_path = 1; if (((c=='p') || (c=='P')) && (i+1<argc)) { password=argv[i+1]; i++; } } } else { if (zipfilenamearg == 0) { zipfilenamearg = i ; } } } } size_buf = WRITEBUFFERSIZE; buf = (void*)malloc(size_buf); if (buf==NULL) { printf("Error allocating memory\n"); return ZIP_INTERNALERROR; } if (zipfilenamearg==0) { zipok=0; } else { int i,len; int dot_found=0; zipok = 1 ; strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); /* strncpy doesnt append the trailing NULL, of the string is too long. */ filename_try[ MAXFILENAME ] = '\0'; len=(int)strlen(filename_try); for (i=0;i<len;i++) if (filename_try[i]=='.') dot_found=1; if (dot_found==0) strcat(filename_try,".zip"); if (opt_overwrite==2) { /* if the file don't exist, we not append file */ if (check_exist_file(filename_try)==0) opt_overwrite=1; } else if (opt_overwrite==0) if (check_exist_file(filename_try)!=0) { char rep=0; do { char answer[128]; int ret; printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); ret = scanf("%1s",answer); if (ret != 1) { exit(EXIT_FAILURE); } rep = answer[0] ; if ((rep>='a') && (rep<='z')) rep -= 0x20; } while ((rep!='Y') && (rep!='N') && (rep!='A')); if (rep=='N') zipok = 0; if (rep=='A') opt_overwrite = 2; } } if (zipok==1) { zipFile zf; int errclose; # ifdef USEWIN32IOAPI zlib_filefunc64_def ffunc; fill_win32_filefunc64A(&ffunc); zf = zipOpen2_64(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); # else zf = zipOpen64(filename_try,(opt_overwrite==2) ? 2 : 0); # endif if (zf == NULL) { printf("error opening %s\n",filename_try); err= ZIP_ERRNO; } else printf("creating %s\n",filename_try); for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) { if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) && ((argv[i][1]=='o') || (argv[i][1]=='O') || (argv[i][1]=='a') || (argv[i][1]=='A') || (argv[i][1]=='p') || (argv[i][1]=='P') || ((argv[i][1]>='0') || (argv[i][1]<='9'))) && (strlen(argv[i]) == 2))) { FILE * fin; int size_read; const char* filenameinzip = argv[i]; const char *savefilenameinzip; zip_fileinfo zi; unsigned long crcFile=0; int zip64 = 0; zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; zi.dosDate = 0; zi.internal_fa = 0; zi.external_fa = 0; filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); /* err = zipOpenNewFileInZip(zf,filenameinzip,&zi, NULL,0,NULL,0,NULL / * comment * /, (opt_compress_level != 0) ? Z_DEFLATED : 0, opt_compress_level); */ if ((password != NULL) && (err==ZIP_OK)) err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); zip64 = isLargeFile(filenameinzip); /* The path name saved, should not include a leading slash. */ /*if it did, windows/xp and dynazip couldn't read the zip file. */ savefilenameinzip = filenameinzip; while( savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/' ) { savefilenameinzip++; } /*should the zip file contain any path at all?*/ if( opt_exclude_path ) { const char *tmpptr; const char *lastslash = 0; for( tmpptr = savefilenameinzip; *tmpptr; tmpptr++) { if( *tmpptr == '\\' || *tmpptr == '/') { lastslash = tmpptr; } } if( lastslash != NULL ) { savefilenameinzip = lastslash+1; // base filename follows last slash. } } /**/ err = zipOpenNewFileInZip3_64(zf,savefilenameinzip,&zi, NULL,0,NULL,0,NULL /* comment*/, (opt_compress_level != 0) ? Z_DEFLATED : 0, opt_compress_level,0, /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password,crcFile, zip64); if (err != ZIP_OK) printf("error in opening %s in zipfile\n",filenameinzip); else { fin = FOPEN_FUNC(filenameinzip,"rb"); if (fin==NULL) { err=ZIP_ERRNO; printf("error in opening %s for reading\n",filenameinzip); } } if (err == ZIP_OK) do { err = ZIP_OK; size_read = (int)fread(buf,1,size_buf,fin); if (size_read < size_buf) if (feof(fin)==0) { printf("error in reading %s\n",filenameinzip); err = ZIP_ERRNO; } if (size_read>0) { err = zipWriteInFileInZip (zf,buf,size_read); if (err<0) { printf("error in writing %s in the zipfile\n", filenameinzip); } } } while ((err == ZIP_OK) && (size_read>0)); if (fin) fclose(fin); if (err<0) err=ZIP_ERRNO; else { err = zipCloseFileInZip(zf); if (err!=ZIP_OK) printf("error in closing %s in the zipfile\n", filenameinzip); } } } errclose = zipClose(zf,NULL); if (errclose != ZIP_OK) printf("error in closing %s\n",filename_try); } else { do_help(); } free(buf); return 0; }
int TRI_ZipFile(char const* filename, char const* dir, std::vector<std::string> const& files, char const* password) { void* buffer; #ifdef USEWIN32IOAPI zlib_filefunc64_def ffunc; #endif if (TRI_ExistsFile(filename)) { return TRI_ERROR_CANNOT_OVERWRITE_FILE; } int bufferSize = 16384; buffer = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, (size_t)bufferSize, false); if (buffer == nullptr) { return TRI_ERROR_OUT_OF_MEMORY; } #ifdef USEWIN32IOAPI fill_win32_filefunc64A(&ffunc); zipFile zf = zipOpen2_64(filename, 0, NULL, &ffunc); #else zipFile zf = zipOpen64(filename, 0); #endif if (zf == nullptr) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer); return ZIP_ERRNO; } int res = TRI_ERROR_NO_ERROR; size_t n = files.size(); for (size_t i = 0; i < n; ++i) { std::string fullfile; if (*dir == '\0') { fullfile = files[i]; } else { fullfile = arangodb::basics::FileUtils::buildFilename(dir, files[i]); } zip_fileinfo zi; memset(&zi, 0, sizeof(zi)); uint32_t crc; res = TRI_Crc32File(fullfile.c_str(), &crc); if (res != TRI_ERROR_NO_ERROR) { break; } int isLarge = (TRI_SizeFile(files[i].c_str()) > 0xFFFFFFFFLL); char const* saveName = files[i].c_str(); while (*saveName == '\\' || *saveName == '/') { ++saveName; } if (zipOpenNewFileInZip3_64( zf, saveName, &zi, NULL, 0, NULL, 0, NULL, /* comment*/ Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, password, (unsigned long)crc, isLarge) != ZIP_OK) { res = TRI_ERROR_INTERNAL; break; } FILE* fin = fopen(fullfile.c_str(), "rb"); if (fin == nullptr) { break; } while (true) { int sizeRead = (int)fread(buffer, 1, bufferSize, fin); if (sizeRead < bufferSize) { if (feof(fin) == 0) { res = TRI_set_errno(TRI_ERROR_SYS_ERROR); break; } } if (sizeRead > 0) { res = zipWriteInFileInZip(zf, buffer, sizeRead); if (res != 0) { break; } } else /* if (sizeRead <= 0) */ { break; } } fclose(fin); zipCloseFileInZip(zf); if (res != TRI_ERROR_NO_ERROR) { break; } } zipClose(zf, NULL); TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer); return res; }
bool MakeZip(TCHAR *tszSource, TCHAR *tszDest, TCHAR *dbname, HWND progress_dialog) { bool ret = false; HANDLE hSrc; zipFile hZip; SYSTEMTIME st; WIN32_FILE_ATTRIBUTE_DATA fad = { 0 }; zip_fileinfo fi = { 0 }; HWND hProgBar; DWORD dwRead; MSG msg; char buf[(256 * 1024)]; // 256 KB DWORDLONG dwSrcFileSize, dwTotalBytes = 0; ptrA szSourceName(mir_u2a(dbname)); ptrT tszDestPath(DoubleSlash(tszDest)); hSrc = CreateFile(tszSource, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hSrc == INVALID_HANDLE_VALUE) return ret; if (GetFileAttributesEx(tszSource, GetFileExInfoStandard, &fad) == FALSE) goto err_out; dwSrcFileSize = ((DWORDLONG)fad.nFileSizeLow | (((DWORDLONG)fad.nFileSizeHigh) << 32)); if (dwSrcFileSize == 0) /* Prevent division by zero error. */ goto err_out; FileTimeToLocalFileTime(&fad.ftLastWriteTime, &fad.ftLastWriteTime); FileTimeToSystemTime(&fad.ftLastWriteTime, &st); hZip = zipOpen2_64(tszDestPath, APPEND_STATUS_CREATE, NULL, NULL); if (hZip == NULL) goto err_out; fi.tmz_date.tm_sec = st.wSecond; fi.tmz_date.tm_min = st.wMinute; fi.tmz_date.tm_hour = st.wHour; fi.tmz_date.tm_mday = st.wDay; fi.tmz_date.tm_mon = (st.wMonth - 1); fi.tmz_date.tm_year = st.wYear; if (zipOpenNewFileInZip(hZip, szSourceName, &fi, NULL, 0, NULL, 0, "", Z_DEFLATED, Z_BEST_COMPRESSION) == ZIP_OK) { hProgBar = GetDlgItem(progress_dialog, IDC_PROGRESS); while (GetWindowLongPtr(progress_dialog, GWLP_USERDATA) != 1) { if (!ReadFile(hSrc, buf, sizeof(buf), &dwRead, NULL)) break; if (dwRead == 0) { // EOF ret = true; break; } if (zipWriteInFileInZip(hZip, buf, dwRead) != ZIP_OK) break; dwTotalBytes += dwRead; SendMessage(hProgBar, PBM_SETPOS, (WPARAM)((100 * dwTotalBytes) / dwSrcFileSize), 0); while (PeekMessage(&msg, progress_dialog, 0, 0, PM_REMOVE) != 0) { if (progress_dialog == NULL || !IsDialogMessage(progress_dialog, &msg)) { /* Wine fix. */ TranslateMessage(&msg); DispatchMessage(&msg); } } } zipCloseFileInZip(hZip); } if (ret) { mir_snprintf(buf, "%s\r\n%s %s %d.%d.%d.%d\r\n", Translate("Miranda NG database"), Translate("Created by:"), __PLUGIN_NAME, __MAJOR_VERSION, __MINOR_VERSION, __RELEASE_NUM, __BUILD_NUM); } else { buf[0] = 0; } zipClose(hZip, buf); err_out: CloseHandle(hSrc); return ret; }
int PackerJob::createZipFile() { int result = ZIP_ERRNO; zipFile zf = zipOpen2_64(m_tszFilePath, 0, nullptr, nullptr); if (zf != nullptr) { result = ZIP_OK; int size_buf = 65536; void *buff = (void *)mir_alloc(size_buf); for (UINT i = 0; i < m_files.size(); i++) { int size_read; zip_fileinfo zi; zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = 0; zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; zi.dosDate = 0; zi.internal_fa = 0; zi.external_fa = 0; getFileTime(m_files[i], &zi.tmz_date, &zi.dosDate); char *file = mir_u2a(Utils::getFileNameFromPath(m_files[i])); int err = zipOpenNewFileInZip(zf, file, &zi, nullptr, 0, nullptr, 0, nullptr, Z_DEFLATED, opt.iCompressionLevel); FREE(file); if (err == ZIP_OK) { FILE *fin = _wfopen(m_files[i], L"rb"); if (fin) { do { if (isCanceled()) { fclose(fin); result = STATUS_CANCELED; goto Cleanup; } err = ZIP_OK; size_read = (int)fread(buff, 1, size_buf, fin); if (size_read < size_buf && feof(fin) == 0) { fclose(fin); result = ZIP_ERRNO; goto Cleanup; } if (size_read > 0) { err = zipWriteInFileInZip(zf, buff, size_read); m_uiReaded += size_read; } updateStats(); } while ((err == ZIP_OK) && (size_read > 0)); fclose(fin); } else err = ZIP_ERRNO; err = zipCloseFileInZip(zf); if (err < 0) { result = ZIP_ERRNO; goto Cleanup; } } else { result = ZIP_ERRNO; break; } } Cleanup: zipClose(zf, nullptr); FREE(buff); } return result; }