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);
}
AbstractFSProvider::status_t ZIPProvider::ZIPHandle::removeDir(const FileName & directory) {
int index = zip_name_locate(handle, directory.getPath().c_str(), 0);
if (index == -1) {
WARN(zip_strerror(handle));
return FAILURE;
}
if (zip_delete(handle, index) == -1) {
WARN(zip_strerror(handle));
return FAILURE;
}
dataWritten = true;
return OK;
}
ZIP_EXTERN zip_int64_t
zip_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;
}
static VALUE zipruby_archive_fdelete(VALUE self, VALUE index) {
struct zipruby_archive *p_archive;
Data_Get_Struct(self, struct zipruby_archive, p_archive);
Check_Archive(p_archive);
if (zip_delete(p_archive->archive, NUM2INT(index)) == -1) {
zip_unchange_all(p_archive->archive);
zip_unchange_archive(p_archive->archive);
rb_raise(Error, "Delete file failed at %d: %s", NUM2INT(index), zip_strerror(p_archive->archive));
}
return Qnil;
}
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();
}
int
main(int argc, char *argv[])
{
int fail, ze;
struct zip *z;
const char *archive;
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) {
printf("%s: opening zip archive ``%s'' failed (%d)\n", prg,
archive, ze);
return 1;
}
fail += find_fail(z, "nosuchfile", 0, ZIP_ER_NOENT);
fail += find_success(z, "test", 0);
fail += find_fail(z, "TeSt", 0, ZIP_ER_NOENT);
fail += find_success(z, "TeSt", ZIP_FL_NOCASE);
fail += find_success(z, "testdir/test2", 0);
fail += find_success(z, "tesTdir/tESt2", ZIP_FL_NOCASE);
fail += find_fail(z, "testdir/test2", ZIP_FL_NODIR, ZIP_ER_NOENT);
fail += find_fail(z, "tesTdir/tESt2", ZIP_FL_NOCASE|ZIP_FL_NODIR,
ZIP_ER_NOENT);
fail += find_fail(z, "test2", 0, ZIP_ER_NOENT);
fail += find_success(z, "test2", ZIP_FL_NODIR);
fail += find_success(z, "TeST2", ZIP_FL_NODIR|ZIP_FL_NOCASE);
zip_delete(z, 0);
fail += find_fail(z, "test", 0, ZIP_ER_NOENT);
fail += find_success(z, "test", ZIP_FL_UNCHANGED);
zip_unchange_all(z);
fail += find_success(z, "test", 0);
exit(fail ? 1 : 0);
}
ZipFileOutput::ZipFileOutput(const std::string& archive)
: m_archiveHandle(0),
m_initialized(false),
m_archive(archive),
m_currentFile(0)
{
int error = 0;
m_archiveHandle = zip_open(m_archive.c_str(), ZIP_CREATE, &error);
if(! m_archiveHandle)
throw FileAccessFailed(m_archive, "Failed to open zip archive.");
// delete all files in the archive
int numFiles = zip_get_num_files(m_archiveHandle);
for(int i = 0; i < numFiles; ++i)
{
if(zip_delete(m_archiveHandle, i) < 0)
throw FileAccessFailed(m_archive, "Failed to delete files in zip archive.");
}
}
static YogVal
compress(YogEnv* env, YogVal self, YogVal pkg, YogVal args, YogVal kw, YogVal block)
{
SAVE_ARGS5(env, self, pkg, args, kw, block);
YogVal path = YUNDEF;
YogVal files = YUNDEF;
PUSH_LOCALS2(env, path, files);
YogCArg params[] = { { "path", &path }, { "*", &files }, { NULL, NULL } };
YogGetArgs_parse_args(env, "compress", params, args, kw);
if (!IS_PTR(path) || (BASIC_OBJ_TYPE(path) != TYPE_STRING)) {
YogError_raise_TypeError(env, "path must be String");
}
struct zip* archive = open_zip(env, pkg, path, ZIP_CREATE);
int n = zip_get_num_files(archive);
int i;
for (i = 0; i < n; i++) {
if (zip_delete(archive, i) != 0) {
raise_ZipError(env, pkg, zip_strerror(archive));
}
}
uint_t size = YogArray_size(env, files);
uint_t j;
for (j = 0; j < size; j++) {
YogHandle* name = VAL2HDL(env, YogArray_at(env, files, j));
YogMisc_check_String(env, name, "Filename");
YogVal bin = YogString_to_bin_in_default_encoding(env, name);
const char* fname = BINARY_CSTR(bin);
struct zip_source* source = zip_source_file(archive, fname, 0, 0);
if (source == NULL) {
raise_ZipError(env, pkg, zip_strerror(archive));
}
if (zip_add(archive, fname, source) < 0) {
raise_ZipError(env, pkg, zip_strerror(archive));
}
}
close_zip(env, pkg, archive);
RETURN(env, YNIL);
}
void DeleteFile(const utf8 * path) override
{
uint64 index = zip_name_locate(_zip, path, 0);
zip_delete(_zip, index);
}
int
main(int argc, char *argv[])
{
const char *archive;
struct zip *za, *z_in;
struct zip_source *zs;
char buf[100];
int c, arg, err, flags, idx;
flags = 0;
prg = argv[0];
if (argc < 2) {
fprintf(stderr, usage, prg);
return 1;
}
while ((c=getopt(argc, argv, "cent")) != -1) {
switch (c) {
case 'c':
flags |= ZIP_CHECKCONS;
break;
case 'e':
flags |= ZIP_EXCL;
break;
case 'n':
flags |= ZIP_CREATE;
break;
case 't':
flags |= ZIP_TRUNCATE;
break;
default:
fprintf(stderr, usage, argv[0]);
return 1;
}
}
arg = optind;
archive = argv[arg++];
if (flags == 0)
flags = ZIP_CREATE;
if ((za=zip_open(archive, flags, &err)) == NULL) {
zip_error_to_str(buf, sizeof(buf), err, errno);
fprintf(stderr, "can't open zip archive `%s': %s\n", archive, buf);
return 1;
}
err = 0;
while (arg < argc) {
if (strcmp(argv[arg], "add") == 0 && arg+2 < argc) {
/* add */
if ((zs=zip_source_buffer(za, argv[arg+2], strlen(argv[arg+2]), 0)) == NULL) {
fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za));
err = 1;
break;
}
if (zip_add(za, argv[arg+1], zs) == -1) {
zip_source_free(zs);
fprintf(stderr, "can't add file `%s': %s\n", argv[arg+1], zip_strerror(za));
err = 1;
break;
}
arg += 3;
} else if (strcmp(argv[arg], "add_dir") == 0 && arg+1 < argc) {
/* add directory */
if (zip_add_dir(za, argv[arg+1]) < 0) {
fprintf(stderr, "can't add directory `%s': %s\n", argv[arg+1], zip_strerror(za));
err = 1;
break;
}
arg += 2;
} else if (strcmp(argv[arg], "add_file") == 0 && arg+4 < argc) {
/* add */
if ((zs=zip_source_file(za, argv[arg+2], atoi(argv[arg+3]), atoi(argv[arg+4]))) == NULL) {
fprintf(stderr, "can't create zip_source from file: %s\n", zip_strerror(za));
err = 1;
break;
}
if (zip_add(za, argv[arg+1], zs) == -1) {
zip_source_free(zs);
fprintf(stderr, "can't add file `%s': %s\n", argv[arg+1], zip_strerror(za));
err = 1;
break;
}
arg += 5;
} else if (strcmp(argv[arg], "add_from_zip") == 0 && arg+5 < argc) {
/* add from another zip file */
idx = atoi(argv[arg+3]);
if ((z_in=zip_open(argv[arg+2], ZIP_CHECKCONS, &err)) == NULL) {
zip_error_to_str(buf, sizeof(buf), err, errno);
fprintf(stderr, "can't open source zip archive `%s': %s\n", argv[arg+2], buf);
err = 1;
break;
}
if ((zs=zip_source_zip(za, z_in, idx, 0, atoi(argv[arg+4]), atoi(argv[arg+5]))) == NULL) {
fprintf(stderr, "error creating file source from `%s' index '%d': %s\n", argv[arg+2], idx, zip_strerror(za));
zip_close(z_in);
err = 1;
break;
}
if (zip_add(za, argv[arg+1], zs) == -1) {
fprintf(stderr, "can't add file `%s': %s\n", argv[arg+1], zip_strerror(za));
zip_source_free(zs);
zip_close(z_in);
err = 1;
break;
}
arg += 6;
} else if (strcmp(argv[arg], "count_extra") == 0 && arg+2 < argc) {
zip_int16_t count;
zip_flags_t ceflags = 0;
idx = atoi(argv[arg+1]);
ceflags = get_flags(argv[arg+2]);
if ((count=zip_file_extra_fields_count(za, idx, ceflags)) < 0) {
fprintf(stderr, "can't get extra field count for file at index `%d': %s\n", idx, zip_strerror(za));
err = 1;
break;
} else {
printf("Extra field count: %d\n", count);
}
arg += 3;
} else if (strcmp(argv[arg], "count_extra_by_id") == 0 && arg+3 < argc) {
zip_int16_t count, eid;
zip_flags_t ceflags = 0;
idx = atoi(argv[arg+1]);
eid = atoi(argv[arg+2]);
ceflags = get_flags(argv[arg+3]);
if ((count=zip_file_extra_fields_count_by_id(za, idx, eid, ceflags)) < 0) {
fprintf(stderr, "can't get extra field count for file at index `%d' and for id `%d': %s\n", idx, eid, zip_strerror(za));
err = 1;
break;
} else {
printf("Extra field count: %d\n", count);
}
arg += 4;
} else if (strcmp(argv[arg], "delete") == 0 && arg+1 < argc) {
/* delete */
idx = atoi(argv[arg+1]);
if (zip_delete(za, idx) < 0) {
fprintf(stderr, "can't delete file at index `%d': %s\n", idx, zip_strerror(za));
err = 1;
break;
}
arg += 2;
} else if (strcmp(argv[arg], "delete_extra") == 0 && arg+1 < argc) {
zip_flags_t geflags;
zip_uint16_t eid;
idx = atoi(argv[arg+1]);
eid = atoi(argv[arg+2]);
geflags = get_flags(argv[arg+3]);
if ((zip_file_extra_field_delete(za, idx, eid, geflags)) < 0) {
fprintf(stderr, "can't delete extra field data for file at index `%d', extra field id `%d': %s\n", idx, eid, zip_strerror(za));
err = 1;
break;
}
arg += 4;
} else if (strcmp(argv[arg], "delete_extra_by_id") == 0 && arg+1 < argc) {
zip_flags_t geflags;
zip_uint16_t eid, eidx;
idx = atoi(argv[arg+1]);
eid = atoi(argv[arg+2]);
eidx = atoi(argv[arg+3]);
geflags = get_flags(argv[arg+4]);
if ((zip_file_extra_field_delete_by_id(za, idx, eid, eidx, geflags)) < 0) {
fprintf(stderr, "can't delete extra field data for file at index `%d', extra field id `%d', extra field idx `%d': %s\n", idx, eid, eidx, zip_strerror(za));
err = 1;
break;
}
arg += 5;
} else if (strcmp(argv[arg], "get_archive_comment") == 0) {
const char *comment;
int len;
/* get archive comment */
if ((comment=zip_get_archive_comment(za, &len, 0)) == NULL)
printf("No archive comment\n");
else
printf("Archive comment: %.*s\n", len, comment);
arg += 1;
} else if (strcmp(argv[arg], "get_extra") == 0 && arg+3 < argc) {
zip_flags_t geflags;
zip_uint16_t id, eidx, eflen;
const zip_uint8_t *efdata;
/* get extra field data */
idx = atoi(argv[arg+1]);
eidx = atoi(argv[arg+2]);
geflags = get_flags(argv[arg+3]);
if ((efdata=zip_file_extra_field_get(za, idx, eidx, &id, &eflen, geflags)) == NULL) {
fprintf(stderr, "can't get extra field data for file at index %d, extra field %d, flags %u: %s\n", idx, eidx, geflags, zip_strerror(za));
err = 1;
} else {
printf("Extra field 0x%04x: len %d", id, eflen);
if (eflen > 0) {
printf(", data ");
hexdump(efdata, eflen);
}
printf("\n");
}
arg += 4;
} else if (strcmp(argv[arg], "get_extra_by_id") == 0 && arg+4 < argc) {
zip_flags_t geflags;
zip_uint16_t eid, eidx, eflen;
const zip_uint8_t *efdata;
idx = atoi(argv[arg+1]);
eid = atoi(argv[arg+2]);
eidx = atoi(argv[arg+3]);
geflags = get_flags(argv[arg+4]);
if ((efdata=zip_file_extra_field_get_by_id(za, idx, eid, eidx, &eflen, geflags)) == NULL) {
fprintf(stderr, "can't get extra field data for file at index %d, extra field id %d, ef index %d, flags %u: %s\n", idx, eid, eidx, geflags, zip_strerror(za));
err = 1;
} else {
printf("Extra field 0x%04x: len %d", eid, eflen);
if (eflen > 0) {
printf(", data ");
hexdump(efdata, eflen);
}
printf("\n");
}
arg += 5;
} else if (strcmp(argv[arg], "get_file_comment") == 0 && arg+1 < argc) {
const char *comment;
int len;
/* get file comment */
idx = atoi(argv[arg+1]);
if ((comment=zip_get_file_comment(za, idx, &len, 0)) == NULL) {
fprintf(stderr, "can't get comment for `%s': %s\n", zip_get_name(za, idx, 0), zip_strerror(za));
err = 1;
break;
} else if (len == 0)
printf("No comment for `%s'\n", zip_get_name(za, idx, 0));
else
printf("File comment for `%s': %.*s\n", zip_get_name(za, idx, 0), len, comment);
arg += 2;
} else if (strcmp(argv[arg], "rename") == 0 && arg+2 < argc) {
/* rename */
idx = atoi(argv[arg+1]);
if (zip_rename(za, idx, argv[arg+2]) < 0) {
fprintf(stderr, "can't rename file at index `%d' to `%s': %s\n", idx, argv[arg+2], zip_strerror(za));
err = 1;
break;
}
arg += 3;
} else if (strcmp(argv[arg], "set_extra") == 0 && arg+5 < argc) {
zip_flags_t geflags;
zip_uint16_t eid, eidx;
const zip_uint8_t *efdata;
idx = atoi(argv[arg+1]);
eid = atoi(argv[arg+2]);
eidx = atoi(argv[arg+3]);
geflags = get_flags(argv[arg+4]);
efdata = (zip_uint8_t *)argv[arg+5];
if ((zip_file_extra_field_set(za, idx, eid, eidx, efdata, (zip_uint16_t)strlen((const char *)efdata), geflags)) < 0) {
fprintf(stderr, "can't set extra field data for file at index `%d', extra field id `%d', index `%d': %s\n", idx, eid, eidx, zip_strerror(za));
err = 1;
break;
}
arg += 6;
} else if (strcmp(argv[arg], "set_file_comment") == 0 && arg+2 < argc) {
/* set file comment */
idx = atoi(argv[arg+1]);
if (zip_file_set_comment(za, idx, argv[arg+2], (zip_uint16_t)strlen(argv[arg+2]), 0) < 0) {
fprintf(stderr, "can't set file comment at index `%d' to `%s': %s\n", idx, argv[arg+2], zip_strerror(za));
err = 1;
break;
}
arg += 3;
} else if (strcmp(argv[arg], "set_file_compression") == 0 && arg+3 < argc) {
/* set file compression */
zip_int32_t method;
zip_uint32_t flags;
idx = atoi(argv[arg+1]);
method = get_compression_method(argv[arg+2]);
flags = atoi(argv[arg+3]);
if (zip_set_file_compression(za, idx, method, flags) < 0) {
fprintf(stderr, "can't set file compression method at index `%d' to `%s', flags `%d': %s\n", idx, argv[arg+2], flags, zip_strerror(za));
err = 1;
break;
}
arg += 4;
} else {
fprintf(stderr, "unrecognized command `%s', or not enough arguments\n", argv[arg]);
err = 1;
break;
}
}
if (zip_close(za) == -1) {
fprintf(stderr, "can't close zip archive `%s': %s\n", archive, zip_strerror(za));
return 1;
}
return err;
}
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);
}
