ErrorCode MinizipUtils::add_file(zipFile zf,
                                 const std::string &name,
                                 const std::vector<unsigned char> &contents)
{
    // Obviously never true, but we'll keep it here just in case
    bool zip64 = static_cast<uint64_t>(contents.size()) >= ((1ull << 32) - 1);

    zip_fileinfo zi;
    memset(&zi, 0, sizeof(zi));

    int ret = zipOpenNewFileInZip2_64(
        zf,                     // file
        name.c_str(),           // filename
        &zi,                    // zip_fileinfo
        nullptr,                // extrafield_local
        0,                      // size_extrafield_local
        nullptr,                // extrafield_global
        0,                      // size_extrafield_global
        nullptr,                // comment
        Z_DEFLATED,             // method
        Z_DEFAULT_COMPRESSION,  // level
        0,                      // raw
        zip64                   // zip64
    );

    if (ret != ZIP_OK) {
        LOGE("minizip: Failed to open inner file: %s",
             zip_error_string(ret).c_str());

        return ErrorCode::ArchiveWriteDataError;
    }

    // Write data to file
    ret = zipWriteInFileInZip(zf, contents.data(),
                              static_cast<uint32_t>(contents.size()));
    if (ret != ZIP_OK) {
        LOGE("minizip: Failed to write inner file data: %s",
             zip_error_string(ret).c_str());
        zipCloseFileInZip(zf);

        return ErrorCode::ArchiveWriteDataError;
    }

    ret = zipCloseFileInZip(zf);
    if (ret != ZIP_OK) {
        LOGE("minizip: Failed to close inner file: %s",
             zip_error_string(ret).c_str());

        return ErrorCode::ArchiveWriteDataError;
    }

    return ErrorCode::NoError;
}
Beispiel #2
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);
}
Beispiel #3
0
static bool AppendFileToZip(zipFile& zf, const WCHAR *nameInZip, const char *fileData, size_t fileSize)
{
    ScopedMem<char> nameInZipUtf(str::conv::ToUtf8(nameInZip));
    str::TransChars(nameInZipUtf, "\\", "/");
    zip_fileinfo zi = { 0 };
    int err = zipOpenNewFileInZip64(zf, nameInZipUtf, &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION, 1);
    if (ZIP_OK == err) {
        err = zipWriteInFileInZip(zf, fileData, fileSize);
        if (ZIP_OK == err)
            err = zipCloseFileInZip(zf);
        else
            zipCloseFileInZip(zf);
    }
    return ZIP_OK == err;
}
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");
	}
}
Beispiel #5
0
extern "C" bool ArchCompressMemoryW(HZIP hZip,void *lpMem,int dwSize,WCHAR *pstrFile)
{
    bool r=false;
    if ((hZip) && (((ZIPCOMPRESSION *)hZip)->bHandleType == HT_COMPRESSOR) && (lpMem) && (dwSize) && (pstrFile))
    {
        ZIPCOMPRESSION *p=(ZIPCOMPRESSION *)hZip;
        char *file=UnicodeToOemEx(pstrFile,-1);
        if (file)
        {
            p->bInMem=true;
            p->lpMem=(byte*)lpMem;
            p->dwSize=dwSize;
            zip_fileinfo zi={0};
            ///filetime(pstrSourceFile,&zi.tmz_date,&zi.dosDate);
            char *lpPassword=NULL;
            unsigned long crcFile=0;
            if (p->bEncrypted)
            {
                crcFile=crc32(0,(byte*)lpMem,dwSize);
                lpPassword=p->szPassword;
            }
            int err=zipOpenNewFileInZip3_64(p->hZip,file,&zi,NULL,0,NULL,0,NULL,(p->dwCompLevel>0) ? Z_DEFLATED:0,p->dwCompLevel,0,-MAX_WBITS,DEF_MEM_LEVEL,Z_DEFAULT_STRATEGY,lpPassword,crcFile,0);
            if (err == ZIP_OK)
            {
                if (zipWriteInFileInZip(p->hZip,lpMem,dwSize) == ZIP_OK)
                    r=true;
                err=zipCloseFileInZip(p->hZip);
            }
        }
    }
    else
        ArchSetLastError(ARCH_INVALID_PARAMETER);
    return r;
}
Beispiel #6
0
void addFileToZip(zipFile z, String filePath, String pathInZip, bool silent) {
			if(!silent)
				printf("Packaging %s as %s\n", filePath.c_str(), pathInZip.c_str());

                	zip_fileinfo zi;
                	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(filePath.c_str(),&zi.tmz_date,&zi.dosDate);
	
			zipOpenNewFileInZip(z, pathInZip.c_str(), &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, 2);

			FILE *f = fopen(filePath.c_str(), "rb");
			fseek(f, 0, SEEK_END);
			long fileSize = ftell(f);
			fseek(f, 0, SEEK_SET);
			char *buf = (char*) malloc(fileSize);
			fread(buf, fileSize, 1, f);
			zipWriteInFileInZip(z, buf, fileSize);
			free(buf);
			fclose(f);

			zipCloseFileInZip(z);

}
Beispiel #7
0
bool addByteArray( zipFile &zf, QString name, QByteArray arr, int compression=0 ){
	zip_fileinfo zi;

	zi.dosDate = 0;
	zi.internal_fa = 0;
	zi.external_fa = 0;
	
	QDateTime time = QDateTime::currentDateTimeUtc();
	setTime( zi.tmz_date, time.date(), time.time() );

	//Start file
	int err = zipOpenNewFileInZip3_64(
			zf, name.toUtf8().constData(), &zi
		,	NULL, 0, NULL, 0, NULL // comment
		, (compression != 0) ? Z_DEFLATED : 0, compression, 0
		//,	0, 0, 0
		,	-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY
		,	NULL, 0, 0  // password, crcFile, zip64);
		);
	
	//Write file
	zipWriteInFileInZip( zf, arr.constData(), arr.size() );
	
	//Finish file
	return zipCloseFileInZip( zf ) == ZIP_OK;;
}
Beispiel #8
0
int DumpMemToPack(struct ExecutionLogging* pEL,const char* filename_to_store,const void* buf,unsigned int size)
{
    zip_fileinfo zi;

    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;

    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 = 9;
    zi.tmz_date.tm_year = 2009;
    zi.tmz_date.tm_mon--;

    int err;

    err = zipOpenNewFileInZip(pEL->zf,filename_to_store,&zi,NULL,0,NULL,0,NULL /* param_list */,
                                 0,0);

    if (err==0)
    {
        err = zipWriteInFileInZip (pEL->zf,buf,size);
        err = zipCloseFileInZip(pEL->zf);
    }

    return (err==0) ? 1 : 0;
}
Beispiel #9
0
bool Zipped::zipItem(const MappedFile& item, const wchar_t* basename, int compressionLevel, unsigned long long itemFiletime)
{
    char s[MAX_BASENAME_LENGTH * 3 + 1]; //assume worst-case non-ASCII 3 bytes per character
    WideCharToMultiByte(CP_UTF8, 0, basename, -1, s, sizeof(s), 0, 0);
    zip_fileinfo fi;
    const zip_fileinfo* fip = setFileInfo(&fi, itemFiletime);
    zipOpenNewFileInZip(zip_, s, fip, 0, 0, 0, 0, 0, Z_DEFLATED, compressionLevel);

    unsigned int numMaps = item.numMaps();
    unsigned int bytesToWrite = (numMaps > 1)? mapSize_: static_cast<unsigned int>(item.size());
    unsigned long long remainingBytes = item.size();
    for (unsigned int i = 0; i < numMaps;)
    {
        const unsigned char* src = item.map(i);
        if (++i == numMaps)
        {
            bytesToWrite = static_cast<unsigned int>(remainingBytes);
        }
        zipWriteInFileInZip(zip_, src, bytesToWrite);
        remainingBytes -= bytesToWrite;
    }

    zipCloseFileInZip(zip_);
    bool ok = true;
    return ok;
}
ZipStreamWriter::~ZipStreamWriter()
{
	if (_zip)
	{
		zipCloseFileInZip(_zip);
	}
}
Beispiel #11
0
void ZipWriter::addFile(std::string name, const void* ptr, unsigned size) {
    auto t = time(nullptr);
    auto tm = *localtime(&t);
    zip_fileinfo info{{(unsigned)tm.tm_sec,
                       (unsigned)tm.tm_min,
                       (unsigned)tm.tm_hour,
                       (unsigned)tm.tm_mday,
                       (unsigned)tm.tm_mon,
                       (unsigned)tm.tm_year + 1900},
                      0,
                      0,
                      0};
    auto ret = zipOpenNewFileInZip64(_zip,
                          name.c_str(),
                          &info,
                          nullptr,
                          0,
                          nullptr,
                          0,
                          nullptr,
                          Z_DEFLATED,
                          Z_DEFAULT_COMPRESSION,
                          1);
    if (ret)
        throw std::runtime_error("can't add a new file to zip");
    ret = zipWriteInFileInZip(_zip, ptr, size);
    if (ret)
        throw std::runtime_error("can't write to zip");
    ret = zipCloseFileInZip(_zip);
    if (ret)
        throw std::runtime_error("can't save zip");
}
Beispiel #12
0
bool
write_ZIP_file(char *file_path)
{
	time_t time_secs;
	tm *local_time_ptr;
	zip_fileinfo file_info;

	// If there is no file open, do nothing.

	if (top_file_ptr == NULL)
		return(false);

	// Open the new file in the ZIP archive.

	time(&time_secs);
	local_time_ptr = localtime(&time_secs);
	file_info.tmz_date.tm_sec = local_time_ptr->tm_sec;
	file_info.tmz_date.tm_min = local_time_ptr->tm_min;
	file_info.tmz_date.tm_hour = local_time_ptr->tm_hour;
	file_info.tmz_date.tm_mday = local_time_ptr->tm_mday;
	file_info.tmz_date.tm_mon = local_time_ptr->tm_mon;
	file_info.tmz_date.tm_year = local_time_ptr->tm_year;
	file_info.dosDate = 0;
	file_info.internal_fa = 0;
	file_info.external_fa = 0;
	zipOpenNewFileInZip(zip_handle, file_path, &file_info, NULL, 0, NULL, 0,
		NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION);

	// Write the top file buffer to the new file.

	zipWriteInFileInZip(zip_handle, top_file_ptr->file_buffer,
		top_file_ptr->file_size);
	zipCloseFileInZip(zip_handle);
	return(true);
}
Beispiel #13
0
// Append a file to a zip file. The zipFile must have been already opened. fileName is the name that the file
// will be given within the zip file. ba is the data that will be in the file.
bool ZipFile::AppendFile(QString fileName, const QByteArray& ba, QString comment)
{
	if (!zf)
		return false;

	zip_fileinfo zi;
	memset(&zi, 0, sizeof(zi));

	int r = zipOpenNewFileInZip(zf,
								fileName.toAscii().constData(),
								&zi,
								NULL,
								0,
								NULL,
								0,
								comment.toAscii().constData(),
								Z_DEFLATED,
								9); // Compression level (9=max)
	if (r != ZIP_OK)
		return false;

	r = zipWriteInFileInZip(zf, ba.constData(), ba.size());
	if (r != ZIP_OK)
		return false;

	r = zipCloseFileInZip(zf);
	if (r != ZIP_OK)
		return false;

	return true;
}
Beispiel #14
0
int ZipArchiveWriter::AddFileItem(IStreamBase* inputStream, const std::string& strNameInZip, int compressFlag)
{
    if (!inputStream || !inputStream->Open())
        return -1;

    zip_fileinfo zi = {0};
    zi.dosDate = (uLong)time(nullptr);

    m_errCode = zipOpenNewFileInZip64(m_hZip, strNameInZip.c_str(), &zi, NULL, 0, NULL, 0, NULL, compressFlag, Z_DEFAULT_COMPRESSION, 1);
    if (m_errCode == ZIP_OK)
    {
        int nRead = 0;
        unsigned char buffer[32768];

        while (m_errCode == ZIP_OK)
        {
            nRead = inputStream->Read(buffer, sizeof(buffer)/sizeof(buffer[0]));
            if (nRead <= 0)
                break;

            m_errCode = zipWriteInFileInZip(m_hZip, buffer, nRead);
        }

        zipCloseFileInZip(m_hZip);

        if (m_errCode == ZIP_OK)
        {
            return 0;
        }
    }

    return -2;
}
Beispiel #15
0
Error EditorExportPlatform::_save_zip_file(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total) {

	String path = p_path.replace_first("res://", "");

	ZipData *zd = (ZipData *)p_userdata;

	zipFile zip = (zipFile)zd->zip;

	zipOpenNewFileInZip(zip,
			path.utf8().get_data(),
			NULL,
			NULL,
			0,
			NULL,
			0,
			NULL,
			Z_DEFLATED,
			Z_DEFAULT_COMPRESSION);

	zipWriteInFileInZip(zip, p_data.ptr(), p_data.size());
	zipCloseFileInZip(zip);

	if (zd->ep->step(TTR("Storing File:") + " " + p_path, 2 + p_file * 100 / p_total, false)) {
		return ERR_SKIP;
	}

	return OK;
}
/*
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);
	}
}
Beispiel #17
0
BOOL fsUploadMgr::Zip_AddFile(void *z, LPCSTR pszFile, LPCSTR pszNameInZip)
{
	zipFile zip = (zipFile) z;
	bool result = false;

	if (pszNameInZip == NULL)
	{
		pszNameInZip = strrchr (pszFile, '\\');
		if (pszNameInZip)
			pszNameInZip++;
		if (pszNameInZip == NULL)
			pszNameInZip = pszFile;
	}
	
	zip_fileinfo zfileinfo = {0};
    struct _stat file_stat = {0};

	FILE* file = fopen (pszFile, "rb");

	_fstat (_fileno (file), &file_stat);
	struct tm* file_time = localtime (&file_stat.st_mtime);
	tm_zip* zip_time = &zfileinfo.tmz_date;
	memcpy (zip_time, file_time, sizeof (tm_zip));

	const int READ_BUFFER_SIZE = 65535;
	char read_buf[READ_BUFFER_SIZE];

	wchar_t wsz [30000];
	MultiByteToWideChar (CP_ACP, 0, pszNameInZip, -1, wsz, 30000);
	char szNameInZip [30000];
	WideCharToMultiByte (CP_OEMCP, 0, wsz, -1, szNameInZip, 30000, NULL, NULL);
	
	if (ZIP_OK == zipOpenNewFileInZip (zip, szNameInZip, &zfileinfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, m_pkg.m_iZipCompressMethod))
    {
		while (!feof (file))
        {
			result = false;
			size_t count = fread (read_buf, sizeof(char), READ_BUFFER_SIZE, file);
            if (!ferror (file))
			{
				if (ZIP_OK == zipWriteInFileInZip (zip, read_buf, count))
                {
					result = true;
                    continue;
                }
                else 
					break;
            }
			else 
				break; 
		}

		result = result && (Z_OK == zipCloseFileInZip(zip));        
	}
        
	result = result && (0 == fclose (file));

	return result;
}
Beispiel #18
0
bool CDialogPackage::AddFileToPackage(const WCHAR* filePath, const WCHAR* zipPath)
{
    std::string zipPathUTF8 = StringUtil::NarrowUTF8(zipPath);
    for (int i = 0, isize = zipPathUTF8.length(); i < isize; ++i)
    {
        if (zipPathUTF8[i] == '\\')
        {
            zipPathUTF8[i] = '/';
        }
    }

    int open = zipOpenNewFileInZip(m_ZipFile, zipPathUTF8.c_str(), NULL, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION);
    if (open != ZIP_OK)
    {
        return false;
    }

    bool result = true;

    if (filePath)
    {
        HANDLE file = CreateFile(filePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,  FILE_ATTRIBUTE_NORMAL, NULL);
        if (file == INVALID_HANDLE_VALUE)
        {
            result = false;
        }
        else
        {
            do
            {
                const DWORD bufferSize = 16 * 1024;
                BYTE buffer[bufferSize];
                DWORD readSize;
                if (!ReadFile(file, buffer, bufferSize, &readSize, NULL))
                {
                    result = false;
                }
                else if (readSize != 0)
                {
                    result = zipWriteInFileInZip(m_ZipFile, buffer, (UINT)readSize) == ZIP_OK;
                }
                else
                {
                    // EOF
                    break;
                }
            }
            while (result);

            CloseHandle(file);
        }
    }
    else
    {
        // Directory entry, so nothing needs to be written.
    }

    return zipCloseFileInZip(m_ZipFile) == ZIP_OK && result;
}
Beispiel #19
0
static int hb_zipStoreFileHandle( zipFile hZip, HB_FHANDLE hFile, const char * szName, const char * szPassword, const char * szComment )
{
   char *       szZipName;
   HB_SIZE      nLen;
   zip_fileinfo zfi;
   int          iResult;
   HB_BOOL      fText;
   HB_U32       ulCRC;

   if( hFile == FS_ERROR || szName == NULL )
      return -200;

   /* change path separators to '/' */
   szZipName = hb_strdup( szName );

   nLen = strlen( szZipName );
   while( nLen-- )
   {
      if( szZipName[ nLen ] == '\\' )
         szZipName[ nLen ] = '/';
   }

   memset( &zfi, 0, sizeof( zfi ) );

   zfi.external_fa      = 0x81B60020;
   zfi.tmz_date.tm_sec  = 0;
   zfi.tmz_date.tm_min  = 0;
   zfi.tmz_date.tm_hour = 0;
   zfi.tmz_date.tm_mday = 1;
   zfi.tmz_date.tm_mon  = 0;
   zfi.tmz_date.tm_year = 0;

   ulCRC = 0;
   fText = HB_FALSE;
   if( szPassword && hb_zipGetFileInfoFromHandle( hFile, &ulCRC, &fText ) )
      zfi.internal_fa = fText ? 1 : 0;
   else
      /* TODO: zip.exe test: 0 for binary file, 1 for text. Does not depend on
         extension. We should analyse content of file to determine this??? */
      zfi.internal_fa = 0;

   iResult = zipOpenNewFileInZip3( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
                                   Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
                                   -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
                                   szPassword, ulCRC );
   if( iResult == 0 )
   {
      char * pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
      hb_fsSeek( hFile, 0, FS_SET );
      while( ( nLen = hb_fsReadLarge( hFile, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
         zipWriteInFileInZip( hZip, pString, ( unsigned ) nLen );
      hb_xfree( pString );

      zipCloseFileInZip( hZip );
   }

   hb_xfree( szZipName );
   return iResult;
}
Beispiel #20
0
PatcherError FileUtils::mzAddFile(zipFile zf,
                                  const std::string &name,
                                  const std::vector<unsigned char> &contents)
{
    // Obviously never true, but we'll keep it here just in case
    bool zip64 = (uint64_t) contents.size() >= ((1ull << 32) - 1);

    zip_fileinfo zi;
    memset(&zi, 0, sizeof(zi));

    int ret = zipOpenNewFileInZip2_64(
        zf,                     // file
        name.c_str(),           // filename
        &zi,                    // zip_fileinfo
        nullptr,                // extrafield_local
        0,                      // size_extrafield_local
        nullptr,                // extrafield_global
        0,                      // size_extrafield_global
        nullptr,                // comment
        Z_DEFLATED,             // method
        Z_DEFAULT_COMPRESSION,  // level
        0,                      // raw
        zip64                   // zip64
    );

    if (ret != ZIP_OK) {
        FLOGW("minizip: Failed to add file (error code: {}): [memory]", ret);

        return PatcherError::createArchiveError(
                ErrorCode::ArchiveWriteDataError, name);
    }

    // Write data to file
    ret = zipWriteInFileInZip(zf, contents.data(), contents.size());
    if (ret != ZIP_OK) {
        FLOGW("minizip: Failed to write data (error code: {}): [memory]", ret);
        zipCloseFileInZip(zf);

        return PatcherError::createArchiveError(
                ErrorCode::ArchiveWriteDataError, name);
    }

    zipCloseFileInZip(zf);

    return PatcherError();
}
Beispiel #21
0
void ZipFile::close()
{
	if (openMode() == NotOpen)
		return;
	
	zipCloseFileInZip(d->archive->d->zip);
	d->archive->d->currentZipFile = 0;
	setOpenMode(NotOpen);
}
//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
}
Beispiel #23
0
//-----------------------------------------------------------------------------
// CZLib::AddFile
//
// Adds a file to the zip archive
//
BOOL CZLib::AddFile(string f_file)
{
   BOOL bReturn = FALSE;

   // Open file being added
   HANDLE hFile = NULL;
   hFile = CreateFile(f_file.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   if (hFile)
   {
      // Get file creation date
      FILETIME       ft = CUtility::getLastWriteFileTime(f_file);
      zip_fileinfo   zi = {0};

      FileTimeToDosDateTime(
         &ft,                       // last write FILETIME
         ((LPWORD)&zi.dosDate)+1,   // dos date
         ((LPWORD)&zi.dosDate)+0);  // dos time

      // Trim path off file name
      string sFileName = f_file.substr(f_file.find_last_of(_T('\\')) + 1);

      // Start a new file in Zip
      if (ZIP_OK == zipOpenNewFileInZip(m_zf, 
                                        sFileName.c_str(), 
                                        &zi, 
                                        NULL, 
                                        0, 
                                        NULL, 
                                        0, 
                                        NULL, 
                                        Z_DEFLATED, 
                                        Z_BEST_COMPRESSION))
      {
         // Write file to Zip in 4 KB chunks 
         const DWORD BUFFSIZE    = 4096;
         TCHAR buffer[BUFFSIZE]  = _T("");
         DWORD dwBytesRead       = 0;

         while (ReadFile(hFile, &buffer, BUFFSIZE, &dwBytesRead, NULL)
                && dwBytesRead)
         {
            if (ZIP_OK == zipWriteInFileInZip(m_zf, buffer, dwBytesRead)
               && dwBytesRead < BUFFSIZE)
            {
               // Success
               bReturn = TRUE;
            }
         }

         bReturn &= (ZIP_OK == zipCloseFileInZip(m_zf));
      }
      
      bReturn &= CloseHandle(hFile);
   }

   return bReturn;
}
Beispiel #24
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;
}
Beispiel #25
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;
}
Beispiel #26
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;
}
Beispiel #27
0
		void ZipArchiveImpl::AddFolder(const bfs::path& path, const bfs::path& archive_path)
		{
			++m_Info.folderCount;

			zip_fileinfo fileinfo;
			fileinfo.internal_fa = 0;
#ifdef _WIN32
			fileinfo.external_fa = ::GetFileAttributesW(path.native().c_str());
#else
			{
				struct stat path_stat;
				if (::stat(path.native().c_str(), &path_stat) == 0)
				{
					fileinfo.external_fa = path_stat.st_mode;
				}
			}
#endif
			fileinfo.dosDate = 0;
			// Read the time from the filesystem and convert it
			auto fsTime = bfs::last_write_time(path);
			auto posixTime = boost::posix_time::from_time_t(fsTime);
			auto tm = boost::posix_time::to_tm(posixTime);

			/* TODO: this is how to get the time for a physfs file
			boost::posix_time::ptime posixTime;
			auto milisPastEpoc = PHYSFS_getLastModTime(path.generic_string().c_str());
			if (milisPastEpoc >= 0)
			time = boost::posix_time::ptime(boost::gregorian::date(1970, 1, 1), boost::posix_time::milliseconds(milisPastEpoc));
			else
			time = boost::posix_time::second_clock::local_time();
			*/

			fileinfo.tmz_date.tm_hour = tm.tm_hour;
			fileinfo.tmz_date.tm_min = tm.tm_min;
			fileinfo.tmz_date.tm_sec = tm.tm_sec;
			fileinfo.tmz_date.tm_year = tm.tm_year;
			fileinfo.tmz_date.tm_mon = tm.tm_mon;
			fileinfo.tmz_date.tm_mday = tm.tm_mday;

			auto r = zipOpenNewFileInZip(m_File, (archive_path.generic_string() + "/").c_str(),
				&fileinfo,
				nullptr, 0,
				nullptr, 0,
				nullptr,
				Z_DEFLATED,
				Z_BEST_SPEED);

			zipCloseFileInZip(m_File);

			for (bfs::directory_iterator it(path), end = bfs::directory_iterator(); it != end; ++it)
			{
				AddPath(it->path(), archive_path / it->path().filename());
			}
		}
Beispiel #28
0
  void ZipFile::addFile(const openstudio::path &t_localPath, const openstudio::path &t_destinationPath)
  {
    if (zipOpenNewFileInZip(m_zipFile, openstudio::toString(t_destinationPath).c_str(),
          0,
          0, 0,
          0, 0,
          0,
          Z_DEFLATED,
          Z_DEFAULT_COMPRESSION) != ZIP_OK)
    {
      throw std::runtime_error("Unable to create new file in archive: " + openstudio::toString(t_destinationPath));
    }

    try {
      std::ifstream ifs(openstudio::toString(t_localPath).c_str(), std::ios_base::in | std::ios_base::binary);

      if (!ifs.is_open() || ifs.fail())
      {
        throw std::runtime_error("Unable to open local file: " + openstudio::toString(t_localPath));
      }

      while (!ifs.eof())
      {
        std::vector<char> buffer(1024);
        ifs.read(&buffer.front(), buffer.size());
        std::streamsize bytesread = ifs.gcount();

        if (ifs.fail() && !ifs.eof())
        {
          throw std::runtime_error("Error reading from local file: " + openstudio::toString(t_localPath));
        }

        zipWriteInFileInZip(m_zipFile, &buffer.front(), static_cast<unsigned int>(bytesread));
      }
    } catch (...) {
      zipCloseFileInZip(m_zipFile);
      throw;
    }

    zipCloseFileInZip(m_zipFile);
  }
static status_t WriteZipFileAux(zipFile zf, const String & baseName, const Message & msg, int compressionLevel, zip_fileinfo * fileInfo)
{
   for (MessageFieldNameIterator iter = msg.GetFieldNameIterator(); iter.HasData(); iter++)
   {
      const String & fn = iter.GetFieldName();

      uint32 fieldType;
      if (msg.GetInfo(fn, &fieldType) != B_NO_ERROR) return B_ERROR;
      switch(fieldType)
      {
         case B_MESSAGE_TYPE:
         {
            String newBaseName = baseName;
            if ((newBaseName.HasChars())&&(newBaseName.EndsWith('/') == false)) newBaseName += '/';
            newBaseName += fn;

            // Message fields we treat as sub-directories   
            MessageRef subMsg;
            for (int32 i=0; msg.FindMessage(fn, i, subMsg) == B_NO_ERROR; i++) if (WriteZipFileAux(zf, newBaseName, *subMsg(), compressionLevel, fileInfo) != B_NO_ERROR) return B_ERROR;
         }
         break;

         case B_RAW_TYPE:
         {
            String fileName = baseName;
            if ((fileName.HasChars())&&(fileName.EndsWith('/') == false)) fileName += '/';
            fileName += fn;

            const void * data;
            uint32 numBytes;
            for (int32 i=0; msg.FindData(fn, B_RAW_TYPE, i, &data, &numBytes) == B_NO_ERROR; i++)
            {
               if (zipOpenNewFileInZip2(zf,
                                        fileName(),  // file name
                                        fileInfo,    // file info
                                        NULL,        // const void* extrafield_local,
                                        0,           // uInt size_extrafield_local,
                                        NULL,        // const void* extrafield_global,
                                        0,           // uInt size_extrafield_global,
                                        NULL,        // const char* comment,
                                        (compressionLevel>0)?Z_DEFLATED:0,  // int method,
                                        compressionLevel,  // int compressionLevel
                                        0) != ZIP_OK) return B_ERROR;
               if (zipWriteInFileInZip(zf, data, numBytes) != ZIP_OK) return B_ERROR;
               if (zipCloseFileInZip(zf) != ZIP_OK) return B_ERROR;
            }
         }
         break;
      }
   }
   return B_NO_ERROR;
}
Beispiel #30
0
static duk_ret_t dukzip_zip_close(duk_context *ctx) {
	int res = ZIP_OK;
	zipFile archive = dukzip_zip_from_this(ctx);

	res = zipCloseFileInZip(archive);

	if (res == ZIP_OK) {
		duk_push_true(ctx);
	} else {
		duk_push_false(ctx);
	}
	return 1;
}