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

ZIP_EXTERN struct zip_file *zip_fopen_index_encrypted(struct zip *za, zip_uint64_t index, zip_flags_t flags,			  const char *password){    struct zip_file *zf;    struct zip_source *src;    if ((src=_zip_source_zip_new(za, za, index, flags, 0, 0, password)) == NULL)	return NULL;    if (zip_source_open(src) < 0) {	_zip_error_set_from_source(&za->error, src);	zip_source_free(src);	return NULL;    }    if ((zf=_zip_file_new(za)) == NULL) {	zip_source_free(src);	return NULL;    }    zf->src = src;    return zf;}

int r_io_zip_flush_file(RIOZipFileObj *zfo) {	int res = false;	struct zip * zipArch;	if (!zfo) {		return res;	}	zipArch = r_io_zip_open_archive (		zfo->archivename, zfo->perm, zfo->mode, zfo->rw);	if (!zipArch) {		return res;	}	struct zip_source *s = zip_source_buffer (zipArch, zfo->b->buf, zfo->b->length, 0);	if (s && zfo->entry != -1) {		if (zip_replace(zipArch, zfo->entry, s) == 0) {			res = true;		}	} else if (s && zfo->name) {		if (zip_add (zipArch, zfo->name, s) == 0) {			zfo->entry = zip_name_locate (zipArch, zfo->name, 0);			res = true;		}	}	// s (zip_source) is freed when the archive is closed, i think - dso	zip_close (zipArch);	if (s) {		zip_source_free (s);	}	return res;}

voidzip_discard(zip_t *za){    zip_uint64_t i;    if (za == NULL)	return;    if (za->src) {	zip_source_close(za->src);	zip_source_free(za->src);    }    free(za->default_password);    _zip_string_free(za->comment_orig);    _zip_string_free(za->comment_changes);    if (za->entry) {	for (i=0; i<za->nentry; i++)	    _zip_entry_finalize(za->entry+i);	free(za->entry);    }    for (i=0; i<za->nopen_source; i++) {	_zip_source_invalidate(za->open_source[i]);    }    free(za->open_source);    zip_error_fini(&za->error);        free(za);    return;}

VFSZipFileTLS* vfs_zipfile_get_tls(VFSNode *node, bool create) {	VFSZipFileData *zdata = node->data1;	VFSZipFileTLS *tls = SDL_TLSGet(zdata->tls_id);	if(tls || !create) {		return tls;	}	tls = calloc(1, sizeof(VFSZipFileTLS));	SDL_TLSSet(zdata->tls_id, tls, (void(*)(void*))vfs_zipfile_free_tls);	zip_source_t *src = zip_source_function_create(vfs_zipfile_srcfunc, node, &tls->error);	zip_t *zip = tls->zip = zip_open_from_source(src, ZIP_RDONLY, &tls->error);	// FIXME: Taisei currently doesn't handle zip files without explicit directory entries correctly (file listing will not work)	if(!zip) {		char *r = vfs_node_repr(zdata->source, true);		vfs_set_error("Failed to open zip archive '%s': %s", r, zip_error_strerror(&tls->error));		free(r);		vfs_zipfile_free_tls(tls);		SDL_TLSSet(zdata->tls_id, 0, NULL);		zip_source_free(src);		return NULL;	}	return tls;}

static intadd_from_zip(int argc, char *argv[]) {    zip_uint64_t idx, start;    zip_int64_t len;    int err;    zip_source_t *zs;    /* add from another zip file */    idx = strtoull(argv[2], NULL, 10);    start = strtoull(argv[3], NULL, 10);    len = strtoll(argv[4], NULL, 10);    if ((z_in[z_in_count]=zip_open(argv[1], ZIP_CHECKCONS, &err)) == NULL) {	zip_error_t error;	zip_error_init_with_code(&error, err);	fprintf(stderr, "can't open zip archive '%s': %s/n", argv[1], zip_error_strerror(&error));	zip_error_fini(&error);	return -1;    }    if ((zs=zip_source_zip(za, z_in[z_in_count], idx, 0, start, len)) == NULL) {	fprintf(stderr, "error creating file source from '%s' index '%" PRIu64 "': %s/n", argv[1], idx, zip_strerror(za));	zip_close(z_in[z_in_count]);	return -1;    }    if (zip_add(za, argv[0], zs) == -1) {	fprintf(stderr, "can't add file '%s': %s/n", argv[0], zip_strerror(za));	zip_source_free(zs);	zip_close(z_in[z_in_count]);	return -1;    }    z_in_count++;    return 0;}

bool add_to_zip(const char *archive, const char *file, const char *name){  struct zip *za;  struct zip_source *zs;  int err;  if ((za=zip_open(archive, ZIP_CREATE, &err)) == NULL) {    return false;  }  if ((zs=zip_source_file(za, file, 0, -1)) == NULL) {    return false;  }  if (zip_add(za, name, zs) == -1) {    zip_source_free(zs);    return false;  }  if (zip_close(za) == -1) {    return false;  }  return true;}

static VALUE zipruby_archive_add_buffer(VALUE self, VALUE name, VALUE source) {  struct zipruby_archive *p_archive;  struct zip_source *zsource;  char *data;  size_t len;  Check_Type(name, T_STRING);  Check_Type(source, T_STRING);  Data_Get_Struct(self, struct zipruby_archive, p_archive);  Check_Archive(p_archive);  len = RSTRING_LEN(source);  if ((data = malloc(len)) == NULL) {    rb_raise(rb_eRuntimeError, "Add file failed: Cannot allocate memory");  }  memset(data, 0, len);  memcpy(data, RSTRING_PTR(source), len);  if ((zsource = zip_source_buffer(p_archive->archive, data, len, 1)) == NULL) {    free(data);    rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) {    zip_source_free(zsource);    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  return Qnil;}

static intadd_file(int argc, char *argv[]) {    zip_source_t *zs;    zip_uint64_t start = strtoull(argv[2], NULL, 10);    zip_int64_t len = strtoll(argv[3], NULL, 10);    if (strcmp(argv[1], "/dev/stdin") == 0) {	if ((zs=zip_source_filep(za, stdin, start, len)) == NULL) {	    fprintf(stderr, "can't create zip_source from stdin: %s/n", zip_strerror(za));	    return -1;	}    } else {	if ((zs=zip_source_file(za, argv[1], start, len)) == NULL) {	    fprintf(stderr, "can't create zip_source from file: %s/n", zip_strerror(za));	    return -1;	}    }    if (zip_add(za, argv[0], zs) == -1) {	zip_source_free(zs);	fprintf(stderr, "can't add file '%s': %s/n", argv[0], zip_strerror(za));	return -1;    }    return 0;}

int r_io_zip_flush_file(RIOZipFileObj *zip_file_obj) {	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);  	if (!zipArch) {		return result;	}	if (zip_file_obj) {		struct zip_source *s = zip_source_buffer(zipArch, zip_file_obj->b, zip_file_obj->b->length, 0);		if (s && zip_file_obj->entry != -1) {			if (zip_replace(zipArch, zip_file_obj->entry, s) == 0)				result = R_TRUE;		}else if (s && zip_file_obj->name) {			if (zip_add(zipArch, zip_file_obj->name, s) == 0) {				zip_file_obj->entry = zip_name_locate(zipArch, zip_file_obj->name, 0);				result = R_TRUE;			}		}		if (s)			zip_source_free(s);			}	if (zipArch)		zip_close(zipArch);	return result;}

ZIP_EXTERN intzip_fclose(struct zip_file *zf){    int ret;    unsigned int i;        if (zf->src)	zip_source_free(zf->src);    if (zf->za) {        for (i=0; i<zf->za->nfile; i++) {            if (zf->za->file[i] == zf) {                zf->za->file[i] = zf->za->file[zf->za->nfile-1];                zf->za->nfile--;                break;            }        }    }    ret = 0;    if (zf->error.zip_err)	ret = zf->error.zip_err;    free(zf);    return ret;}

static VALUE zipruby_archive_add_file(int argc, VALUE *argv, VALUE self) {  VALUE name, fname;  struct zipruby_archive *p_archive;  struct zip_source *zsource;  rb_scan_args(argc, argv, "11", &name, &fname);  if (NIL_P(fname)) {    fname = name;    name = Qnil;  }  Check_Type(fname, T_STRING);  if (NIL_P(name)) {    name = rb_funcall(rb_cFile, rb_intern("basename"), 1, fname);  }  Check_Type(name, T_STRING);  Data_Get_Struct(self, struct zipruby_archive, p_archive);  Check_Archive(p_archive);  if ((zsource = zip_source_file(p_archive->archive, RSTRING_PTR(fname), 0, -1)) == NULL) {    rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) {    zip_source_free(zsource);    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  return Qnil;}

intmain(int argc, char *argv[]){    const char *archive;    const char *file;    const char *name;    zip_t *za;    zip_source_t *zs;    int err;    FILE *fp;    prg = argv[0];    if (argc != 3) {	fprintf(stderr, "usage: %s archive file/n", prg);	return 1;    }    archive = argv[1];    file = argv[2];        if ((za=zip_open(archive, ZIP_CREATE, &err)) == NULL) {	zip_error_t error;	zip_error_init_with_code(&error, err);	fprintf(stderr, "%s: can't open zip archive '%s': %s/n", prg, archive, zip_error_strerror(&error));	zip_error_fini(&error);	return 1;    }    if ((fp=fopen(file, "r")) == NULL) {	fprintf(stderr, "%s: can't open input file '%s': %s/n", prg,		file, strerror(errno));	return 1;    }    if ((zs=zip_source_filep(za, fp, 0, -1)) == NULL) {	fprintf(stderr, "%s: error creating file source for '%s': %s/n", prg,		file, zip_strerror(za));	return 1;    }    if ((name=strrchr(file, '/')) == NULL)	name = file;    if (zip_add(za, name, zs) == -1) {	zip_source_free(zs);	fprintf(stderr, "%s: can't add file '%s': %s/n", prg,		file, zip_strerror(za));	return 1;    }    if (zip_close(za) == -1) {	fprintf(stderr, "%s: can't close zip archive '%s': %s/n", prg,		archive, zip_strerror(za));	return 1;    }    return 0;}

static VALUE zipruby_archive_replace_function(int argc, VALUE *argv, VALUE self) {  VALUE index, flags, mtime;  struct zipruby_archive *p_archive;  struct zip_source *zsource;  struct read_proc *z;  int i_index, i_flags = 0;  rb_scan_args(argc, argv, "12", &index, &mtime, &flags);  rb_need_block();  if (TYPE(index) != T_STRING && !FIXNUM_P(index)) {    rb_raise(rb_eTypeError, "wrong argument type %s (expected Fixnum or String)", rb_class2name(CLASS_OF(index)));  }  if (NIL_P(mtime)) {    mtime = rb_funcall(rb_cTime, rb_intern("now"), 0);  } else if (!rb_obj_is_instance_of(mtime, rb_cTime)) {    rb_raise(rb_eTypeError, "wrong argument type %s (expected Time)", rb_class2name(CLASS_OF(mtime)));  }  if (!NIL_P(flags)) {    i_flags = NUM2INT(flags);  }  Data_Get_Struct(self, struct zipruby_archive, p_archive);  Check_Archive(p_archive);  if (FIXNUM_P(index)) {    i_index = NUM2INT(index);  } else if ((i_index = zip_name_locate(p_archive->archive, RSTRING_PTR(index), i_flags)) == -1) {    rb_raise(Error, "Replace file failed - %s: Archive does not contain a file", RSTRING_PTR(index));  }  if ((z = malloc(sizeof(struct read_proc))) == NULL) {    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(rb_eRuntimeError, "Replace failed at %d: Cannot allocate memory", i_index);  }  z->proc = rb_block_proc();  rb_ary_push(p_archive->sources, z->proc);  z->mtime = TIME2LONG(mtime);  if ((zsource = zip_source_proc(p_archive->archive, z)) == NULL) {    free(z);    rb_raise(Error, "Replace failed at %d: %s", i_index, zip_strerror(p_archive->archive));  }  if (zip_replace(p_archive->archive, i_index, zsource) == -1) {    zip_source_free(zsource);    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(Error, "Replace failed at %d: %s", i_index, zip_strerror(p_archive->archive));  }  return Qnil;}

AbstractFSProvider::status_t ZIPProvider::ZIPHandle::writeFile(const FileName & file, const std::vector<uint8_t> & data, bool overwrite) {	if (file.getFile().empty()) {		return FAILURE;	}	bool replace = false;	int index = zip_name_locate(handle, file.getPath().c_str(), 0);	if (index != -1) {		// File already exists.		if (!overwrite) {			return FAILURE;		} else {			replace = true;		}	}	// Store data temporary because libzip writes data not until zip_close.	tempStore.emplace_back(data);	zip_source * source = zip_source_buffer(handle,			tempStore.back().data(), static_cast<off_t>(tempStore.back().size()), 0);	if (source == nullptr) {		WARN(zip_strerror(handle));		zip_source_free(source);		tempStore.pop_back();		return FAILURE;	}	int newIndex;	if (replace) {		newIndex = zip_replace(handle, index, source);	} else {		newIndex = zip_add(handle, file.getPath().c_str(), source);	}	if (newIndex == -1) {		WARN(zip_strerror(handle));		zip_source_free(source);		tempStore.pop_back();		return FAILURE;	}	dataWritten = true;	return OK;}

static VALUE zipruby_archive_add_io(int argc, VALUE *argv, VALUE self) {  VALUE name, file, mtime;  struct zipruby_archive *p_archive;  struct zip_source *zsource;  struct read_io *z;  rb_scan_args(argc, argv, "11", &name, &file);  if (NIL_P(file)) {    file = name;    name = Qnil;  }  Check_IO(file);  if (NIL_P(name)) {    if (rb_obj_is_kind_of(file, rb_cFile)) {      name = rb_funcall(rb_cFile, rb_intern("basename"), 1, rb_funcall(file, rb_intern("path"), 0));    } else {      rb_raise(rb_eRuntimeError, "Add io failed - %s: Entry name is not given", RSTRING(rb_inspect(file)));    }  }  if (rb_obj_is_kind_of(file, rb_cFile)) {    mtime = rb_funcall(file, rb_intern("mtime"), 0);  } else {    mtime = rb_funcall(rb_cTime, rb_intern("now"), 0);  }  Data_Get_Struct(self, struct zipruby_archive, p_archive);  Check_Archive(p_archive);  if ((z = malloc(sizeof(struct read_io))) == NULL) {    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(rb_eRuntimeError, "Add io failed - %s: Cannot allocate memory", RSTRING(rb_inspect(file)));  }  z->io = file;  rb_ary_push(p_archive->sources, file);  z->mtime = TIME2LONG(mtime);  if ((zsource = zip_source_io(p_archive->archive, z)) == NULL) {    free(z);    rb_raise(Error, "Add io failed - %s: %s", RSTRING(rb_inspect(file)), zip_strerror(p_archive->archive));  }  if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) {    zip_source_free(zsource);    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(Error, "Add io failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  return Qnil;}

/* zipfile.addFile(nameInArchive, name, offset, len) */Handle<Value> ZipFile::Add_File(const Arguments& args){    ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This());    struct zip_source *source;    if (zf->Busy())      return ThrowException(Exception::Error(String::New("Zipfile already in use..")));    if (!args[0]->IsString())      return ThrowException(Exception::TypeError(                 String::New("Argument must be a file name.")));    std::string archive_file = TOSTR(args[0]);    std::string name;    if (args[1]->IsUndefined())      name = archive_file;    else      if (!args[1]->IsString())        return ThrowException(Exception::TypeError(                   String::New("Argument must be a file name.")));      name = TOSTR(args[1]);    zip_int64_t off;    if (args[2]->IsUndefined())      off = 0;    else      off = args[2]->Int32Value();    zip_int64_t len;    if (args[3]->IsUndefined())      len = -1;    else      len = args[3]->Int32Value();    source = zip_source_file(zf->archive, name.c_str(), off, len);    if (source == NULL) {      std::stringstream s;      s << "Error while adding file " << name << " to zip archive: " << zip_strerror(zf->archive) << "/n";      return ThrowException(Exception::Error(String::New(s.str().c_str())));    }     int ret = zip_add(zf->archive, archive_file.c_str(), source);     if (ret < 0) {      zip_source_free(source);      std::stringstream s;      s << "Error while adding file " << name << " to zip archive: " << zip_strerror(zf->archive) << "/n";      return ThrowException(Exception::Error(String::New(s.str().c_str())));    }    zf->GetNames();    return Undefined();}

intmain(int argc, char *argv[]){    const char *archive;    const char *file;    const char *name;    struct zip *za;    struct zip_source *zs;    char buf[100];    int err;    prg = argv[0];    if (argc != 3) {	fprintf(stderr, "usage: %s archive file/n", prg);	return 1;    }    archive = argv[1];    file = argv[2];        if ((za=zip_open(archive, ZIP_CREATE, &err)) == NULL) {	zip_error_to_str(buf, sizeof(buf), err, errno);	fprintf(stderr, "%s: can't open zip archive %s: %s/n", prg,		archive, buf);	return 1;    }    if ((zs=zip_source_file(za, file, 0, -1)) == NULL) {	fprintf(stderr, "%s: error creating file source for `%s': %s/n", prg,		file, zip_strerror(za));	return 1;    }    if ((name=strrchr(file, '/')) == NULL)	name = file;    if (zip_add(za, name, zs) == -1) {	zip_source_free(zs);	fprintf(stderr, "%s: can't add file `%s': %s/n", prg,		file, zip_strerror(za));	return 1;    }    if (zip_close(za) == -1) {	fprintf(stderr, "%s: can't close zip archive `%s'/n", prg,		archive);	return 1;    }    return 0;}

zip_t *_zip_open(zip_source_t *src, unsigned int flags, zip_error_t *error){    zip_t *za;    zip_cdir_t *cdir;    struct zip_stat st;    zip_uint64_t len;    zip_stat_init(&st);    if (zip_source_stat(src, &st) < 0) {	_zip_error_set_from_source(error, src);	return NULL;    }    if ((st.valid & ZIP_STAT_SIZE) == 0) {	zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);	return NULL;    }    len = st.size;    /* treat empty files as empty archives */    if (len == 0) {	if ((za=_zip_allocate_new(src, flags, error)) == NULL) {	    zip_source_free(src);	    return NULL;	}	return za;    }    if ((za=_zip_allocate_new(src, flags, error)) == NULL) {        return NULL;    }        if ((cdir = _zip_find_central_dir(za, len)) == NULL) {        _zip_error_copy(error, &za->error);	/* keep src so discard does not get rid of it */	zip_source_keep(src);	zip_discard(za);	return NULL;    }    za->entry = cdir->entry;    za->nentry = cdir->nentry;    za->nentry_alloc = cdir->nentry_alloc;    za->comment_orig = cdir->comment;        za->ch_flags = za->flags;    free(cdir);    return za;}

ZIP_EXTERN zip_int64_tzip_dir_add(struct zip *za, const char *name, zip_flags_t flags){    size_t len;    zip_int64_t idx;    char *s;    struct zip_source *source;    if (ZIP_IS_RDONLY(za)) {	_zip_error_set(&za->error, ZIP_ER_RDONLY, 0);	return -1;    }    if (name == NULL) {	_zip_error_set(&za->error, ZIP_ER_INVAL, 0);	return -1;    }    s = NULL;    len = strlen(name);    if (name[len-1] != '/') {	if ((s=(char *)malloc(len+2)) == NULL) {	    _zip_error_set(&za->error, ZIP_ER_MEMORY, 0);	    return -1;	}	strcpy(s, name);	s[len] = '/';	s[len+1] = '/0';    }    if ((source=zip_source_buffer(za, NULL, 0, 0)) == NULL) {	free(s);	return -1;    }	    idx = _zip_file_replace(za, ZIP_UINT64_MAX, s ? s : name, source, flags);    free(s);    if (idx < 0)	zip_source_free(source);    else {	if (zip_file_set_external_attributes(za, (zip_uint64_t)idx, 0, ZIP_OPSYS_DEFAULT, ZIP_EXT_ATTRIB_DEFAULT_DIR) < 0) {	    zip_delete(za, (zip_uint64_t)idx);	    return -1;	}    }    return idx;}

 void ZipFileOutput::dumpFile() {     if(m_currentFile)     {         m_bufferedFiles.push_back(m_currentFile->str());         std::string & fileContent = m_bufferedFiles.back();                  zip_source* source = zip_source_buffer(m_archiveHandle, fileContent.c_str(), fileContent.size(), 0);         if(! source)             throw FileAccessFailed(m_currentFilename, m_archive, "Failed to allocate ZLib source.");                  // check if the file exists         struct zip_stat stat;         if(zip_stat(m_archiveHandle, m_currentFilename.c_str(), 0, &stat) < 0)         {              // the file does not exist             // add it to the archive             if(zip_add(m_archiveHandle, m_currentFilename.c_str(), source) < 0)             {                 zip_source_free(source);                 throw FileAccessFailed(m_currentFilename, m_archive, "Failed to add file to zip archive.");             }         }         else         {             // the file exists             // replace it in the archive             if(zip_replace(m_archiveHandle, stat.index, source) < 0)             {                 zip_source_free(source);                 throw FileAccessFailed(m_currentFilename, m_archive, "Failed to replace file in zip archive.");             }         }                  delete m_currentFile;         m_currentFile = 0;     } }

static VALUE zipruby_archive_replace_buffer(int argc, VALUE *argv, VALUE self) {  struct zipruby_archive *p_archive;  struct zip_source *zsource;  VALUE index, source, flags;  int i_index, i_flags = 0;  char *data;  size_t len;  rb_scan_args(argc, argv, "21", &index, &source, &flags);  if (TYPE(index) != T_STRING && !FIXNUM_P(index)) {    rb_raise(rb_eTypeError, "wrong argument type %s (expected Fixnum or String)", rb_class2name(CLASS_OF(index)));  }  if (!NIL_P(flags)) {    i_flags = NUM2INT(flags);  }  Check_Type(source, T_STRING);  Data_Get_Struct(self, struct zipruby_archive, p_archive);  Check_Archive(p_archive);  if (FIXNUM_P(index)) {    i_index = NUM2INT(index);  } else if ((i_index = zip_name_locate(p_archive->archive, RSTRING_PTR(index), i_flags)) == -1) {    rb_raise(Error, "Replace file failed - %s: Archive does not contain a file", RSTRING_PTR(index));  }  len = RSTRING_LEN(source);  if ((data = malloc(len)) == NULL) {    rb_raise(rb_eRuntimeError, "Replace file failed: Cannot allocate memory");  }  memcpy(data, RSTRING_PTR(source), len);  if ((zsource = zip_source_buffer(p_archive->archive, data, len, 1)) == NULL) {    free(data);    rb_raise(Error, "Replace file failed at %d: %s", i_index, zip_strerror(p_archive->archive));  }  if (zip_replace(p_archive->archive, i_index, zsource) == -1) {    zip_source_free(zsource);    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(Error, "Replace file failed at %d: %s", i_index, zip_strerror(p_archive->archive));  }  return Qnil;}

int main(){	int err = 0;	int ret = 0;	struct zip *z = NULL;	struct zip_source *s = NULL;	if ((z = zip_open("./first.zip", ZIP_CREATE | ZIP_EXCL, &err)) == NULL) {		fprintf(stderr, "ERROR: zip_open(): [%s]/n", zip_strerror(z));	}	s = zip_source_file(z, "zip.c", 0, -1);	if(s != NULL) {		if ((ret = zip_add(z, "zip.c", s)) < 0) {			fprintf(stderr, "ERROR: zip_add(): [%s]/n", zip_strerror(z));			zip_source_free(s);		}	} else {		fprintf(stderr, "ERROR: zip_source_file(): [%s]/n", zip_strerror(z));		zip_source_free(s);	}	s = zip_source_file(z, "unzip.c", 0, -1);	if(s != NULL) {		zip_add(z, "unzip.c", s);	} else {		fprintf(stderr, "ERROR: zip_source_file(): [%s]/n", zip_strerror(z));		zip_source_free(s);	}	char strerr[1024];	if ((err = zip_close(z)) < 0) {		fprintf(stderr, "ERROR: zip_close(): [%s]/n", zip_strerror(z));	}	return 0;}

static intadd(int argc, char *argv[]) {    zip_source_t *zs;    if ((zs=zip_source_buffer(za, argv[1], strlen(argv[1]), 0)) == NULL) {	fprintf(stderr, "can't create zip_source from buffer: %s/n", zip_strerror(za));	return -1;    }    if (zip_add(za, argv[0], zs) == -1) {	zip_source_free(zs);	fprintf(stderr, "can't add file '%s': %s/n", argv[0], zip_strerror(za));	return -1;    }    return 0;}

intmain(int argc, char *argv[]){    const char *archive;    struct zip *za;    struct zip_source *zs;    char buf[100];    int err;    prg = argv[0];    if (argc != 2) {	fprintf(stderr, "usage: %s archive/n", prg);	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, "%s: can't open zip archive '%s': %s/n", prg,		archive, buf);	return 1;    }    if ((zs=zip_source_buffer(za, teststr, strlen(teststr), 0)) == NULL) {	fprintf(stderr, "%s: can't create zip_source from buffer: %s/n", prg,		zip_strerror(za));	exit(1);    }    if (zip_add(za, file, zs) == -1) {	zip_source_free(zs);	fprintf(stderr, "%s: can't add file '%s': %s/n", prg,		file, zip_strerror(za));	return 1;    }    if (zip_close(za) == -1) {	fprintf(stderr, "%s: can't close zip archive '%s': %s/n", prg,		archive, zip_strerror(za));	return 1;    }    return 0;}

static intadd_nul(int argc, char *argv[]) {    zip_source_t *zs;    zip_uint64_t length = strtoull(argv[1], NULL, 10);    if ((zs=source_nul(za, length)) == NULL) {        fprintf(stderr, "can't create zip_source for length: %s/n", zip_strerror(za));        return -1;    }    if (zip_add(za, argv[0], zs) == -1) {        zip_source_free(zs);        fprintf(stderr, "can't add file '%s': %s/n", argv[0], zip_strerror(za));        return -1;    }    return 0;}

zip_source_free(struct zip_source *src){    if (src == NULL)	return;    if (src->is_open)	zip_source_close(src);    if (src->src == NULL)	(void)src->cb.f(src->ud, NULL, 0, ZIP_SOURCE_FREE);    else {	(void)src->cb.l(src->src, src->ud, NULL, 0, ZIP_SOURCE_FREE);	zip_source_free(src->src);    }    free(src);}

void_zip_unchange_data(zip_entry_t *ze){    if (ze->source) {	zip_source_free(ze->source);	ze->source = NULL;    }    if (ze->changes != NULL && (ze->changes->changed & ZIP_DIRENT_COMP_METHOD) && ze->changes->comp_method == ZIP_CM_REPLACED_DEFAULT) {	ze->changes->changed &= ~ZIP_DIRENT_COMP_METHOD;	if (ze->changes->changed == 0) {	    _zip_dirent_free(ze->changes);	    ze->changes = NULL;	}    }    ze->deleted = 0;}

ZIP_EXTERN zip_int64_tzip_dir_add(struct zip *za, const char *name, zip_flags_t flags){    size_t len;    zip_int64_t ret;    char *s;    struct zip_source *source;    if (ZIP_IS_RDONLY(za)) {	_zip_error_set(&za->error, ZIP_ER_RDONLY, 0);	return -1;    }    if (name == NULL) {	_zip_error_set(&za->error, ZIP_ER_INVAL, 0);	return -1;    }    s = NULL;    len = strlen(name);    if (name[len-1] != '/') {	if ((s=(char *)malloc(len+2)) == NULL) {	    _zip_error_set(&za->error, ZIP_ER_MEMORY, 0);	    return -1;	}	strcpy(s, name);	s[len] = '/';	s[len+1] = '/0';    }    if ((source=zip_source_buffer(za, NULL, 0, 0)) == NULL) {	free(s);	return -1;    }	    ret = _zip_file_replace(za, ZIP_UINT64_MAX, s ? s : name, source, flags);    free(s);    if (ret < 0)	zip_source_free(source);    return ret;}

void cnpy::npz_save_data(const std::string& zipname, const std::string& name,                         const unsigned char* data, const cnpy::Type dtype,                         const size_t elemSize, const std::vector<size_t>& shape,                         const char mode){    //first, append a .npy to the fname    std::string fname(name);    fname += ".npy";    if(mode=='w' && std::ifstream(zipname).is_open())    {        // Remove the old file if present        if(std::remove(zipname.c_str())!=0)            throw std::runtime_error("Unable to overwrite "+zipname);    }    Handler<struct zip> zip = zip_open(zipname.c_str(), ZIP_CREATE, nullptr);    if(zip.handle()==nullptr)        throw std::runtime_error("Error opening npz file "+zipname);    // Remove the old array if present    int nameLookup = zip_name_locate(zip.handle(), fname.c_str(), 0);    if(nameLookup>=0 && zip_delete(zip.handle(), nameLookup)!=0)        throw std::runtime_error("Unable to overwrite "+name+" array");    std::vector<char> header = create_npy_header(dtype, elemSize, shape);    const int dataSize = std::accumulate(shape.cbegin(), shape.cend(), elemSize, std::multiplies<size_t>());    ZipSourceCallbackData cbData(header, data, dataSize);    Handler<struct zip_source> zipSource = zip_source_function(zip.handle(), zipSourceCallback, &cbData);    if(zipSource.handle()==nullptr)        throw std::runtime_error("Error creating "+name+" array");    zip_int64_t fid = zip_add(zip.handle(), fname.c_str(), zipSource.handle());    if(fid<0)    {        zip_source_free(zipSource.handle());        throw std::runtime_error("Error creating "+name+" array");    }    zip.close();}

static VALUE zipruby_archive_add_function(int argc, VALUE *argv, VALUE self) {  VALUE name, mtime;  struct zipruby_archive *p_archive;  struct zip_source *zsource;  struct read_proc *z;  rb_scan_args(argc, argv, "11", &name, &mtime);  rb_need_block();  Check_Type(name, T_STRING);  if (NIL_P(mtime)) {    mtime = rb_funcall(rb_cTime, rb_intern("now"), 0);  } else if (!rb_obj_is_instance_of(mtime, rb_cTime)) {    rb_raise(rb_eTypeError, "wrong argument type %s (expected Time)", rb_class2name(CLASS_OF(mtime)));  }  Data_Get_Struct(self, struct zipruby_archive, p_archive);  Check_Archive(p_archive);  if ((z = malloc(sizeof(struct read_proc))) == NULL) {    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(rb_eRuntimeError, "Add failed - %s: Cannot allocate memory", RSTRING_PTR(name));  }  z->proc = rb_block_proc();  rb_ary_push(p_archive->sources, z->proc);  z->mtime = TIME2LONG(mtime);  if ((zsource = zip_source_proc(p_archive->archive, z)) == NULL) {    free(z);    rb_raise(Error, "Add failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  if (zip_add(p_archive->archive, RSTRING_PTR(name), zsource) == -1) {    zip_source_free(zsource);    zip_unchange_all(p_archive->archive);    zip_unchange_archive(p_archive->archive);    rb_raise(Error, "Add file failed - %s: %s", RSTRING_PTR(name), zip_strerror(p_archive->archive));  }  return Qnil;}