Esempio n. 1
0
static int save_archive(char *filename, char *buffer, int size)
{	
    zipFile fd = NULL;
    int ret = 0;
    fd=zipOpen(filename,0);
    if(!fd)
    {
       printf("Failed to create zip\r\n");
       return (0);
    }

    ret=zipOpenNewFileInZip(fd,"SNAPSHOT",
			    NULL,
				NULL,0,
			    NULL,0,
			    NULL,
			    Z_DEFLATED,
			    Z_BEST_COMPRESSION);
			    
    if(ret != ZIP_OK)
    {
       zipClose(fd,NULL);
       printf("Failed to create file in zip\r\n");
       return (0);    
    }

    ret=zipWriteInFileInZip(fd,buffer,size);
    if(ret != ZIP_OK)
    {
      zipCloseFileInZip(fd);
      zipClose(fd,NULL);
      printf("Failed to write file in zip\r\n");
      return (0);
    }

    ret=zipCloseFileInZip(fd);
    if(ret != ZIP_OK)
    {
      zipClose(fd,NULL);
      printf("Failed to close file in zip\r\n");
      return (0);
    }

    ret=zipClose(fd,NULL);
    if(ret != ZIP_OK)
    {
      printf("Failed to close zip\r\n");
      return (0);
    }
	
    return(1);
}
Esempio n. 2
0
void ZipFileHandler::OnHandleDestroy(HandleType_t, void *object)
{
    if (NULL != object)
    {
        zipClose((zipFile)object, NULL);
    }
}
/*
Trying to write offset and vertices data to file.
*/
void CPathEstimator::WriteFile(string name) {
	// We need this directory to exist
	boost::filesystem::path f("./maps/paths");
	if (!boost::filesystem::exists(f))
		boost::filesystem::create_directories(f);

	unsigned int hash = Hash();
	char hashString[50];
	sprintf(hashString,"%u",hash);

	string filename = string("maps/paths/") + stupidGlobalMapname.substr(0, stupidGlobalMapname.find('.') + 1) + hashString + "." + name + ".zip";
	zipFile file = zipOpen(filename.c_str(), APPEND_STATUS_CREATE);

	if (file) {
		zipOpenNewFileInZip(file, "pathinfo", NULL, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_BEST_COMPRESSION);
		
		//Write hash.
		unsigned int hash = Hash();
		zipWriteInFileInZip(file, (void*)&hash, 4);

		//Write block-center-offsets.
		int blocknr;
		for(blocknr = 0; blocknr < nbrOfBlocks; blocknr++) {
			zipWriteInFileInZip(file, (void*)blockState[blocknr].sqrCenter, moveinfo->moveData.size() * sizeof(int2));
			//file.write((char*)blockState[blocknr].sqrCenter, moveinfo->moveData.size() * sizeof(int2));
		}

		//Write vertices.
		zipWriteInFileInZip(file, (void*)vertex, nbrOfVertices * sizeof(float));
		//file.write((char*)vertex, nbrOfVertices * sizeof(float));

		zipCloseFileInZip(file);
		zipClose(file, NULL);
	}
}
Esempio n. 4
0
bool ZipFile::SwitchMode(short mode)
{
    if(mode == ZipFile::OPEN)
    {
        if(zFile)
        {
            zipClose(zFile, NULL);
            zFile = 0;
        }

        if(!uzFile)
            uzFile = unzOpen(ZipFilePath.c_str());

        return (uzFile != 0);
    }
    else if(mode == ZipFile::CREATE || mode == ZipFile::APPEND)
    {
        if(uzFile)
        {
            unzClose(uzFile);
            uzFile = 0;
        }

        if(!zFile)
            zFile = zipOpen(ZipFilePath.c_str(), mode);

        return (zFile != 0);
    }

    return false;
}
Esempio n. 5
0
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;
}
Esempio n. 6
0
void FileUtils::addToZip(const char* archivePath, const char* path, const char* content, int length) throw (IOException)
{
	int result = ZIP_OK;

	int appendMode = fileExists(archivePath) ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE;

	zipFile archive = zipOpen(archivePath, appendMode);
	result = zipOpenNewFileInZip(archive, path, 0 /* file attributes */, 0 /* extra field */, 0 /* extra field size */,
						0/* global extra field */, 0 /* global extra field size */, 0 /* comment */, Z_DEFLATED /* method */,
						Z_DEFAULT_COMPRESSION /* level */);
	if (result != ZIP_OK)
	{
		throw IOException("Unable to add new file to zip archive");
	}
	result = zipWriteInFileInZip(archive, content, static_cast<unsigned int>(length));
	if (result != ZIP_OK)
	{
		throw IOException("Unable to write file data to zip archive");
	}
	result = zipCloseFileInZip(archive);
	if (result != ZIP_OK)
	{
		throw IOException("Unable to close file in zip archive");
	}
	result = zipClose(archive, 0 /* global comment */);
	if (result != ZIP_OK)
	{
		throw IOException("Unable to close zip archive");
	}
}
Esempio n. 7
0
//-----------------------------------------------------------------------------
// CZLib::Close
//
// Close open zip file
//
void CZLib::Close()
{
   if (m_zf)
      zipClose(m_zf, NULL);

   m_zf = 0;
}
Esempio n. 8
0
void QuaZip::close()
{
  p->zipError=UNZ_OK;
  switch(p->mode) {
    case mdNotOpen:
      qWarning("QuaZip::close(): ZIP is not open");
      return;
    case mdUnzip:
      p->zipError=unzClose(p->unzFile_f);
      break;
    case mdCreate:
    case mdAppend:
    case mdAdd:
      p->zipError=zipClose(p->zipFile_f, p->commentCodec->fromUnicode(p->comment).constData());
      break;
    default:
      qWarning("QuaZip::close(): unknown mode: %d", (int)p->mode);
      return;
  }
  // opened by name, need to delete the internal IO device
  if (!p->zipName.isEmpty())
    delete p->ioDevice;
  if(p->zipError==UNZ_OK)
    p->mode=mdNotOpen;
}
Esempio n. 9
0
// 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;
}
Esempio n. 10
0
bool ZipFile::Close(QString comment)
{
	if (!zf)
		return false;
	bool success = zipClose(zf, comment.toAscii().constData()) == ZIP_OK;
	zf = NULL;
	return success;
}
Esempio n. 11
0
ZipFile::~ZipFile()
{
    ClearList();
    if(uzFile)
        unzClose(uzFile);
    if(zFile)
        zipClose(zFile, NULL);
}
Esempio n. 12
0
void ZipArchive::close()
{
	if (!isOpen())
		return;
	
	zipClose(d->zip, 0);
	d->zip = 0;
}
Esempio n. 13
0
void
close_ZIP_archive(void)
{
	if (unzipping)
		unzClose(unzip_handle);
	else
		zipClose(zip_handle, NULL);
}
Esempio n. 14
0
		ZipArchiveImpl::~ZipArchiveImpl()
		{
			int r = ZIP_OK;
			if (m_File)
				r = zipClose(m_File, ":)");
			m_File = nullptr;
			m_Info = ArchiveInfo();
		}
Esempio n. 15
0
BOOL fsUploadMgr::ZipFiles ()
{
	if (m_bZipFileCreated)
		return TRUE;

	Event (UMGRE_ZIP_FILES_START);

	char szTmpFile [MAX_PATH];
	char szTmpPath [MAX_PATH];
	GetTempPath (MAX_PATH, szTmpPath);
	GetTempFileName (szTmpPath, "tmp", 0, szTmpFile);
	m_strUploadFile = szTmpFile;
	
	zipFile zip = zipOpen (m_strUploadFile, 0);
	BOOL bOk = TRUE;

	m_strZipContentsDescHtml = "<ul>";

	for (size_t i = 0; i < m_pkg.m_vPathes.size () && bOk && m_bNeedStop == false; i++)
	{
		LPCSTR psz = m_pkg.m_vPathes [i];

		char szName [1000] = "";
		fsGetFileName (psz, szName);

		if (GetFileAttributes (psz) & FILE_ATTRIBUTE_DIRECTORY)
		{
			AddItemToZipContentsDescHtml (szName, _UI64_MAX);
			m_strZipContentsDescHtml += "<ul>";
			bOk = bOk && Zip_AddFolder (zip, psz, NULL, 1);
			m_strZipContentsDescHtml += "</ul>";
		}
		else
		{
			bOk = bOk && Zip_AddFile (zip, psz, NULL);
			if (bOk)
			{
				WIN32_FILE_ATTRIBUTE_DATA wfad;
				GetFileAttributesEx (psz, GetFileExInfoStandard, &wfad);
				AddItemToZipContentsDescHtml (szName, ((UINT64)wfad.nFileSizeHigh << 32) + wfad.nFileSizeLow);
			}
		}
	}

	m_strZipContentsDescHtml += "</ul>";

	zipClose (zip, NULL);

	if (m_bNeedStop || bOk == FALSE)
		DeleteFile (m_strUploadFile);
	else
		m_bZipFileCreated = TRUE;

	if (m_bNeedStop == false)
		Event (bOk ? UMGRE_ZIP_FILES_DONE : UMGRE_ZIP_FILES_FAILED);

	return m_bZipFileCreated;
}
Esempio n. 16
0
bool Zip::Close()
{
    if (m_zipFile) {
        m_errcode = zipClose(m_zipFile, nullptr);
        m_zipFile = nullptr;
        return m_errcode == ZIP_OK;
    }
    return true;
}
Esempio n. 17
0
 void ZipWriter::Close()
 {
   if (IsOpen())
   {
     zipClose(pimpl_->file_, "Created by Orthanc");
     pimpl_->file_ = NULL;
     hasFileInZip_ = false;
   }
 }
//by stone
bool FileSystemZip::Init_zMemory(std::string NameInZip, unsigned char* buf, int size, int append)
{
	unzFile			zf;
	zip_fileinfo	zi;
	time_t			tm_t;
	struct tm*		filedate;
	int				opt_compress_level = Z_BEST_COMPRESSION; //use best compress

	if( m_compress_buf )
	{
		delete m_compress_buf;
		m_compress_buf = NULL;
	}

	m_compress_buf = new byte[size];
	
	zf = ZipOpen_Memory(m_compress_buf, size, append);
	if (!zf)
	{
		LogError("Cannot create memory using");
		return false;
	}
	LogMsg("deflate zip as memory");

	memset(&zi,0,sizeof(zip_fileinfo));
	
	tm_t		= time(NULL);
	filedate	= localtime(&tm_t);
			
	zi.tmz_date.tm_sec  = filedate->tm_sec;
	zi.tmz_date.tm_min  = filedate->tm_min;
	zi.tmz_date.tm_hour = filedate->tm_hour;
	zi.tmz_date.tm_mday = filedate->tm_mday;
	zi.tmz_date.tm_mon  = filedate->tm_mon ;
	zi.tmz_date.tm_year = filedate->tm_year;

	zipOpenNewFileInZip(zf,
						NameInZip.c_str(),
						&zi,
						NULL,
						0,
						NULL,
						0,
						NULL,
						Z_DEFLATED,
						opt_compress_level);

	zipWriteInFileInZip(zf,buf,size);
	zipCloseFileInZip(zf);
	
	m_zip_size = zipClose(zf, NULL);
	
	//m_zipFileName = zipFileName; //save it in case we need to spawn more zip readers for streaming operations
	//CacheIndex();

	return true; //success
}
Esempio n. 19
0
// ////////////////////////////////////////////////////////////////////////////////
// @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;
}
Esempio n. 20
0
int hts_extract_meta(const char* path) {
    char catbuff[CATBUFF_SIZE];
    unzFile zFile = unzOpen(fconcat(catbuff,path,"hts-cache/new.zip"));
    zipFile zFileOut = zipOpen(fconcat(catbuff,path,"hts-cache/meta.zip"), 0);
    if (zFile != NULL && zFileOut != NULL) {
        if (unzGoToFirstFile(zFile) == Z_OK) {
            zip_fileinfo fi;
            unz_file_info ufi;
            char BIGSTK filename[HTS_URLMAXSIZE * 4];
            char BIGSTK comment[8192];
            memset(comment, 0, sizeof(comment));       // for truncated reads
            memset(&fi, 0, sizeof(fi));
            memset(&ufi, 0, sizeof(ufi));
            do  {
                int readSizeHeader;
                filename[0] = '\0';
                comment[0] = '\0';

                if (unzOpenCurrentFile(zFile) == Z_OK) {
                    if (
                        (readSizeHeader = unzGetLocalExtrafield(zFile, comment, sizeof(comment) - 2)) > 0
                        &&
                        unzGetCurrentFileInfo(zFile, &ufi, filename, sizeof(filename) - 2, NULL, 0, NULL, 0) == Z_OK
                    )
                    {
                        comment[readSizeHeader] = '\0';
                        fi.dosDate = ufi.dosDate;
                        fi.internal_fa = ufi.internal_fa;
                        fi.external_fa = ufi.external_fa;
                        if (zipOpenNewFileInZip(zFileOut,
                                                filename,
                                                &fi,
                                                NULL,
                                                0,
                                                NULL,
                                                0,
                                                NULL, /* comment */
                                                Z_DEFLATED,
                                                Z_DEFAULT_COMPRESSION) == Z_OK)
                        {
                            if (zipWriteInFileInZip(zFileOut, comment, (int) strlen(comment)) != Z_OK) {
                            }
                            if (zipCloseFileInZip(zFileOut) != Z_OK) {
                            }
                        }
                    }
                    unzCloseCurrentFile(zFile);
                }
            } while( unzGoToNextFile(zFile) == Z_OK );
        }
        zipClose(zFileOut, "Meta-data extracted by HTTrack/"HTTRACK_VERSION);
        unzClose(zFile);
        return 1;
    }
    return 0;
}
Esempio n. 21
0
static HB_GARBAGE_FUNC( hb_zipfile_destructor )
{
   zipFile * phZip = ( zipFile * ) Cargo;

   if( *phZip )
   {
      zipClose( *phZip, NULL );
      *phZip = NULL;
   }
}
void MkInterfaceForZipFileWriting::Clear(void)
{
	if (m_ZipFile != NULL)
	{
		m_CurrentFilePath.Clear();

		zipClose(m_ZipFile, NULL);
		m_ZipFile = NULL;
	}
}
Esempio n. 23
0
/*
========================
idZipBuilder::CleanSourceFolder

this folder is assumed to be a path under FSPATH_BASE
========================
*/
void idZipBuilder::CloseZipFile( zipFile zf )
{
	// close the zip file
	int closeError = zipClose( zf, zipFileName );
	if( closeError != ZIP_OK )
	{
		idLib::Warning( "[%s] - error closing file '%s'!", __FUNCTION__, zipFileName.c_str() );
	}
	idLib::PrintfIf( zip_verbosity.GetBool(), "Done.\n" );
}
Esempio n. 24
0
// ----------------------------------------------------------------------------
// Compress
// ----------------------------------------------------------------------------
bool archive_Compress(std::string zipFilename, std::string filename, const byte* data, uint size) {
  if(zipFilename.empty( ) || zipFilename.size( ) == 0) {
    logger_LogError("Zip filename is invalid.", ARCHIVE_SOURCE);
    return false;
  }  
  if(filename.empty( ) || filename.size( ) == 0) {
    logger_LogError("Filename is invalid.", ARCHIVE_SOURCE);
    return false;
  }
  if(data == NULL) {
    logger_LogError("Data parameter is invalid.", ARCHIVE_SOURCE);
    return false;  
  }
  
  zipFile file = zipOpen(zipFilename.c_str( ), APPEND_STATUS_CREATE);
  if(file == NULL) {
    logger_LogInfo("Failed to create the zip file " + zipFilename + ".", ARCHIVE_SOURCE);
    return false;
  }
  
  zip_fileinfo fileInfo = {0};
  fileInfo.dosDate = 1;
  
  int result = zipOpenNewFileInZip(file, filename.c_str( ), &fileInfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_BEST_COMPRESSION);
  if(result != ZIP_OK) {
    logger_LogInfo("Failed to open a new file within the zip file " + filename + ".", ARCHIVE_SOURCE);
    logger_LogInfo("Result: " + result, ARCHIVE_SOURCE);
    zipClose(file, "Failed to compress.");
    return false;  
  }
  
  result = zipWriteInFileInZip(file, data, size);
  if(result != ZIP_OK) {
    logger_LogInfo("Failed to write data to the zip file " + filename + ".", ARCHIVE_SOURCE);
    zipCloseFileInZip(file);
    zipClose(file, "Failed to compress.");
    return false;
  }
 
  zipCloseFileInZip(file);
  zipClose(file, "Comment");
  return true;
}
Esempio n. 25
0
void ZipArchiveWriter::Close()
{
    m_errCode = Z_ERRNO;

    if (m_hZip)
    {
        zipClose(m_hZip, nullptr);
        m_hZip = nullptr;
    }
}
Esempio n. 26
0
bool CZipper::CloseZip()
{
	int nRet = m_uzFile ? zipClose(m_uzFile, NULL) : ZIP_OK;

	m_uzFile = NULL;
	m_szRootFolder[0] = 0;
	ZeroMemory(&m_info, sizeof(m_info));

	return (nRet == ZIP_OK);
}
Esempio n. 27
0
static int writezip_cb(lua_State* L)
{
	const char* zipname = luaL_checkstring(L, 1);
	luaL_checktype(L, 2, LUA_TTABLE);
	int result = 0;

	zipFile zf = zipOpen(zipname, APPEND_STATUS_CREATE);
	if (zf)
	{
		result = 1;

		lua_pushnil(L);
		while (lua_next(L, 2) != 0)
		{
			const char* key = lua_tostring(L, -2);
			size_t valuelen;
			const char* value = lua_tolstring(L, -1, &valuelen);

			int i = zipOpenNewFileInZip(zf, key, NULL,
					NULL, 0,
					NULL, 0,
					NULL,
					Z_DEFLATED,
					Z_DEFAULT_COMPRESSION);
			if (i != ZIP_OK)
			{
				result = 0;
				break;
			}

			i = zipWriteInFileInZip(zf, value, valuelen);
			if (i != ZIP_OK)
			{
				result = 0;
				break;
			}

			i = zipCloseFileInZip(zf);
			if (i != ZIP_OK)
			{
				result = 0;
				break;
			}

			lua_pop(L, 1); /* leave key on stack */
		}

		zipClose(zf, NULL);
	}

	if (!result)
		return 0;
	lua_pushboolean(L, true);
	return 1;
}
Esempio n. 28
0
void QZipFile::close()
{
    if (m_unzFile) {
        unzClose(m_unzFile);
        m_unzFile = 0;
    }

    if (m_zipFile) {
        zipClose(m_zipFile, NULL);
        m_zipFile = NULL;
    }
}
Esempio n. 29
0
int FILE_compress_dir(const string& src_path, const string& dst_path, const string& prefix)
{
	zipFile archive = zipOpen(dst_path.c_str(), 0);
	if(archive == NULL)
		return -1;

	int r = compress_recursive(archive, src_path,prefix);
	
	zipClose(archive, NULL);
	
	return r;
	
}
Esempio n. 30
0
	bool CompressFiles(const wchar_t* zip_file_path, const RequestFileCallback& callback, void* pParam, int compression_level)
	{
		zipFile zip_file_handle = zipOpenHelp(zip_file_path);

		if(NULL != zip_file_handle)
		{
			zip_fileinfo zi = {0};
#if defined(_WIN32) || defined (_WIN64)
			SYSTEMTIME currTime;
			GetLocalTime( &currTime );
			zi.tmz_date.tm_sec = currTime.wSecond;
			zi.tmz_date.tm_min = currTime.wMinute;
			zi.tmz_date.tm_hour = currTime.wHour;
			zi.tmz_date.tm_mday = currTime.wDay;
			zi.tmz_date.tm_mon = currTime.wMonth;
			zi.tmz_date.tm_year = currTime.wYear;
#endif

			BYTE* pData = NULL;
			long nSize;
			std::wstring in_zip_filename;
			while(callback(in_zip_filename, pData, nSize, pParam))
			{
				std::string in_zip_filenameA = codepage_issue_fixToOEM(in_zip_filename);
				if (ZIP_OK != zipOpenNewFileInZip( zip_file_handle, in_zip_filenameA.c_str(), &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, compression_level ) ||
					ZIP_OK != zipWriteInFileInZip(zip_file_handle, pData, nSize) ||
					ZIP_OK != zipCloseFileInZip(zip_file_handle))
				{
					zipClose(zip_file_handle, NULL);
					return false;
				}
			}
			zipClose(zip_file_handle, NULL);

			return true;
		}
		return false;
	}