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;
}
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;
}
bool zipobject::writeData(const QByteArray& data,const QString& inZipPath){
TEST_ZIP;
int length=data.length();
void* p=new char[length+1];
// 此处不得不复制。
// 由于 libzip 只会在 close 的时候才会真正将数据写入zip文件
// 如果不复制，写入数据时 data 已经析构，数据内容全部为空
memcpy(p,data.constData(),length);
zip_source* pSource = zip_source_buffer(m_zip,p,length,1);
if(NULL == pSource){
const char* pStr = zip_strerror(m_zip);
qDebug()<<"create source failed : "<<pStr;
return false;
}else{
int index = zip_name_locate(m_zip,getCharPtr(inZipPath),0);
if( -1 == index ){
int rAdd = zip_add(m_zip,getCharPtr(inZipPath),pSource);
if( -1 == rAdd ){
qDebug()<<"add source failed : "<<zip_strerror(m_zip);
}
return -1 == rAdd ;
}else{
int rReplace = zip_replace(m_zip,index,pSource);
if( -1 == rReplace ){
qDebug()<<"replace source failed : "<<zip_strerror(m_zip);
}
return -1 == rReplace ;
}
}
}
int
main(int argc, char *argv[])
{
int fail, ze;
struct zip *z;
struct zip_source *zs;
char *archive;
char errstr[1024];
fail = 0;
prg = argv[0];
if (argc != 2) {
fprintf(stderr, "usage: %s archive\n", prg);
return 1;
}
archive = argv[1];
if ((z=zip_open(archive, 0, &ze)) == NULL) {
zip_error_to_str(errstr, sizeof(errstr), ze, errno);
printf("%s: opening zip archive ``%s'' failed: %s\n",
prg, archive, errstr);
return 1;
}
fail += do_read(z, "storedok", 0, WHEN_NEVER, 0, 0);
fail += do_read(z, "deflateok", 0, WHEN_NEVER, 0, 0);
fail += do_read(z, "storedcrcerror", 0, WHEN_READ, ZIP_ER_CRC, 0);
fail += do_read(z, "deflatecrcerror", 0, WHEN_READ, ZIP_ER_CRC, 0);
fail += do_read(z, "deflatezliberror", 0, WHEN_READ, ZIP_ER_ZLIB, -3);
fail += do_read(z, NULL, 0, WHEN_OPEN, ZIP_ER_INVAL, 0);
fail += do_read(z, "nosuchfile", 0, WHEN_OPEN, ZIP_ER_NOENT, 0);
fail += do_read(z, "deflatezliberror", ZIP_FL_COMPRESSED, WHEN_NEVER, 0,0);
fail += do_read(z, "deflatecrcerror", ZIP_FL_COMPRESSED, WHEN_NEVER, 0, 0);
fail += do_read(z, "storedcrcerror", ZIP_FL_COMPRESSED,
WHEN_READ, ZIP_ER_CRC, 0);
fail += do_read(z, "storedok", ZIP_FL_COMPRESSED, WHEN_NEVER, 0, 0);
zs = zip_source_buffer(z, "asdf", 4, 0);
zip_replace(z, zip_name_locate(z, "storedok", 0), zs);
fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
zip_delete(z, zip_name_locate(z, "storedok", 0));
fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_NOENT, 0);
fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
zs = zip_source_buffer(z, "asdf", 4, 0);
zip_add(z, "new_file", zs);
fail += do_read(z, "new_file", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
zip_unchange_all(z);
if (zip_close(z) == -1) {
fprintf(stderr, "%s: can't close zip archive `%s'\n", prg, archive);
return 1;
}
exit(fail ? 1 : 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;
}
void SetFileData(const utf8 * path, void * data, size_t dataSize) override
{
zip_source_t * source = zip_source_buffer(_zip, data, dataSize, 0);
sint64 index = zip_name_locate(_zip, path, 0);
if (index == -1)
{
zip_add(_zip, path, source);
}
else
{
zip_replace(_zip, index, source);
}
}
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;
}
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 int S_archive_replace(lua_State* L) {
struct zip** ar = check_archive(L, 1);
int idx = luaL_checkinteger(L, 2);
struct zip_source* src = S_create_source(L, *ar);
if ( ! *ar ) return 0;
idx = zip_replace(*ar, idx-1, src) + 1;
if ( 0 == idx ) {
zip_source_free(src);
lua_pushstring(L, zip_strerror(*ar));
lua_error(L);
}
S_archive_add_ref(L, 0, 1, 4);
lua_pushinteger(L, idx);
return 1;
}
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 int
merge_zip(struct zip *za, const char *tname, const char *sname,
struct zip **zsp)
{
struct zip *zs;
struct zip_source *source;
int i, idx, err;
char errstr[1024];
const char *fname;
if ((zs=zip_open(sname, 0, &err)) == NULL) {
zip_error_to_str(errstr, sizeof(errstr), err, errno);
fprintf(stderr, "%s: cannot open zip archive `%s': %s\n",
prg, sname, errstr);
return -1;
}
for (i=0; i<zip_get_num_files(zs); i++) {
fname = zip_get_name(zs, i, 0);
if ((idx=zip_name_locate(za, fname, name_flags)) != -1) {
switch (confirm_replace(za, tname, idx, zs, sname, i)) {
case 0:
break;
case 1:
if ((source=zip_source_zip(za, zs, i, 0, 0, 0)) == NULL
|| zip_replace(za, idx, source) < 0) {
zip_source_free(source);
fprintf(stderr,
"%s: cannot replace `%s' in `%s': %s\n",
prg, fname, tname, zip_strerror(za));
return -1;
}
break;
case -1:
zip_close(zs);
return -1;
default:
fprintf(stderr, "%s: internal error: "
"unexpected return code from confirm (%d)\n",
prg, err);
zip_close(zs);
return -1;
}
}
else {
if ((source=zip_source_zip(za, zs, i, 0, 0, 0)) == NULL
|| zip_add(za, fname, source) < 0) {
zip_source_free(source);
fprintf(stderr,
"%s: cannot add `%s' to `%s': %s\n",
prg, fname, tname, zip_strerror(za));
zip_close(zs);
return -1;
}
}
}
*zsp = zs;
return 0;
}
static int zip_append(const struct sr_output *o, unsigned char *buf,
int unitsize, int length)
{
struct out_context *outc;
struct zip *archive;
struct zip_source *logicsrc;
zip_int64_t num_files;
struct zip_file *zf;
struct zip_stat zs;
struct zip_source *metasrc;
GKeyFile *kf;
GError *error;
gsize len;
int chunk_num, next_chunk_num, tmpfile, ret, i;
const char *entry_name;
char *metafile, tmpname[32], chunkname[16];
outc = o->priv;
if (!(archive = zip_open(outc->filename, 0, &ret)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) == -1)
return SR_ERR;
metafile = g_malloc(zs.size);
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
/*
* If the file was only initialized but doesn't yet have any
* data it in, it won't have a unitsize field in metadata yet.
*/
error = NULL;
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, &error)) {
sr_err("Failed to parse metadata: %s.", error->message);
return SR_ERR;
}
g_free(metafile);
tmpname[0] = '\0';
if (!g_key_file_has_key(kf, "device 1", "unitsize", &error)) {
if (error && error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
sr_err("Failed to check unitsize key: %s", error ? error->message : "?");
return SR_ERR;
}
/* Add unitsize field. */
g_key_file_set_integer(kf, "device 1", "unitsize", unitsize);
metafile = g_key_file_to_data(kf, &len, &error);
strcpy(tmpname, "sigrok-meta-XXXXXX");
if ((tmpfile = g_mkstemp(tmpname)) == -1)
return SR_ERR;
if (write(tmpfile, metafile, len) < 0) {
sr_dbg("Failed to create new metadata: %s", strerror(errno));
g_free(metafile);
unlink(tmpname);
return SR_ERR;
}
close(tmpfile);
if (!(metasrc = zip_source_file(archive, tmpname, 0, -1))) {
sr_err("Failed to create zip source for metadata.");
g_free(metafile);
unlink(tmpname);
return SR_ERR;
}
if (zip_replace(archive, zs.index, metasrc) == -1) {
sr_err("Failed to replace metadata file.");
g_free(metafile);
unlink(tmpname);
return SR_ERR;
}
g_free(metafile);
}
g_key_file_free(kf);
next_chunk_num = 1;
num_files = zip_get_num_entries(archive, 0);
for (i = 0; i < num_files; i++) {
entry_name = zip_get_name(archive, i, 0);
if (strncmp(entry_name, "logic-1", 7))
continue;
if (strlen(entry_name) == 7) {
/* This file has no extra chunks, just a single "logic-1".
* Rename it to "logic-1-1" * and continue with chunk 2. */
if (zip_rename(archive, i, "logic-1-1") == -1) {
sr_err("Failed to rename 'logic-1' to 'logic-1-1'.");
unlink(tmpname);
return SR_ERR;
}
next_chunk_num = 2;
break;
} else if (strlen(entry_name) > 8 && entry_name[7] == '-') {
chunk_num = strtoull(entry_name + 8, NULL, 10);
if (chunk_num >= next_chunk_num)
next_chunk_num = chunk_num + 1;
}
}
snprintf(chunkname, 15, "logic-1-%d", next_chunk_num);
if (!(logicsrc = zip_source_buffer(archive, buf, length, FALSE))) {
unlink(tmpname);
return SR_ERR;
}
if (zip_add(archive, chunkname, logicsrc) == -1) {
unlink(tmpname);
return SR_ERR;
}
if ((ret = zip_close(archive)) == -1) {
sr_info("error saving session file: %s", zip_strerror(archive));
unlink(tmpname);
return SR_ERR;
}
unlink(tmpname);
return SR_OK;
}
static VALUE zipruby_archive_update(int argc, VALUE *argv, VALUE self) {
struct zipruby_archive *p_archive, *p_srcarchive;
VALUE srcarchive, flags;
int i, num_files, i_flags = 0;
rb_scan_args(argc, argv, "11", &srcarchive, &flags);
if (!rb_obj_is_instance_of(srcarchive, Archive)) {
rb_raise(rb_eTypeError, "wrong argument type %s (expected Zip::Archive)", rb_class2name(CLASS_OF(srcarchive)));
}
if (!NIL_P(flags)) {
i_flags = NUM2INT(flags);
}
Data_Get_Struct(self, struct zipruby_archive, p_archive);
Check_Archive(p_archive);
Data_Get_Struct(srcarchive, struct zipruby_archive, p_srcarchive);
Check_Archive(p_srcarchive);
num_files = zip_get_num_files(p_srcarchive->archive);
for (i = 0; i < num_files; i++) {
struct zip_source *zsource;
struct zip_file *fzip;
struct zip_stat sb;
char *buf;
const char *name;
int index, error;
zip_stat_init(&sb);
if (zip_stat_index(p_srcarchive->archive, i, 0, &sb)) {
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_srcarchive->archive));
}
if ((buf = malloc(sb.size)) == NULL) {
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(rb_eRuntimeError, "Update archive failed: Cannot allocate memory");
}
fzip = zip_fopen_index(p_srcarchive->archive, i, 0);
if (fzip == NULL) {
free(buf);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_srcarchive->archive));
}
if (zip_fread(fzip, buf, sb.size) == -1) {
free(buf);
zip_fclose(fzip);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_file_strerror(fzip));
}
if ((error = zip_fclose(fzip)) != 0) {
char errstr[ERRSTR_BUFSIZE];
free(buf);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
zip_error_to_str(errstr, ERRSTR_BUFSIZE, error, errno);
rb_raise(Error, "Update archive failed: %s", errstr);
}
if ((zsource = zip_source_buffer(p_archive->archive, buf, sb.size, 1)) == NULL) {
free(buf);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_archive->archive));
}
if ((name = zip_get_name(p_srcarchive->archive, i, 0)) == NULL) {
zip_source_free(zsource);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_srcarchive->archive));
}
index = zip_name_locate(p_archive->archive, name, i_flags);
if (index >= 0) {
if (zip_replace(p_archive->archive, i, zsource) == -1) {
zip_source_free(zsource);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_archive->archive));
}
} else {
if (zip_add(p_archive->archive, name, zsource) == -1) {
zip_source_free(zsource);
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Update archive failed: %s", zip_strerror(p_archive->archive));
}
}
}
return Qnil;
}
/* zipfile.replaceFile(nameInArchive, name, offset, len) */
Handle<Value> ZipFile::Replace_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();
int idx = -1;
std::vector<std::string>::iterator it = std::find(zf->names.begin(), zf->names.end(), archive_file);
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: '" << archive_file << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
source = zip_source_file(zf->archive, name.c_str(), off, len);
if (source == NULL) {
std::stringstream s;
s << "Error while replacing file " << name << " in zip archive: " << zip_strerror(zf->archive) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
int ret = zip_replace(zf->archive, idx, source);
if (ret < 0) {
zip_source_free(source);
std::stringstream s;
s << "Error while replacing file " << name << " in zip archive: " << zip_strerror(zf->archive) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
return Undefined();
}
int
main(int argc, char *argv[])
{
int fail, ze;
int c;
struct zip *z;
struct zip_source *zs;
char *archive;
char errstr[1024];
verbose = 0;
fail = 0;
prg = argv[0];
while ((c=getopt(argc, argv, "v")) != -1) {
switch (c) {
case 'v':
verbose = 1;
break;
default:
fprintf(stderr, usage, prg);
return 1;
}
}
if (argc-optind != 1) {
fprintf(stderr, usage, prg);
return 1;
}
archive = argv[optind];
if ((z=zip_open(archive, 0, &ze)) == NULL) {
zip_error_to_str(errstr, sizeof(errstr), ze, errno);
printf("%s: can't open zip archive '%s': %s\n",
prg, archive, errstr);
return 1;
}
fail += do_read(z, "storedok", 0, WHEN_NEVER, 0, 0);
fail += do_read(z, "deflateok", 0, WHEN_NEVER, 0, 0);
fail += do_read(z, "storedcrcerror", 0, WHEN_READ, ZIP_ER_CRC, 0);
fail += do_read(z, "deflatecrcerror", 0, WHEN_READ, ZIP_ER_CRC, 0);
fail += do_read(z, "deflatezliberror", 0, WHEN_READ, ZIP_ER_ZLIB, -3);
fail += do_read(z, NULL, 0, WHEN_OPEN, ZIP_ER_INVAL, 0);
fail += do_read(z, "nosuchfile", 0, WHEN_OPEN, ZIP_ER_NOENT, 0);
fail += do_read(z, "deflatezliberror", ZIP_FL_COMPRESSED, WHEN_NEVER, 0,0);
fail += do_read(z, "deflatecrcerror", ZIP_FL_COMPRESSED, WHEN_NEVER, 0, 0);
fail += do_read(z, "storedcrcerror", ZIP_FL_COMPRESSED,
WHEN_READ, ZIP_ER_CRC, 0);
fail += do_read(z, "storedok", ZIP_FL_COMPRESSED, WHEN_NEVER, 0, 0);
fail += do_read(z, "cryptok", 0, WHEN_OPEN, ZIP_ER_NOPASSWD, 0);
zip_set_default_password(z, "crypt");
fail += do_read(z, "cryptok", 0, WHEN_NEVER, 0, 0);
zip_set_default_password(z, "wrong");
fail += do_read(z, "cryptok", 0, WHEN_OPEN, ZIP_ER_WRONGPASSWD, 0);
zip_set_default_password(z, NULL);
zs = zip_source_buffer(z, "asdf", 4, 0);
zip_replace(z, zip_name_locate(z, "storedok", 0), zs);
fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
zip_delete(z, zip_name_locate(z, "storedok", 0));
fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_NOENT, 0);
fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
zs = zip_source_buffer(z, "asdf", 4, 0);
if (zip_file_add(z, "new_file", zs, 0) < 0)
fprintf(stderr, "%s: can't add file to zip archive '%s': %s\n", prg, archive, zip_strerror(z));
fail += do_read(z, "new_file", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
zip_unchange_all(z);
if (zip_close(z) == -1) {
fprintf(stderr, "%s: can't close zip archive '%s': %s\n", prg, archive, zip_strerror(z));
return 1;
}
exit(fail ? 1 : 0);
}
