void g_createBufferFromCompressedFile(const char* sz_file_name, unsigned char** out_p_buffer, unsigned int* out_buffer_length) { if (out_p_buffer) { *out_p_buffer = NULL; zip_file* p_file = zip_fopen(g_p_zip_file, sz_file_name, 0); if (p_file) { unsigned int length = p_file->bytes_left; unsigned char* p_buffer = malloc(length); if (p_buffer) { zip_fread(p_file, p_buffer, length); *out_p_buffer = p_buffer; if (out_buffer_length) *out_buffer_length = length; } zip_fclose(p_file); } } }
const bool CCZipFile::open(const char *file) { // Grab the APK (zip) file to access resource m_apkArchive = zip_open( CCDeviceFileManager::apkPath.buffer, 0, NULL ); if( m_apkArchive == NULL ) { DEBUGLOG( "Error loading APK" ); return false; } // It's not an image, so add res/raw/ to the path to look in the correct directory CCText fullFilePath = "res/raw/"; fullFilePath += file; // Open the supplied file as read-only m_File = zip_fopen( m_apkArchive, fullFilePath.buffer, 0 ); if( m_File != NULL ) { // Get the file size struct zip_stat stat; zip_stat( m_apkArchive, fullFilePath.buffer, 0, &stat ); m_Size = stat.size; return true; } DEBUGLOG( "Error loading file %s: %s", fullFilePath.buffer, strerror( errno ) ); return false; }
extern void *FileOpen( const char *path, int flags ) { data_source *ds; char *alt_path; ds = malloc( sizeof( *ds ) ); if( ds == NULL ) return( NULL ); ds->zf = NULL; if( srcType == DS_ZIP ) { /* First try opening the file inside a ZIP archive */ alt_path = flipBackSlashes( path ); if( alt_path != NULL ) { ds->zf = zip_fopen( srcZip, alt_path, 0 ); ds->type = DS_ZIP; free( alt_path ); } } if( ds->zf == NULL ) { /* If that fails, try opening the file directly */ ds->fhandle = open( path, flags ); ds->type = DS_FILE; } if( ds->type == DS_FILE && ds->fhandle == -1 ) { free( ds ); ds = NULL; } return( ds ); }
FILE* g_fileOpen(const char* sz_file_name, unsigned int* out_start_offset, unsigned int* out_length) { struct zip_file* p_zip_file = zip_fopen(g_p_zip_file, sz_file_name, 0); if (p_zip_file) { FILE* p_file = NULL; if (out_start_offset) *out_start_offset = p_zip_file->fpos; if (out_length) *out_length = p_zip_file->bytes_left; zip_fclose(p_zip_file); p_file = fopen(g_package_name, "rb"); fseek(p_file, p_zip_file->fpos, SEEK_SET); return p_file; } else { return NULL; } }
uint8_t * zip_read(app_t *app, const char *key, size_t *size) { struct zip_stat stat; if(!zip_stat(app->io, key, 0, &stat)) { size_t fsize = stat.size; struct zip_file *f = zip_fopen(app->io, key, 0); if(f) { uint8_t *str = malloc(fsize); if(str) { if(zip_fread(f, str, fsize) == -1) { free(str); str = NULL; fsize = 0; } else { ; //success } } zip_fclose(f); *size = fsize; return str; } } *size = 0; return NULL; }
static int S_archive_file_open(lua_State* L) { struct zip** ar = check_archive(L, 1); const char* path = (lua_isnumber(L, 2)) ? NULL : luaL_checkstring(L, 2); int path_idx = (lua_isnumber(L, 2)) ? luaL_checkint(L, 2)-1 : -1; int flags = (lua_gettop(L) < 3) ? 0 : luaL_checkint(L, 3); struct zip_file** file = (struct zip_file**) lua_newuserdata(L, sizeof(struct zip_file*)); *file = NULL; if ( ! *ar ) return 0; if ( NULL == path ) { *file = zip_fopen_index(*ar, path_idx, flags); } else { *file = zip_fopen(*ar, path, flags); } if ( ! *file ) { lua_pushnil(L); lua_pushstring(L, zip_strerror(*ar)); return 2; } luaL_getmetatable(L, ARCHIVE_FILE_MT); assert(!lua_isnil(L, -1)/* ARCHIVE_FILE_MT found? */); lua_setmetatable(L, -2); S_archive_add_ref(L, 1, 1, -1); return 1; }
void * GetFileData(const utf8 * path, size_t * outSize) const override { void * data = nullptr; size_t index = (size_t)zip_name_locate(_zip, path, 0); uint64 dataSize = GetFileSize(index); if (dataSize > 0 && dataSize < SIZE_MAX) { zip_file_t * zipFile = zip_fopen(_zip, path, 0); if (zipFile != nullptr) { data = Memory::Allocate<void>((size_t)dataSize); uint64 readBytes = zip_fread(zipFile, data, dataSize); if (readBytes != dataSize) { Memory::Free(data); data = nullptr; dataSize = 0; } zip_fclose(zipFile); } } if (outSize != nullptr) *outSize = (size_t)dataSize; return data; }
static int fzip2buffer(struct zip *fzip, int index, byte **buffer) { struct zip_stat fstat; struct zip_file *file = NULL; *buffer = NULL; zip_stat_index(fzip, index, 0, &fstat); *buffer = malloc(fstat.size); // Read zipped file if((file = zip_fopen(fzip, fstat.name, ZIP_FL_UNCHANGED))==NULL) goto error; if(zip_fread(file, *buffer, fstat.size)!=fstat.size) goto error; zip_fclose(file); file = NULL; return fstat.size; error: free(*buffer); *buffer = NULL; if(file) zip_fclose(file); return -1; }
bool ZipFileByteStream::Open(struct zip *archive, const string &path, int flags) { if ( _file != nullptr ) Close(); _file = zip_fopen(archive, path.c_str(), flags); return ( _file != nullptr ); }
ArchiveFile* ZipArchive::OpenFile(const char* name) { zip_file *zip_file = zip_fopen(zip, name, 0); if (zip_file == NULL) return NULL; return new ZipArchiveFile(zip_file); }
/** @private */ SR_PRIV int sr_sessionfile_check(const char *filename) { struct zip *archive; struct zip_file *zf; struct zip_stat zs; uint64_t version; int ret; char s[11]; if (!filename) return SR_ERR_ARG; if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { sr_err("Not a regular file: %s.", filename); return SR_ERR; } if (!(archive = zip_open(filename, 0, NULL))) /* No logging: this can be used just to check if it's * a sigrok session file or not. */ return SR_ERR; /* check "version" */ if (!(zf = zip_fopen(archive, "version", 0))) { sr_dbg("Not a sigrok session file: no version found."); zip_discard(archive); return SR_ERR; } ret = zip_fread(zf, s, sizeof(s) - 1); if (ret < 0) { sr_err("Failed to read version file: %s", zip_file_strerror(zf)); zip_fclose(zf); zip_discard(archive); return SR_ERR; } zip_fclose(zf); s[ret] = '\0'; version = g_ascii_strtoull(s, NULL, 10); if (version == 0 || version > 2) { sr_dbg("Cannot handle sigrok session file version %" PRIu64 ".", version); zip_discard(archive); return SR_ERR; } sr_spew("Detected sigrok session file version %" PRIu64 ".", version); /* read "metadata" */ if (zip_stat(archive, "metadata", 0, &zs) < 0) { sr_dbg("Not a valid sigrok session file."); zip_discard(archive); return SR_ERR; } zip_discard(archive); return SR_OK; }
ResourceManager::file ResourceManager::open(const char *filename) { #ifdef _DEBUG if(fileExists(filename)) { FILE *fp = fopen(filename, "rb"); return file(filename, fp); } #endif zip_file *zfile = zip_fopen(archive, filename, 0); return file(filename, zfile); }
char *get_contents_zip(const char *path, const char *name, time_t *last_modified) { zip_t *archive = zip_open(path, ZIP_RDONLY, NULL); if (archive == NULL) { char buffer[1024]; snprintf(buffer, 1024, "Could not open %s\n", path); engine_print(buffer); return NULL; } zip_stat_t stat; if (zip_stat(archive, name, 0, &stat) < 0) { goto close_archive; } zip_file_t *f = zip_fopen(archive, name, 0); if (f == NULL) { print_zip_err("zip_fopen", archive); goto close_archive; } if (last_modified != NULL) { *last_modified = stat.mtime; } char *buf = malloc(stat.size + 1); if (!buf) { engine_println("zip malloc"); goto close_f; } if (zip_fread(f, buf, stat.size) < 0) { print_zip_err("zip_fread", archive); goto free_buf; } buf[stat.size] = '\0'; zip_fclose(f); zip_close(archive); return buf; free_buf: free(buf); close_f: zip_fclose(f); close_archive: zip_close(archive); return NULL; }
bool ResourceManager::file::rewind() { #ifdef _DEBUG if(ffile) { ::rewind(ffile); return true; } #endif if(!zfile) return false; zip_fclose(zfile); zfile = zip_fopen(ResourceManager::instance()->archive, filename.c_str(), 0); return true; }
/** @private */ SR_PRIV int sr_sessionfile_check(const char *filename) { struct stat st; struct zip *archive; struct zip_file *zf; struct zip_stat zs; int version, ret; char s[11]; if (!filename) return SR_ERR_ARG; if (stat(filename, &st) == -1) { sr_err("Couldn't stat %s: %s", filename, g_strerror(errno)); return SR_ERR; } if (!(archive = zip_open(filename, 0, &ret))) /* No logging: this can be used just to check if it's * a sigrok session file or not. */ return SR_ERR; /* check "version" */ if (!(zf = zip_fopen(archive, "version", 0))) { sr_dbg("Not a sigrok session file: no version found."); return SR_ERR; } if ((ret = zip_fread(zf, s, 10)) == -1) return SR_ERR; zip_fclose(zf); s[ret] = 0; version = strtoull(s, NULL, 10); if (version > 2) { sr_dbg("Cannot handle sigrok session file version %d.", version); return SR_ERR; } sr_spew("Detected sigrok session file version %d.", version); /* read "metadata" */ if (zip_stat(archive, "metadata", 0, &zs) == -1) { sr_dbg("Not a valid sigrok session file."); return SR_ERR; } if ((ret = zip_close(archive)) == -1) { sr_dbg("error closing zipfile: %s", zip_strerror(archive)); return SR_ERR; } return SR_OK; }
static int do_read(struct zip *z, const char *name, int flags, enum when when_ex, int ze_ex, int se_ex) { struct zip_file *zf; enum when when_got; int err, ze_got, se_got; char b[8192]; zip_int64_t n; char expected[80]; char got[80]; when_got = WHEN_NEVER; ze_got = se_got = 0; if ((zf=zip_fopen(z, name, flags)) == NULL) { when_got = WHEN_OPEN; zip_error_get(z, &ze_got, &se_got); } else { while ((n=zip_fread(zf, b, sizeof(b))) > 0) ; if (n < 0) { when_got = WHEN_READ; zip_file_error_get(zf, &ze_got, &se_got); } err = zip_fclose(zf); if (when_got == WHEN_NEVER && err != 0) { when_got = WHEN_CLOSE; ze_got = err; se_got = 0; } } if (when_got != when_ex || ze_got != ze_ex || se_got != se_ex) { zip_error_to_str(expected, sizeof(expected), ze_ex, se_ex); zip_error_to_str(got, sizeof(got), ze_got, se_got); printf("%s: %s: got %s error (%s), expected %s error (%s)\n", prg, name, when_name[when_got], got, when_name[when_ex], expected); return 1; } else if (verbose) printf("%s: %s: passed\n", prg, name); return 0; }
struct VFile* _vdzOpenFile(struct VDir* vd, const char* path, int mode) { UNUSED(mode); // TODO: support truncating, appending and creating, and write struct VDirZip* vdz = (struct VDirZip*) vd; if ((mode & O_RDWR) == O_RDWR) { // libzip doesn't allow for random access, so read/write is impossible without // reading the entire file first. This approach will be supported eventually. return 0; } if (mode & O_WRONLY) { // Write support is not yet implemented. return 0; } struct zip_stat s; if (zip_stat(vdz->z, path, 0, &s) < 0) { return 0; } struct zip_file* zf = zip_fopen(vdz->z, path, 0); if (!zf) { return 0; } struct VFileZip* vfz = malloc(sizeof(struct VFileZip)); vfz->zf = zf; vfz->buffer = 0; vfz->offset = 0; vfz->bufferSize = 0; vfz->readSize = 0; vfz->fileSize = s.size; vfz->d.close = _vfzClose; vfz->d.seek = _vfzSeek; vfz->d.read = _vfzRead; vfz->d.readline = VFileReadline; vfz->d.write = _vfzWrite; vfz->d.map = _vfzMap; vfz->d.unmap = _vfzUnmap; vfz->d.truncate = _vfzTruncate; vfz->d.size = _vfzSize; vfz->d.sync = _vfzSync; return &vfz->d; }
int main(int argc, char *argv[]) { const char *archive; struct zip *za; struct zip_source *zs; char buf[100]; int err; if (argc != 2) { fprintf(stderr, "usage: %s archive\n", argv[0]); return 1; } archive = argv[1]; if ((za=zip_open(archive, ZIP_CREATE, &err)) == NULL) { zip_error_to_str(buf, sizeof(buf), err, errno); fprintf(stderr, "can't open zip archive '%s': %s\n", archive, buf); return 1; } if ((zs=zip_source_buffer(za, teststr, strlen(teststr), 0)) == NULL) { fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za)); exit(1); } if (zip_add(za, file, zs) == -1) { zip_source_free(zs); fprintf(stderr, "can't add file '%s': %s\n", file, zip_strerror(za)); return 1; } if (zip_fopen(za, file, ZIP_FL_UNCHANGED) == NULL) { fprintf(stderr, "can't zip_fopen file '%s': %s\n", file, zip_strerror(za)); return 1; } if (zip_close(za) == -1) { fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za)); return 1; } return 0; }
static int fs_file_open_in_zip(struct fs_file *f, const char *filename) { struct directory *d; char buf[NAME_MAX]; d = sf_list_tail(&fs.directories); get_zip_cwd(buf, NAME_MAX); strcat(buf, filename); f->isinzip = 1; if ((f->zip_file = zip_fopen(d->zip, buf, 0)) == NULL) { sf_log(SF_LOG_ERR, "failed to open %s", filename); return SF_ERR; } return SF_OK; }
uint8_t *ReadFromZip(zip *archive, const char* filename, size_t *size) { // Figure out the file size first. struct zip_stat zstat; zip_file *file = zip_fopen(archive, filename, ZIP_FL_NOCASE|ZIP_FL_UNCHANGED); if (!file) { ELOG("Error opening %s from ZIP", filename); return 0; } zip_stat(archive, filename, ZIP_FL_NOCASE|ZIP_FL_UNCHANGED, &zstat); uint8_t *contents = new uint8_t[zstat.size + 1]; zip_fread(file, contents, zstat.size); zip_fclose(file); contents[zstat.size] = 0; *size = zstat.size; return contents; }
char *get_contents_zip(char *path, char *name, time_t *last_modified) { zip_t *archive = zip_open(path, ZIP_RDONLY, NULL); if (archive == NULL) { print_zip_err("zip_open", archive); return NULL; } zip_stat_t stat; if (zip_stat(archive, name, 0, &stat) < 0) { print_zip_err("zip_stat", archive); goto close_archive; } zip_file_t *f = zip_fopen(archive, name, 0); if (f == NULL) { print_zip_err("zip_fopen", archive); goto close_archive; } if (last_modified != NULL) { *last_modified = stat.mtime; } char *buf = malloc(stat.size + 1); if (zip_fread(f, buf, stat.size) < 0) { print_zip_err("zip_fread", archive); goto free_buf; } buf[stat.size] = '\0'; zip_fclose(f); zip_close(archive); return buf; free_buf: free(buf); zip_fclose(f); close_archive: zip_close(archive); return NULL; }
QByteArray readZipFile(const char *archiveName, const char *fileName) { int error = 0; zip *archive; zip_file *file; char buffer[1024]; int readsize = 0; QByteArray ret; archive = zip_open(archiveName, 0, &error); if (!archive) { qDebug() << "Error when opening archive" << archiveName; return ret; } file = zip_fopen(archive, fileName, 0); if (!file) { qDebug() << "Error when opening file "<< fileName <<" in archive: " << archiveName <<" : " << zip_strerror(archive); zip_close(archive); return ret; } do { ret.append(buffer, readsize); readsize = zip_fread(file, buffer, 1024); } while (readsize > 0) ; if (readsize < 0) { qDebug() << "Error when reading file "<< fileName <<" in archive: " << archiveName <<" : " << zip_file_strerror(file); } zip_fclose(file); zip_close(archive); return ret; }
bool ZipFileManager::FileExists(const gs2d::str_type::string& fileName) const { if (!IsLoaded()) return false; str_type::string fixedPath = fileName; FixSlashesForUnix(fixedPath); zip_file *file = zip_fopen(m_archive, fixedPath.c_str(), 0); if (file != NULL) { zip_fclose(file); return true; } else { return false; } }
wxImage ZipEntry::LoadImage() { mutex->Lock(); if (IsDirectory()) return wxImage(); struct zip_stat stat; zip_stat(zipFile, innerPath, 0, &stat); auto file = zip_fopen(zipFile, innerPath, 0); auto size = stat.size; auto buffer = new unsigned char[size]; auto read = zip_fread(file, buffer, size); wxMemoryInputStream stream(buffer, size); wxImage output(stream); delete[] buffer; mutex->Unlock(); return output; }
//------------------------------------------------------------------------------------------------------- void Unpack::Decompress(const std::string& from, const std::string& to) { struct zip_stat zs; zip_stat(m_pAPKArchive, from.c_str(), ZIP_FL_UNCHANGED , &zs);//读取zip属性 DEBUGLOG("%s size is %d ", from.c_str(), zs.size); byte* data = NEW byte[zs.size]; zip_file* zipfile; zipfile = zip_fopen(m_pAPKArchive, from.c_str(), 0); //打开文件流 zip_fread(zipfile, data, zs.size); //读取文件 DEBUGLOG("save to %s", to.c_str()); FilePtr writeto; File::Instance().OpenFile(to.c_str(), File::FILE_WRITE, writeto); File::Instance().WriteFile(data, zs.size, 1, writeto); File::Instance().CloseFile(writeto); zip_fclose(zipfile);//关闭文件 }
/************************************************* Function: readDexFile Descroption: Input: 1.zip* z 2.filename 3.char* buf Output: Return: Other: *************************************************/ long readDexFile(struct zip* z, char* filename, unsigned char** buf) { int i; long ReadNum = 0; struct zip_stat fstat; if(z != NULL && NULL != buf) { zip_stat_init(&fstat); int c = zip_get_num_files(z); if(c > 0) { for (i = 0 ; i < c; i++) { const char* name = zip_get_name(z, i, 0); if(0 == strcmp(name,filename)) { zip_stat(z, name,0,&fstat); //LOGI("File %i:%s Size1: %lld Size2: %lld\n", i,fstat.name,fstat.size ,fstat.comp_size); struct zip_file* file = zip_fopen(z, filename, 0); if (file) { *buf =(unsigned char *)malloc(fstat.size+1); memset(*buf,0,(fstat.size+1)); ReadNum = zip_fread(file, *buf,fstat.size); zip_fclose(file); } break; } } } } else { return 0; } return ReadNum; }
bool ZipFileManager::GetFileBuffer(const str_type::string &fileName, FileBuffer &out) { if (!IsLoaded()) return false; str_type::string fixedPath = fileName; FixSlashesForUnix(fixedPath); zip_file *file = zip_fopen(m_archive, fixedPath.c_str(), 0); if (file == NULL) return false; struct zip_stat stat; zip_stat(m_archive, fixedPath.c_str(), 0, &stat); out = FileBuffer(new _FileBuffer<unsigned char>(static_cast<unsigned long>(stat.size))); zip_fread(file, out->GetAddress(), stat.size); zip_fclose(file); return true; }
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { struct zip_stat zs; struct session_vdev *vdev; int ret; vdev = sdi->priv; sr_info("Opening archive %s file %s", vdev->sessionfile, vdev->capturefile); if (!(vdev->archive = zip_open(vdev->sessionfile, 0, &ret))) { sr_err("Failed to open session file '%s': " "zip error %d\n", vdev->sessionfile, ret); return SR_ERR; } if (zip_stat(vdev->archive, vdev->capturefile, 0, &zs) == -1) { sr_err("Failed to check capture file '%s' in " "session file '%s'.", vdev->capturefile, vdev->sessionfile); return SR_ERR; } if (!(vdev->capfile = zip_fopen(vdev->archive, vdev->capturefile, 0))) { sr_err("Failed to open capture file '%s' in " "session file '%s'.", vdev->capturefile, vdev->sessionfile); return SR_ERR; } /* Send header packet to the session bus. */ std_session_send_df_header(sdi, LOG_PREFIX); /* freewheeling source */ sr_session_source_add(-1, 0, 0, receive_data, sdi); return SR_OK; }
static jstatus_t __stdcall open( struct judgefs *fs, /* out */ struct judgefs_file **file, const char *path) { struct zipfs *zipfs = (struct zipfs *)fs; struct zip_file *zip_file; int zep; EnterCriticalSection(&zipfs->zip_cs); zip_file = zip_fopen(zipfs->zip, path, ZIP_FL_NOCASE); if (zip_file) { LeaveCriticalSection(&zipfs->zip_cs); *file = (struct judgefs_file *)zip_file; judgefs_add_ref(fs); return JSTATUS_SUCCESS; } else { zip_error_get(zipfs->zip, &zep, NULL); LeaveCriticalSection(&zipfs->zip_cs); return zep_to_jstatus(zep); } }
AbstractFSProvider::status_t ZIPProvider::ZIPHandle::readFile(const FileName & file, std::vector<uint8_t> & data) { if (file.getFile().empty()) { return FAILURE; } const size_t size = fileSize(file); if (size == 0) { return FAILURE; } zip_file * fileHandle = zip_fopen(handle, file.getPath().c_str(), 0); if (fileHandle == nullptr) { WARN(zip_strerror(handle)); return FAILURE; } data.resize(size); const int bytesRead = zip_fread(fileHandle, data.data(), data.size()); if (bytesRead == -1) { WARN(zip_strerror(handle)); zip_fclose(fileHandle); return FAILURE; } if (static_cast<size_t>(bytesRead) != size) { WARN("Sizes differ during read."); zip_fclose(fileHandle); return FAILURE; } if (zip_fclose(fileHandle) == -1) { WARN(zip_strerror(handle)); return FAILURE; } return OK; }