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

int ipsw_get_file_size(const char* ipsw, const char* infile, off_t* size) {	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;	}	*size = zstat.size;	ipsw_close(archive);	return 0;}

FileNode *FileNode::createNodeForZipEntry(struct zip *zip,        const char *fname, zip_int64_t id) {    FileNode *n = new FileNode(zip, fname, id);    if (n == NULL) {        return NULL;    }    n->is_dir = false;    n->open_count = 0;    n->state = CLOSED;    struct zip_stat stat;    zip_stat_index(zip, id, 0, &stat);    // check that all used fields are valid    zip_uint64_t needValid = ZIP_STAT_NAME | ZIP_STAT_INDEX |        ZIP_STAT_SIZE | ZIP_STAT_MTIME;    // required fields are always valid for existing items or newly added    // directories (see zip_stat_index.c from libzip)    assert((stat.valid & needValid) == needValid);    n->m_mtime = n->m_atime = n->m_ctime = stat.mtime;    n->has_cretime = false;    n->m_size = stat.size;    n->parse_name();    n->processExternalAttributes();    n->processExtraFields();    return n;}

static int r_io_zip_slurp_file(RIOZipFileObj *zfo) {	struct zip_file *zFile = NULL;	struct zip *zipArch;	struct zip_stat sb;	bool res = false;	if (!zfo) {		return res;	}	zipArch = r_io_zip_open_archive (		zfo->archivename, zfo->perm,		zfo->mode, zfo->rw);	if (zipArch && zfo && zfo->entry != -1) {		zFile = zip_fopen_index (zipArch, zfo->entry, 0);		if (!zfo->b) {			zfo->b = r_buf_new ();		}		zip_stat_init (&sb);		if (zFile && zfo->b && !zip_stat_index (zipArch, zfo->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 (zfo->b, buf, sb.size);				res = true;				zfo->opened = true;				free (buf);			}		}		zip_fclose (zFile);	}	zip_close (zipArch);	return res;}

RList * r_io_zip_get_files(char *archivename, ut32 flags, int mode, int rw) {	ut64 num_entries = 0, i = 0;	struct zip * zipArch = r_io_zip_open_archive(archivename, flags, mode, rw);	struct zip_stat sb; 	RList *files = NULL; 	//eprintf("Slurping file");	if (zipArch) {		files = r_list_new();		num_entries = zip_get_num_files(zipArch);		for (i=0; i < num_entries; i++) {			char *name = NULL;				zip_stat_init(&sb );			zip_stat_index(zipArch, i, 0, &sb );				//eprintf("Comparing %s == %s = %d/n", sb.name, filename, strcmp(sb.name, filename));			name = strdup(sb.name);			if (name) {				r_list_append(files, name);			}		}	}	if (zipArch)		zip_close(zipArch);	return files;}

static int zip_enumerate(arch_enum_t e,struct arch_enum_callbacks *cb,void*arg){    if (cb->data!=NULL) Abort("cannot enumerate data");    while(e->next<e->count){        struct zip_stat sb;        int res=zip_stat_index(e->archive->archive,e->next,0,&sb);        if (res<0) {            Abort("cannot stat zip archive: %s/n",zip_strerror(e->archive->archive));        }        if(cb->new_item) {            res=cb->new_item(arg,e->next,sb.name);            if (res) {                e->next++;                return res;            }        }        if(cb->stat) {            struct archive_item_s item;            item.name=sb.name;            item.code=zip_get_file_comment(e->archive->archive,e->next,NULL,0);            item.length=sb.size;            item.compressed=sb.comp_size;            res=cb->stat(arg,e->next,&item);            if (res) {                e->next++;                return res;            }                    }        e->next++;    }    return 0;}

/* The file can be a file in the archive or ::[num].  */RIOZipFileObj* r_io_zip_alloc_zipfileobj(const char *archivename, const char *filename, ut32 perm, int mode, int rw) {	RIOZipFileObj *zfo = NULL;	ut64 i, num_entries;	struct zip_stat sb;	struct zip *zipArch = r_io_zip_open_archive (archivename, perm, mode, rw);	if (!zipArch) {		return NULL;	}	num_entries = zip_get_num_files (zipArch);	for (i = 0; i < num_entries; i++) {		zip_stat_init (&sb);		zip_stat_index (zipArch, i, 0, &sb);		if (sb.name != NULL) {			if (strcmp (sb.name, filename) == 0) {				zfo = r_io_zip_create_new_file (					archivename, filename, &sb,					perm, mode, rw);				r_io_zip_slurp_file (zfo);				break;			}		}	}	if (!zfo) {		zfo = r_io_zip_create_new_file (archivename,			filename, NULL, perm, mode, rw);	}	zip_close (zipArch);	return zfo;}

archive_t arch_zip_read(const char* name,int buf){    archive_t arch=(archive_t)HREmalloc(NULL,sizeof(struct archive_s));    arch_init(arch);    int err;    arch->archive=zip_open(name,ZIP_CHECKCONS,&err);    if (arch->archive==NULL){        char errstr[1024];        zip_error_to_str(errstr, sizeof(errstr), err, errno);        Abort("cannot open zip archive `%s': %s/n",name , errstr);    }    arch->stream_index=SIcreate();#ifdef LIBZIP_VERSION    int count=zip_get_num_entries(arch->archive,0);#else    int count=zip_get_num_files(arch->archive);#endif    for(int i=0;i<count;i++){        struct zip_stat sb;        int res=zip_stat_index(arch->archive,i,0,&sb);        if (res<0) {            Abort("cannot stat zip archive: %s/n",zip_strerror(arch->archive));        }        SIputAt(arch->stream_index,sb.name,i);        Print(infoShort,"stream %d is %s",i,sb.name);    }    arch->procs.contains=zip_contains;    arch->procs.read=hre_zip_read;    arch->procs.read_raw=hre_zip_read_raw;    arch->procs.enumerator=zip_enum;    arch->procs.close=hre_zip_close;    arch->buf=buf;    return arch;}

size_t Unzip(const char *dst_path_, const char *archive, const UnzipFileHandler& handler){    struct zip *za;    struct zip_file *zf;    struct zip_stat sb;    char buf[1024];    size_t ret = 0;    std::string dst_path = dst_path_;    int err;    if ((za = zip_open(archive, 0, &err)) == nullptr) {        zip_error_to_str(buf, sizeof(buf), err, errno);        return false;    }    for (int i = 0; i < zip_get_num_entries(za, 0); ++i) {        if (zip_stat_index(za, i, 0, &sb) == 0) {            std::string dstpath = dst_path + '/' + sb.name;            if (dstpath.back() == '/') {                std::experimental::filesystem::create_directories(dstpath.c_str());            }            else {                zf = zip_fopen_index(za, i, 0);                if (!zf) {                    goto bail_out;                }                FILE *of = fopen(dstpath.c_str(), "wb");                if (of == nullptr) {                    goto bail_out;                }                size_t sum = 0;                while (sum != sb.size) {                    size_t len = (size_t)zip_fread(zf, buf, sizeof(buf));                    if (len < 0) {                        fclose(of);                        goto bail_out;                    }                    fwrite(buf, 1, len, of);                    sum += len;                }                fclose(of);                zip_fclose(zf);                if (handler) { handler(dstpath.c_str()); }                ++ret;            }        }    }    if (zip_close(za) == -1) {        return false;    }    return ret;bail_out:    zip_close(za);    return ret;}

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

int r_io_zip_slurp_file(RIOZipFileObj *zfo) {	int res = R_FALSE;	struct zip_stat sb;	struct zip_file *zFile = NULL;	struct zip * zipArch ;	if (!zfo) return res;	zipArch = r_io_zip_open_archive (		zfo->archivename, zfo->flags,		zfo->mode, zfo->rw);	//eprintf("Slurping file");	if (zipArch && zfo && zfo->entry != -1) {		zFile = zip_fopen_index (zipArch, zfo->entry, 0);		if (!zfo->b)			zfo->b = r_buf_new ();		zip_stat_init (&sb);		if (zFile && zfo->b && !zip_stat_index(zipArch,				zfo->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 (zfo->b, buf, sb.size);				res = zfo->opened = R_TRUE;				free (buf);			}		}		zip_fclose (zFile);	}	zip_close (zipArch);	return res;}

QStringList KaraokePlayable_ZIP::enumerate(){    QStringList filelist;    // http://www.nih.at/libzip/zip_get_num_entries.html    int files = zip_get_num_entries( m_zip, ZIP_FL_UNCHANGED );    if ( files == 0 )    {        m_errorMsg = "archive has no files";        return filelist;    }    for ( int i = 0; i < files; i++ )    {        // Retrieve the file size        struct zip_stat fileinfo;        // http://www.nih.at/libzip/zip_stat_index.html        if ( zip_stat_index( m_zip, i, 0, &fileinfo) != 0 )        {            m_errorMsg = "file info not found";            return QStringList();        }        filelist.push_back( decodeFilename( fileinfo.name ) );    }    return filelist;}

QByteArray zipobject::readData(const QString& inZipPath)const{    if( NULL == m_zip){        qDebug()<<"zip unopened";        return QByteArray();    }    int index = zip_name_locate(m_zip,getCharPtr(inZipPath),0);    if( -1 == index ){        qDebug()<<"no such file : "<<inZipPath;        return QByteArray();    }    zip_file *pFile = zip_fopen_index(m_zip,index,0);    if( NULL == pFile){        qDebug()<<"fopen is NULL"<<zip_strerror(m_zip);        return QByteArray();    }    struct zip_stat stat;    int rStat = zip_stat_index(m_zip,index, 0, &stat);    if( -1 == rStat ){        qDebug()<<"stat failed : "<<zip_strerror(m_zip);        return QByteArray();    }    const int length = stat.size;    char buffer[length +1 ];    int rRead = zip_fread(pFile,buffer,sizeof(buffer));    if( -1 == rRead ){        qDebug()<<"read failed : "<<zip_strerror(m_zip);        return QByteArray();    }    return QByteArray (buffer,rRead);}

bool zipobject::extractTo(const QString& dirPath){    int num_entries = zip_get_num_files(m_zip) ;    for( int i = 0 ; i < num_entries ; ++i ){        qDebug()<<zip_get_name(m_zip,i,0);        zip_file* pFile = zip_fopen_index(m_zip,i,0);        struct zip_stat stat ;        zip_stat_index(m_zip,i,0,&stat);                const int length = stat.size ;        char buffer[length +1 ] ;        int rRead = zip_fread(pFile,buffer,sizeof(buffer));        if( -1 == rRead ){            qDebug()<<"read failed : "<<zip_strerror(m_zip);            return false;        }                QFileInfo fileInfo(dirPath + '/' + stat.name);        QDir dir = fileInfo.absoluteDir() ;        if(!dir.mkpath(".")){            return false;        }                QFile file(dirPath + '/' + stat.name);        file.open(QIODevice::WriteOnly);        file.write(QByteArray(buffer,length));        file.close();    }    return true;}

static intconfirm_replace(struct zip *za, const char *tname, int it,		struct zip *zs, const char *sname, int is){    char line[1024];    struct zip_stat st, ss;    if (confirm & CONFIRM_ALL_YES)	return 1;    else if (confirm & CONFIRM_ALL_NO)	return 0;    if (zip_stat_index(za, it, ZIP_FL_UNCHANGED, &st) < 0) {	fprintf(stderr, "%s: cannot stat file %d in `%s': %s/n",		prg, it, tname, zip_strerror(za));	return -1;    }    if (zip_stat_index(zs, is, 0, &ss) < 0) {	fprintf(stderr, "%s: cannot stat file %d in `%s': %s/n",		prg, is, sname, zip_strerror(zs));	return -1;    }    if (st.size == ss.size && st.crc == ss.crc) {	if (confirm & CONFIRM_SAME_YES)	    return 1;	else if (confirm & CONFIRM_SAME_NO)	    return 0;    }    printf("replace `%s' (%llu / %08x) in `%s'/n"	   "   with `%s' (%llu / %08x) from `%s'? ",	   st.name, st.size, st.crc, tname,	   ss.name, ss.size, ss.crc, sname);    fflush(stdout);    if (fgets(line, sizeof(line), stdin) == NULL) {	fprintf(stderr, "%s: read error from stdin: %s/n",		prg, strerror(errno));	return -1;    }    if (tolower((unsigned char)line[0]) == 'y')	return 1;    return 0;}

const char* _vdezName(struct VDirEntry* vde) {	struct VDirEntryZip* vdez = (struct VDirEntryZip*) vde;	struct zip_stat s;	if (zip_stat_index(vdez->z, vdez->index, 0, &s) < 0) {		return 0;	}	return s.name;}

bool Upgrader::unzipper(int targetfile){    bfs::path target = path(DATA) / "upgrade";    if (!verifyPath(target.c_str(), true)) {return false;}    const char *targetzip = (target / targetswitch(targetfile)).string().c_str();    struct zip *archive;    struct zip_file *zipfile;    struct zip_stat filestat;    char buffer[1024*1024];    FILE *file;    int bufferlength, err;    unsigned long long sum;    printf("Extracting %s/n", targetzip);    if ((archive = zip_open(targetzip, 0, &err)) == NULL) {        printf("Failed to open archive %s/n", targetzip);        return false;    }     for (unsigned int i = 0; i < zip_get_num_entries(archive, 0); i++)     {        if (zip_stat_index(archive, i, 0, &filestat) == 0)        {            verifyPath((target / filestat.name).parent_path(), true);            if (!is_directory(target / filestat.name))            {                zipfile = zip_fopen_index(archive, i, 0);                if (!zipfile) {                    printf("Could not open %s in archive/n", filestat.name);                    continue;                }                file = fopen((target / filestat.name).string().c_str(), "w");                 sum = 0;                while (sum != filestat.size) {                    bufferlength = zip_fread(zipfile, buffer, 1024*1024);                    fwrite(buffer, sizeof(char), bufferlength, file);                    sum += bufferlength;                }                printf("Finished extracting %s/n", filestat.name);                fclose(file);                zip_fclose(zipfile);            }        }    }    if (zip_close(archive) == -1)     {        printf("Can't close zip archive %s/n", targetzip);        return false;    }    bfs::remove(target / targetswitch(targetfile));    return true;}

ZIP_EXTERN intzip_stat(struct zip *za, const char *fname, zip_flags_t flags, struct zip_stat *st){    zip_int64_t idx;    if ((idx=zip_name_locate(za, fname, flags)) < 0)	return -1;    return zip_stat_index(za, (zip_uint64_t)idx, flags, st);}

ZIP_EXTERN intzip_stat(struct zip *za, const char *fname, int flags, struct zip_stat *st){    int idx;    if ((idx=zip_name_locate(za, fname, flags)) < 0)	return -1;    return zip_stat_index(za, idx, flags, st);}

static STRBUF *read_from_zip(const char *zipfile, const char *filename){	int r = 0;	STRBUF *content = NULL;#ifdef HAVE_LIBZIP	int zip_error;	struct zip *zip = NULL;	struct zip_stat stat;	struct zip_file *unzipped = NULL;	char *buf = NULL;	if ( !(zip = zip_open(zipfile, 0, &zip_error)) ||	     (r = zip_name_locate(zip, filename, 0)) < 0 ||	     (zip_stat_index(zip, r, ZIP_FL_UNCHANGED, &stat) < 0) ||	     !(unzipped = zip_fopen_index(zip, r, ZIP_FL_UNCHANGED)) ) {		if (unzipped)			zip_fclose(unzipped);		if (zip)			zip_close(zip);		r = -1;	}#else	r = kunzip_get_offset_by_name((char*)zipfile, (char*)filename, 3, -1);#endif	if(-1 == r) {		fprintf(stderr,			"Can't read from %s: Is it an OpenDocument Text?/n", zipfile);		exit(EXIT_FAILURE);	}#ifdef HAVE_LIBZIP	if ( !(buf = ymalloc(stat.size + 1)) ||	     (zip_fread(unzipped, buf, stat.size) != stat.size) ||	     !(content = strbuf_slurp_n(buf, stat.size)) ) {		if (buf)			yfree(buf);		content = NULL;	}	zip_fclose(unzipped);	zip_close(zip);#else	content = kunzip_next_tobuf((char*)zipfile, r);#endif	if (!content) {		fprintf(stderr,			"Can't extract %s from %s.  Maybe the file is corrupted?/n",			filename, zipfile);		exit(EXIT_FAILURE);	}	return content;}

Handle<Value> ZipFile::readFileSync(const Arguments& args) {    HandleScope scope;    if (args.Length() != 1 || !args[0]->IsString())        return ThrowException(Exception::TypeError(                                  String::New("first argument must be a file name inside the zip")));    std::string name = TOSTR(args[0]);    ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This());    struct zip_file *zf_ptr;    int idx = -1;    std::vector<std::string>::iterator it = std::find(zf->names_.begin(), zf->names_.end(), name);    if (it != zf->names_.end()) {        idx = distance(zf->names_.begin(), it);    }    if (idx == -1) {        std::stringstream s;        s << "No file found by the name of: '" << name << "/n";        return ThrowException(Exception::Error(String::New(s.str().c_str())));    }    if ((zf_ptr=zip_fopen_index(zf->archive_, idx, 0)) == NULL) {        zip_fclose(zf_ptr);        std::stringstream s;        s << "cannot open file #" << idx << " in " << name << ": archive error: " << zip_strerror(zf->archive_) << "/n";        return ThrowException(Exception::Error(String::New(s.str().c_str())));    }    struct zip_stat st;    zip_stat_index(zf->archive_, idx, 0, &st);    std::vector<unsigned char> data;    data.clear();    data.resize(st.size);    int result = 0;    result = static_cast<int>(zip_fread(zf_ptr, reinterpret_cast<void*> (&data[0]), data.size()));    if (result < 0) {        zip_fclose(zf_ptr);        std::stringstream s;        s << "error reading file #" << idx << " in " << name << ": archive error: " << zip_file_strerror(zf_ptr) << "/n";        return ThrowException(Exception::Error(String::New(s.str().c_str())));    }    node::Buffer *retbuf = Buffer::New(reinterpret_cast<char *>(&data[0]), data.size());    zip_fclose(zf_ptr);    return scope.Close(retbuf->handle_);}

void ZipFile::GetNames(){    int num = zip_get_num_files(this->archive);    this->names.clear();    this->names.reserve(num);    int i = 0;    for (i=0; i<num; i++) {        struct zip_stat st;        zip_stat_index(this->archive, i, 0, &st);        this->names.push_back(st.name);    }}

 const uint64 GetFileSize(size_t index) const override {     zip_stat_t zipFileStat;     if (zip_stat_index(_zip, index, 0, &zipFileStat) == ZIP_ER_OK)     {         return zipFileStat.size;     }     else     {         return 0;     } }

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 int S_archive_stat(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_stat stat;    int             result;    if ( ! *ar ) return 0;    if ( NULL == path ) {        result = zip_stat_index(*ar, path_idx, flags, &stat);    } else {        result = zip_stat(*ar, path, flags, &stat);    }    if ( result != 0 ) {        lua_pushnil(L);        lua_pushstring(L, zip_strerror(*ar));        return 2;    }    lua_createtable(L, 0, 8);    lua_pushstring(L, stat.name);    lua_setfield(L, -2, "name");    lua_pushinteger(L, stat.index+1);    lua_setfield(L, -2, "index");    lua_pushnumber(L, stat.crc);    lua_setfield(L, -2, "crc");    lua_pushnumber(L, stat.size);    lua_setfield(L, -2, "size");    lua_pushnumber(L, stat.mtime);    lua_setfield(L, -2, "mtime");    lua_pushnumber(L, stat.comp_size);    lua_setfield(L, -2, "comp_size");    lua_pushnumber(L, stat.comp_method);    lua_setfield(L, -2, "comp_method");    lua_pushnumber(L, stat.encryption_method);    lua_setfield(L, -2, "encryption_method");    return 1;}

	void iterateFiles(FunctorT Functor)	{		struct zip_stat Stat;		auto NumEntries = zip_get_num_entries(mZip, 0);		for (zip_uint64_t I = 0; I != NumEntries; ++I)		{			auto Error = zip_stat_index(mZip, I, 0, &Stat);			if (Error != 0) throw std::runtime_error{"Error reading zip"};			auto Length = std::char_traits<char>::length(Stat.name);			if (Length == 0 || Stat.name[Length - 1] == '/') continue;			auto File = ZipFileT{Stat.name, zip_fopen_index(mZip, I, 0)};			Functor(File);		}	}

/** * 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_;}

	PImportStream COpcPackageReader::openZIPEntryIndexed(_In_ nfUint64 nIndex)	{		zip_stat_t Stat;		nfInt32 nResult = zip_stat_index(m_ZIParchive, nIndex, ZIP_FL_UNCHANGED, &Stat);		if (nResult != 0)			throw CNMRException(NMR_ERROR_COULDNOTSTATZIPENTRY);		nfUint64 nSize = Stat.size;		zip_file_t * pFile = zip_fopen_index(m_ZIParchive, nIndex, ZIP_FL_UNCHANGED);		if (pFile == nullptr)			throw CNMRException(NMR_ERROR_COULDNOTOPENZIPENTRY);		return std::make_shared<CImportStream_ZIP>(pFile, nSize);	}

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

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