自学教程：C++ zip_fread函数代码示例

int ipsw_extract_to_memory(const char* ipsw, const char* infile, unsigned char** pbuffer, unsigned int* psize) {	ipsw_archive* archive = ipsw_open(ipsw);	if (archive == NULL || archive->zip == NULL) {		error("ERROR: Invalid archive/n");		return -1;	}	int zindex = zip_name_locate(archive->zip, infile, 0);	if (zindex < 0) {		error("ERROR: zip_name_locate: %s/n", infile);		return -1;	}	struct zip_stat zstat;	zip_stat_init(&zstat);	if (zip_stat_index(archive->zip, zindex, 0, &zstat) != 0) {		error("ERROR: zip_stat_index: %s/n", infile);		return -1;	}	struct zip_file* zfile = zip_fopen_index(archive->zip, zindex, 0);	if (zfile == NULL) {		error("ERROR: zip_fopen_index: %s/n", infile);		return -1;	}	int size = zstat.size;	unsigned char* buffer = (unsigned char*) malloc(size+1);	if (buffer == NULL) {		error("ERROR: Out of memory/n");		zip_fclose(zfile);		return -1;	}	if (zip_fread(zfile, buffer, size) != size) {		error("ERROR: zip_fread: %s/n", infile);		zip_fclose(zfile);		free(buffer);		return -1;	}	buffer[size] = '/0';	zip_fclose(zfile);	ipsw_close(archive);	*pbuffer = buffer;	*psize = size;	return 0;}

static void zip_read(struct zip_file *file, const char *filename){	int size = 1024, n, read = 0;	char *mem = malloc(size);	while ((n = zip_fread(file, mem + read, size - read)) > 0) {		read += n;		size = read * 3 / 2;		mem = realloc(mem, size);	}	mem[read] = 0;	(void) parse_xml_buffer(filename, mem, read, &dive_table, NULL);	free(mem);}

/** * Read the contents of the first file of the ZIP file and load * it into a ModPlugFile.**/static ModPlugFile* loadZipFile(const char *path){	ModPlugFile *self_ = NULL;	int err = 0;	struct zip *zf = zip_open(path, 0, &err);	if (!zf) return NULL;	struct zip_stat sb;	// FIXME: Assumes the first file is the mod-file	if (zip_stat_index(zf, 0, 0, &sb)) {		MPSP_EPRINTF("failed to stat ZIP member: %s/n", zip_strerror(zf));		goto exit1;	}	// FIXME: Assumes the first file is the mod-file	struct zip_file *file = zip_fopen_index(zf, 0, 0);	if (!file) {		MPSP_EPRINTF("failed to open ZIP member: %s/n", zip_strerror(zf));		goto exit1;	}	void *data = malloc(sb.size);	if (!data) {		MPSP_EPRINTF("failed to allocate memory: %s/n", strerror(errno));		goto exit2;	}	if (zip_fread(file, data, sb.size) != sb.size) {		MPSP_EPRINTF("failed to read ZIP member: %s/n", zip_file_strerror(file));		goto exit3;	}	self_ = ModPlug_Load(data, sb.size);exit3:	free(data);exit2:	(void) zip_fclose(file);exit1:	(void) zip_close(zf);	return self_;}

cv::Mat ZipByteReader::Read(size_t seqId, const std::string& path, bool grayscale){    // Find index of the file in .zip file.    auto r = m_seqIdToIndex.find(seqId);    if (r == m_seqIdToIndex.end())        RuntimeError("Could not find file %s in the zip file, sequence id = %lu", path.c_str(), (long)seqId);    zip_uint64_t index = std::get<0>((*r).second);    zip_uint64_t size = std::get<1>((*r).second);    auto contents = m_workspace.pop_or_create([size]() { return vector<unsigned char>(size); });    if (contents.size() < size)        contents.resize(size);    auto zipFile = m_zips.pop_or_create([this]() { return OpenZip(); });    {        std::unique_ptr<zip_file_t, void(*)(zip_file_t*)> file(            zip_fopen_index(zipFile.get(), index, 0),            [](zip_file_t* f)            {                assert(f != nullptr);                int err = zip_fclose(f);                assert(ZIP_ER_OK == err);#ifdef NDEBUG                UNUSED(err);#endif            });        assert(nullptr != file);        if (nullptr == file)        {            RuntimeError("Could not open file %s in the zip file, sequence id = %lu, zip library error: %s",                         path.c_str(), (long)seqId, GetZipError(zip_error_code_zip(zip_get_error(zipFile.get()))).c_str());        }        assert(contents.size() >= size);        zip_uint64_t bytesRead = zip_fread(file.get(), contents.data(), size);        assert(bytesRead == size);        if (bytesRead != size)        {            RuntimeError("Bytes read %lu != expected %lu while reading file %s",                         (long)bytesRead, (long)size, path.c_str());        }    }    m_zips.push(std::move(zipFile));    cv::Mat img;     img = cv::imdecode(cv::Mat(1, (int)size, CV_8UC1, contents.data()), grayscale ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);    assert(nullptr != img.data);    m_workspace.push(std::move(contents));    return img;}

static intdo_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;}

const uint CCZipFile::read(void *dest, const uint size){	ASSERT( m_File != NULL && m_apkArchive != NULL );	// Regular file handle	const uint sz = zip_fread( m_File, dest, size );	ASSERT( sz == size );	if( sz > 0 )	{		m_Position += size;		return size;	}	ASSERT_MESSAGE( false, "File::Read(...) : ERROR! Error reading" );    return 0;}

/* {{{ php_zip_ops_read */static size_t php_zip_ops_read(php_stream *stream, char *buf, size_t count TSRMLS_DC){	int n = 0;	STREAM_DATA_FROM_STREAM();	if (self->za && self->zf) {		n = (size_t)zip_fread(self->zf, buf, (int)count);		if (n == 0) {			stream->eof = 1;		} else {			self->cursor += n;		}	}	return n<1 ? 0 : n;}

/** @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, 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" */    version = 0;    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;    }    return SR_OK;}

void ZipFile::Work_ReadFile(uv_work_t* req) {    closure_t *closure = static_cast<closure_t *>(req->data);    struct zip_file *zf_ptr = NULL;    int idx = -1;    std::vector<std::string>::iterator it = std::find(closure->zf->names_.begin(),                                                      closure->zf->names_.end(),                                                      closure->name);    if (it != closure->zf->names_.end()) {        idx = distance(closure->zf->names_.begin(), it);    }    if (idx == -1) {        std::stringstream s;        s << "No file found by the name of: '" << closure->name << "/n";        closure->error = true;        closure->error_name = s.str();    } else {        if ((zf_ptr = zip_fopen_index(closure->za, idx, 0)) == NULL) {            std::stringstream s;            s << "cannot open file #" << idx << " in "              << closure->name << ": archive error: " << zip_strerror(closure->za) << "/n";            closure->error = true;            closure->error_name = s.str();        } else {            struct zip_stat st;            zip_stat_index(closure->za, idx, 0, &st);            closure->data.clear();            closure->data.resize(st.size);            int result =  0;            result = static_cast<int>(zip_fread(zf_ptr, reinterpret_cast<void*> (&closure->data[0]), closure->data.size()));            if (result < 0) {                std::stringstream s;                s << "error reading file #" << idx << " in "                  << closure->name << ": archive error: " << zip_file_strerror(zf_ptr) << "/n";                closure->error = true;                closure->error_name = s.str();            }        }    }    zip_fclose(zf_ptr);}

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;}

ByteStream::size_type ZipFileByteStream::ReadBytes(void *buf, size_type len){    if (len == 0) return 0;    if ( _file == nullptr )        return 0;        ssize_t numRead = zip_fread(_file, buf, len);    if ( numRead < 0 )    {        Close();        return 0;    }	_eof = (_file->bytes_left == 0);        return numRead;}

extern size_t FileRead( void *handle, void *buffer, size_t length ){    data_source     *ds = handle;    size_t          amt;    switch( ds->type ) {    case DS_FILE:        amt = read( ds->fhandle, buffer, length );        break;    case DS_ZIP:        amt = zip_fread( ds->zf, buffer, length );        break;    default:        amt = 0;    }    return( amt );}

int _zip_fseek_by_reading(struct zip_file* zf, size_t toread){    char bytes[1024];    while (toread > 0) {        ssize_t numRead = zip_fread(zf, bytes, (toread < 1024 ? toread : 1024));        if (numRead < 0 )            return -1;      /* error already set */        if (numRead == 0) {            /* avoid infinite loops */            _zip_error_set(&zf->error, ZIP_ER_INCONS, 0);            return -1;        }                toread -= numRead;    }        /* zf has been updated for us by zip_fread() already */    return 0;}

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;}

static int zip_get_contents(struct zip *zf, const char *filename, int locate_flags, char **buffer, uint32_t *len){	struct zip_stat zs;	struct zip_file *zfile;	int zindex = zip_name_locate(zf, filename, locate_flags);	*buffer = NULL;	*len = 0;	if (zindex < 0) {		return -1;	}	zip_stat_init(&zs);	if (zip_stat_index(zf, zindex, 0, &zs) != 0) {		fprintf(stderr, "ERROR: zip_stat_index '%s' failed!/n", filename);		return -2;	}	if (zs.size > 10485760) {		fprintf(stderr, "ERROR: file '%s' is too large!/n", filename);		return -3;	}	zfile = zip_fopen_index(zf, zindex, 0);	if (!zfile) {		fprintf(stderr, "ERROR: zip_fopen '%s' failed!/n", filename);		return -4;	}	*buffer = malloc(zs.size);	if (zs.size > LLONG_MAX || zip_fread(zfile, *buffer, zs.size) != (zip_int64_t)zs.size) {		fprintf(stderr, "ERROR: zip_fread %" PRIu64 " bytes from '%s'/n", (uint64_t)zs.size, filename);		free(*buffer);		*buffer = NULL;		zip_fclose(zfile);		return -5;	}	*len = zs.size;	zip_fclose(zfile);	return 0;}

bool get_jar_entry(  const std::string &jar_file,  std::size_t index,  std::string &dest){  #ifdef HAVE_LIBZIP  int zip_error;    struct zip *zip=    zip_open(jar_file.c_str(), 0, &zip_error);      if(zip==NULL)    return true; // error      struct zip_file *zip_file=    zip_fopen_index(zip, index, 0);    if(zip_file==NULL)  {    zip_close(zip);    return true; // error  }  std::vector<char> buffer;  buffer.resize(ZIP_READ_SIZE);    while(true)  {    int bytes_read=      zip_fread(zip_file, buffer.data(), ZIP_READ_SIZE);    assert(bytes_read<=ZIP_READ_SIZE);    if(bytes_read<=0) break;    dest.insert(dest.end(), buffer.begin(), buffer.begin()+bytes_read);  }  zip_fclose(zip_file);      zip_close(zip);    return false;  #else  return true;  #endif}

/** * Read metadata entries from a session archive. * * @param[in] archive An open ZIP archive. * @param[in] entry Stat buffer filled in for the metadata archive member. * * @return A new key/value store containing the session metadata. * * @private */SR_PRIV GKeyFile *sr_sessionfile_read_metadata(struct zip *archive,			const struct zip_stat *entry){	GKeyFile *keyfile;	GError *error;	struct zip_file *zf;	char *metabuf;	int metalen;	if (entry->size > G_MAXINT || !(metabuf = g_try_malloc(entry->size))) {		sr_err("Metadata buffer allocation failed.");		return NULL;	}	zf = zip_fopen_index(archive, entry->index, 0);	if (!zf) {		sr_err("Failed to open metadata: %s", zip_strerror(archive));		g_free(metabuf);		return NULL;	}	metalen = zip_fread(zf, metabuf, entry->size);	if (metalen < 0) {		sr_err("Failed to read metadata: %s", zip_file_strerror(zf));		zip_fclose(zf);		g_free(metabuf);		return NULL;	}	zip_fclose(zf);	keyfile = g_key_file_new();	error = NULL;	g_key_file_load_from_data(keyfile, metabuf, metalen,			G_KEY_FILE_NONE, &error);	g_free(metabuf);	if (error) {		sr_err("Failed to parse metadata: %s", error->message);		g_error_free(error);		g_key_file_free(keyfile);		return NULL;	}	return keyfile;}

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;}

void *ResourceManager::loadFile(const char *filename, int &fsize) {#ifdef _DEBUG	if(fileExists(filename)) 		return ::loadFile(filename, fsize);#endif	int fidx = zip_name_locate(archive, filename, 0);	if( fidx == -1)		return 0;	struct zip_stat st;	if( zip_stat_index(archive, fidx, 0, &st) == -1 )		return 0;	zip_file *zfile = zip_fopen_index(archive, fidx, 0);	if (!zfile)		return 0;	char *buffer = new char[ st.size+1 ];	if(!buffer)		return 0;	int size = st.size;	char *buf = buffer;	while(size > 0) {		ssize_t rs = zip_fread(zfile, buf, std::min(size, 0x8000) );		if(rs <= 0) {			zip_fclose(zfile);			delete buffer;			return 0;		}		buf += rs;		size -= rs;	}	buffer[st.size] = 0;	zip_fclose(zfile);	fsize = st.size;	return buffer;}

static intcat(int argc, char *argv[]) {    /* output file contents to stdout */    zip_uint64_t idx;    zip_int64_t n;    zip_file_t *zf;    char buf[8192];    int err;    idx = strtoull(argv[0], NULL, 10);#ifdef _WIN32    /* Need to set stdout to binary mode for Windows */    setmode(fileno(stdout), _O_BINARY);#endif    if ((zf=zip_fopen_index(za, idx, 0)) == NULL) {	fprintf(stderr, "can't open file at index '%" PRIu64 "': %s/n", idx, zip_strerror(za));	return -1;    }    while ((n=zip_fread(zf, buf, sizeof(buf))) > 0) {	if (fwrite(buf, (size_t)n, 1, stdout) != 1) {	    zip_fclose(zf);	    fprintf(stderr, "can't write file contents to stdout: %s/n", strerror(errno));	    return -1;	}    }    if (n == -1) {	zip_fclose(zf);	fprintf(stderr, "can't read file at index '%" PRIu64 "': %s/n", idx, zip_file_strerror(zf));	return -1;    }    if ((err = zip_fclose(zf)) != 0) {	zip_error_t error;	zip_error_init_with_code(&error, err);	fprintf(stderr, "can't close file at index '%" PRIu64 "': %s/n", idx, zip_error_strerror(&error));	return -1;    }    return 0;}

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;}

/* {{{ php_zip_ops_read */static size_t php_zip_ops_read(php_stream *stream, char *buf, size_t count TSRMLS_DC){	int n = 0;	STREAM_DATA_FROM_STREAM();	if (self->za && self->zf) {		n = (size_t)zip_fread(self->zf, buf, (int)count);		if (n < 0) {			int ze, se;			zip_file_error_get(self->zf, &ze, &se);			stream->eof = 1;			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zip stream error: %s", zip_file_strerror(self->zf));			return 0;		}		if (n == 0 || n < count) {			stream->eof = 1;		} else {			self->cursor += n;		}	}	return n<1 ? 0 : n;}

static int S_archive_file_read(lua_State* L) {    struct zip_file** file = check_archive_file(L, 1);    int               len  = luaL_checkint(L, 2);    char*             buff;    if ( len <= 0 ) luaL_argerror(L, 2, "Must be > 0");    if ( ! *file ) return 0;    buff = (char*)lua_newuserdata(L, len);    len = zip_fread(*file, buff, len);    if ( -1 == len ) {        lua_pushnil(L);        lua_pushstring(L, zip_file_strerror(*file));        return 2;    }    lua_pushlstring(L, buff, len);    return 1;}

std::string jar_filet::get_entry(std::size_t i){  if(zip==nullptr)    return std::string("");  assert(i<index.size());  std::string dest;  #ifdef HAVE_LIBZIP  struct zip_file *zip_file=    zip_fopen_index(static_cast<struct zip *>(zip), i, 0);  if(zip_file==NULL)  {    zip_close(static_cast<struct zip *>(zip));    zip=nullptr;    return std::string(""); // error  }  std::vector<char> buffer;  buffer.resize(ZIP_READ_SIZE);  while(true)  {    int bytes_read=      zip_fread(zip_file, buffer.data(), ZIP_READ_SIZE);    assert(bytes_read<=ZIP_READ_SIZE);    if(bytes_read<=0) break;    dest.insert(dest.end(), buffer.begin(), buffer.begin()+bytes_read);  }  zip_fclose(zip_file);  #endif  return dest;}

int r_io_zip_slurp_file(RIOZipFileObj *zip_file_obj) {	struct zip_file *zFile = NULL;	int result = R_FALSE;	struct zip * zipArch = r_io_zip_open_archive(zip_file_obj->archivename, zip_file_obj->flags, zip_file_obj->mode, zip_file_obj->rw);	struct zip_stat sb; 	//eprintf("Slurping file");	if (zip_file_obj && zip_file_obj->entry != -1) {		zFile = zip_fopen_index(zipArch, zip_file_obj->entry, 0);		if (!zip_file_obj->b) {			zip_file_obj->b = r_buf_new();		}		zip_stat_init(&sb);		if (zFile && zip_file_obj->b && !zip_stat_index(zipArch, zip_file_obj->entry, 0, &sb) ) {			ut8 *buf = malloc(sb.size);			memset(buf, 0, sb.size);			if (buf) {							zip_fread(zFile, buf, sb.size);				r_buf_set_bytes(zip_file_obj->b, buf, sb.size);				zip_file_obj->opened = 1;				result = R_TRUE;			}			if (buf)				free(buf);		}		if (zFile) {			zip_fclose(zFile);		}	}	if (zipArch)		zip_close(zipArch);	return result;}

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;}