#endif
#endif
-#if PHP_VERSION_ID < 50400
-#define ARG_PATH "s"
-#define KEY_ARG_DC
-#define KEY_ARG_CC
-#else
-#define ARG_PATH "p"
-#define KEY_ARG_DC , const zend_literal *key
-#define KEY_ARG_CC , key
-#endif
-
-#if PHP_VERSION_ID < 50500
-#define TYPE_ARG_DC
-#define TYPE_ARG_CC
-#else
-#define TYPE_ARG_DC , int type
-#define TYPE_ARG_CC , type
-#endif
+#define ARG_PATH "P"
/* {{{ Resource le */
static int le_zip_dir;
RETURN_TRUE;
/* }}} */
-#if (PHP_MAJOR_VERSION < 6)
# define add_ascii_assoc_string add_assoc_string
# define add_ascii_assoc_long add_assoc_long
-#endif
-
/* Flatten a path by making a relative path (to .)*/
static char * php_zip_make_relative_path(char *path, int path_len) /* {{{ */
}
/* }}} */
-#ifdef PHP_ZIP_USE_OO
-
-#if PHP_VERSION_ID < 50600
-# define CWD_STATE_ALLOC(l) malloc(l)
-# define CWD_STATE_FREE(s) free(s)
-#else
# define CWD_STATE_ALLOC(l) emalloc(l)
# define CWD_STATE_FREE(s) efree(s)
-#endif
/* {{{ php_zip_extract_file */
static int php_zip_extract_file(struct zip * za, char *dest, char *file, int file_len TSRMLS_DC)
}
php_stat(resolved_path, strlen(resolved_path), FS_EXISTS, &exists_flag TSRMLS_CC);
- if (!Z_BVAL(exists_flag)) {
+ if (Z_TYPE(exists_flag) == IS_FALSE) {
return -1;
}
}
/* }}} */
-static int php_zip_parse_options(zval *options, long *remove_all_path,
- char **remove_path, int *remove_path_len, char **add_path, int *add_path_len TSRMLS_DC) /* {{{ */
+static int php_zip_parse_options(zval *options, long *remove_all_path, char **remove_path, int *remove_path_len, char **add_path, int *add_path_len TSRMLS_DC) /* {{{ */
{
- zval **option;
- if (zend_hash_find(HASH_OF(options), "remove_all_path", sizeof("remove_all_path"), (void **)&option) == SUCCESS) {
+ zval *option;
+ if ((option = zend_hash_str_find(HASH_OF(options), "remove_all_path", sizeof("remove_all_path") - 1)) != NULL) {
long opt;
- if (Z_TYPE_PP(option) != IS_LONG) {
- zval tmp = **option;
- zval_copy_ctor(&tmp);
+ if (Z_TYPE_P(option) != IS_LONG) {
+ zval tmp;
+ ZVAL_DUP(&tmp, option);
convert_to_long(&tmp);
opt = Z_LVAL(tmp);
} else {
- opt = Z_LVAL_PP(option);
+ opt = Z_LVAL_P(option);
}
*remove_all_path = opt;
}
/* If I add more options, it would make sense to create a nice static struct and loop over it. */
- if (zend_hash_find(HASH_OF(options), "remove_path", sizeof("remove_path"), (void **)&option) == SUCCESS) {
- if (Z_TYPE_PP(option) != IS_STRING) {
+ if ((options = zend_hash_str_find(HASH_OF(options), "remove_path", sizeof("remove_path") - 1)) != NULL) {
+ if (Z_TYPE_P(option) != IS_STRING) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "remove_path option expected to be a string");
return -1;
}
- if (Z_STRLEN_PP(option) < 1) {
+ if (Z_STRLEN_P(option) < 1) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Empty string given as remove_path option");
return -1;
}
- if (Z_STRLEN_PP(option) >= MAXPATHLEN) {
+ if (Z_STRLEN_P(option) >= MAXPATHLEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "remove_path string is too long (max: %i, %i given)",
- MAXPATHLEN - 1, Z_STRLEN_PP(option));
+ MAXPATHLEN - 1, Z_STRLEN_P(option));
return -1;
}
- *remove_path_len = Z_STRLEN_PP(option);
- *remove_path = Z_STRVAL_PP(option);
+ *remove_path_len = Z_STRLEN_P(option);
+ *remove_path = Z_STRVAL_P(option);
}
- if (zend_hash_find(HASH_OF(options), "add_path", sizeof("add_path"), (void **)&option) == SUCCESS) {
- if (Z_TYPE_PP(option) != IS_STRING) {
+ if ((option = zend_hash_str_find(HASH_OF(options), "add_path", sizeof("add_path") - 1)) != NULL) {
+ if (Z_TYPE_P(option) != IS_STRING) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "add_path option expected to be a string");
return -1;
}
- if (Z_STRLEN_PP(option) < 1) {
+ if (Z_STRLEN_P(option) < 1) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Empty string given as the add_path option");
return -1;
}
- if (Z_STRLEN_PP(option) >= MAXPATHLEN) {
+ if (Z_STRLEN_P(option) >= MAXPATHLEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "add_path string too long (max: %i, %i given)",
- MAXPATHLEN - 1, Z_STRLEN_PP(option));
+ MAXPATHLEN - 1, Z_STRLEN_P(option));
return -1;
}
- *add_path_len = Z_STRLEN_PP(option);
- *add_path = Z_STRVAL_PP(option);
+ *add_path_len = Z_STRLEN_P(option);
+ *add_path = Z_STRVAL_P(option);
}
return 1;
}
/* {{{ ZIP_FROM_OBJECT */
#define ZIP_FROM_OBJECT(intern, object) \
{ \
- ze_zip_object *obj = (ze_zip_object*) zend_object_store_get_object(object TSRMLS_CC); \
+ ze_zip_object *obj = Z_ZIP_P(object); \
intern = obj->za; \
if (!intern) { \
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid or uninitialized Zip object"); \
}
/* }}} */
-int php_zip_pcre(char *regexp, int regexp_len, char *path, int path_len, zval *return_value TSRMLS_DC) /* {{{ */
+int php_zip_pcre(zend_string *regexp, char *path, int path_len, zval *return_value TSRMLS_DC) /* {{{ */
{
#ifdef ZTS
char cwd[MAXPATHLEN];
char *result;
#endif
int files_cnt;
- char **namelist;
+ zend_string **namelist;
#ifdef ZTS
if (!IS_ABSOLUTE_PATH(path, path_len)) {
files_cnt = php_stream_scandir(path, &namelist, NULL, (void *) php_stream_dirent_alphasort);
if (files_cnt > 0) {
- pcre *re = NULL;
+ pcre *re = NULL;
pcre_extra *pcre_extra = NULL;
int preg_options = 0, i;
char fullpath[MAXPATHLEN];
int ovector[3];
int matches;
- int namelist_len = strlen(namelist[i]);
+ int namelist_len = namelist[i]->len;
-
- if ((namelist_len == 1 && namelist[i][0] == '.') ||
- (namelist_len == 2 && namelist[i][0] == '.' && namelist[i][1] == '.')) {
- efree(namelist[i]);
+ if ((namelist_len == 1 && namelist[i]->val[0] == '.') ||
+ (namelist_len == 2 && namelist[i]->val[0] == '.' && namelist[i]->val[1] == '.')) {
+ STR_RELEASE(namelist[i]);
continue;
}
if ((path_len + namelist_len + 1) >= MAXPATHLEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "add_path string too long (max: %i, %i given)",
MAXPATHLEN - 1, (path_len + namelist_len + 1));
- efree(namelist[i]);
+ STR_RELEASE(namelist[i]);
break;
}
- snprintf(fullpath, MAXPATHLEN, "%s%c%s", path, DEFAULT_SLASH, namelist[i]);
+ snprintf(fullpath, MAXPATHLEN, "%s%c%s", path, DEFAULT_SLASH, namelist[i]->val);
if (0 != VCWD_STAT(fullpath, &s)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot read <%s>", fullpath);
- efree(namelist[i]);
+ STR_RELEASE(namelist[i]);
continue;
}
if (S_IFDIR == (s.st_mode & S_IFMT)) {
- efree(namelist[i]);
+ STR_RELEASE(namelist[i]);
continue;
}
- matches = pcre_exec(re, NULL, namelist[i], strlen(namelist[i]), 0, 0, ovector, 3);
+ matches = pcre_exec(re, NULL, namelist[i]->val, namelist[i]->len, 0, 0, ovector, 3);
/* 0 means that the vector is too small to hold all the captured substring offsets */
if (matches < 0) {
- efree(namelist[i]);
+ STR_RELEASE(namelist[i]);
continue;
}
add_next_index_string(return_value, fullpath);
- efree(namelist[i]);
+ STR_RELEASE(namelist[i]);
}
efree(namelist);
}
}
/* }}} */
-#endif
-
/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO_EX(arginfo_zip_open, 0, 0, 1)
ZEND_ARG_INFO(0, filename)
/* }}} */
/* {{{ ZE2 OO definitions */
-#ifdef PHP_ZIP_USE_OO
static zend_class_entry *zip_class_entry;
static zend_object_handlers zip_object_handlers;
int type;
} zip_prop_handler;
-#endif
/* }}} */
-#ifdef PHP_ZIP_USE_OO
static void php_zip_register_prop_handler(HashTable *prop_handler, char *name, zip_read_int_t read_int_func, zip_read_const_char_t read_char_func, zip_read_const_char_from_ze_t read_char_from_obj_func, int rettype TSRMLS_DC) /* {{{ */
{
zip_prop_handler hnd;
hnd.read_int_func = read_int_func;
hnd.read_const_char_from_obj_func = read_char_from_obj_func;
hnd.type = rettype;
- zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(zip_prop_handler), NULL);
+ zend_hash_str_add_mem(prop_handler, name, strlen(name), &hnd, sizeof(zip_prop_handler));
}
/* }}} */
-static int php_zip_property_reader(ze_zip_object *obj, zip_prop_handler *hnd, zval **retval, int newzval TSRMLS_DC) /* {{{ */
+static zval *php_zip_property_reader(ze_zip_object *obj, zip_prop_handler *hnd, zval *rv TSRMLS_DC) /* {{{ */
{
const char *retchar = NULL;
int retint = 0;
retint = hnd->read_int_func(obj->za TSRMLS_CC);
if (retint == -1) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal zip error returned");
- return FAILURE;
+ return NULL;
}
} else {
if (hnd->read_const_char_from_obj_func) {
}
}
- if (newzval) {
- ALLOC_ZVAL(*retval);
- }
-
switch (hnd->type) {
case IS_STRING:
if (retchar) {
- ZVAL_STRINGL(*retval, (char *) retchar, len, 1);
+ ZVAL_STRINGL(rv, (char *) retchar, len);
} else {
- ZVAL_EMPTY_STRING(*retval);
+ ZVAL_EMPTY_STRING(rv);
}
break;
- case IS_BOOL:
- ZVAL_BOOL(*retval, (long)retint);
+ /* case IS_TRUE */
+ case IS_FALSE:
+ ZVAL_BOOL(rv, (long)retint);
break;
case IS_LONG:
- ZVAL_LONG(*retval, (long)retint);
+ ZVAL_LONG(rv, (long)retint);
break;
default:
- ZVAL_NULL(*retval);
+ ZVAL_NULL(rv);
}
- return SUCCESS;
+ return rv;
}
/* }}} */
-static zval **php_zip_get_property_ptr_ptr(zval *object, zval *member TYPE_ARG_DC KEY_ARG_DC TSRMLS_DC) /* {{{ */
+static zval *php_zip_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
{
ze_zip_object *obj;
zval tmp_member;
- zval **retval = NULL;
-
- zip_prop_handler *hnd;
+ zval *retval = NULL;
+ zip_prop_handler *hnd = NULL;
zend_object_handlers *std_hnd;
- int ret;
- if (member->type != IS_STRING) {
- tmp_member = *member;
- zval_copy_ctor(&tmp_member);
+ if (Z_TYPE_P(member) != IS_STRING) {
+ ZVAL_DUP(&tmp_member, member);
convert_to_string(&tmp_member);
member = &tmp_member;
-#if PHP_VERSION_ID >= 50400
- key = NULL;
-#endif
+ cache_slot = -1;
}
- ret = FAILURE;
- obj = (ze_zip_object *)zend_objects_get_address(object TSRMLS_CC);
+ obj = Z_ZIP_P(object);
if (obj->prop_handler != NULL) {
-#if PHP_VERSION_ID >= 50400
- if (key) {
- ret = zend_hash_quick_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, key->hash_value, (void **) &hnd);
- } else
-#endif
- ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
+ hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
-
- if (ret == FAILURE) {
+ if (hnd == NULL) {
std_hnd = zend_get_std_object_handlers();
- retval = std_hnd->get_property_ptr_ptr(object, member TYPE_ARG_CC KEY_ARG_CC TSRMLS_CC);
+ retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot TSRMLS_CC);
}
if (member == &tmp_member) {
zval_dtor(member);
}
+
return retval;
}
/* }}} */
-static zval* php_zip_read_property(zval *object, zval *member, int type KEY_ARG_DC TSRMLS_DC) /* {{{ */
+static zval *php_zip_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
{
ze_zip_object *obj;
zval tmp_member;
- zval *retval;
- zip_prop_handler *hnd;
+ zval *retval = NULL;
+ zip_prop_handler *hnd = NULL;
zend_object_handlers *std_hnd;
- int ret;
- if (member->type != IS_STRING) {
- tmp_member = *member;
- zval_copy_ctor(&tmp_member);
+ if (Z_TYPE_P(member) != IS_STRING) {
+ ZVAL_DUP(&tmp_member, member);
convert_to_string(&tmp_member);
member = &tmp_member;
-#if PHP_VERSION_ID >= 50400
- key = NULL;
-#endif
+ cache_slot = -1;
}
- ret = FAILURE;
- obj = (ze_zip_object *)zend_objects_get_address(object TSRMLS_CC);
+ obj = Z_ZIP_P(object);
if (obj->prop_handler != NULL) {
-#if PHP_VERSION_ID >= 50400
- if (key) {
- ret = zend_hash_quick_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, key->hash_value, (void **) &hnd);
- } else
-#endif
- ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
+ hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
- if (ret == SUCCESS) {
- ret = php_zip_property_reader(obj, hnd, &retval, 1 TSRMLS_CC);
- if (ret == SUCCESS) {
- /* ensure we're creating a temporary variable */
- Z_SET_REFCOUNT_P(retval, 0);
- } else {
- retval = EG(uninitialized_zval_ptr);
+ if (hnd != NULL) {
+ retval = php_zip_property_reader(obj, hnd, rv TSRMLS_CC);
+ if (retval == NULL) {
+ retval = &EG(uninitialized_zval);
}
} else {
std_hnd = zend_get_std_object_handlers();
- retval = std_hnd->read_property(object, member, type KEY_ARG_CC TSRMLS_CC);
+ retval = std_hnd->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
}
if (member == &tmp_member) {
zval_dtor(member);
}
+
return retval;
}
/* }}} */
-static int php_zip_has_property(zval *object, zval *member, int type KEY_ARG_DC TSRMLS_DC) /* {{{ */
+static int php_zip_has_property(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
{
ze_zip_object *obj;
zval tmp_member;
- zip_prop_handler *hnd;
+ zip_prop_handler *hnd = NULL;
zend_object_handlers *std_hnd;
- int ret, retval = 0;
+ int retval = 0;
- if (member->type != IS_STRING) {
- tmp_member = *member;
- zval_copy_ctor(&tmp_member);
+ if (Z_TYPE_P(member) != IS_STRING) {
+ ZVAL_DUP(&tmp_member, member);
convert_to_string(&tmp_member);
member = &tmp_member;
-#if PHP_VERSION_ID >= 50400
- key = NULL;
-#endif
+ cache_slot = -1;
}
- ret = FAILURE;
- obj = (ze_zip_object *)zend_objects_get_address(object TSRMLS_CC);
+ obj = Z_ZIP_P(object);
if (obj->prop_handler != NULL) {
-#if PHP_VERSION_ID >= 50400
- if (key) {
- ret = zend_hash_quick_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, key->hash_value, (void **) &hnd);
- } else
-#endif
- ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
+ hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
}
- if (ret == SUCCESS) {
- zval *tmp;
- ALLOC_INIT_ZVAL(tmp);
+ if (hnd != NULL) {
+ zval tmp, *prop;
if (type == 2) {
retval = 1;
- } else if (php_zip_property_reader(obj, hnd, &tmp, 0 TSRMLS_CC) == SUCCESS) {
- Z_SET_REFCOUNT_P(tmp, 1);
- Z_UNSET_ISREF_P(tmp);
+ } else if ((prop = php_zip_property_reader(obj, hnd, &tmp TSRMLS_CC)) != NULL) {
if (type == 1) {
-#if PHP_VERSION_ID >= 50699
- retval = zend_is_true(tmp TSRMLS_CC);
-#else
- retval = zend_is_true(tmp);
-#endif
+ retval = zend_is_true(&tmp TSRMLS_CC);
} else if (type == 0) {
- retval = (Z_TYPE_P(tmp) != IS_NULL);
+ retval = (Z_TYPE(tmp) != IS_NULL);
}
}
zval_ptr_dtor(&tmp);
} else {
std_hnd = zend_get_std_object_handlers();
- retval = std_hnd->has_property(object, member, type KEY_ARG_CC TSRMLS_CC);
+ retval = std_hnd->has_property(object, member, type, cache_slot TSRMLS_CC);
}
if (member == &tmp_member) {
zval_dtor(member);
}
+
return retval;
}
/* }}} */
static HashTable *php_zip_get_properties(zval *object TSRMLS_DC)/* {{{ */
{
ze_zip_object *obj;
- zip_prop_handler *hnd;
HashTable *props;
- zval *val;
- int ret;
- char *key;
- uint key_len;
- HashPosition pos;
+ zip_prop_handler *hnd;
+ zend_string *key;
ulong num_key;
- obj = (ze_zip_object *)zend_objects_get_address(object TSRMLS_CC);
+ obj = Z_ZIP_P(object);
props = zend_std_get_properties(object TSRMLS_CC);
if (obj->prop_handler == NULL) {
return NULL;
}
- zend_hash_internal_pointer_reset_ex(obj->prop_handler, &pos);
- while (zend_hash_get_current_data_ex(obj->prop_handler, (void**)&hnd, &pos) == SUCCESS) {
- zend_hash_get_current_key_ex(obj->prop_handler, &key, &key_len, &num_key, 0, &pos);
- MAKE_STD_ZVAL(val);
- ret = php_zip_property_reader(obj, hnd, &val, 0 TSRMLS_CC);
- if (ret != SUCCESS) {
- val = EG(uninitialized_zval_ptr);
+ ZEND_HASH_FOREACH_KEY_PTR(obj->prop_handler, num_key, key, hnd) {
+ zval *ret, val;
+ ret = php_zip_property_reader(obj, hnd, &val TSRMLS_CC);
+ if (ret == NULL) {
+ ret = &EG(uninitialized_zval);
}
- zend_hash_update(props, key, key_len, (void *)&val, sizeof(zval *), NULL);
- zend_hash_move_forward_ex(obj->prop_handler, &pos);
- }
+ zend_hash_update(props, key, ret);
+ } ZEND_HASH_FOREACH_END();
+
return props;
}
/* }}} */
-static void php_zip_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_zip_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
{
- ze_zip_object * intern = (ze_zip_object *) object;
+ ze_zip_object * intern = php_zip_fetch_object(object);
int i;
if (!intern) {
}
intern->za = NULL;
-
-#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 && PHP_RELEASE_VERSION > 2) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 1) || (PHP_MAJOR_VERSION > 5)
zend_object_std_dtor(&intern->zo TSRMLS_CC);
-#else
- if (intern->zo.guards) {
- zend_hash_destroy(intern->zo.guards);
- FREE_HASHTABLE(intern->zo.guards);
- }
-
- if (intern->zo.properties) {
- zend_hash_destroy(intern->zo.properties);
- FREE_HASHTABLE(intern->zo.properties);
- }
-#endif
if (intern->filename) {
efree(intern->filename);
}
- efree(intern);
}
/* }}} */
-static zend_object_value php_zip_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_zip_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
{
-#if PHP_VERSION_ID < 50400
- zval *tmp;
-#endif
ze_zip_object *intern;
- zend_object_value retval;
-
- intern = emalloc(sizeof(ze_zip_object));
- memset(&intern->zo, 0, sizeof(zend_object));
- intern->za = NULL;
- intern->buffers = NULL;
- intern->filename = NULL;
- intern->buffers_cnt = 0;
+ intern = ecalloc(1, sizeof(ze_zip_object) + sizeof(zval) * (class_type->default_properties_count - 1));
intern->prop_handler = &zip_prop_handlers;
-
-#if ((PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 1) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 && PHP_RELEASE_VERSION > 2))
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
-#else
- ALLOC_HASHTABLE(intern->zo.properties);
- zend_hash_init(intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
- intern->zo.ce = class_type;
-#endif
-
-
-#if PHP_VERSION_ID < 50400
- zend_hash_copy(intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref,
- (void *) &tmp, sizeof(zval *));
-#else
object_properties_init(&intern->zo, class_type);
-#endif
- retval.handle = zend_objects_store_put(intern,
- NULL,
- (zend_objects_free_object_storage_t) php_zip_object_free_storage,
- NULL TSRMLS_CC);
-
- retval.handlers = (zend_object_handlers *) & zip_object_handlers;
+ intern->zo.handlers = &zip_object_handlers;
- return retval;
+ return &intern->zo;
}
/* }}} */
-#endif
/* {{{ Resource dtors */
/* {{{ php_zip_free_dir */
-static void php_zip_free_dir(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void php_zip_free_dir(zend_resource *rsrc TSRMLS_DC)
{
zip_rsrc * zip_int = (zip_rsrc *) rsrc->ptr;
/* }}} */
/* {{{ php_zip_free_entry */
-static void php_zip_free_entry(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void php_zip_free_entry(zend_resource *rsrc TSRMLS_DC)
{
zip_read_rsrc *zr_rsrc = (zip_read_rsrc *) rsrc->ptr;
Create new zip using source uri for output */
static PHP_NAMED_FUNCTION(zif_zip_open)
{
- char *filename;
- int filename_len;
char resolved_path[MAXPATHLEN + 1];
zip_rsrc *rsrc_int;
int err = 0;
+ zend_string *filename;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH, &filename, &filename_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH, &filename) == FAILURE) {
return;
}
- if (filename_len == 0) {
+ if (filename->len == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string as source");
RETURN_FALSE;
}
- if (ZIP_OPENBASEDIR_CHECKPATH(filename)) {
+ if (ZIP_OPENBASEDIR_CHECKPATH(filename->val)) {
RETURN_FALSE;
}
- if(!expand_filepath(filename, resolved_path TSRMLS_CC)) {
+ if(!expand_filepath(filename->val, resolved_path TSRMLS_CC)) {
RETURN_FALSE;
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zip) == FAILURE) {
return;
}
- ZEND_FETCH_RESOURCE(z_rsrc, zip_rsrc *, &zip, -1, le_zip_dir_name, le_zip_dir);
+ ZEND_FETCH_RESOURCE(z_rsrc, zip_rsrc *, zip, -1, le_zip_dir_name, le_zip_dir);
/* really close the zip will break BC :-D */
- zend_list_delete(Z_LVAL_P(zip));
+ zend_list_close(Z_RES_P(zip));
}
/* }}} */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zip_dp) == FAILURE) {
return;
}
- ZEND_FETCH_RESOURCE(rsrc_int, zip_rsrc *, &zip_dp, -1, le_zip_dir_name, le_zip_dir);
+
+ ZEND_FETCH_RESOURCE(rsrc_int, zip_rsrc *, zip_dp, -1, le_zip_dir_name, le_zip_dir);
if (rsrc_int && rsrc_int->za) {
if (rsrc_int->index_current >= rsrc_int->num_files) {
return;
}
- ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, &zip_entry, -1, le_zip_entry_name, le_zip_entry);
- ZEND_FETCH_RESOURCE(z_rsrc, zip_rsrc *, &zip, -1, le_zip_dir_name, le_zip_dir);
+ ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, zip_entry, -1, le_zip_entry_name, le_zip_entry);
+ ZEND_FETCH_RESOURCE(z_rsrc, zip_rsrc *, zip, -1, le_zip_dir_name, le_zip_dir);
if (zr_rsrc->zf != NULL) {
RETURN_TRUE;
return;
}
- ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, &zip_entry, -1, le_zip_entry_name, le_zip_entry);
+ ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, zip_entry, -1, le_zip_entry_name, le_zip_entry);
- RETURN_BOOL(SUCCESS == zend_list_delete(Z_LVAL_P(zip_entry)));
+ RETURN_BOOL(SUCCESS == zend_list_close(Z_RES_P(zip_entry)));
}
/* }}} */
zval * zip_entry;
long len = 0;
zip_read_rsrc * zr_rsrc;
- char *buffer;
+ zend_string *buffer;
int n = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zip_entry, &len) == FAILURE) {
return;
}
- ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, &zip_entry, -1, le_zip_entry_name, le_zip_entry);
+ ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, zip_entry, -1, le_zip_entry_name, le_zip_entry);
if (len <= 0) {
len = 1024;
}
if (zr_rsrc->zf) {
- buffer = safe_emalloc(len, 1, 1);
- n = zip_fread(zr_rsrc->zf, buffer, len);
+ buffer = STR_ALLOC(len, 0);
+ n = zip_fread(zr_rsrc->zf, buffer->val, buffer->len);
if (n > 0) {
- buffer[n] = 0;
- RETURN_STRINGL(buffer, n, 0);
+ buffer->val[n] = '\0';
+ buffer->len = n;
+ RETURN_STR(buffer);
} else {
- efree(buffer);
+ STR_FREE(buffer);
RETURN_EMPTY_STRING()
}
} else {
return;
}
- ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, &zip_entry, -1, le_zip_entry_name, le_zip_entry);
+ ZEND_FETCH_RESOURCE(zr_rsrc, zip_read_rsrc *, zip_entry, -1, le_zip_entry_name, le_zip_entry);
if (!zr_rsrc->zf) {
RETURN_FALSE;
switch (opt) {
case 0:
- RETURN_STRING((char *)zr_rsrc->sb.name, 1);
+ RETURN_STRING((char *)zr_rsrc->sb.name);
break;
case 1:
RETURN_LONG((long) (zr_rsrc->sb.comp_size));
case 3:
switch (zr_rsrc->sb.comp_method) {
case 0:
- RETURN_STRING("stored", 1);
+ RETURN_STRING("stored");
break;
case 1:
- RETURN_STRING("shrunk", 1);
+ RETURN_STRING("shrunk");
break;
case 2:
case 3:
case 4:
case 5:
- RETURN_STRING("reduced", 1);
+ RETURN_STRING("reduced");
break;
case 6:
- RETURN_STRING("imploded", 1);
+ RETURN_STRING("imploded");
break;
case 7:
- RETURN_STRING("tokenized", 1);
+ RETURN_STRING("tokenized");
break;
case 8:
- RETURN_STRING("deflated", 1);
+ RETURN_STRING("deflated");
break;
case 9:
- RETURN_STRING("deflatedX", 1);
+ RETURN_STRING("deflatedX");
break;
case 10:
- RETURN_STRING("implodedX", 1);
+ RETURN_STRING("implodedX");
break;
default:
RETURN_FALSE;
}
/* }}} */
-#ifdef PHP_ZIP_USE_OO
/* {{{ proto mixed ZipArchive::open(string source [, int flags])
Create new zip using source uri for output, return TRUE on success or the error code */
static ZIPARCHIVE_METHOD(open)
{
struct zip *intern;
- char *filename;
- int filename_len;
int err = 0;
long flags = 0;
char *resolved_path;
-
+ zend_string *filename;
zval *this = getThis();
ze_zip_object *ze_obj = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|l", &filename, &filename_len, &flags) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|l", &filename, &flags) == FAILURE) {
return;
}
if (this) {
/* We do not use ZIP_FROM_OBJECT, zip init function here */
- ze_obj = (ze_zip_object*) zend_object_store_get_object(this TSRMLS_CC);
+ ze_obj = Z_ZIP_P(this);
}
- if (filename_len == 0) {
+ if (filename->len == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string as source");
RETURN_FALSE;
}
- if (ZIP_OPENBASEDIR_CHECKPATH(filename)) {
+ if (ZIP_OPENBASEDIR_CHECKPATH(filename->val)) {
RETURN_FALSE;
}
- if (!(resolved_path = expand_filepath(filename, NULL TSRMLS_CC))) {
+ if (!(resolved_path = expand_filepath(filename->val, NULL TSRMLS_CC))) {
RETURN_FALSE;
}
ZIP_FROM_OBJECT(intern, this);
- ze_obj = (ze_zip_object*) zend_object_store_get_object(this TSRMLS_CC);
+ ze_obj = Z_ZIP_P(this);
if (zip_close(intern)) {
zip_discard(intern);
zip_error_get(intern, &zep, &syp);
len = zip_error_to_str(error_string, 128, zep, syp);
- RETVAL_STRINGL(error_string, len, 1);
+ RETVAL_STRINGL(error_string, len);
}
/* }}} */
{
struct zip *intern;
zval *this = getThis();
- char *pattern;
char *path = NULL;
char *remove_path = NULL;
char *add_path = NULL;
- int pattern_len, add_path_len, remove_path_len = 0, path_len = 0;
+ int add_path_len, remove_path_len = 0, path_len = 0;
long remove_all_path = 0;
long flags = 0;
zval *options = NULL;
int found;
+ zend_string *pattern;
if (!this) {
RETURN_FALSE;
}
ZIP_FROM_OBJECT(intern, this);
- /* 1 == glob, 2==pcre */
+ /* 1 == glob, 2 == pcre */
if (type == 1) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|la",
- &pattern, &pattern_len, &flags, &options) == FAILURE) {
+ &pattern, &flags, &options) == FAILURE) {
return;
}
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|sa",
- &pattern, &pattern_len, &path, &path_len, &options) == FAILURE) {
+ &pattern, &path, &path_len, &options) == FAILURE) {
return;
}
}
- if (pattern_len == 0) {
+ if (pattern->len == 0) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Empty string as pattern");
RETURN_FALSE;
}
}
if (type == 1) {
- found = php_zip_glob(pattern, pattern_len, flags, return_value TSRMLS_CC);
+ found = php_zip_glob(pattern->val, pattern->len, flags, return_value TSRMLS_CC);
} else {
- found = php_zip_pcre(pattern, pattern_len, path, path_len, return_value TSRMLS_CC);
+ found = php_zip_pcre(pattern, path, path_len, return_value TSRMLS_CC);
}
if (found > 0) {
int i;
- zval **zval_file = NULL;
+ zval *zval_file;
for (i = 0; i < found; i++) {
char *file_stripped, *entry_name;
char entry_name_buf[MAXPATHLEN];
zend_string *basename = NULL;
- if (zend_hash_index_find(Z_ARRVAL_P(return_value), i, (void **) &zval_file) == SUCCESS) {
+ if ((zval_file = zend_hash_index_find(Z_ARRVAL_P(return_value), i)) != NULL) {
if (remove_all_path) {
- basename = php_basename(Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file), NULL, 0,
- &basename TSRMLS_CC);
+ basename = php_basename(Z_STRVAL_P(zval_file), Z_STRLEN_P(zval_file), NULL, 0);
file_stripped = basename->val;
file_stripped_len = basename->len;
- } else if (remove_path && strstr(Z_STRVAL_PP(zval_file), remove_path) != NULL) {
- file_stripped = Z_STRVAL_PP(zval_file) + remove_path_len + 1;
- file_stripped_len = Z_STRLEN_PP(zval_file) - remove_path_len - 1;
+ } else if (remove_path && strstr(Z_STRVAL_P(zval_file), remove_path) != NULL) {
+ file_stripped = Z_STRVAL_P(zval_file) + remove_path_len + 1;
+ file_stripped_len = Z_STRLEN_P(zval_file) - remove_path_len - 1;
} else {
- file_stripped = Z_STRVAL_PP(zval_file);
- file_stripped_len = Z_STRLEN_PP(zval_file);
+ file_stripped = Z_STRVAL_P(zval_file);
+ file_stripped_len = Z_STRLEN_P(zval_file);
}
if (add_path) {
if ((add_path_len + file_stripped_len) > MAXPATHLEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Entry name too long (max: %d, %ld given)",
MAXPATHLEN - 1, (add_path_len + file_stripped_len));
- zval_dtor(return_value);
+ zval_ptr_dtor(return_value);
RETURN_FALSE;
}
entry_name = entry_name_buf;
entry_name_len = strlen(entry_name);
} else {
- entry_name = Z_STRVAL_PP(zval_file);
- entry_name_len = Z_STRLEN_PP(zval_file);
+ entry_name = Z_STRVAL_P(zval_file);
+ entry_name_len = Z_STRLEN_P(zval_file);
}
if (basename) {
STR_RELEASE(basename);
basename = NULL;
}
- if (php_zip_add_file(intern, Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file),
+ if (php_zip_add_file(intern, Z_STRVAL_P(zval_file), Z_STRLEN_P(zval_file),
entry_name, entry_name_len, 0, 0 TSRMLS_CC) < 0) {
zval_dtor(return_value);
RETURN_FALSE;
{
struct zip *intern;
zval *this = getThis();
- char *filename;
- int filename_len;
char *entry_name = NULL;
int entry_name_len = 0;
long offset_start = 0, offset_len = 0;
+ zend_string *filename;
if (!this) {
RETURN_FALSE;
ZIP_FROM_OBJECT(intern, this);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|sll",
- &filename, &filename_len, &entry_name, &entry_name_len, &offset_start, &offset_len) == FAILURE) {
+ &filename, &entry_name, &entry_name_len, &offset_start, &offset_len) == FAILURE) {
return;
}
- if (filename_len == 0) {
+ if (filename->len == 0) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Empty string as filename");
RETURN_FALSE;
}
if (entry_name_len == 0) {
- entry_name = filename;
- entry_name_len = filename_len;
+ entry_name = filename->val;
+ entry_name_len = filename->len;
}
- if (php_zip_add_file(intern, filename, filename_len,
- entry_name, entry_name_len, 0, 0 TSRMLS_CC) < 0) {
+ if (php_zip_add_file(intern, filename->val, filename->len, entry_name, entry_name_len, 0, 0 TSRMLS_CC) < 0) {
RETURN_FALSE;
} else {
RETURN_TRUE;
return;
}
- ze_obj = (ze_zip_object*) zend_object_store_get_object(this TSRMLS_CC);
+ ze_obj = Z_ZIP_P(this);
if (ze_obj->buffers_cnt) {
ze_obj->buffers = (char **)erealloc(ze_obj->buffers, sizeof(char *) * (ze_obj->buffers_cnt+1));
pos = ze_obj->buffers_cnt++;
{
struct zip *intern;
zval *this = getThis();
- char *name;
- int name_len;
long flags = 0;
struct zip_stat sb;
+ zend_string *name;
if (!this) {
RETURN_FALSE;
ZIP_FROM_OBJECT(intern, this);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|l",
- &name, &name_len, &flags) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|l", &name, &flags) == FAILURE) {
return;
}
- PHP_ZIP_STAT_PATH(intern, name, name_len, flags, sb);
+ PHP_ZIP_STAT_PATH(intern, name->val, name->len, flags, sb);
RETURN_SB(&sb);
}
{
struct zip *intern;
zval *this = getThis();
- char *name;
- int name_len;
long flags = 0;
long idx = -1;
+ zend_string *name;
if (!this) {
RETURN_FALSE;
ZIP_FROM_OBJECT(intern, this);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|l",
- &name, &name_len, &flags) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|l", &name, &flags) == FAILURE) {
return;
}
- if (name_len<1) {
+
+ if (name->len < 1) {
RETURN_FALSE;
}
- idx = (long)zip_name_locate(intern, (const char *)name, flags);
+ idx = (long)zip_name_locate(intern, (const char *)name->val, flags);
if (idx >= 0) {
RETURN_LONG(idx);
name = zip_get_name(intern, (int) index, flags);
if (name) {
- RETVAL_STRING((char *)name, 1);
+ RETVAL_STRING((char *)name);
} else {
RETURN_FALSE;
}
if(comment==NULL) {
RETURN_FALSE;
}
- RETURN_STRINGL((char *)comment, (long)comment_len, 1);
+ RETURN_STRINGL((char *)comment, (long)comment_len);
}
/* }}} */
}
comment = zip_get_file_comment(intern, idx, &comment_len, (int)flags);
- RETURN_STRINGL((char *)comment, (long)comment_len, 1);
+ RETURN_STRINGL((char *)comment, (long)comment_len);
}
/* }}} */
PHP_ZIP_STAT_INDEX(intern, index, 0, sb);
comment = zip_get_file_comment(intern, index, &comment_len, (int)flags);
- RETURN_STRINGL((char *)comment, (long)comment_len, 1);
+ RETURN_STRINGL((char *)comment, (long)comment_len);
}
/* }}} */
zval *this = getThis();
zval *zval_files = NULL;
- zval **zval_file = NULL;
+ zval *zval_file = NULL;
php_stream_statbuf ssb;
char *pathto;
int pathto_len;
RETURN_FALSE;
}
for (i = 0; i < nelems; i++) {
- if (zend_hash_index_find(Z_ARRVAL_P(zval_files), i, (void **) &zval_file) == SUCCESS) {
- switch (Z_TYPE_PP(zval_file)) {
+ if ((zval_file = zend_hash_index_find(Z_ARRVAL_P(zval_files), i)) != NULL) {
+ switch (Z_TYPE_P(zval_file)) {
case IS_LONG:
break;
case IS_STRING:
- if (!php_zip_extract_file(intern, pathto, Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file) TSRMLS_CC)) {
+ if (!php_zip_extract_file(intern, pathto, Z_STRVAL_P(zval_file), Z_STRLEN_P(zval_file) TSRMLS_CC)) {
RETURN_FALSE;
}
break;
struct zip_stat sb;
struct zip_file *zf;
- char *filename;
- int filename_len;
long index = -1;
long flags = 0;
long len = 0;
- char *buffer;
+ zend_string *filename;
+ zend_string *buffer;
+
int n = 0;
if (!this) {
ZIP_FROM_OBJECT(intern, this);
if (type == 1) {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|ll", &filename, &filename_len, &len, &flags) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH "|ll", &filename, &len, &flags) == FAILURE) {
return;
}
- PHP_ZIP_STAT_PATH(intern, filename, filename_len, flags, sb);
+ PHP_ZIP_STAT_PATH(intern, filename->val, filename->len, flags, sb);
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|ll", &index, &len, &flags) == FAILURE) {
return;
if (index >= 0) {
zf = zip_fopen_index(intern, index, flags);
} else {
- zf = zip_fopen(intern, filename, flags);
+ zf = zip_fopen(intern, filename->val, flags);
}
if (zf == NULL) {
RETURN_FALSE;
}
- buffer = safe_emalloc(len, 1, 2);
- n = zip_fread(zf, buffer, len);
+ buffer = STR_ALLOC(len, 0);
+ n = zip_fread(zf, buffer->val, buffer->len);
if (n < 1) {
- efree(buffer);
+ STR_FREE(buffer);
RETURN_EMPTY_STRING();
}
zip_fclose(zf);
- buffer[n] = 0;
- RETURN_STRINGL(buffer, n, 0);
+ buffer->val[n] = '\0';
+ buffer->len = n;
+ RETURN_STR(buffer);
}
/* }}} */
struct zip *intern;
zval *this = getThis();
struct zip_stat sb;
- char *filename;
- int filename_len;
char *mode = "rb";
+ zend_string *filename;
php_stream *stream;
ze_zip_object *obj;
ZIP_FROM_OBJECT(intern, this);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH, &filename, &filename_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, ARG_PATH, &filename) == FAILURE) {
return;
}
- if (zip_stat(intern, filename, 0, &sb) != 0) {
+ if (zip_stat(intern, filename->val, 0, &sb) != 0) {
RETURN_FALSE;
}
- obj = (ze_zip_object*) zend_object_store_get_object(this TSRMLS_CC);
+ obj = Z_ZIP_P(this);
- stream = php_stream_zip_open(obj->filename, filename, mode STREAMS_CC TSRMLS_CC);
+ stream = php_stream_zip_open(obj->filename, filename->val, mode STREAMS_CC TSRMLS_CC);
if (stream) {
php_stream_to_zval(stream, return_value);
}
{NULL, NULL, NULL}
};
/* }}} */
-#endif
/* {{{ PHP_MINIT_FUNCTION */
static PHP_MINIT_FUNCTION(zip)
{
-#ifdef PHP_ZIP_USE_OO
zend_class_entry ce;
memcpy(&zip_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
- zip_object_handlers.clone_obj = NULL;
+ zip_object_handlers.offset = XtOffsetOf(ze_zip_object, zo);
+ zip_object_handlers.free_obj = php_zip_object_free_storage;
+ zip_object_handlers.clone_obj = NULL;
zip_object_handlers.get_property_ptr_ptr = php_zip_get_property_ptr_ptr;
zip_object_handlers.get_properties = php_zip_get_properties;
#endif /* ifdef ZIP_OPSYS_DEFAULT */
php_register_url_stream_wrapper("zip", &php_stream_zip_wrapper TSRMLS_CC);
-#endif /* ifdef PHP_ZIP_USE_OO */
le_zip_dir = zend_register_list_destructors_ex(php_zip_free_dir, NULL, le_zip_dir_name, module_number);
le_zip_entry = zend_register_list_destructors_ex(php_zip_free_entry, NULL, le_zip_entry_name, module_number);
*/
static PHP_MSHUTDOWN_FUNCTION(zip)
{
-#ifdef PHP_ZIP_USE_OO
zend_hash_destroy(&zip_prop_handlers);
php_unregister_url_stream_wrapper("zip" TSRMLS_CC);
-#endif
return SUCCESS;
}
/* }}} */
projects / php / commitdiff