static int
copy_source(zip_t *za, zip_source_t *src)
{
zip_uint8_t buf[BUFSIZE];
zip_int64_t n;
int ret;
if (zip_source_open(src) < 0) {
_zip_error_set_from_source(&za->error, src);
return -1;
}
ret = 0;
while ((n=zip_source_read(src, buf, sizeof(buf))) > 0) {
if (_zip_write(za, buf, (zip_uint64_t)n) < 0) {
ret = -1;
break;
}
}
if (n < 0) {
_zip_error_set_from_source(&za->error, src);
ret = -1;
}
zip_source_close(src);
return ret;
}
void
zip_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;
}
static int
copy_source(struct zip *za, struct zip_source *src, FILE *ft)
{
char buf[BUFSIZE];
zip_int64_t n;
int ret;
if (zip_source_open(src) < 0) {
_zip_error_set_from_source(&za->error, src);
return -1;
}
ret = 0;
while ((n=zip_source_read(src, buf, sizeof(buf))) > 0) {
if (fwrite(buf, 1, (size_t)n, ft) != (size_t)n) {
_zip_error_set(&za->error, ZIP_ER_WRITE, errno);
ret = -1;
break;
}
}
if (n < 0) {
if (ret == 0)
_zip_error_set_from_source(&za->error, src);
ret = -1;
}
zip_source_close(src);
return ret;
}
void COpcPackageReader::releaseZIP()
{
if (m_ZIParchive != nullptr)
zip_close(m_ZIParchive);
if (m_ZIPsource != nullptr)
zip_source_close(m_ZIPsource);
zip_error_fini(&m_ZIPError);
m_Buffer.resize(0);
m_ZIPsource = nullptr;
m_ZIParchive = nullptr;
}
ZIP_EXTERN void
zip_source_close(struct zip_source *src)
{
if (!src->is_open)
return;
if (src->src == NULL)
(void)src->cb.f(src->ud, NULL, 0, ZIP_SOURCE_CLOSE);
else {
(void)src->cb.l(src->src, src->ud, NULL, 0, ZIP_SOURCE_CLOSE);
zip_source_close(src->src);
}
src->is_open = 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);
}
ZIP_EXTERN int
zip_source_open(zip_source_t *src) {
if (src->source_closed) {
return -1;
}
if (src->write_state == ZIP_SOURCE_WRITE_REMOVED) {
zip_error_set(&src->error, ZIP_ER_DELETED, 0);
return -1;
}
if (ZIP_SOURCE_IS_OPEN_READING(src)) {
if ((zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK)) == 0) {
zip_error_set(&src->error, ZIP_ER_INUSE, 0);
return -1;
}
}
else {
if (ZIP_SOURCE_IS_LAYERED(src)) {
if (zip_source_open(src->src) < 0) {
_zip_error_set_from_source(&src->error, src->src);
return -1;
}
}
if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_OPEN) < 0) {
if (ZIP_SOURCE_IS_LAYERED(src)) {
zip_source_close(src->src);
}
return -1;
}
}
src->eof = false;
src->had_read_error = false;
_zip_error_clear(&src->error);
src->open_count++;
return 0;
}
ZIP_EXTERN zip_t *
zip_open_from_source(zip_source_t *src, int _flags, zip_error_t *error)
{
static zip_int64_t needed_support_read = -1;
static zip_int64_t needed_support_write = -1;
unsigned int flags;
zip_int64_t supported;
exists_t exists;
if (_flags < 0 || src == NULL) {
zip_error_set(error, ZIP_ER_INVAL, 0);
return NULL;
}
flags = (unsigned int)_flags;
supported = zip_source_supports(src);
if (needed_support_read == -1) {
needed_support_read = zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_STAT, -1);
needed_support_write = zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, -1);
}
if ((supported & needed_support_read) != needed_support_read) {
zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
return NULL;
}
if ((supported & needed_support_write) != needed_support_write) {
flags |= ZIP_RDONLY;
}
if ((flags & (ZIP_RDONLY|ZIP_TRUNCATE)) == (ZIP_RDONLY|ZIP_TRUNCATE)) {
zip_error_set(error, ZIP_ER_RDONLY, 0);
return NULL;
}
exists = _zip_file_exists(src, error);
switch (exists) {
case EXISTS_ERROR:
return NULL;
case EXISTS_NOT:
if ((flags & ZIP_CREATE) == 0) {
zip_error_set(error, ZIP_ER_NOENT, 0);
return NULL;
}
return _zip_allocate_new(src, flags, error);
default: {
zip_t *za;
if (flags & ZIP_EXCL) {
zip_error_set(error, ZIP_ER_EXISTS, 0);
return NULL;
}
if (zip_source_open(src) < 0) {
_zip_error_set_from_source(error, src);
return NULL;
}
if (flags & ZIP_TRUNCATE) {
za = _zip_allocate_new(src, flags, error);
}
else {
/* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, just like open() */
za = _zip_open(src, flags, error);
}
if (za == NULL) {
zip_source_close(src);
return NULL;
}
return za;
}
}
}