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; }
/* * tests for file existence */ static exists_t _zip_file_exists(zip_source_t *src, zip_error_t *error) { struct zip_stat st; zip_stat_init(&st); if (zip_source_stat(src, &st) != 0) { zip_error_t *src_error = zip_source_error(src); if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) { return EXISTS_NOT; } _zip_error_copy(error, src_error); return EXISTS_ERROR; } return (st.valid & ZIP_STAT_SIZE) && st.size == 0 ? EXISTS_EMPTY : EXISTS_NONEMPTY; }
struct zip_source * zip_source_zip(struct zip *za, struct zip *srcza, int srcidx, int flags, off_t start, off_t len) { struct zip_error error; struct zip_source *zs; struct read_zip *p; if (za == NULL) return NULL; if (srcza == NULL || start < 0 || len < -1 || srcidx < 0 || srcidx >= srcza->nentry) { _zip_error_set(&za->error, ZIP_ER_INVAL, 0); return NULL; } if ((flags & ZIP_FL_UNCHANGED) == 0 && ZIP_ENTRY_DATA_CHANGED(srcza->entry+srcidx)) { _zip_error_set(&za->error, ZIP_ER_CHANGED, 0); return NULL; } if (len == 0) len = -1; if (start == 0 && len == -1) flags |= ZIP_FL_COMPRESSED; else flags &= ~ZIP_FL_COMPRESSED; if ((p=(struct read_zip *)malloc(sizeof(*p))) == NULL) { _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); return NULL; } _zip_error_copy(&error, &srcza->error); if (zip_stat_index(srcza, srcidx, flags, &p->st) < 0 || (p->zf=zip_fopen_index(srcza, srcidx, flags)) == NULL) { free(p); _zip_error_copy(&za->error, &srcza->error); _zip_error_copy(&srcza->error, &error); return NULL; } p->off = start; p->len = len; if ((flags & ZIP_FL_COMPRESSED) == 0) { p->st.size = p->st.comp_size = len; p->st.comp_method = ZIP_CM_STORE; p->st.crc = 0; } if ((zs=zip_source_function(za, read_zip, p)) == NULL) { free(p); return NULL; } return zs; }
static zip_cdir_t * _zip_find_central_dir(zip_t *za, zip_uint64_t len) { zip_cdir_t *cdir, *cdirnew; zip_uint8_t *match; zip_int64_t buf_offset; zip_uint64_t buflen; zip_int64_t a; zip_int64_t best; zip_error_t error; zip_buffer_t *buffer; if (len < EOCDLEN) { zip_error_set(&za->error, ZIP_ER_NOZIP, 0); return NULL; } buflen = (len < CDBUFSIZE ? len : CDBUFSIZE); if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) { zip_error_t *src_error = zip_source_error(za->src); if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) { /* seek before start of file on my machine */ _zip_error_copy(&za->error, src_error); return NULL; } } if ((buf_offset = zip_source_tell(za->src)) < 0) { _zip_error_set_from_source(&za->error, za->src); return NULL; } if ((buffer = _zip_buffer_new_from_source(za->src, buflen, NULL, &za->error)) == NULL) { return NULL; } best = -1; cdir = NULL; if (buflen >= CDBUFSIZE) { /* EOCD64 locator is before EOCD, so leave place for it */ _zip_buffer_set_offset(buffer, EOCD64LOCLEN); } zip_error_set(&error, ZIP_ER_NOZIP, 0); match = _zip_buffer_get(buffer, 0); while ((match=_zip_memmem(match, _zip_buffer_left(buffer)-(EOCDLEN-4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) { _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer))); if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) { if (cdir) { if (best <= 0) { best = _zip_checkcons(za, cdir, &error); } a = _zip_checkcons(za, cdirnew, &error); if (best < a) { _zip_cdir_free(cdir); cdir = cdirnew; best = a; } else { _zip_cdir_free(cdirnew); } } else { cdir = cdirnew; if (za->open_flags & ZIP_CHECKCONS) best = _zip_checkcons(za, cdir, &error); else { best = 0; } } cdirnew = NULL; } match++; _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer))); } _zip_buffer_free(buffer); if (best < 0) { _zip_error_copy(&za->error, &error); _zip_cdir_free(cdir); return NULL; } return cdir; }
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, idx; 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; free(cdir); _zip_hash_reserve_capacity(za->names, za->nentry, &za->error); for (idx = 0; idx < za->nentry; idx++) { const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error); if (name == NULL) { /* keep src so discard does not get rid of it */ zip_source_keep(src); zip_discard(za); return NULL; } if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) { if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) { _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->ch_flags = za->flags; return za; }
ZIP_EXTERN struct zip_file * zip_fopen_index(struct zip *za, int fileno, int flags) { int len, ret; int zfflags; struct zip_file *zf; if ((fileno < 0) || (fileno >= za->nentry)) { _zip_error_set(&za->error, ZIP_ER_INVAL, 0); return NULL; } if ((flags & ZIP_FL_UNCHANGED) == 0 && ZIP_ENTRY_DATA_CHANGED(za->entry+fileno)) { _zip_error_set(&za->error, ZIP_ER_CHANGED, 0); return NULL; } if (fileno >= za->cdir->nentry) { _zip_error_set(&za->error, ZIP_ER_INVAL, 0); return NULL; } zfflags = 0; switch (za->cdir->entry[fileno].comp_method) { case ZIP_CM_STORE: zfflags |= ZIP_ZF_CRC; break; case ZIP_CM_DEFLATE: if ((flags & ZIP_FL_COMPRESSED) == 0) zfflags |= ZIP_ZF_CRC | ZIP_ZF_DECOMP; break; default: if ((flags & ZIP_FL_COMPRESSED) == 0) { _zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0); return NULL; } break; } zf = _zip_file_new(za); zf->flags = zfflags; /* zf->name = za->cdir->entry[fileno].filename; */ zf->method = za->cdir->entry[fileno].comp_method; zf->bytes_left = za->cdir->entry[fileno].uncomp_size; zf->cbytes_left = za->cdir->entry[fileno].comp_size; zf->crc_orig = za->cdir->entry[fileno].crc; if ((zf->fpos=_zip_file_get_offset(za, fileno)) == 0) { zip_fclose(zf); return NULL; } if ((zf->flags & ZIP_ZF_DECOMP) == 0) zf->bytes_left = zf->cbytes_left; else { if ((zf->buffer=(char *)malloc(BUFSIZE)) == NULL) { _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); zip_fclose(zf); return NULL; } len = _zip_file_fillbuf(zf->buffer, BUFSIZE, zf); if (len <= 0) { _zip_error_copy(&za->error, &zf->error); zip_fclose(zf); return NULL; } if ((zf->zstr = (z_stream *)malloc(sizeof(z_stream))) == NULL) { _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); zip_fclose(zf); return NULL; } zf->zstr->zalloc = Z_NULL; zf->zstr->zfree = Z_NULL; zf->zstr->opaque = NULL; zf->zstr->next_in = (Bytef *)zf->buffer; zf->zstr->avail_in = len; /* negative value to tell zlib that there is no header */ if ((ret=inflateInit2(zf->zstr, -MAX_WBITS)) != Z_OK) { _zip_error_set(&za->error, ZIP_ER_ZLIB, ret); zip_fclose(zf); return NULL; } } return zf; }
void _zip_error_set_from_source(zip_error_t *err, zip_source_t *src) { _zip_error_copy(err, zip_source_error(src)); }