Exemplo n.º 1
0
void *minizip_unpack_to_memory(void *ptr, int len, int *unpack_len)
{
  char *data = (char*)ptr;
  if (data[0]!='P'||data[1]!='K') goto unpack_to_mem_fail;
  zlib_filefunc_def pzlib_filefunc_def;
  fill_memory_filefunc(&pzlib_filefunc_def);
  char memname[128];
  sprintf(memname,"%lx+%lx", (unsigned long)ptr, (unsigned long)len);
  unzFile hFile = unzOpen2(memname,&pzlib_filefunc_def);
  if (unzGoToFirstFile(hFile) != UNZ_OK) goto unpack_to_mem_fail;
  if (unzOpenCurrentFile(hFile) != UNZ_OK) goto unpack_to_mem_fail;
  unsigned char *tot = 0;
  unsigned int n_tot=0, n_read=0;
  unsigned char buf[1024];
  while ((n_read = unzReadCurrentFile(hFile, buf, 1024)) > 0) {
    if (tot==0) tot = malloc(n_read); else tot = realloc(tot,n_tot+n_read);
    if (tot==0) goto unpack_to_mem_fail;
    memcpy(tot+n_tot,buf,n_read);
    n_tot+=n_read;
  }
  unzClose(hFile);
  *unpack_len = n_tot;
  return tot;
  unpack_to_mem_fail:
  return 0;
}
Exemplo n.º 2
0
	void Zips::add(vector<char> &data)
	{
		zlib_filefunc_def ff;
		fill_memory_filefunc(&ff);

		zmemdata dta;
		dta.data = (char*)&data.front();
		dta.size = data.size();

		unzFile zp = unzOpen2((const char*)&dta, &ff);
		OX_ASSERT(zp);
		if (!zp)
			return;
		
		_zps.push_back(zpitem());
		zpitem& item = _zps.back();
		item.handle = zp;
		swap(item.data, data);

		read(zp);
	}
Exemplo n.º 3
0
	void Zips::add(const unsigned char* data, unsigned int size)
	{
		zlib_filefunc_def ff;
		fill_memory_filefunc(&ff);
		
		zmemdata dta;
		dta.data = (char*)data;
		dta.size = size;

		unzFile zp = unzOpen2((const char*)&dta, &ff);
		OX_ASSERT(zp);
		if (!zp)
			return;


		zpitem item;
		item.handle = zp;
		_zps.push_back(item);

		read(zp);
	}
Exemplo n.º 4
0
extern "C" HZIP OpenArchiveW(WCHAR *lpstrZipFile,char *lpPassword,int dwPasswordLen,bool bZipInMem,int dwFileSize)
{
    void *r=NULL;
    if (lpstrZipFile)
    {
        ZIPDECOMPRESSION *p=(ZIPDECOMPRESSION*)_alloc(sizeof(ZIPDECOMPRESSION));
        p->bHandleType=HT_DECOMPRESSOR;
        if (p)
        {
            zlib_filefunc64_def ffunc;

            p->bInMem=bZipInMem;
            if (!bZipInMem)
                fill_fopen64_filefunc(&ffunc);
            else
            {
                fill_memory_filefunc(&ffunc);

                char filePath[30];
                wsprintfA(filePath,"%x+%x",(int)lpstrZipFile,dwFileSize);
                lpstrZipFile=(WCHAR*)filePath;
            }

            if (((lpPassword) && (dwPasswordLen > 0)))
            {
                p->bEncrypted=true;
                memcpy(p->szPassword,lpPassword,dwPasswordLen);
            }

            p->hZip=unzOpen2_64(lpstrZipFile,&ffunc);
            if (p->hZip)
                r=p;
        }
        if (!r)
            MemFree(p);
    }
    else
        ArchSetLastError(ARCH_INVALID_PARAMETER);
    return r;
}
Exemplo n.º 5
0
// Static.
MgByteReader * WriteKmz(const std::string& kml) 
{
  zlib_filefunc_def fdef;
  fill_memory_filefunc(&fdef);
  
  char buff[256];
  
  int outsize = kml.length() + 256;;
  char* outbuff = (char*)malloc(outsize);
   
  ourmemory_t *mem = (ourmemory_t *)malloc(sizeof(*mem)); 
  
  mem->base = outbuff;
  mem->size = outsize;
  mem->limit = 0;
  mem->cur_offset = 0;
   
  sprintf(buff,"%p",mem);
  zipFile zipfile_ = zipOpen2(buff, 0,0,&fdef);
  if (!zipfile_) {
    return false;
  }
  zipOpenNewFileInZip(zipfile_, "doc.kml", 0, 0, 0, 0, 0, 0, Z_DEFLATED,
                      Z_DEFAULT_COMPRESSION);
  //zipWriteInFileInZip(zipfile_, (void* const)kml.data(),
  zipWriteInFileInZip(zipfile_, static_cast<const void*>(kml.data()),
                      static_cast<unsigned int>(kml.size()));
  zipCloseFileInZip(zipfile_);
  zipClose(zipfile_, 0);
  
  
  MgByteReader *breader = new MgByteReader((unsigned char*)outbuff,mem->limit,MgMimeType::Kmz);
  
  free(outbuff);
  free(mem);
  
  return breader;
 
}
Exemplo n.º 6
0
enum ApkResult
apk_uncompress_internal(AndroidApk *apk, char **buffer, size_t *size)
{
    zlib_filefunc_def filefunc;
    fill_memory_filefunc(&filefunc);
    char *old_buffer = *buffer;
    char path[1024];
    sprintf(path, "%x+%x", *buffer, *size);

    /* Decompress a single file in a .zip from memory */
    unz_file_info info;
    unzFile *unz = unzOpen2(path, &filefunc);
    unzGoToFirstFile(unz);
    unzGetCurrentFileInfo(unz, &info, NULL, 0, NULL, 0, NULL, 0);
    *size = info.uncompressed_size;
    *buffer = malloc(*size);
    unzOpenCurrentFile(unz);
    unzReadCurrentFile(unz, *buffer, *size);
    unzCloseCurrentFile(unz);
    unzClose(unz);
    free(old_buffer);

    return APK_OK;
}
Exemplo n.º 7
0
int minizip_unpack_to_disk(char *path, void *ptr, int len)
{
  // check the magic
  char *data = (char*)ptr;
  if (data[0]!='P'||data[1]!='K') goto unpack_to_disk_fail;

  // setup the memory image
  zlib_filefunc_def pzlib_filefunc_def;
  fill_memory_filefunc(&pzlib_filefunc_def);
  char memname[128];
  sprintf(memname,"%lx+%lx", (unsigned long)ptr, (unsigned long)len);
  unzFile hFile = unzOpen2(memname,&pzlib_filefunc_def);

  // get info  
  unz_global_info  globalInfo = {0};
  if (!unzGetGlobalInfo(hFile, &globalInfo )==UNZ_OK ) goto unpack_to_disk_fail;
  int entries = globalInfo.number_entry;

  // do the unpacking 
  if (unzGoToFirstFile(hFile) != UNZ_OK) goto unpack_to_disk_fail;
  int i=0;

  while (1) {
    char fname[1024];
    char filename_inzip[256]={0};
    unz_file_info64 file_info;
    if (unzGetCurrentFileInfo64(hFile,&file_info,
          filename_inzip,sizeof(filename_inzip), 
          NULL,0,NULL,0)!=UNZ_OK) goto unpack_to_disk_fail;

    sprintf(fname,"%s%c%s", path,
      #ifdef WIN32 
      '\\'
      #else
      '/'
      #endif
      , filename_inzip);

    int fname_len = strlen(filename_inzip);
    if (filename_inzip[fname_len-1]=='/'||filename_inzip[fname_len-1]=='\\') {
      // it's a directory
      _minizip_mkdir(fname);
    } else {
      // it's a file
      if (unzOpenCurrentFile(hFile) != UNZ_OK) goto unpack_to_disk_fail;
      FILE *fd =0;
      int n_tot=0, n_read=0;
      unsigned char buf[32768];
      while ((n_read = unzReadCurrentFile(hFile, buf, 32768)) > 0) {
        if (!n_tot&&!fd&&!_minizip_file_exists(fname)) {
          DMSG("fopen %s", fname);
          fd = fopen(fname,"wb");
        } 
        if (fd) {
          DMSG("fwrite %i", n_read);
          fwrite(buf,n_read,1,fd);
        }
        n_tot+=n_read;
      }
      if (fd) { DMSG("fclose"); fclose(fd); }
      
      DMSG("%s [%i]",fname,n_tot);

      unzCloseCurrentFile(hFile);
    }

    if (++i==entries) break;
    if (unzGoToNextFile(hFile)!=UNZ_OK) goto unpack_to_disk_fail;
  }
 
  // cleanup
  unzClose(hFile);
  return 0;
  unpack_to_disk_fail:
  return 1;
}