From df5ad846c6c789a319bed176d5ead14a0a2ff264 Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Thu, 8 May 2014 18:30:07 +0400 Subject: [PATCH] Support for ext/phar (incomplete) --- ext/phar/dirstream.c | 79 ++--- ext/phar/func_interceptors.c | 152 ++++----- ext/phar/phar.c | 242 +++++++------- ext/phar/phar_internal.h | 10 +- ext/phar/phar_object.c | 616 ++++++++++++++++------------------- ext/phar/stream.c | 152 ++++----- ext/phar/tar.c | 107 +++--- ext/phar/util.c | 339 ++++++++----------- ext/phar/zip.c | 169 ++++++---- 9 files changed, 903 insertions(+), 963 deletions(-) diff --git a/ext/phar/dirstream.c b/ext/phar/dirstream.c index c2a2b7d7f9..d24a4c76da 100644 --- a/ext/phar/dirstream.c +++ b/ext/phar/dirstream.c @@ -94,23 +94,22 @@ static size_t phar_dir_read(php_stream *stream, char *buf, size_t count TSRMLS_D { size_t to_read; HashTable *data = (HashTable *)stream->abstract; - char *str_key; - uint keylen; + zend_string *str_key; ulong unused; - if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(data, &str_key, &keylen, &unused, 0, NULL)) { + if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(data, &str_key, &unused, 0, &data->nInternalPointer)) { return 0; } zend_hash_move_forward(data); - to_read = MIN(keylen, count); + to_read = MIN(str_key->len, count); - if (to_read == 0 || count < keylen) { + if (to_read == 0 || count < str_key->len) { return 0; } memset(buf, 0, sizeof(php_stream_dirent)); - memcpy(((php_stream_dirent *) buf)->d_name, str_key, to_read); + memcpy(((php_stream_dirent *) buf)->d_name, str_key->val, to_read); ((php_stream_dirent *) buf)->d_name[to_read + 1] = '\0'; return sizeof(php_stream_dirent); @@ -143,9 +142,10 @@ static int phar_dir_flush(php_stream *stream TSRMLS_DC) /* {{{ */ */ static int phar_add_empty(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */ { - void *dummy = (char *) 1; + zval dummy; - return zend_hash_update(ht, arKey, nKeyLength, (void *) &dummy, sizeof(void *), NULL); + ZVAL_NULL(&dummy); + return (zend_hash_str_update(ht, arKey, nKeyLength, &dummy) != NULL) ? SUCCESS : FAILURE; } /* }}} */ @@ -160,7 +160,7 @@ static int phar_compare_dir_name(const void *a, const void *b TSRMLS_DC) /* {{{ f = (Bucket *) a; s = (Bucket *) b; - result = zend_binary_strcmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength); + result = zend_binary_strcmp(f->key->val, f->key->len, s->key->val, s->key->len); if (result < 0) { return -1; @@ -181,7 +181,8 @@ static php_stream *phar_make_dirstream(char *dir, HashTable *manifest TSRMLS_DC) { HashTable *data; int dirlen = strlen(dir); - char *entry, *found, *save, *str_key; + char *entry, *found, *save; + zend_string *str_key; uint keylen; ulong unused; @@ -198,12 +199,13 @@ static php_stream *phar_make_dirstream(char *dir, HashTable *manifest TSRMLS_DC) zend_hash_internal_pointer_reset(manifest); while (FAILURE != zend_hash_has_more_elements(manifest)) { - if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(manifest, &str_key, &keylen, &unused, 0, NULL)) { + if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(manifest, &str_key, &unused, 0, &manifest->nInternalPointer)) { break; } + keylen = str_key->len; if (keylen <= (uint)dirlen) { - if (keylen < (uint)dirlen || !strncmp(str_key, dir, dirlen)) { + if (keylen < (uint)dirlen || !strncmp(str_key->val, dir, dirlen)) { if (SUCCESS != zend_hash_move_forward(manifest)) { break; } @@ -213,7 +215,7 @@ static php_stream *phar_make_dirstream(char *dir, HashTable *manifest TSRMLS_DC) if (*dir == '/') { /* root directory */ - if (keylen >= sizeof(".phar")-1 && !memcmp(str_key, ".phar", sizeof(".phar")-1)) { + if (keylen >= sizeof(".phar")-1 && !memcmp(str_key->val, ".phar", sizeof(".phar")-1)) { /* do not add any magic entries to this directory */ if (SUCCESS != zend_hash_move_forward(manifest)) { break; @@ -221,28 +223,28 @@ static php_stream *phar_make_dirstream(char *dir, HashTable *manifest TSRMLS_DC) continue; } - if (NULL != (found = (char *) memchr(str_key, '/', keylen))) { + if (NULL != (found = (char *) memchr(str_key->val, '/', keylen))) { /* the entry has a path separator and is a subdirectory */ - entry = (char *) safe_emalloc(found - str_key, 1, 1); - memcpy(entry, str_key, found - str_key); - keylen = found - str_key; + entry = (char *) safe_emalloc(found - str_key->val, 1, 1); + memcpy(entry, str_key->val, found - str_key->val); + keylen = found - str_key->val; entry[keylen] = '\0'; } else { entry = (char *) safe_emalloc(keylen, 1, 1); - memcpy(entry, str_key, keylen); + memcpy(entry, str_key->val, keylen); entry[keylen] = '\0'; } goto PHAR_ADD_ENTRY; } else { - if (0 != memcmp(str_key, dir, dirlen)) { + if (0 != memcmp(str_key->val, dir, dirlen)) { /* entry in directory not found */ if (SUCCESS != zend_hash_move_forward(manifest)) { break; } continue; } else { - if (str_key[dirlen] != '/') { + if (str_key->val[dirlen] != '/') { if (SUCCESS != zend_hash_move_forward(manifest)) { break; } @@ -251,7 +253,7 @@ static php_stream *phar_make_dirstream(char *dir, HashTable *manifest TSRMLS_DC) } } - save = str_key; + save = str_key->val; save += dirlen + 1; /* seek to just past the path separator */ if (NULL != (found = (char *) memchr(save, '/', keylen - dirlen - 1))) { @@ -302,8 +304,8 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper *wrapper, const char *path, { php_url *resource = NULL; php_stream *ret; - char *internal_file, *error, *str_key; - uint keylen; + char *internal_file, *error; + zend_string *str_key; ulong unused; phar_archive_data *phar; phar_entry_info *entry = NULL; @@ -364,7 +366,7 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper *wrapper, const char *path, return NULL; } - if (SUCCESS == zend_hash_find(&phar->manifest, internal_file, strlen(internal_file), (void**)&entry) && !entry->is_dir) { + if (NULL != (entry = zend_hash_str_find_ptr(&phar->manifest, internal_file, strlen(internal_file))) && !entry->is_dir) { php_url_free(resource); return NULL; } else if (entry && entry->is_dir) { @@ -383,8 +385,8 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper *wrapper, const char *path, while (FAILURE != zend_hash_has_more_elements(&phar->manifest)) { if (HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex( - &phar->manifest, &str_key, &keylen, &unused, 0, NULL)) { - if (keylen > (uint)i_len && 0 == memcmp(str_key, internal_file, i_len)) { + &phar->manifest, &str_key, &unused, 0, &phar->manifest.nInternalPointer)) { + if (str_key->len > (uint)i_len && 0 == memcmp(str_key->val, internal_file, i_len)) { /* directory found */ internal_file = estrndup(internal_file, i_len); @@ -515,7 +517,7 @@ int phar_wrapper_mkdir(php_stream_wrapper *wrapper, const char *url_from, int mo entry.flags = PHAR_ENT_PERM_DEF_DIR; entry.old_flags = PHAR_ENT_PERM_DEF_DIR; - if (SUCCESS != zend_hash_add(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL == zend_hash_str_add_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: cannot create directory \"%s\" in phar \"%s\", adding to manifest failed", entry.filename, phar->fname); efree(error); efree(entry.filename); @@ -526,7 +528,7 @@ int phar_wrapper_mkdir(php_stream_wrapper *wrapper, const char *url_from, int mo if (error) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: cannot create directory \"%s\" in phar \"%s\", %s", entry.filename, phar->fname, error); - zend_hash_del(&phar->manifest, entry.filename, entry.filename_len); + zend_hash_str_del(&phar->manifest, entry.filename, entry.filename_len); efree(error); return 0; } @@ -547,8 +549,7 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url, int options int arch_len, entry_len; php_url *resource = NULL; uint host_len; - char *str_key; - uint key_len; + zend_string *str_key; ulong unused; uint path_len; @@ -611,12 +612,12 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url, int options if (!entry->is_deleted) { for (zend_hash_internal_pointer_reset(&phar->manifest); - HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->manifest, &str_key, &key_len, &unused, 0, NULL); + HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->manifest, &str_key, &unused, 0, &phar->manifest.nInternalPointer); zend_hash_move_forward(&phar->manifest) ) { - if (key_len > path_len && - memcmp(str_key, resource->path+1, path_len) == 0 && - IS_SLASH(str_key[path_len])) { + if (str_key->len > path_len && + memcmp(str_key->val, resource->path+1, path_len) == 0 && + IS_SLASH(str_key->val[path_len])) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: Directory not empty"); if (entry->is_temp_dir) { efree(entry->filename); @@ -628,12 +629,12 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url, int options } for (zend_hash_internal_pointer_reset(&phar->virtual_dirs); - HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->virtual_dirs, &str_key, &key_len, &unused, 0, NULL); + HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->virtual_dirs, &str_key, &unused, 0, &phar->virtual_dirs.nInternalPointer); zend_hash_move_forward(&phar->virtual_dirs)) { - if (key_len > path_len && - memcmp(str_key, resource->path+1, path_len) == 0 && - IS_SLASH(str_key[path_len])) { + if (str_key->len > path_len && + memcmp(str_key->val, resource->path+1, path_len) == 0 && + IS_SLASH(str_key->val[path_len])) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: Directory not empty"); if (entry->is_temp_dir) { efree(entry->filename); @@ -646,7 +647,7 @@ int phar_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url, int options } if (entry->is_temp_dir) { - zend_hash_del(&phar->virtual_dirs, resource->path+1, path_len); + zend_hash_str_del(&phar->virtual_dirs, resource->path+1, path_len); efree(entry->filename); efree(entry); } else { diff --git a/ext/phar/func_interceptors.c b/ext/phar/func_interceptors.c index 5080ddf7c8..392f7d73ab 100644 --- a/ext/phar/func_interceptors.c +++ b/ext/phar/func_interceptors.c @@ -95,10 +95,9 @@ PHAR_FUNC(phar_file_get_contents) /* {{{ */ { char *filename; int filename_len; - char *contents; + zend_string *contents; zend_bool use_include_path = 0; php_stream *stream; - int len; long offset = -1; long maxlen = PHP_STREAM_COPY_ALL; zval *zcontext = NULL; @@ -160,7 +159,7 @@ PHAR_FUNC(phar_file_get_contents) /* {{{ */ } else { entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC); if (entry[0] == '/') { - if (!zend_hash_exists(&(phar->manifest), entry + 1, entry_len - 1)) { + if (!zend_hash_str_exists(&(phar->manifest), entry + 1, entry_len - 1)) { /* this file is not in the phar, use the original path */ notfound: efree(arch); @@ -168,7 +167,7 @@ notfound: goto skip_phar; } } else { - if (!zend_hash_exists(&(phar->manifest), entry, entry_len)) { + if (!zend_hash_str_exists(&(phar->manifest), entry, entry_len)) { goto notfound; } } @@ -202,10 +201,11 @@ phar_it: } /* uses mmap if possible */ - if ((len = php_stream_copy_to_mem(stream, &contents, maxlen, 0)) > 0) { - RETVAL_STRINGL(contents, len, 0); - efree(contents); - } else if (len == 0) { + contents = php_stream_copy_to_mem(stream, maxlen, 0); + if (contents && contents->len > 0) { + RETVAL_STR(contents); + } else if (contents) { + STR_RELEASE(contents); RETVAL_EMPTY_STRING(); } else { RETVAL_FALSE; @@ -277,7 +277,7 @@ PHAR_FUNC(phar_readfile) /* {{{ */ } else { entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC); if (entry[0] == '/') { - if (!zend_hash_exists(&(phar->manifest), entry + 1, entry_len - 1)) { + if (!zend_hash_str_exists(&(phar->manifest), entry + 1, entry_len - 1)) { /* this file is not in the phar, use the original path */ notfound: efree(entry); @@ -285,7 +285,7 @@ notfound: goto skip_phar; } } else { - if (!zend_hash_exists(&(phar->manifest), entry, entry_len)) { + if (!zend_hash_str_exists(&(phar->manifest), entry, entry_len)) { goto notfound; } } @@ -373,7 +373,7 @@ PHAR_FUNC(phar_fopen) /* {{{ */ } else { entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC); if (entry[0] == '/') { - if (!zend_hash_exists(&(phar->manifest), entry + 1, entry_len - 1)) { + if (!zend_hash_str_exists(&(phar->manifest), entry + 1, entry_len - 1)) { /* this file is not in the phar, use the original path */ notfound: efree(entry); @@ -381,7 +381,7 @@ notfound: goto skip_phar; } } else { - if (!zend_hash_exists(&(phar->manifest), entry, entry_len)) { + if (!zend_hash_str_exists(&(phar->manifest), entry, entry_len)) { /* this file is not in the phar, use the original path */ goto notfound; } @@ -404,7 +404,7 @@ notfound: } php_stream_to_zval(stream, return_value); if (zcontext) { - zend_list_addref(Z_RESVAL_P(zcontext)); + Z_ADDREF_P(zcontext); } return; } @@ -435,8 +435,8 @@ skip_phar: */ static void phar_fancy_stat(struct stat *stat_sb, int type, zval *return_value TSRMLS_DC) { - zval *stat_dev, *stat_ino, *stat_mode, *stat_nlink, *stat_uid, *stat_gid, *stat_rdev, - *stat_size, *stat_atime, *stat_mtime, *stat_ctime, *stat_blksize, *stat_blocks; + zval stat_dev, stat_ino, stat_mode, stat_nlink, stat_uid, stat_gid, stat_rdev, + stat_size, stat_atime, stat_mtime, stat_ctime, stat_blksize, stat_blocks; int rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */ char *stat_sb_names[13] = { "dev", "ino", "mode", "nlink", "uid", "gid", "rdev", @@ -506,14 +506,14 @@ static void phar_fancy_stat(struct stat *stat_sb, int type, zval *return_value T #endif case FS_TYPE: if (S_ISLNK(stat_sb->st_mode)) { - RETURN_STRING("link", 1); + RETURN_STRING("link"); } switch(stat_sb->st_mode & S_IFMT) { - case S_IFDIR: RETURN_STRING("dir", 1); - case S_IFREG: RETURN_STRING("file", 1); + case S_IFDIR: RETURN_STRING("dir"); + case S_IFREG: RETURN_STRING("file"); } php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unknown file type (%u)", stat_sb->st_mode & S_IFMT); - RETURN_STRING("unknown", 1); + RETURN_STRING("unknown"); case FS_IS_W: RETURN_BOOL((stat_sb->st_mode & wmask) != 0); case FS_IS_R: @@ -533,67 +533,67 @@ static void phar_fancy_stat(struct stat *stat_sb, int type, zval *return_value T case FS_STAT: array_init(return_value); - MAKE_LONG_ZVAL_INCREF(stat_dev, stat_sb->st_dev); - MAKE_LONG_ZVAL_INCREF(stat_ino, stat_sb->st_ino); - MAKE_LONG_ZVAL_INCREF(stat_mode, stat_sb->st_mode); - MAKE_LONG_ZVAL_INCREF(stat_nlink, stat_sb->st_nlink); - MAKE_LONG_ZVAL_INCREF(stat_uid, stat_sb->st_uid); - MAKE_LONG_ZVAL_INCREF(stat_gid, stat_sb->st_gid); + ZVAL_LONG(&stat_dev, stat_sb->st_dev); + ZVAL_LONG(&stat_ino, stat_sb->st_ino); + ZVAL_LONG(&stat_mode, stat_sb->st_mode); + ZVAL_LONG(&stat_nlink, stat_sb->st_nlink); + ZVAL_LONG(&stat_uid, stat_sb->st_uid); + ZVAL_LONG(&stat_gid, stat_sb->st_gid); #ifdef HAVE_ST_RDEV - MAKE_LONG_ZVAL_INCREF(stat_rdev, stat_sb->st_rdev); + ZVAL_LONG(&stat_rdev, stat_sb->st_rdev); #else - MAKE_LONG_ZVAL_INCREF(stat_rdev, -1); + ZVAL_LONG(&stat_rdev, -1); #endif - MAKE_LONG_ZVAL_INCREF(stat_size, stat_sb->st_size); + ZVAL_LONG(&stat_size, stat_sb->st_size); #ifdef NETWARE - MAKE_LONG_ZVAL_INCREF(stat_atime, (stat_sb->st_atime).tv_sec); - MAKE_LONG_ZVAL_INCREF(stat_mtime, (stat_sb->st_mtime).tv_sec); - MAKE_LONG_ZVAL_INCREF(stat_ctime, (stat_sb->st_ctime).tv_sec); + ZVAL_LONG(&stat_atime, (stat_sb->st_atime).tv_sec); + ZVAL_LONG(&stat_mtime, (stat_sb->st_mtime).tv_sec); + ZVAL_LONG(&stat_ctime, (stat_sb->st_ctime).tv_sec); #else - MAKE_LONG_ZVAL_INCREF(stat_atime, stat_sb->st_atime); - MAKE_LONG_ZVAL_INCREF(stat_mtime, stat_sb->st_mtime); - MAKE_LONG_ZVAL_INCREF(stat_ctime, stat_sb->st_ctime); + ZVAL_LONG(&stat_atime, stat_sb->st_atime); + ZVAL_LONG(&stat_mtime, stat_sb->st_mtime); + ZVAL_LONG(&stat_ctime, stat_sb->st_ctime); #endif #ifdef HAVE_ST_BLKSIZE - MAKE_LONG_ZVAL_INCREF(stat_blksize, stat_sb->st_blksize); + ZVAL_LONG(&stat_blksize, stat_sb->st_blksize); #else - MAKE_LONG_ZVAL_INCREF(stat_blksize,-1); + ZVAL_LONG(&stat_blksize,-1); #endif #ifdef HAVE_ST_BLOCKS - MAKE_LONG_ZVAL_INCREF(stat_blocks, stat_sb->st_blocks); + ZVAL_LONG(&stat_blocks, stat_sb->st_blocks); #else - MAKE_LONG_ZVAL_INCREF(stat_blocks,-1); + ZVAL_LONG(&stat_blocks,-1); #endif /* Store numeric indexes in propper order */ - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_dev, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ino, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mode, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_nlink, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_uid, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_gid, sizeof(zval *), NULL); - - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_rdev, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_size, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_atime, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mtime, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ctime, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blksize, sizeof(zval *), NULL); - zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_ino); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_mode); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_nlink); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_uid); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_gid); + + zend_hash_next_index_insert(HASH_OF(return_value), &stat_rdev); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_size); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_atime); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_mtime); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_ctime); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_blksize); + zend_hash_next_index_insert(HASH_OF(return_value), &stat_blocks); /* Store string indexes referencing the same zval*/ - zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0]), &stat_dev); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1]), &stat_ino); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2]), &stat_mode); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3]), &stat_nlink); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4]), &stat_uid); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5]), &stat_gid); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6]), &stat_rdev); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7]), &stat_size); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8]), &stat_atime); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9]), &stat_mtime); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10]), &stat_ctime); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11]), &stat_blksize); + zend_hash_str_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12]), &stat_blocks); return; } @@ -647,17 +647,17 @@ static void phar_file_stat(const char *filename, php_stat_len filename_length, i splitted: entry = phar_fix_filepath(entry, &entry_len, 1 TSRMLS_CC); if (entry[0] == '/') { - if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &data)) { + if (NULL != (data = zend_hash_str_find_ptr(&(phar->manifest), entry + 1, entry_len - 1))) { efree(entry); goto stat_entry; } goto notfound; } - if (SUCCESS == zend_hash_find(&(phar->manifest), entry, entry_len, (void **) &data)) { + if (NULL != (data = zend_hash_str_find_ptr(&(phar->manifest), entry, entry_len))) { efree(entry); goto stat_entry; } - if (zend_hash_exists(&(phar->virtual_dirs), entry, entry_len)) { + if (zend_hash_str_exists(&(phar->virtual_dirs), entry, entry_len)) { efree(entry); efree(arch); if (IS_EXISTS_CHECK(type)) { @@ -691,7 +691,7 @@ notfound: PHAR_G(cwd_len) = 0; /* clean path without cwd */ entry = phar_fix_filepath(entry, &entry_len, 1 TSRMLS_CC); - if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &data)) { + if (NULL != (data = zend_hash_str_find_ptr(&(phar->manifest), entry + 1, entry_len - 1))) { PHAR_G(cwd) = save; PHAR_G(cwd_len) = save_len; efree(entry); @@ -701,7 +701,7 @@ notfound: } goto stat_entry; } - if (zend_hash_exists(&(phar->virtual_dirs), entry + 1, entry_len - 1)) { + if (zend_hash_str_exists(&(phar->virtual_dirs), entry + 1, entry_len - 1)) { PHAR_G(cwd) = save; PHAR_G(cwd_len) = save_len; efree(entry); @@ -927,7 +927,7 @@ PHAR_FUNC(phar_is_file) /* {{{ */ entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC); if (entry[0] == '/') { - if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &etemp)) { + if (NULL != (etemp = zend_hash_str_find_ptr(&(phar->manifest), entry + 1, entry_len - 1))) { /* this file is not in the current directory, use the original path */ found_it: efree(entry); @@ -935,7 +935,7 @@ found_it: RETURN_BOOL(!etemp->is_dir); } } else { - if (SUCCESS == zend_hash_find(&(phar->manifest), entry, entry_len, (void **) &etemp)) { + if (NULL != (etemp = zend_hash_str_find_ptr(&(phar->manifest), entry, entry_len))) { goto found_it; } } @@ -994,7 +994,7 @@ PHAR_FUNC(phar_is_link) /* {{{ */ entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC); if (entry[0] == '/') { - if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &etemp)) { + if (NULL != (etemp = zend_hash_str_find_ptr(&(phar->manifest), entry + 1, entry_len - 1))) { /* this file is not in the current directory, use the original path */ found_it: efree(entry); @@ -1002,7 +1002,7 @@ found_it: RETURN_BOOL(etemp->link); } } else { - if (SUCCESS == zend_hash_find(&(phar->manifest), entry, entry_len, (void **) &etemp)) { + if (NULL != (etemp = zend_hash_str_find_ptr(&(phar->manifest), entry, entry_len))) { goto found_it; } } @@ -1049,7 +1049,7 @@ void phar_release_functions(TSRMLS_D) /* {{{ void phar_intercept_functions_init(TSRMLS_D) */ #define PHAR_INTERCEPT(func) \ PHAR_G(orig_##func) = NULL; \ - if (SUCCESS == zend_hash_find(CG(function_table), #func, sizeof(#func), (void **)&orig)) { \ + if (NULL != (orig = zend_hash_str_find_ptr(CG(function_table), #func, sizeof(#func)-1))) { \ PHAR_G(orig_##func) = orig->internal_function.handler; \ orig->internal_function.handler = phar_##func; \ } @@ -1086,7 +1086,7 @@ void phar_intercept_functions_init(TSRMLS_D) /* {{{ void phar_intercept_functions_shutdown(TSRMLS_D) */ #define PHAR_RELEASE(func) \ - if (PHAR_G(orig_##func) && SUCCESS == zend_hash_find(CG(function_table), #func, sizeof(#func), (void **)&orig)) { \ + if (PHAR_G(orig_##func) && NULL != (orig = zend_hash_str_find_ptr(CG(function_table), #func, sizeof(#func)-1))) { \ orig->internal_function.handler = PHAR_G(orig_##func); \ } \ PHAR_G(orig_##func) = NULL; diff --git a/ext/phar/phar.c b/ext/phar/phar.c index a23c1b89c2..05a90fc2df 100644 --- a/ext/phar/phar.c +++ b/ext/phar/phar.c @@ -24,7 +24,7 @@ #include "SAPI.h" #include "func_interceptors.h" -static void destroy_phar_data(void *pDest); +static void destroy_phar_data(zval *zv); ZEND_DECLARE_MODULE_GLOBALS(phar) char *(*phar_save_resolve_path)(const char *filename, int filename_len TSRMLS_DC); @@ -32,10 +32,10 @@ char *(*phar_save_resolve_path)(const char *filename, int filename_len TSRMLS_DC /** * set's phar->is_writeable based on the current INI value */ -static int phar_set_writeable_bit(void *pDest, void *argument TSRMLS_DC) /* {{{ */ +static int phar_set_writeable_bit(zval *zv, void *argument TSRMLS_DC) /* {{{ */ { zend_bool keep = *(zend_bool *)argument; - phar_archive_data *phar = *(phar_archive_data **)pDest; + phar_archive_data *phar = (phar_archive_data *)Z_PTR_P(zv); if (!phar->is_data) { phar->is_writeable = !keep; @@ -115,12 +115,11 @@ static void phar_split_cache_list(TSRMLS_D) /* {{{ */ /* fake request startup */ PHAR_GLOBALS->request_init = 1; - if (zend_hash_init(&EG(regular_list), 0, NULL, NULL, 0) == SUCCESS) { - EG(regular_list).nNextFreeElement=1; /* we don't want resource id 0 */ - } + zend_hash_init(&EG(regular_list), 0, NULL, NULL, 0); + EG(regular_list).nNextFreeElement=1; /* we don't want resource id 0 */ - PHAR_G(has_bz2) = zend_hash_exists(&module_registry, "bz2", sizeof("bz2")); - PHAR_G(has_zlib) = zend_hash_exists(&module_registry, "zlib", sizeof("zlib")); + PHAR_G(has_bz2) = zend_hash_str_exists(&module_registry, "bz2", sizeof("bz2")-1); + PHAR_G(has_zlib) = zend_hash_str_exists(&module_registry, "zlib", sizeof("zlib")-1); /* these two are dummies and will be destroyed later */ zend_hash_init(&cached_phars, sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data, 1); zend_hash_init(&cached_alias, sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1); @@ -236,11 +235,11 @@ void phar_destroy_phar_data(phar_archive_data *phar TSRMLS_DC) /* {{{ */ phar->virtual_dirs.arHash = NULL; } - if (phar->metadata) { + if (Z_TYPE(phar->metadata) != IS_UNDEF) { if (phar->is_persistent) { if (phar->metadata_len) { /* for zip comments that are strings */ - free(phar->metadata); + free(Z_PTR(phar->metadata)); } else { zval_internal_ptr_dtor(&phar->metadata); } @@ -248,7 +247,7 @@ void phar_destroy_phar_data(phar_archive_data *phar TSRMLS_DC) /* {{{ */ zval_ptr_dtor(&phar->metadata); } phar->metadata_len = 0; - phar->metadata = 0; + ZVAL_UNDEF(&phar->metadata); } if (phar->fp) { @@ -276,7 +275,7 @@ int phar_archive_delref(phar_archive_data *phar TSRMLS_DC) /* {{{ */ if (--phar->refcount < 0) { if (PHAR_GLOBALS->request_done - || zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) { + || zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) { phar_destroy_phar_data(phar TSRMLS_CC); } return 1; @@ -297,7 +296,7 @@ int phar_archive_delref(phar_archive_data *phar TSRMLS_DC) /* {{{ */ if (!zend_hash_num_elements(&phar->manifest)) { /* this is a new phar that has perhaps had an alias/metadata set, but has never been flushed */ - if (zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) { + if (zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) { phar_destroy_phar_data(phar TSRMLS_CC); } return 1; @@ -310,9 +309,9 @@ int phar_archive_delref(phar_archive_data *phar TSRMLS_DC) /* {{{ */ /** * Destroy phar's in shutdown, here we don't care about aliases */ -static void destroy_phar_data_only(void *pDest) /* {{{ */ +static void destroy_phar_data_only(zval *zv) /* {{{ */ { - phar_archive_data *phar_data = *(phar_archive_data **) pDest; + phar_archive_data *phar_data = (phar_archive_data *) Z_PTR_P(zv); TSRMLS_FETCH(); if (EG(exception) || --phar_data->refcount < 0) { @@ -324,18 +323,18 @@ static void destroy_phar_data_only(void *pDest) /* {{{ */ /** * Delete aliases to phar's that got kicked out of the global table */ -static int phar_unalias_apply(void *pDest, void *argument TSRMLS_DC) /* {{{ */ +static int phar_unalias_apply(zval *zv, void *argument TSRMLS_DC) /* {{{ */ { - return *(void**)pDest == argument ? ZEND_HASH_APPLY_REMOVE : ZEND_HASH_APPLY_KEEP; + return Z_PTR_P(zv) == argument ? ZEND_HASH_APPLY_REMOVE : ZEND_HASH_APPLY_KEEP; } /* }}} */ /** * Delete aliases to phar's that got kicked out of the global table */ -static int phar_tmpclose_apply(void *pDest TSRMLS_DC) /* {{{ */ +static int phar_tmpclose_apply(zval *zv TSRMLS_DC) /* {{{ */ { - phar_entry_info *entry = (phar_entry_info *) pDest; + phar_entry_info *entry = (phar_entry_info *) Z_PTR_P(zv); if (entry->fp_type != PHAR_TMP) { return ZEND_HASH_APPLY_KEEP; @@ -353,16 +352,16 @@ static int phar_tmpclose_apply(void *pDest TSRMLS_DC) /* {{{ */ /** * Filename map destructor */ -static void destroy_phar_data(void *pDest) /* {{{ */ +static void destroy_phar_data(zval *zv) /* {{{ */ { - phar_archive_data *phar_data = *(phar_archive_data **) pDest; + phar_archive_data *phar_data = (phar_archive_data *)Z_PTR_P(zv); TSRMLS_FETCH(); if (PHAR_GLOBALS->request_ends) { /* first, iterate over the manifest and close all PHAR_TMP entry fp handles, this prevents unnecessary unfreed stream resources */ zend_hash_apply(&(phar_data->manifest), phar_tmpclose_apply TSRMLS_CC); - destroy_phar_data_only(pDest); + destroy_phar_data_only(zv); return; } @@ -377,9 +376,9 @@ static void destroy_phar_data(void *pDest) /* {{{ */ /** * destructor for the manifest hash, frees each file's entry */ -void destroy_phar_manifest_entry(void *pDest) /* {{{ */ +void destroy_phar_manifest_entry(zval *zv) /* {{{ */ { - phar_entry_info *entry = (phar_entry_info *)pDest; + phar_entry_info *entry = (phar_entry_info *)Z_PTR_P(zv); TSRMLS_FETCH(); if (entry->cfp) { @@ -392,11 +391,11 @@ void destroy_phar_manifest_entry(void *pDest) /* {{{ */ entry->fp = 0; } - if (entry->metadata) { + if (Z_TYPE(entry->metadata) != IS_UNDEF) { if (entry->is_persistent) { if (entry->metadata_len) { /* for zip comments that are strings */ - free(entry->metadata); + free(Z_PTR(entry->metadata)); } else { zval_internal_ptr_dtor(&entry->metadata); } @@ -404,12 +403,12 @@ void destroy_phar_manifest_entry(void *pDest) /* {{{ */ zval_ptr_dtor(&entry->metadata); } entry->metadata_len = 0; - entry->metadata = 0; + ZVAL_UNDEF(&entry->metadata); } - if (entry->metadata_str.c) { + if (entry->metadata_str.s) { smart_str_free(&entry->metadata_str); - entry->metadata_str.c = 0; + entry->metadata_str.s = NULL; } pefree(entry->filename, entry->is_persistent); @@ -423,6 +422,8 @@ void destroy_phar_manifest_entry(void *pDest) /* {{{ */ pefree(entry->tmp, entry->is_persistent); entry->tmp = 0; } + + pefree(entry, entry->is_persistent); } /* }}} */ @@ -464,7 +465,7 @@ void phar_entry_remove(phar_entry_data *idata, char **error TSRMLS_DC) /* {{{ */ if (idata->fp && idata->fp != idata->phar->fp && idata->fp != idata->phar->ufp && idata->fp != idata->internal_file->fp) { php_stream_close(idata->fp); } - zend_hash_del(&idata->phar->manifest, idata->internal_file->filename, idata->internal_file->filename_len); + zend_hash_str_del(&idata->phar->manifest, idata->internal_file->filename, idata->internal_file->filename_len); idata->phar->refcount--; efree(idata); } else { @@ -562,7 +563,7 @@ int phar_open_parsed_phar(char *fname, int fname_len, char *alias, int alias_len if (!is_data) { /* prevent any ".phar" without a stub getting through */ if (!phar->halt_offset && !phar->is_brandnew && (phar->is_tar || phar->is_zip)) { - if (PHAR_G(readonly) && FAILURE == zend_hash_find(&(phar->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1, (void **)&stub)) { + if (PHAR_G(readonly) && NULL == (stub = zend_hash_str_find_ptr(&(phar->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1))) { if (error) { spprintf(error, 0, "'%s' is not a phar archive. Use PharData::__construct() for a standard zip or tar archive", fname); } @@ -601,7 +602,7 @@ int phar_open_parsed_phar(char *fname, int fname_len, char *alias, int alias_len * * data is the serialized zval */ -int phar_parse_metadata(char **buffer, zval **metadata, int zip_metadata_len TSRMLS_DC) /* {{{ */ +int phar_parse_metadata(char **buffer, zval *metadata, int zip_metadata_len TSRMLS_DC) /* {{{ */ { const unsigned char *p; php_uint32 buf_len; @@ -614,15 +615,14 @@ int phar_parse_metadata(char **buffer, zval **metadata, int zip_metadata_len TSR } if (buf_len) { - ALLOC_ZVAL(*metadata); - INIT_ZVAL(**metadata); + ZVAL_NULL(metadata); p = (const unsigned char*) *buffer; PHP_VAR_UNSERIALIZE_INIT(var_hash); if (!php_var_unserialize(metadata, &p, p + buf_len, &var_hash TSRMLS_CC)) { PHP_VAR_UNSERIALIZE_DESTROY(var_hash); zval_ptr_dtor(metadata); - *metadata = NULL; + ZVAL_UNDEF(metadata); return FAILURE; } @@ -631,13 +631,13 @@ int phar_parse_metadata(char **buffer, zval **metadata, int zip_metadata_len TSR if (PHAR_G(persist)) { /* lazy init metadata */ zval_ptr_dtor(metadata); - *metadata = (zval *) pemalloc(buf_len, 1); - memcpy(*metadata, *buffer, buf_len); + Z_PTR_P(metadata) = pemalloc(buf_len, 1); + memcpy(Z_PTR_P(metadata), *buffer, buf_len); *buffer += buf_len; return SUCCESS; } } else { - *metadata = NULL; + ZVAL_UNDEF(metadata); } if (!zip_metadata_len) { @@ -1129,9 +1129,9 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char switch (entry.flags & PHAR_ENT_COMPRESSION_MASK) { case PHAR_ENT_COMPRESSED_GZ: if (!PHAR_G(has_zlib)) { - if (entry.metadata) { + if (Z_TYPE(entry.metadata) != IS_UNDEF) { if (entry.is_persistent) { - free(entry.metadata); + free(Z_PTR(entry.metadata)); } else { zval_ptr_dtor(&entry.metadata); } @@ -1142,9 +1142,9 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char break; case PHAR_ENT_COMPRESSED_BZ2: if (!PHAR_G(has_bz2)) { - if (entry.metadata) { + if (Z_TYPE(entry.metadata) != IS_UNDEF) { if (entry.is_persistent) { - free(entry.metadata); + free(Z_PTR(entry.metadata)); } else { zval_ptr_dtor(&entry.metadata); } @@ -1155,9 +1155,9 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char break; default: if (entry.uncompressed_filesize != entry.compressed_filesize) { - if (entry.metadata) { + if (Z_TYPE(entry.metadata) != IS_UNDEF) { if (entry.is_persistent) { - free(entry.metadata); + free(Z_PTR(entry.metadata)); } else { zval_ptr_dtor(&entry.metadata); } @@ -1172,7 +1172,7 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char /* if signature matched, no need to check CRC32 for each file */ entry.is_crc_checked = (manifest_flags & PHAR_HDR_SIGNATURE ? 1 : 0); phar_set_inode(&entry TSRMLS_CC); - zend_hash_add(&mydata->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL); + zend_hash_str_add_mem(&mydata->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info)); } snprintf(mydata->version, sizeof(mydata->version), "%u.%u.%u", manifest_ver >> 12, (manifest_ver >> 8) & 0xF, (manifest_ver >> 4) & 0xF); @@ -1202,7 +1202,7 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char phar_request_initialize(TSRMLS_C); if (register_alias) { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; mydata->is_temporary_alias = temp_alias; @@ -1212,20 +1212,20 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char MAPPHAR_FAIL("Cannot open archive \"%s\", invalid alias"); } - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void **)&fd_ptr)) { - if (SUCCESS != phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { + if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len TSRMLS_CC)) { signature = NULL; fp = NULL; MAPPHAR_FAIL("Cannot open archive \"%s\", alias is already in use by existing archive"); } } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&mydata, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, mydata); } else { mydata->is_temporary_alias = 1; } - zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, (void*)&mydata, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata); efree(savebuf); if (pphar) { @@ -1283,7 +1283,7 @@ check_file: if (PHAR_G(readonly) && !(*test)->is_data && ((*test)->is_tar || (*test)->is_zip)) { phar_entry_info *stub; - if (FAILURE == zend_hash_find(&((*test)->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1, (void **)&stub)) { + if (NULL == (stub = zend_hash_str_find_ptr(&((*test)->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1))) { spprintf(error, 0, "'%s' is not a phar archive. Use PharData::__construct() for a standard zip or tar archive", fname); return FAILURE; } @@ -1410,7 +1410,7 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a mydata->is_writeable = 1; mydata->is_brandnew = 1; phar_request_initialize(TSRMLS_C); - zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, (void*)&mydata, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata); if (is_data) { alias = NULL; @@ -1419,15 +1419,15 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a /* assume tar format, PharData can specify other */ mydata->is_tar = 1; } else { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; - if (alias && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void **)&fd_ptr)) { - if (SUCCESS != phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) { + if (alias && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { + if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len TSRMLS_CC)) { if (error) { spprintf(error, 4096, "phar error: phar \"%s\" cannot set alias \"%s\", already in use by another phar archive", mydata->fname, alias); } - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); if (pphar) { *pphar = NULL; @@ -1442,14 +1442,14 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a } if (alias_len && alias) { - if (FAILURE == zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&mydata, sizeof(phar_archive_data*), NULL)) { + if (NULL == zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, mydata)) { if (options & REPORT_ERRORS) { if (error) { spprintf(error, 0, "archive \"%s\" cannot be associated with alias \"%s\", already in use", fname, alias); } } - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); if (pphar) { *pphar = NULL; @@ -1743,13 +1743,13 @@ static int phar_analyze_path(const char *fname, const char *ext, int ext_len, in #ifdef PHP_WIN32 phar_unixify_path_separators(realpath, strlen(realpath)); #endif - if (zend_hash_exists(&(PHAR_GLOBALS->phar_fname_map), realpath, strlen(realpath))) { + if (zend_hash_str_exists(&(PHAR_GLOBALS->phar_fname_map), realpath, strlen(realpath))) { efree(realpath); efree(filename); return SUCCESS; } - if (PHAR_G(manifest_cached) && zend_hash_exists(&cached_phars, realpath, strlen(realpath))) { + if (PHAR_G(manifest_cached) && zend_hash_str_exists(&cached_phars, realpath, strlen(realpath))) { efree(realpath); efree(filename); return SUCCESS; @@ -1912,13 +1912,13 @@ int phar_detect_phar_fname_ext(const char *filename, int filename_len, const cha *ext_str = NULL; return FAILURE; } - if (zend_hash_exists(&(PHAR_GLOBALS->phar_alias_map), (char *) filename, pos - filename)) { + if (zend_hash_str_exists(&(PHAR_GLOBALS->phar_alias_map), (char *) filename, pos - filename)) { *ext_str = pos; *ext_len = -1; return FAILURE; } - if (PHAR_G(manifest_cached) && zend_hash_exists(&cached_alias, (char *) filename, pos - filename)) { + if (PHAR_G(manifest_cached) && zend_hash_str_exists(&cached_alias, (char *) filename, pos - filename)) { *ext_str = pos; *ext_len = -1; return FAILURE; @@ -1926,71 +1926,70 @@ int phar_detect_phar_fname_ext(const char *filename, int filename_len, const cha } if (zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)) || PHAR_G(manifest_cached)) { - phar_archive_data **pphar; + phar_archive_data *pphar; if (is_complete) { - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), (char *) filename, filename_len, (void **)&pphar)) { - *ext_str = filename + (filename_len - (*pphar)->ext_len); + if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), (char *) filename, filename_len))) { + *ext_str = filename + (filename_len - pphar->ext_len); woohoo: - *ext_len = (*pphar)->ext_len; + *ext_len = pphar->ext_len; if (executable == 2) { return SUCCESS; } - if (executable == 1 && !(*pphar)->is_data) { + if (executable == 1 && !pphar->is_data) { return SUCCESS; } - if (!executable && (*pphar)->is_data) { + if (!executable && pphar->is_data) { return SUCCESS; } return FAILURE; } - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, (char *) filename, filename_len, (void **)&pphar)) { - *ext_str = filename + (filename_len - (*pphar)->ext_len); + if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, (char *) filename, filename_len))) { + *ext_str = filename + (filename_len - pphar->ext_len); goto woohoo; } } else { - char *str_key; - uint keylen; + zend_string *str_key; ulong unused; for (zend_hash_internal_pointer_reset(&(PHAR_GLOBALS->phar_fname_map)); - HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&(PHAR_GLOBALS->phar_fname_map), &str_key, &keylen, &unused, 0, NULL); + HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&(PHAR_GLOBALS->phar_fname_map), &str_key, &unused, 0, &PHAR_GLOBALS->phar_fname_map.nInternalPointer); zend_hash_move_forward(&(PHAR_GLOBALS->phar_fname_map)) ) { - if (keylen > (uint) filename_len) { + if (str_key->len > (uint) filename_len) { continue; } - if (!memcmp(filename, str_key, keylen) && ((uint)filename_len == keylen - || filename[keylen] == '/' || filename[keylen] == '\0')) { - if (FAILURE == zend_hash_get_current_data(&(PHAR_GLOBALS->phar_fname_map), (void **) &pphar)) { + if (!memcmp(filename, str_key->val, str_key->len) && ((uint)filename_len == str_key->len + || filename[str_key->len] == '/' || filename[str_key->len] == '\0')) { + if (NULL == (pphar = zend_hash_get_current_data_ptr(&(PHAR_GLOBALS->phar_fname_map)))) { break; } - *ext_str = filename + (keylen - (*pphar)->ext_len); + *ext_str = filename + (str_key->len - pphar->ext_len); goto woohoo; } } if (PHAR_G(manifest_cached)) { for (zend_hash_internal_pointer_reset(&cached_phars); - HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&cached_phars, &str_key, &keylen, &unused, 0, NULL); + HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&cached_phars, &str_key, &unused, 0, &cached_phars.nInternalPointer); zend_hash_move_forward(&cached_phars) ) { - if (keylen > (uint) filename_len) { + if (str_key->len > (uint) filename_len) { continue; } - if (!memcmp(filename, str_key, keylen) && ((uint)filename_len == keylen - || filename[keylen] == '/' || filename[keylen] == '\0')) { - if (FAILURE == zend_hash_get_current_data(&cached_phars, (void **) &pphar)) { + if (!memcmp(filename, str_key->val, str_key->len) && ((uint)filename_len == str_key->len + || filename[str_key->len] == '/' || filename[str_key->len] == '\0')) { + if (NULL == (pphar = zend_hash_get_current_data_ptr(&cached_phars))) { break; } - *ext_str = filename + (keylen - (*pphar)->ext_len); + *ext_str = filename + (str_key->len - pphar->ext_len); goto woohoo; } } @@ -2253,7 +2252,7 @@ int phar_split_fname(const char *filename, int filename_len, char **arch, int *a #ifdef PHP_WIN32 *arch = save; #else - *arch = filename; + *arch = (char*)filename; #endif } @@ -2297,7 +2296,7 @@ int phar_split_fname(const char *filename, int filename_len, char **arch, int *a int phar_open_executed_filename(char *alias, int alias_len, char **error TSRMLS_DC) /* {{{ */ { char *fname; - zval *halt_constant; +//??? zval *halt_constant; php_stream *fp; int fname_len; char *actual = NULL; @@ -2321,17 +2320,13 @@ int phar_open_executed_filename(char *alias, int alias_len, char **error TSRMLS_ return FAILURE; } - MAKE_STD_ZVAL(halt_constant); - - if (0 == zend_get_constant("__COMPILER_HALT_OFFSET__", 24, halt_constant TSRMLS_CC)) { - FREE_ZVAL(halt_constant); + if (0 == zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1 TSRMLS_CC)) { if (error) { spprintf(error, 0, "__HALT_COMPILER(); must be declared in a phar"); } return FAILURE; } - FREE_ZVAL(halt_constant); #if PHP_API_VERSION < 20100412 if (PG(safe_mode) && (!php_checkuid(fname, NULL, CHECKUID_ALLOW_ONLY_FILE))) { @@ -2469,9 +2464,9 @@ static inline void phar_set_32(char *buffer, int var) /* {{{ */ #endif } /* }}} */ -static int phar_flush_clean_deleted_apply(void *data TSRMLS_DC) /* {{{ */ +static int phar_flush_clean_deleted_apply(zval *zv TSRMLS_DC) /* {{{ */ { - phar_entry_info *entry = (phar_entry_info *)data; + phar_entry_info *entry = (phar_entry_info *)Z_PTR_P(zv); if (entry->fp_refcount <= 0 && entry->is_deleted) { return ZEND_HASH_APPLY_REMOVE; @@ -2607,7 +2602,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, zend_string *suser_stub; if (len < 0) { /* resource passed in */ - if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) { + if (!(php_stream_from_zval_no_verify(stubfile, (zval *)user_stub))) { if (closeoldfile) { php_stream_close(oldfile); } @@ -2717,20 +2712,18 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, zend_hash_apply(&phar->manifest, phar_flush_clean_deleted_apply TSRMLS_CC); /* compress as necessary, calculate crcs, serialize meta-data, manifest size, and file sizes */ - main_metadata_str.c = 0; - if (phar->metadata) { + main_metadata_str.s = NULL; + if (Z_TYPE(phar->metadata) != IS_UNDEF) { PHP_VAR_SERIALIZE_INIT(metadata_hash); php_var_serialize(&main_metadata_str, &phar->metadata, &metadata_hash TSRMLS_CC); PHP_VAR_SERIALIZE_DESTROY(metadata_hash); - } else { - main_metadata_str.len = 0; } new_manifest_count = 0; offset = 0; for (zend_hash_internal_pointer_reset(&phar->manifest); zend_hash_has_more_elements(&phar->manifest) == SUCCESS; zend_hash_move_forward(&phar->manifest)) { - if (zend_hash_get_current_data(&phar->manifest, (void **)&entry) == FAILURE) { + if ((entry = zend_hash_get_current_data_ptr(&phar->manifest)) == NULL) { continue; } if (entry->cfp) { @@ -2762,25 +2755,23 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, /* we use this to calculate API version, 1.1.1 is used for phars with directories */ has_dirs = 1; } - if (entry->metadata) { - if (entry->metadata_str.c) { + if (Z_TYPE(entry->metadata) != IS_UNDEF) { + if (entry->metadata_str.s) { smart_str_free(&entry->metadata_str); } - entry->metadata_str.c = 0; - entry->metadata_str.len = 0; + entry->metadata_str.s = NULL; PHP_VAR_SERIALIZE_INIT(metadata_hash); php_var_serialize(&entry->metadata_str, &entry->metadata, &metadata_hash TSRMLS_CC); PHP_VAR_SERIALIZE_DESTROY(metadata_hash); } else { - if (entry->metadata_str.c) { + if (entry->metadata_str.s) { smart_str_free(&entry->metadata_str); } - entry->metadata_str.c = 0; - entry->metadata_str.len = 0; + entry->metadata_str.s = NULL; } /* 32 bits for filename length, length of filename, manifest + metadata, and add 1 for trailing / if a directory */ - offset += 4 + entry->filename_len + sizeof(entry_buffer) + entry->metadata_str.len + (entry->is_dir ? 1 : 0); + offset += 4 + entry->filename_len + sizeof(entry_buffer) + (entry->metadata_str.s ? entry->metadata_str.s->len : 0) + (entry->is_dir ? 1 : 0); /* compress and rehash as necessary */ if ((oldfile && !entry->is_modified) || entry->is_dir) { @@ -2906,7 +2897,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, phar->alias_len = 0; } - manifest_len = offset + phar->alias_len + sizeof(manifest) + main_metadata_str.len; + manifest_len = offset + phar->alias_len + sizeof(manifest) + (main_metadata_str.s ? main_metadata_str.s->len : 0); phar_set_32(manifest, manifest_len); /* Hack - see bug #65028, add padding byte to the end of the manifest */ if(manifest[0] == '\r' || manifest[0] == '\n') { @@ -2945,9 +2936,9 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, phar->alias_len = restore_alias_len; - phar_set_32(manifest, main_metadata_str.len); - if (4 != php_stream_write(newfile, manifest, 4) || (main_metadata_str.len - && main_metadata_str.len != php_stream_write(newfile, main_metadata_str.c, main_metadata_str.len))) { + phar_set_32(manifest, main_metadata_str.s ? main_metadata_str.s->len : 0); + if (4 != php_stream_write(newfile, manifest, 4) || ((main_metadata_str.s ? main_metadata_str.s->len : 0) + && main_metadata_str.s->len != php_stream_write(newfile, main_metadata_str.s->val, main_metadata_str.s->len))) { smart_str_free(&main_metadata_str); if (closeoldfile) { @@ -2973,7 +2964,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, zend_hash_has_more_elements(&phar->manifest) == SUCCESS; zend_hash_move_forward(&phar->manifest)) { - if (zend_hash_get_current_data(&phar->manifest, (void **)&entry) == FAILURE) { + if ((entry = zend_hash_get_current_data_ptr(&phar->manifest)) == NULL) { continue; } @@ -3021,10 +3012,10 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, phar_set_32(entry_buffer+8, entry->compressed_filesize); phar_set_32(entry_buffer+12, entry->crc32); phar_set_32(entry_buffer+16, entry->flags); - phar_set_32(entry_buffer+20, entry->metadata_str.len); + phar_set_32(entry_buffer+20, entry->metadata_str.s ? entry->metadata_str.s->len : 0); if (sizeof(entry_buffer) != php_stream_write(newfile, entry_buffer, sizeof(entry_buffer)) - || entry->metadata_str.len != php_stream_write(newfile, entry->metadata_str.c, entry->metadata_str.len)) { + || entry->metadata_str.s->len != php_stream_write(newfile, entry->metadata_str.s->val, entry->metadata_str.s->len)) { if (closeoldfile) { php_stream_close(oldfile); } @@ -3061,7 +3052,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert, zend_hash_has_more_elements(&phar->manifest) == SUCCESS; zend_hash_move_forward(&phar->manifest)) { - if (zend_hash_get_current_data(&phar->manifest, (void **)&entry) == FAILURE) { + if ((entry = zend_hash_get_current_data_ptr(&phar->manifest)) == NULL) { continue; } @@ -3380,6 +3371,11 @@ static zend_op_array *phar_compile_file(zend_file_handle *file_handle, int type typedef zend_op_array* (zend_compile_t)(zend_file_handle*, int TSRMLS_DC); typedef zend_compile_t* (compile_hook)(zend_compile_t *ptr); +static void mime_type_dtor(zval *zv) +{ + free(Z_PTR_P(zv)); +} + PHP_GINIT_FUNCTION(phar) /* {{{ */ { phar_mime_type mime; @@ -3387,13 +3383,13 @@ PHP_GINIT_FUNCTION(phar) /* {{{ */ memset(phar_globals, 0, sizeof(zend_phar_globals)); phar_globals->readonly = 1; - zend_hash_init(&phar_globals->mime_types, 0, NULL, NULL, 1); + zend_hash_init(&phar_globals->mime_types, 0, NULL, mime_type_dtor, 1); #define PHAR_SET_MIME(mimetype, ret, fileext) \ mime.mime = mimetype; \ mime.len = sizeof((mimetype))+1; \ mime.type = ret; \ - zend_hash_add(&phar_globals->mime_types, fileext, sizeof(fileext)-1, (void *)&mime, sizeof(phar_mime_type), NULL); \ + zend_hash_str_add_mem(&phar_globals->mime_types, fileext, sizeof(fileext)-1, (void *)&mime, sizeof(phar_mime_type)); \ PHAR_SET_MIME("text/html", PHAR_MIME_PHPS, "phps") PHAR_SET_MIME("text/plain", PHAR_MIME_OTHER, "c") @@ -3490,8 +3486,8 @@ void phar_request_initialize(TSRMLS_D) /* {{{ */ { PHAR_G(last_phar) = NULL; PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL; - PHAR_G(has_bz2) = zend_hash_exists(&module_registry, "bz2", sizeof("bz2")); - PHAR_G(has_zlib) = zend_hash_exists(&module_registry, "zlib", sizeof("zlib")); + PHAR_G(has_bz2) = zend_hash_str_exists(&module_registry, "bz2", sizeof("bz2")-1); + PHAR_G(has_zlib) = zend_hash_str_exists(&module_registry, "zlib", sizeof("zlib")-1); PHAR_GLOBALS->request_init = 1; PHAR_GLOBALS->request_ends = 0; PHAR_GLOBALS->request_done = 0; @@ -3500,13 +3496,13 @@ void phar_request_initialize(TSRMLS_D) /* {{{ */ zend_hash_init(&(PHAR_GLOBALS->phar_alias_map), 5, zend_get_hash_value, NULL, 0); if (PHAR_G(manifest_cached)) { - phar_archive_data **pphar; + phar_archive_data *pphar; phar_entry_fp *stuff = (phar_entry_fp *) ecalloc(zend_hash_num_elements(&cached_phars), sizeof(phar_entry_fp)); for (zend_hash_internal_pointer_reset(&cached_phars); - zend_hash_get_current_data(&cached_phars, (void **)&pphar) == SUCCESS; + (pphar = zend_hash_get_current_data_ptr(&cached_phars)) != NULL; zend_hash_move_forward(&cached_phars)) { - stuff[pphar[0]->phar_pos].manifest = (phar_entry_fp_info *) ecalloc( zend_hash_num_elements(&(pphar[0]->manifest)), sizeof(phar_entry_fp_info)); + stuff[pphar->phar_pos].manifest = (phar_entry_fp_info *) ecalloc( zend_hash_num_elements(&(pphar->manifest)), sizeof(phar_entry_fp_info)); } PHAR_GLOBALS->cached_fp = stuff; @@ -3593,7 +3589,7 @@ PHP_MINFO_FUNCTION(phar) /* {{{ */ #ifdef PHAR_HAVE_OPENSSL php_info_print_table_row(2, "Native OpenSSL support", "enabled"); #else - if (zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) { + if (zend_hash_str_exists(&module_registry, "openssl", sizeof("openssl")-1)) { php_info_print_table_row(2, "OpenSSL support", "enabled"); } else { php_info_print_table_row(2, "OpenSSL support", "disabled (install ext/openssl)"); diff --git a/ext/phar/phar_internal.h b/ext/phar/phar_internal.h index 12f0057763..c3610f8823 100644 --- a/ext/phar/phar_internal.h +++ b/ext/phar/phar_internal.h @@ -243,7 +243,7 @@ typedef struct _phar_entry_info { /* remainder */ /* when changing compression, save old flags in case fp is NULL */ php_uint32 old_flags; - zval *metadata; + zval metadata; int metadata_len; /* only used for cached manifests */ php_uint32 filename_len; char *filename; @@ -311,7 +311,7 @@ struct _phar_archive_data { php_uint32 sig_flags; int sig_len; char *signature; - zval *metadata; + zval metadata; int metadata_len; /* only used for cached manifests */ uint phar_pos; /* if 1, then this alias was manually specified by the user and is not a permanent alias */ @@ -538,7 +538,7 @@ static inline void phar_set_inode(phar_entry_info *entry TSRMLS_DC) /* {{{ */ tmp_len = entry->filename_len + entry->phar->fname_len; memcpy(tmp, entry->phar->fname, entry->phar->fname_len); memcpy(tmp + entry->phar->fname_len, entry->filename, entry->filename_len); - entry->inode = (unsigned short)zend_get_hash_value(tmp, tmp_len); + entry->inode = (unsigned short)zend_hash_func(tmp, tmp_len); } /* }}} */ @@ -570,8 +570,8 @@ int phar_mount_entry(phar_archive_data *phar, char *filename, int filename_len, char *phar_find_in_include_path(char *file, int file_len, phar_archive_data **pphar TSRMLS_DC); char *phar_fix_filepath(char *path, int *new_len, int use_cwd TSRMLS_DC); phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry, char **error TSRMLS_DC); -int phar_parse_metadata(char **buffer, zval **metadata, int zip_metadata_len TSRMLS_DC); -void destroy_phar_manifest_entry(void *pDest); +int phar_parse_metadata(char **buffer, zval *metadata, int zip_metadata_len TSRMLS_DC); +void destroy_phar_manifest_entry(zval *zv); int phar_seek_efp(phar_entry_info *entry, off_t offset, int whence, off_t position, int follow_links TSRMLS_DC); php_stream *phar_get_efp(phar_entry_info *entry, int follow_links TSRMLS_DC); int phar_copy_entry_fp(phar_entry_info *source, phar_entry_info *dest, char **error TSRMLS_DC); diff --git a/ext/phar/phar_object.c b/ext/phar/phar_object.c index bb2b4a1098..5a45dcfdbd 100644 --- a/ext/phar/phar_object.c +++ b/ext/phar/phar_object.c @@ -47,7 +47,7 @@ static int phar_file_type(HashTable *mimes, char *file, char **mime_type TSRMLS_ return PHAR_MIME_OTHER; } ++ext; - if (SUCCESS != zend_hash_find(mimes, ext, strlen(ext), (void **) &mime)) { + if (NULL == (mime = zend_hash_str_find_ptr(mimes, ext, strlen(ext)))) { *mime_type = "application/octet-stream"; return PHAR_MIME_OTHER; } @@ -59,43 +59,42 @@ static int phar_file_type(HashTable *mimes, char *file, char **mime_type TSRMLS_ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char *basename, int request_uri_len TSRMLS_DC) /* {{{ */ { HashTable *_SERVER; - zval **stuff; + zval *stuff; char *path_info; int basename_len = strlen(basename); int code; - zval *temp; + zval temp; /* "tweak" $_SERVER variables requested in earlier call to Phar::mungServer() */ - if (!PG(http_globals)[TRACK_VARS_SERVER]) { + if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) == IS_UNDEF) { return; } - _SERVER = Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]); + _SERVER = Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]); /* PATH_INFO and PATH_TRANSLATED should always be munged */ - if (SUCCESS == zend_hash_find(_SERVER, "PATH_INFO", sizeof("PATH_INFO"), (void **) &stuff)) { - path_info = Z_STRVAL_PP(stuff); - code = Z_STRLEN_PP(stuff); - - if (Z_STRLEN_PP(stuff) > entry_len && !memcmp(Z_STRVAL_PP(stuff), entry, entry_len)) { - ZVAL_STRINGL(*stuff, Z_STRVAL_PP(stuff) + entry_len, request_uri_len, 1); - - MAKE_STD_ZVAL(temp); - ZVAL_STRINGL(temp, path_info, code, 0); - - zend_hash_update(_SERVER, "PHAR_PATH_INFO", sizeof("PHAR_PATH_INFO"), &temp, sizeof(zval **), NULL); + if (NULL != (stuff = zend_hash_str_find(_SERVER, "PATH_INFO", sizeof("PATH_INFO")-1))) { + path_info = Z_STRVAL_P(stuff); + code = Z_STRLEN_P(stuff); + if (code > entry_len && !memcmp(path_info, entry, entry_len)) { + ZVAL_STR(&temp, Z_STR_P(stuff)); + ZVAL_STRINGL(stuff, path_info + entry_len, request_uri_len); + zend_hash_str_update(_SERVER, "PHAR_PATH_INFO", sizeof("PHAR_PATH_INFO")-1, &temp); } } - if (SUCCESS == zend_hash_find(_SERVER, "PATH_TRANSLATED", sizeof("PATH_TRANSLATED"), (void **) &stuff)) { - path_info = Z_STRVAL_PP(stuff); - code = Z_STRLEN_PP(stuff); - Z_STRLEN_PP(stuff) = spprintf(&(Z_STRVAL_PP(stuff)), 4096, "phar://%s%s", fname, entry); + if (NULL != (stuff = zend_hash_str_find(_SERVER, "PATH_TRANSLATED", sizeof("PATH_TRANSLATED")-1))) { + char *str = NULL; + int len; - MAKE_STD_ZVAL(temp); - ZVAL_STRINGL(temp, path_info, code, 0); + // TODO: avoid reallocation ??? + len = spprintf(&str, 4096, "phar://%s%s", fname, entry); - zend_hash_update(_SERVER, "PHAR_PATH_TRANSLATED", sizeof("PHAR_PATH_TRANSLATED"), (void *) &temp, sizeof(zval **), NULL); + ZVAL_STR(&temp, Z_STR_P(stuff)); + ZVAL_STRINGL(stuff, str, len); + efree(str); + + zend_hash_str_update(_SERVER, "PHAR_PATH_TRANSLATED", sizeof("PHAR_PATH_TRANSLATED")-1, (void *) &temp); } if (!PHAR_GLOBALS->phar_SERVER_mung_list) { @@ -103,60 +102,51 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char } if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_REQUEST_URI) { - if (SUCCESS == zend_hash_find(_SERVER, "REQUEST_URI", sizeof("REQUEST_URI"), (void **) &stuff)) { - path_info = Z_STRVAL_PP(stuff); - code = Z_STRLEN_PP(stuff); - - if (Z_STRLEN_PP(stuff) > basename_len && !memcmp(Z_STRVAL_PP(stuff), basename, basename_len)) { - ZVAL_STRINGL(*stuff, Z_STRVAL_PP(stuff) + basename_len, Z_STRLEN_PP(stuff) - basename_len, 1); - - MAKE_STD_ZVAL(temp); - ZVAL_STRINGL(temp, path_info, code, 0); - - zend_hash_update(_SERVER, "PHAR_REQUEST_URI", sizeof("PHAR_REQUEST_URI"), (void *) &temp, sizeof(zval **), NULL); + if (NULL != (stuff = zend_hash_str_find(_SERVER, "REQUEST_URI", sizeof("REQUEST_URI")-1))) { + path_info = Z_STRVAL_P(stuff); + code = Z_STRLEN_P(stuff); + if (code > basename_len && !memcmp(path_info, basename, basename_len)) { + ZVAL_STR(&temp, Z_STR_P(stuff)); + ZVAL_STRINGL(stuff, path_info + basename_len, code - basename_len); + zend_hash_str_update(_SERVER, "PHAR_REQUEST_URI", sizeof("PHAR_REQUEST_URI")-1, &temp); } } } if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_PHP_SELF) { - if (SUCCESS == zend_hash_find(_SERVER, "PHP_SELF", sizeof("PHP_SELF"), (void **) &stuff)) { - path_info = Z_STRVAL_PP(stuff); - code = Z_STRLEN_PP(stuff); - - if (Z_STRLEN_PP(stuff) > basename_len && !memcmp(Z_STRVAL_PP(stuff), basename, basename_len)) { - ZVAL_STRINGL(*stuff, Z_STRVAL_PP(stuff) + basename_len, Z_STRLEN_PP(stuff) - basename_len, 1); - - MAKE_STD_ZVAL(temp); - ZVAL_STRINGL(temp, path_info, code, 0); - - zend_hash_update(_SERVER, "PHAR_PHP_SELF", sizeof("PHAR_PHP_SELF"), (void *) &temp, sizeof(zval **), NULL); + if (NULL != (stuff = zend_hash_str_find(_SERVER, "PHP_SELF", sizeof("PHP_SELF")-1))) { + path_info = Z_STRVAL_P(stuff); + code = Z_STRLEN_P(stuff); + + if (code > basename_len && !memcmp(path_info, basename, basename_len)) { + ZVAL_STR(&temp, Z_STR_P(stuff)); + ZVAL_STRINGL(stuff, path_info + basename_len, code - basename_len); + zend_hash_str_update(_SERVER, "PHAR_PHP_SELF", sizeof("PHAR_PHP_SELF")-1, &temp); } } } if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_NAME) { - if (SUCCESS == zend_hash_find(_SERVER, "SCRIPT_NAME", sizeof("SCRIPT_NAME"), (void **) &stuff)) { - path_info = Z_STRVAL_PP(stuff); - code = Z_STRLEN_PP(stuff); - ZVAL_STRINGL(*stuff, entry, entry_len, 1); - - MAKE_STD_ZVAL(temp); - ZVAL_STRINGL(temp, path_info, code, 0); - - zend_hash_update(_SERVER, "PHAR_SCRIPT_NAME", sizeof("PHAR_SCRIPT_NAME"), (void *) &temp, sizeof(zval **), NULL); + if (NULL != (stuff = zend_hash_str_find(_SERVER, "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1))) { + ZVAL_STR(&temp, Z_STR_P(stuff)); + ZVAL_STRINGL(stuff, entry, entry_len); + zend_hash_str_update(_SERVER, "PHAR_SCRIPT_NAME", sizeof("PHAR_SCRIPT_NAME")-1, &temp); } } if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_FILENAME) { - if (SUCCESS == zend_hash_find(_SERVER, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME"), (void **) &stuff)) { - path_info = Z_STRVAL_PP(stuff); - code = Z_STRLEN_PP(stuff); - Z_STRLEN_PP(stuff) = spprintf(&(Z_STRVAL_PP(stuff)), 4096, "phar://%s%s", fname, entry); + if (NULL != (stuff = zend_hash_str_find(_SERVER, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1))) { + char *str = NULL; + int len; + + // TODO: avoid reallocation ??? + len = spprintf(&str, 4096, "phar://%s%s", fname, entry); - MAKE_STD_ZVAL(temp); - ZVAL_STRINGL(temp, path_info, code, 0); + ZVAL_STR(&temp, Z_STR_P(stuff)); + ZVAL_STRINGL(stuff, str, len); + efree(str); - zend_hash_update(_SERVER, "PHAR_SCRIPT_FILENAME", sizeof("PHAR_SCRIPT_FILENAME"), (void *) &temp, sizeof(zval **), NULL); + zend_hash_str_update(_SERVER, "PHAR_SCRIPT_FILENAME", sizeof("PHAR_SCRIPT_FILENAME")-1, &temp); } } } @@ -169,10 +159,11 @@ static int phar_file_action(phar_archive_data *phar, phar_entry_info *info, char zend_syntax_highlighter_ini syntax_highlighter_ini; sapi_header_line ctr = {0}; size_t got; - int dummy = 1, name_len; + zval dummy; + int name_len; zend_file_handle file_handle; zend_op_array *new_op_array; - zval *result = NULL; + zval result; php_stream *fp; off_t position; @@ -258,7 +249,8 @@ static int phar_file_action(phar_archive_data *phar, phar_entry_info *info, char PHAR_G(cwd) = NULL; PHAR_G(cwd_len) = 0; - if (zend_hash_add(&EG(included_files), name, name_len+1, (void *)&dummy, sizeof(int), NULL) == SUCCESS) { + ZVAL_NULL(&dummy); + if (zend_hash_str_add(&EG(included_files), name, name_len, &dummy) != NULL) { if ((cwd = zend_memrchr(entry, '/', entry_len))) { PHAR_G(cwd_init) = 1; if (entry == cwd) { @@ -277,7 +269,7 @@ static int phar_file_action(phar_archive_data *phar, phar_entry_info *info, char new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE TSRMLS_CC); if (!new_op_array) { - zend_hash_del(&EG(included_files), name, name_len+1); + zend_hash_str_del(&EG(included_files), name, name_len); } zend_destroy_file_handle(&file_handle TSRMLS_CC); @@ -290,11 +282,11 @@ static int phar_file_action(phar_archive_data *phar, phar_entry_info *info, char efree(arch); #endif if (new_op_array) { - EG(return_value_ptr_ptr) = &result; + ZVAL_UNDEF(&result); EG(active_op_array) = new_op_array; zend_try { - zend_execute(new_op_array TSRMLS_CC); + zend_execute(new_op_array, &result TSRMLS_CC); if (PHAR_G(cwd)) { efree(PHAR_G(cwd)); PHAR_G(cwd) = NULL; @@ -305,11 +297,7 @@ static int phar_file_action(phar_archive_data *phar, phar_entry_info *info, char efree(name); destroy_op_array(new_op_array TSRMLS_CC); efree(new_op_array); - - - if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) { - zval_ptr_dtor(EG(return_value_ptr_ptr)); - } + zval_ptr_dtor(&result); } zend_catch { if (PHAR_G(cwd)) { efree(PHAR_G(cwd)); @@ -377,17 +365,17 @@ static void phar_postprocess_ru_web(char *fname, int fname_len, char **entry, in { char *e = *entry + 1, *u = NULL, *u1 = NULL, *saveu = NULL; int e_len = *entry_len - 1, u_len = 0; - phar_archive_data **pphar = NULL; + phar_archive_data *pphar; /* we already know we can retrieve the phar if we reach here */ - zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, (void **) &pphar); + pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len); if (!pphar && PHAR_G(manifest_cached)) { - zend_hash_find(&cached_phars, fname, fname_len, (void **) &pphar); + pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len); } do { - if (zend_hash_exists(&((*pphar)->manifest), e, e_len)) { + if (zend_hash_str_exists(&(pphar->manifest), e, e_len)) { if (u) { u[0] = '/'; *ru = estrndup(u, u_len+1); @@ -454,15 +442,18 @@ PHP_METHOD(Phar, running) if (fname_len > 7 && !memcmp(fname, "phar://", 7) && SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) { efree(entry); if (retphar) { - RETVAL_STRINGL(fname, arch_len + 7, 1); + RETVAL_STRINGL(fname, arch_len + 7); efree(arch); return; } else { - RETURN_STRINGL(arch, arch_len, 0); + // TODO: avoid reallocation ??? + RETVAL_STRINGL(arch, arch_len); + efree(arch); + return; } } - RETURN_STRINGL("", 0, 1); + RETURN_EMPTY_STRING(); } /* }}} */ @@ -476,7 +467,7 @@ PHP_METHOD(Phar, mount) { char *fname, *arch = NULL, *entry = NULL, *path, *actual; int fname_len, arch_len, entry_len, path_len, actual_len; - phar_archive_data **pphar; + phar_archive_data *pphar; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &path, &path_len, &actual, &actual_len) == FAILURE) { return; @@ -499,9 +490,9 @@ PHP_METHOD(Phar, mount) return; } carry_on2: - if (SUCCESS != zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **)&pphar)) { - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, arch, arch_len, (void **)&pphar)) { - if (SUCCESS == phar_copy_on_write(pphar TSRMLS_CC)) { + if (NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len))) { + if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, arch, arch_len))) { + if (SUCCESS == phar_copy_on_write(&pphar TSRMLS_CC)) { goto carry_on; } } @@ -514,7 +505,7 @@ carry_on2: return; } carry_on: - if (SUCCESS != phar_mount_entry(*pphar, actual, actual_len, path, path_len TSRMLS_CC)) { + if (SUCCESS != phar_mount_entry(pphar, actual, actual_len, path, path_len TSRMLS_CC)) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Mounting of %s to %s within phar %s failed", path, actual, arch); if (path && path == entry) { efree(entry); @@ -536,10 +527,10 @@ carry_on: } return; - } else if (PHAR_GLOBALS->phar_fname_map.arHash && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, (void **)&pphar)) { + } else if (PHAR_GLOBALS->phar_fname_map.arHash && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) { goto carry_on; - } else if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, fname, fname_len, (void **)&pphar)) { - if (SUCCESS == phar_copy_on_write(pphar TSRMLS_CC)) { + } else if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len))) { + if (SUCCESS == phar_copy_on_write(&pphar TSRMLS_CC)) { goto carry_on; } @@ -565,7 +556,7 @@ PHP_METHOD(Phar, webPhar) { zval *mimeoverride = NULL, *rewrite = NULL; char *alias = NULL, *error, *index_php = NULL, *f404 = NULL, *ru = NULL; - int alias_len = 0, ret, f404_len = 0, free_pathinfo = 0, ru_len = 0; + int alias_len = 0, f404_len = 0, free_pathinfo = 0, ru_len = 0; char *fname, *path_info, *mime_type = NULL, *entry, *pt; const char *basename; int fname_len, entry_len, code, index_php_len = 0, not_cgi; @@ -608,31 +599,31 @@ PHP_METHOD(Phar, webPhar) if ((strlen(sapi_module.name) == sizeof("cgi-fcgi")-1 && !strncmp(sapi_module.name, "cgi-fcgi", sizeof("cgi-fcgi")-1)) || (strlen(sapi_module.name) == sizeof("cgi")-1 && !strncmp(sapi_module.name, "cgi", sizeof("cgi")-1))) { - if (PG(http_globals)[TRACK_VARS_SERVER]) { - HashTable *_server = Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]); - zval **z_script_name, **z_path_info; + if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) != IS_UNDEF) { + HashTable *_server = Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]); + zval *z_script_name, *z_path_info; - if (SUCCESS != zend_hash_find(_server, "SCRIPT_NAME", sizeof("SCRIPT_NAME"), (void**)&z_script_name) || - IS_STRING != Z_TYPE_PP(z_script_name) || - !strstr(Z_STRVAL_PP(z_script_name), basename)) { + if (NULL == (z_script_name = zend_hash_str_find(_server, "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1)) || + IS_STRING != Z_TYPE_P(z_script_name) || + !strstr(Z_STRVAL_P(z_script_name), basename)) { return; } - if (SUCCESS == zend_hash_find(_server, "PATH_INFO", sizeof("PATH_INFO"), (void**)&z_path_info) && - IS_STRING == Z_TYPE_PP(z_path_info)) { - entry_len = Z_STRLEN_PP(z_path_info); - entry = estrndup(Z_STRVAL_PP(z_path_info), entry_len); - path_info = emalloc(Z_STRLEN_PP(z_script_name) + entry_len + 1); - memcpy(path_info, Z_STRVAL_PP(z_script_name), Z_STRLEN_PP(z_script_name)); - memcpy(path_info + Z_STRLEN_PP(z_script_name), entry, entry_len + 1); + if (NULL != (z_path_info = zend_hash_str_find(_server, "PATH_INFO", sizeof("PATH_INFO")-1)) && + IS_STRING == Z_TYPE_P(z_path_info)) { + entry_len = Z_STRLEN_P(z_path_info); + entry = estrndup(Z_STRVAL_P(z_path_info), entry_len); + path_info = emalloc(Z_STRLEN_P(z_script_name) + entry_len + 1); + memcpy(path_info, Z_STRVAL_P(z_script_name), Z_STRLEN_P(z_script_name)); + memcpy(path_info + Z_STRLEN_P(z_script_name), entry, entry_len + 1); free_pathinfo = 1; } else { entry_len = 0; entry = estrndup("", 0); - path_info = Z_STRVAL_PP(z_script_name); + path_info = Z_STRVAL_P(z_script_name); } - pt = estrndup(Z_STRVAL_PP(z_script_name), Z_STRLEN_PP(z_script_name)); + pt = estrndup(Z_STRVAL_P(z_script_name), Z_STRLEN_P(z_script_name)); } else { char *testit; @@ -679,11 +670,9 @@ PHP_METHOD(Phar, webPhar) if (rewrite) { zend_fcall_info fci; zend_fcall_info_cache fcc; - zval *params, *retval_ptr, **zp[1]; + zval params, retval; - MAKE_STD_ZVAL(params); - ZVAL_STRINGL(params, entry, entry_len, 1); - zp[0] = ¶ms; + ZVAL_STRINGL(¶ms, entry, entry_len); if (FAILURE == zend_fcall_info_init(rewrite, 0, &fci, &fcc, NULL, NULL TSRMLS_CC)) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar error: invalid rewrite callback"); @@ -696,9 +685,9 @@ PHP_METHOD(Phar, webPhar) } fci.param_count = 1; - fci.params = zp; - Z_ADDREF_P(params); - fci.retval_ptr_ptr = &retval_ptr; + fci.params = ¶ms; + Z_ADDREF(params); + fci.retval = &retval; if (FAILURE == zend_call_function(&fci, &fcc TSRMLS_CC)) { if (!EG(exception)) { @@ -712,7 +701,7 @@ PHP_METHOD(Phar, webPhar) return; } - if (!fci.retval_ptr_ptr || !retval_ptr) { + if (Z_TYPE_P(fci.retval) == IS_UNDEF || Z_TYPE(retval) == IS_UNDEF) { if (free_pathinfo) { efree(path_info); } @@ -720,20 +709,21 @@ PHP_METHOD(Phar, webPhar) return; } - switch (Z_TYPE_P(retval_ptr)) { + switch (Z_TYPE(retval)) { case IS_STRING: efree(entry); - if (fci.retval_ptr_ptr != &retval_ptr) { - entry = estrndup(Z_STRVAL_PP(fci.retval_ptr_ptr), Z_STRLEN_PP(fci.retval_ptr_ptr)); - entry_len = Z_STRLEN_PP(fci.retval_ptr_ptr); + if (fci.retval != &retval) { + entry = estrndup(Z_STRVAL_P(fci.retval), Z_STRLEN_P(fci.retval)); + entry_len = Z_STRLEN_P(fci.retval); } else { - entry = Z_STRVAL_P(retval_ptr); - entry_len = Z_STRLEN_P(retval_ptr); + entry = Z_STRVAL(retval); + entry_len = Z_STRLEN(retval); } break; - case IS_BOOL: + case IS_TRUE: + case IS_FALSE: phar_do_403(entry, entry_len TSRMLS_CC); if (free_pathinfo) { @@ -743,8 +733,6 @@ PHP_METHOD(Phar, webPhar) zend_bailout(); return; default: - efree(retval_ptr); - if (free_pathinfo) { efree(path_info); } @@ -831,17 +819,17 @@ PHP_METHOD(Phar, webPhar) if (mimeoverride && zend_hash_num_elements(Z_ARRVAL_P(mimeoverride))) { const char *ext = zend_memrchr(entry, '.', entry_len); - zval **val; + zval *val; if (ext) { ++ext; - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(mimeoverride), ext, strlen(ext)+1, (void **) &val)) { - switch (Z_TYPE_PP(val)) { + if (NULL != (val = zend_hash_str_find(Z_ARRVAL_P(mimeoverride), ext, strlen(ext)))) { + switch (Z_TYPE_P(val)) { case IS_LONG: - if (Z_LVAL_PP(val) == PHAR_MIME_PHP || Z_LVAL_PP(val) == PHAR_MIME_PHPS) { + if (Z_LVAL_P(val) == PHAR_MIME_PHP || Z_LVAL_P(val) == PHAR_MIME_PHPS) { mime_type = ""; - code = Z_LVAL_PP(val); + code = Z_LVAL_P(val); } else { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown mime type specifier used, only Phar::PHP, Phar::PHPS and a mime type string are allowed"); #ifdef PHP_WIN32 @@ -851,7 +839,7 @@ PHP_METHOD(Phar, webPhar) } break; case IS_STRING: - mime_type = Z_STRVAL_PP(val); + mime_type = Z_STRVAL_P(val); code = PHAR_MIME_OTHER; break; default: @@ -868,7 +856,7 @@ PHP_METHOD(Phar, webPhar) if (!mime_type) { code = phar_file_type(&PHAR_G(mime_types), entry, &mime_type TSRMLS_CC); } - ret = phar_file_action(phar, info, mime_type, code, entry, entry_len, fname, pt, ru, ru_len TSRMLS_CC); + phar_file_action(phar, info, mime_type, code, entry, entry_len, fname, pt, ru, ru_len TSRMLS_CC); } /* }}} */ @@ -899,32 +887,32 @@ PHP_METHOD(Phar, mungServer) phar_request_initialize(TSRMLS_C); for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(mungvalues)); SUCCESS == zend_hash_has_more_elements(Z_ARRVAL_P(mungvalues)); zend_hash_move_forward(Z_ARRVAL_P(mungvalues))) { - zval **data = NULL; + zval *data = NULL; - if (SUCCESS != zend_hash_get_current_data(Z_ARRVAL_P(mungvalues), (void **) &data)) { + if (NULL == (data = zend_hash_get_current_data(Z_ARRVAL_P(mungvalues)))) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "unable to retrieve array value in Phar::mungServer()"); return; } - if (Z_TYPE_PP(data) != IS_STRING) { + if (Z_TYPE_P(data) != IS_STRING) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Non-string value passed to Phar::mungServer(), expecting an array of any of these strings: PHP_SELF, REQUEST_URI, SCRIPT_FILENAME, SCRIPT_NAME"); return; } - if (Z_STRLEN_PP(data) == sizeof("PHP_SELF")-1 && !strncmp(Z_STRVAL_PP(data), "PHP_SELF", sizeof("PHP_SELF")-1)) { + if (Z_STRLEN_P(data) == sizeof("PHP_SELF")-1 && !strncmp(Z_STRVAL_P(data), "PHP_SELF", sizeof("PHP_SELF")-1)) { PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_PHP_SELF; } - if (Z_STRLEN_PP(data) == sizeof("REQUEST_URI")-1) { - if (!strncmp(Z_STRVAL_PP(data), "REQUEST_URI", sizeof("REQUEST_URI")-1)) { + if (Z_STRLEN_P(data) == sizeof("REQUEST_URI")-1) { + if (!strncmp(Z_STRVAL_P(data), "REQUEST_URI", sizeof("REQUEST_URI")-1)) { PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_REQUEST_URI; } - if (!strncmp(Z_STRVAL_PP(data), "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1)) { + if (!strncmp(Z_STRVAL_P(data), "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1)) { PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_NAME; } } - if (Z_STRLEN_PP(data) == sizeof("SCRIPT_FILENAME")-1 && !strncmp(Z_STRVAL_PP(data), "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1)) { + if (Z_STRLEN_P(data) == sizeof("SCRIPT_FILENAME")-1 && !strncmp(Z_STRVAL_P(data), "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1)) { PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_FILENAME; } } @@ -970,7 +958,9 @@ PHP_METHOD(Phar, createDefaultStub) efree(error); return; } - RETURN_STRINGL(stub, stub_len, 0); + // TODO: avoid reallocation ??? + RETVAL_STRINGL(stub, stub_len); + efree(stub); } /* }}} */ @@ -1024,7 +1014,7 @@ PHP_METHOD(Phar, apiVersion) if (zend_parse_parameters_none() == FAILURE) { return; } - RETURN_STRINGL(PHP_PHAR_API_VERSION, sizeof(PHP_PHAR_API_VERSION)-1, 1); + RETURN_STRINGL(PHP_PHAR_API_VERSION, sizeof(PHP_PHAR_API_VERSION)-1); } /* }}}*/ @@ -1148,7 +1138,7 @@ PHP_METHOD(Phar, __construct) phar_archive_data *phar_data; zval *zobj = getThis(), arg1, arg2; - phar_obj = (phar_archive_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + phar_obj = (phar_archive_object*)Z_OBJ_P(getThis()); is_data = instanceof_function(Z_OBJCE_P(zobj), phar_ce_data TSRMLS_CC); @@ -1246,19 +1236,19 @@ PHP_METHOD(Phar, __construct) fname_len = spprintf(&fname, 0, "phar://%s", phar_data->fname); } - INIT_PZVAL(&arg1); - ZVAL_STRINGL(&arg1, fname, fname_len, 0); - INIT_PZVAL(&arg2); + ZVAL_STRINGL(&arg1, fname, fname_len); ZVAL_LONG(&arg2, flags); - zend_call_method_with_2_params(&zobj, Z_OBJCE_P(zobj), + zend_call_method_with_2_params(zobj, Z_OBJCE_P(zobj), &spl_ce_RecursiveDirectoryIterator->constructor, "__construct", NULL, &arg1, &arg2); + zval_ptr_dtor(&arg1); + if (!phar_data->is_persistent) { phar_obj->arc.archive->is_data = is_data; } else if (!EG(exception)) { /* register this guy so we can modify if necessary */ - zend_hash_add(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->arc.archive, sizeof(phar_obj->arc.archive), (void *) &phar_obj, sizeof(phar_archive_object **), NULL); + zend_hash_str_add_ptr(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->arc.archive, sizeof(phar_obj->arc.archive), phar_obj); } phar_obj->spl.info_class = phar_ce_entry; @@ -1287,7 +1277,7 @@ PHP_METHOD(Phar, getSupportedSignatures) #if PHAR_HAVE_OPENSSL add_next_index_stringl(return_value, "OpenSSL", 7); #else - if (zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) { + if (zend_hash_str_exists(&module_registry, "openssl", sizeof("openssl")-1)) { add_next_index_stringl(return_value, "OpenSSL", 7); } #endif @@ -1384,7 +1374,7 @@ PHP_METHOD(Phar, unlinkArchive) #if HAVE_SPL #define PHAR_ARCHIVE_OBJECT() \ - phar_archive_object *phar_obj = (phar_archive_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \ + phar_archive_object *phar_obj = (phar_archive_object*)Z_OBJ_P((getThis())); \ if (!phar_obj->arc.archive) { \ zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \ "Cannot call method on an uninitialized Phar object"); \ @@ -1396,10 +1386,10 @@ PHP_METHOD(Phar, unlinkArchive) */ PHP_METHOD(Phar, __destruct) { - phar_archive_object *phar_obj = (phar_archive_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + phar_archive_object *phar_obj = (phar_archive_object*)Z_OBJ_P((getThis())); if (phar_obj->arc.archive && phar_obj->arc.archive->is_persistent) { - zend_hash_del(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->arc.archive, sizeof(phar_obj->arc.archive)); + zend_hash_str_del(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->arc.archive, sizeof(phar_obj->arc.archive)); } } /* }}} */ @@ -1416,7 +1406,7 @@ struct _phar_t { static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */ { - zval **value; + zval *value; zend_bool close_fp = 1; struct _phar_t *p_obj = (struct _phar_t*) puser; uint str_key_len, base_len = p_obj->l, fname_len; @@ -1429,7 +1419,7 @@ static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ phar_archive_object *phar_obj = p_obj->p; char *str = "[stream]"; - iter->funcs->get_current_data(iter, &value TSRMLS_CC); + value = iter->funcs->get_current_data(iter TSRMLS_CC); if (EG(exception)) { return ZEND_HASH_APPLY_STOP; @@ -1441,7 +1431,7 @@ static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ return ZEND_HASH_APPLY_STOP; } - switch (Z_TYPE_PP(value)) { + switch (Z_TYPE_P(value)) { case IS_STRING: break; case IS_RESOURCE: @@ -1480,10 +1470,10 @@ static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ opened = (char *) estrndup(str, sizeof("[stream]") + 1); goto after_open_fp; case IS_OBJECT: - if (instanceof_function(Z_OBJCE_PP(value), spl_ce_SplFileInfo TSRMLS_CC)) { + if (instanceof_function(Z_OBJCE_P(value), spl_ce_SplFileInfo TSRMLS_CC)) { char *test = NULL; zval dummy; - spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(*value TSRMLS_CC); + spl_filesystem_object *intern = (spl_filesystem_object*)Z_OBJ_P(value); if (!base_len) { zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Iterator %v returns an SplFileInfo object, so base directory must be specified", ce->name); @@ -1496,7 +1486,7 @@ static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ fname_len = spprintf(&fname, 0, "%s%c%s", test, DEFAULT_SLASH, intern->u.dir.entry.d_name); php_stat(fname, fname_len, FS_IS_DIR, &dummy TSRMLS_CC); - if (Z_BVAL(dummy)) { + if (Z_TYPE(dummy) == IS_TRUE) { /* ignore directories */ efree(fname); return ZEND_HASH_APPLY_KEEP; @@ -1534,8 +1524,8 @@ static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ return ZEND_HASH_APPLY_STOP; } - fname = Z_STRVAL_PP(value); - fname_len = Z_STRLEN_PP(value); + fname = Z_STRVAL_P(value); + fname_len = Z_STRLEN_P(value); phar_spl_fileinfo: if (base_len) { @@ -1746,7 +1736,7 @@ PHP_METHOD(Phar, buildFromDirectory) char *dir, *error, *regex = NULL; int dir_len, regex_len = 0; zend_bool apply_reg = 0; - zval arg, arg2, *iter, *iteriter, *regexiter = NULL; + zval arg, arg2, iter, iteriter, regexiter; struct _phar_t pass; PHAR_ARCHIVE_OBJECT(); @@ -1761,30 +1751,25 @@ PHP_METHOD(Phar, buildFromDirectory) RETURN_FALSE; } - MAKE_STD_ZVAL(iter); - - if (SUCCESS != object_init_ex(iter, spl_ce_RecursiveDirectoryIterator)) { + if (SUCCESS != object_init_ex(&iter, spl_ce_RecursiveDirectoryIterator)) { zval_ptr_dtor(&iter); zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate directory iterator for %s", phar_obj->arc.archive->fname); RETURN_FALSE; } - INIT_PZVAL(&arg); - ZVAL_STRINGL(&arg, dir, dir_len, 0); - INIT_PZVAL(&arg2); + ZVAL_STRINGL(&arg, dir, dir_len); ZVAL_LONG(&arg2, SPL_FILE_DIR_SKIPDOTS|SPL_FILE_DIR_UNIXPATHS); zend_call_method_with_2_params(&iter, spl_ce_RecursiveDirectoryIterator, &spl_ce_RecursiveDirectoryIterator->constructor, "__construct", NULL, &arg, &arg2); + zval_ptr_dtor(&arg); if (EG(exception)) { zval_ptr_dtor(&iter); RETURN_FALSE; } - MAKE_STD_ZVAL(iteriter); - - if (SUCCESS != object_init_ex(iteriter, spl_ce_RecursiveIteratorIterator)) { + if (SUCCESS != object_init_ex(&iteriter, spl_ce_RecursiveIteratorIterator)) { zval_ptr_dtor(&iter); zval_ptr_dtor(&iteriter); zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate directory iterator for %s", phar_obj->arc.archive->fname); @@ -1792,7 +1777,7 @@ PHP_METHOD(Phar, buildFromDirectory) } zend_call_method_with_1_params(&iteriter, spl_ce_RecursiveIteratorIterator, - &spl_ce_RecursiveIteratorIterator->constructor, "__construct", NULL, iter); + &spl_ce_RecursiveIteratorIterator->constructor, "__construct", NULL, &iter); if (EG(exception)) { zval_ptr_dtor(&iter); @@ -1804,25 +1789,24 @@ PHP_METHOD(Phar, buildFromDirectory) if (regex_len > 0) { apply_reg = 1; - MAKE_STD_ZVAL(regexiter); - if (SUCCESS != object_init_ex(regexiter, spl_ce_RegexIterator)) { + if (SUCCESS != object_init_ex(®exiter, spl_ce_RegexIterator)) { zval_ptr_dtor(&iteriter); - zval_dtor(regexiter); + zval_dtor(®exiter); zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate regex iterator for %s", phar_obj->arc.archive->fname); RETURN_FALSE; } - INIT_PZVAL(&arg2); - ZVAL_STRINGL(&arg2, regex, regex_len, 0); + ZVAL_STRINGL(&arg2, regex, regex_len); zend_call_method_with_2_params(®exiter, spl_ce_RegexIterator, - &spl_ce_RegexIterator->constructor, "__construct", NULL, iteriter, &arg2); + &spl_ce_RegexIterator->constructor, "__construct", NULL, &iteriter, &arg2); + zval_ptr_dtor(&arg2); } array_init(return_value); - pass.c = apply_reg ? Z_OBJCE_P(regexiter) : Z_OBJCE_P(iteriter); + pass.c = apply_reg ? Z_OBJCE(regexiter) : Z_OBJCE(iteriter); pass.p = phar_obj; pass.b = dir; pass.l = dir_len; @@ -1844,7 +1828,7 @@ PHP_METHOD(Phar, buildFromDirectory) return; } - if (SUCCESS == spl_iterator_apply((apply_reg ? regexiter : iteriter), (spl_iterator_apply_func_t) phar_build, (void *) &pass TSRMLS_CC)) { + if (SUCCESS == spl_iterator_apply((apply_reg ? ®exiter : &iteriter), (spl_iterator_apply_func_t) phar_build, (void *) &pass TSRMLS_CC)) { zval_ptr_dtor(&iteriter); if (apply_reg) { @@ -2020,19 +2004,19 @@ static int phar_copy_file_contents(phar_entry_info *entry, php_stream *fp TSRMLS } /* }}} */ -static zval *phar_rename_archive(phar_archive_data *phar, char *ext, zend_bool compress TSRMLS_DC) /* {{{ */ +static zend_object *phar_rename_archive(phar_archive_data *phar, char *ext, zend_bool compress TSRMLS_DC) /* {{{ */ { const char *oldname = NULL; char *oldpath = NULL; char *basename = NULL, *basepath = NULL; char *newname = NULL, *newpath = NULL; - zval *ret, arg1; + zval ret, arg1; zend_class_entry *ce; char *error; const char *pcr_error; int ext_len = ext ? strlen(ext) : 0; int oldname_len; - phar_archive_data **pphar = NULL; + phar_archive_data *pphar = NULL; php_stream_statbuf ssb; if (!ext) { @@ -2113,23 +2097,23 @@ static zval *phar_rename_archive(phar_archive_data *phar, char *ext, zend_bool c efree(basepath); efree(newname); - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, newpath, phar->fname_len, (void **) &pphar)) { + if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, newpath, phar->fname_len))) { efree(oldpath); zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to add newly converted phar \"%s\" to the list of phars, new phar name is in phar.cache_list", phar->fname); return NULL; } - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, (void **) &pphar)) { - if ((*pphar)->fname_len == phar->fname_len && !memcmp((*pphar)->fname, phar->fname, phar->fname_len)) { + if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len))) { + if (pphar->fname_len == phar->fname_len && !memcmp(pphar->fname, phar->fname, phar->fname_len)) { if (!zend_hash_num_elements(&phar->manifest)) { - (*pphar)->is_tar = phar->is_tar; - (*pphar)->is_zip = phar->is_zip; - (*pphar)->is_data = phar->is_data; - (*pphar)->flags = phar->flags; - (*pphar)->fp = phar->fp; + pphar->is_tar = phar->is_tar; + pphar->is_zip = phar->is_zip; + pphar->is_data = phar->is_data; + pphar->flags = phar->flags; + pphar->fp = phar->fp; phar->fp = NULL; phar_destroy_phar_data(phar TSRMLS_CC); - phar = *pphar; + phar = pphar; phar->refcount++; newpath = oldpath; goto its_ok; @@ -2161,7 +2145,7 @@ its_ok: phar->alias = estrndup(newpath, strlen(newpath)); phar->alias_len = strlen(newpath); phar->is_temporary_alias = 1; - zend_hash_update(&(PHAR_GLOBALS->phar_alias_map), newpath, phar->fname_len, (void*)&phar, sizeof(phar_archive_data*), NULL); + zend_hash_str_update_ptr(&(PHAR_GLOBALS->phar_alias_map), newpath, phar->fname_len, phar); } } @@ -2177,7 +2161,7 @@ its_ok: phar->alias_len = 0; } - if ((!pphar || phar == *pphar) && SUCCESS != zend_hash_update(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, (void*)&phar, sizeof(phar_archive_data*), NULL)) { + if ((!pphar || phar == pphar) && NULL == zend_hash_str_update_ptr(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, phar)) { efree(oldpath); zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to add newly converted phar \"%s\" to the list of phars", phar->fname); return NULL; @@ -2200,27 +2184,26 @@ its_ok: ce = phar_ce_archive; } - MAKE_STD_ZVAL(ret); - - if (SUCCESS != object_init_ex(ret, ce)) { - zval_dtor(ret); + ZVAL_NULL(&ret); + if (SUCCESS != object_init_ex(&ret, ce)) { + zval_dtor(&ret); zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate phar object when converting archive \"%s\"", phar->fname); return NULL; } - INIT_PZVAL(&arg1); - ZVAL_STRINGL(&arg1, phar->fname, phar->fname_len, 0); + ZVAL_STRINGL(&arg1, phar->fname, phar->fname_len); zend_call_method_with_1_params(&ret, ce, &ce->constructor, "__construct", NULL, &arg1); - return ret; + zval_ptr_dtor(&arg1); + return Z_OBJ(ret); } /* }}} */ -static zval *phar_convert_to_other(phar_archive_data *source, int convert, char *ext, php_uint32 flags TSRMLS_DC) /* {{{ */ +static zend_object *phar_convert_to_other(phar_archive_data *source, int convert, char *ext, php_uint32 flags TSRMLS_DC) /* {{{ */ { phar_archive_data *phar; phar_entry_info *entry, newentry; - zval *ret; + zend_object *ret; /* invalidate phar cache */ PHAR_G(last_phar) = NULL; @@ -2260,22 +2243,15 @@ static zval *phar_convert_to_other(phar_archive_data *source, int convert, char phar->is_temporary_alias = source->is_temporary_alias; phar->alias = source->alias; - if (source->metadata) { - zval *t; - - t = source->metadata; - ALLOC_ZVAL(phar->metadata); - *phar->metadata = *t; - zval_copy_ctor(phar->metadata); - Z_SET_REFCOUNT_P(phar->metadata, 1); - + if (Z_TYPE(source->metadata) != IS_UNDEF) { + zval_copy_ctor(&phar->metadata); phar->metadata_len = 0; } /* first copy each file's uncompressed contents to a temporary file and set per-file flags */ for (zend_hash_internal_pointer_reset(&source->manifest); SUCCESS == zend_hash_has_more_elements(&source->manifest); zend_hash_move_forward(&source->manifest)) { - if (FAILURE == zend_hash_get_current_data(&source->manifest, (void **) &entry)) { + if (NULL == (entry = zend_hash_get_current_data_ptr(&source->manifest))) { zend_hash_destroy(&(phar->manifest)); php_stream_close(phar->fp); efree(phar); @@ -2296,7 +2272,7 @@ static zval *phar_convert_to_other(phar_archive_data *source, int convert, char goto no_copy; } - newentry.metadata_str.c = 0; + newentry.metadata_str.s = NULL; if (FAILURE == phar_copy_file_contents(&newentry, phar->fp TSRMLS_CC)) { zend_hash_destroy(&(phar->manifest)); @@ -2308,17 +2284,9 @@ static zval *phar_convert_to_other(phar_archive_data *source, int convert, char no_copy: newentry.filename = estrndup(newentry.filename, newentry.filename_len); - if (newentry.metadata) { - zval *t; - - t = newentry.metadata; - ALLOC_ZVAL(newentry.metadata); - *newentry.metadata = *t; - zval_copy_ctor(newentry.metadata); - Z_SET_REFCOUNT_P(newentry.metadata, 1); - - newentry.metadata_str.c = NULL; - newentry.metadata_str.len = 0; + if (Z_TYPE(newentry.metadata) != IS_UNDEF) { + zval_copy_ctor(&newentry.metadata); + newentry.metadata_str.s = NULL; } newentry.is_zip = phar->is_zip; @@ -2332,7 +2300,7 @@ no_copy: newentry.phar = phar; newentry.old_flags = newentry.flags & ~PHAR_ENT_COMPRESSION_MASK; /* remove compression from old_flags */ phar_set_inode(&newentry TSRMLS_CC); - zend_hash_add(&(phar->manifest), newentry.filename, newentry.filename_len, (void*)&newentry, sizeof(phar_entry_info), NULL); + zend_hash_str_add_mem(&(phar->manifest), newentry.filename, newentry.filename_len, (void*)&newentry, sizeof(phar_entry_info)); phar_add_virtual_dirs(phar, newentry.filename, newentry.filename_len TSRMLS_CC); } @@ -2360,7 +2328,7 @@ PHP_METHOD(Phar, convertToExecutable) char *ext = NULL; int is_data, ext_len = 0; php_uint32 flags; - zval *ret; + zend_object *ret; /* a number that is not 0, 1 or 2 (Which is also Greg's birthday, so there) */ long format = 9021976, method = 9021976; PHAR_ARCHIVE_OBJECT(); @@ -2446,7 +2414,7 @@ PHP_METHOD(Phar, convertToExecutable) phar_obj->arc.archive->is_data = is_data; if (ret) { - RETURN_ZVAL(ret, 1, 1); + ZVAL_OBJ(return_value, ret); } else { RETURN_NULL(); } @@ -2463,7 +2431,7 @@ PHP_METHOD(Phar, convertToData) char *ext = NULL; int is_data, ext_len = 0; php_uint32 flags; - zval *ret; + zend_object *ret; /* a number that is not 0, 1 or 2 (Which is also Greg's birthday so there) */ long format = 9021976, method = 9021976; PHAR_ARCHIVE_OBJECT(); @@ -2548,7 +2516,7 @@ PHP_METHOD(Phar, convertToData) phar_obj->arc.archive->is_data = is_data; if (ret) { - RETURN_ZVAL(ret, 1, 1); + ZVAL_OBJ(return_value, ret); } else { RETURN_NULL(); } @@ -2632,8 +2600,8 @@ PHP_METHOD(Phar, delete) zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname); return; } - if (zend_hash_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) { - if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void**)&entry)) { + if (zend_hash_str_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) { + if (NULL != (entry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, fname, (uint) fname_len))) { if (entry->is_deleted) { /* entry is deleted, but has not been flushed to disk yet */ RETURN_TRUE; @@ -2670,7 +2638,7 @@ PHP_METHOD(Phar, getAlias) } if (phar_obj->arc.archive->alias && phar_obj->arc.archive->alias != phar_obj->arc.archive->fname) { - RETURN_STRINGL(phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len, 1); + RETURN_STRINGL(phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len); } } /* }}} */ @@ -2686,7 +2654,7 @@ PHP_METHOD(Phar, getPath) return; } - RETURN_STRINGL(phar_obj->arc.archive->fname, phar_obj->arc.archive->fname_len, 1); + RETURN_STRINGL(phar_obj->arc.archive->fname, phar_obj->arc.archive->fname_len); } /* }}} */ @@ -2697,7 +2665,7 @@ PHP_METHOD(Phar, getPath) PHP_METHOD(Phar, setAlias) { char *alias, *error, *oldalias; - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; int alias_len, oldalias_len, old_temp, readd = 0; PHAR_ARCHIVE_OBJECT(); @@ -2727,9 +2695,9 @@ PHP_METHOD(Phar, setAlias) if (alias_len == phar_obj->arc.archive->alias_len && memcmp(phar_obj->arc.archive->alias, alias, alias_len) == 0) { RETURN_TRUE; } - if (alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void**)&fd_ptr)) { - spprintf(&error, 0, "alias \"%s\" is already used for archive \"%s\" and cannot be used for other archives", alias, (*fd_ptr)->fname); - if (SUCCESS == phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) { + if (alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { + spprintf(&error, 0, "alias \"%s\" is already used for archive \"%s\" and cannot be used for other archives", alias, fd_ptr->fname); + if (SUCCESS == phar_free_alias(fd_ptr, alias, alias_len TSRMLS_CC)) { efree(error); goto valid_alias; } @@ -2747,8 +2715,8 @@ valid_alias: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname); return; } - if (phar_obj->arc.archive->alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len, (void**)&fd_ptr)) { - zend_hash_del(&(PHAR_GLOBALS->phar_alias_map), phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len); + if (phar_obj->arc.archive->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len))) { + zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len); readd = 1; } @@ -2772,13 +2740,13 @@ valid_alias: phar_obj->arc.archive->is_temporary_alias = old_temp; zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error); if (readd) { - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), oldalias, oldalias_len, (void*)&(phar_obj->arc.archive), sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), oldalias, oldalias_len, phar_obj->arc.archive); } efree(error); RETURN_FALSE; } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&(phar_obj->arc.archive), sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, phar_obj->arc.archive); if (oldalias) { efree(oldalias); @@ -2802,7 +2770,7 @@ PHP_METHOD(Phar, getVersion) return; } - RETURN_STRING(phar_obj->arc.archive->version, 1); + RETURN_STRING(phar_obj->arc.archive->version); } /* }}} */ @@ -2896,7 +2864,7 @@ PHP_METHOD(Phar, setStub) } if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zstub, &len) == SUCCESS) { - if ((php_stream_from_zval_no_verify(stream, &zstub)) != NULL) { + if ((php_stream_from_zval_no_verify(stream, zstub)) != NULL) { if (len > 0) { len = -len; } else { @@ -3134,9 +3102,9 @@ PHP_METHOD(Phar, getModified) } /* }}} */ -static int phar_set_compression(void *pDest, void *argument TSRMLS_DC) /* {{{ */ +static int phar_set_compression(zval *zv, void *argument TSRMLS_DC) /* {{{ */ { - phar_entry_info *entry = (phar_entry_info *)pDest; + phar_entry_info *entry = (phar_entry_info *)Z_PTR_P(zv); php_uint32 compress = *(php_uint32 *)argument; if (entry->is_deleted) { @@ -3151,9 +3119,9 @@ static int phar_set_compression(void *pDest, void *argument TSRMLS_DC) /* {{{ */ } /* }}} */ -static int phar_test_compression(void *pDest, void *argument TSRMLS_DC) /* {{{ */ +static int phar_test_compression(zval *zv, void *argument TSRMLS_DC) /* {{{ */ { - phar_entry_info *entry = (phar_entry_info *)pDest; + phar_entry_info *entry = (phar_entry_info *)Z_PTR_P(zv); if (entry->is_deleted) { return ZEND_HASH_APPLY_KEEP; @@ -3202,7 +3170,7 @@ PHP_METHOD(Phar, compress) char *ext = NULL; int ext_len = 0; php_uint32 flags; - zval *ret; + zend_object *ret; PHAR_ARCHIVE_OBJECT(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|s", &method, &ext, &ext_len) == FAILURE) { @@ -3255,7 +3223,7 @@ PHP_METHOD(Phar, compress) } if (ret) { - RETURN_ZVAL(ret, 1, 1); + ZVAL_OBJ(return_value, ret); } else { RETURN_NULL(); } @@ -3269,7 +3237,7 @@ PHP_METHOD(Phar, decompress) { char *ext = NULL; int ext_len = 0; - zval *ret; + zend_object *ret; PHAR_ARCHIVE_OBJECT(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &ext, &ext_len) == FAILURE) { @@ -3295,7 +3263,7 @@ PHP_METHOD(Phar, decompress) } if (ret) { - RETURN_ZVAL(ret, 1, 1); + ZVAL_OBJ(return_value, ret); } else { RETURN_NULL(); } @@ -3462,14 +3430,14 @@ PHP_METHOD(Phar, copy) RETURN_FALSE; } - if (!zend_hash_exists(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len) || SUCCESS != zend_hash_find(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len, (void**)&oldentry) || oldentry->is_deleted) { + if (!zend_hash_str_exists(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len) || NULL == (oldentry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len)) || oldentry->is_deleted) { zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "file \"%s\" cannot be copied to file \"%s\", file does not exist in %s", oldfile, newfile, phar_obj->arc.archive->fname); RETURN_FALSE; } - if (zend_hash_exists(&phar_obj->arc.archive->manifest, newfile, (uint) newfile_len)) { - if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, newfile, (uint) newfile_len, (void**)&temp) || !temp->is_deleted) { + if (zend_hash_str_exists(&phar_obj->arc.archive->manifest, newfile, (uint) newfile_len)) { + if (NULL != (temp = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, newfile, (uint) newfile_len)) || !temp->is_deleted) { zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "file \"%s\" cannot be copied to file \"%s\", file must not already exist in phar %s", oldfile, newfile, phar_obj->arc.archive->fname); RETURN_FALSE; @@ -3488,22 +3456,14 @@ PHP_METHOD(Phar, copy) return; } /* re-populate with copied-on-write entry */ - zend_hash_find(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len, (void**)&oldentry); + oldentry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len); } memcpy((void *) &newentry, oldentry, sizeof(phar_entry_info)); - if (newentry.metadata) { - zval *t; - - t = newentry.metadata; - ALLOC_ZVAL(newentry.metadata); - *newentry.metadata = *t; - zval_copy_ctor(newentry.metadata); - Z_SET_REFCOUNT_P(newentry.metadata, 1); - - newentry.metadata_str.c = NULL; - newentry.metadata_str.len = 0; + if (Z_TYPE(newentry.metadata) != IS_UNDEF) { + zval_copy_ctor(&newentry.metadata); + newentry.metadata_str.s = NULL; } newentry.filename = estrndup(newfile, newfile_len); @@ -3520,7 +3480,7 @@ PHP_METHOD(Phar, copy) } } - zend_hash_add(&oldentry->phar->manifest, newfile, newfile_len, (void*)&newentry, sizeof(phar_entry_info), NULL); + zend_hash_str_add_mem(&oldentry->phar->manifest, newfile, newfile_len, &newentry, sizeof(phar_entry_info)); phar_obj->arc.archive->is_modified = 1; phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC); @@ -3548,8 +3508,8 @@ PHP_METHOD(Phar, offsetExists) return; } - if (zend_hash_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) { - if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void**)&entry)) { + if (zend_hash_str_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) { + if (NULL != (entry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, fname, (uint) fname_len))) { if (entry->is_deleted) { /* entry is deleted, but has not been flushed to disk yet */ RETURN_FALSE; @@ -3562,7 +3522,7 @@ PHP_METHOD(Phar, offsetExists) } RETURN_TRUE; } else { - if (zend_hash_exists(&phar_obj->arc.archive->virtual_dirs, fname, (uint) fname_len)) { + if (zend_hash_str_exists(&phar_obj->arc.archive->virtual_dirs, fname, (uint) fname_len)) { RETURN_TRUE; } RETURN_FALSE; @@ -3577,7 +3537,7 @@ PHP_METHOD(Phar, offsetGet) { char *fname, *error; int fname_len; - zval *zfname; + zval zfname; phar_entry_info *entry; PHAR_ARCHIVE_OBJECT(); @@ -3610,9 +3570,8 @@ PHP_METHOD(Phar, offsetGet) } fname_len = spprintf(&fname, 0, "phar://%s/%s", phar_obj->arc.archive->fname, fname); - MAKE_STD_ZVAL(zfname); - ZVAL_STRINGL(zfname, fname, fname_len, 0); - spl_instantiate_arg_ex1(phar_obj->spl.info_class, return_value, zfname TSRMLS_CC); + ZVAL_STRINGL(&zfname, fname, fname_len); + spl_instantiate_arg_ex1(phar_obj->spl.info_class, return_value, &zfname TSRMLS_CC); zval_ptr_dtor(&zfname); } } @@ -3653,7 +3612,7 @@ static void phar_add_file(phar_archive_data **pphar, char *filename, int filenam return; } } else { - if (!(php_stream_from_zval_no_verify(contents_file, &zresource))) { + if (!(php_stream_from_zval_no_verify(contents_file, zresource))) { zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s could not be written to", filename); return; } @@ -3772,8 +3731,8 @@ PHP_METHOD(Phar, offsetUnset) return; } - if (zend_hash_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) { - if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void**)&entry)) { + if (zend_hash_str_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) { + if (NULL != (entry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, fname, (uint) fname_len))) { if (entry->is_deleted) { /* entry is deleted, but has not been flushed to disk yet */ return; @@ -3785,7 +3744,7 @@ PHP_METHOD(Phar, offsetUnset) return; } /* re-populate entry after copy on write */ - zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void **)&entry); + entry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, fname, (uint) fname_len); } entry->is_modified = 0; entry->is_deleted = 1; @@ -3836,7 +3795,7 @@ PHP_METHOD(Phar, addFile) char *fname, *localname = NULL; int fname_len, localname_len = 0; php_stream *resource; - zval *zresource; + zval zresource; PHAR_ARCHIVE_OBJECT(); @@ -3866,10 +3825,9 @@ PHP_METHOD(Phar, addFile) fname_len = localname_len; } - MAKE_STD_ZVAL(zresource); - php_stream_to_zval(resource, zresource); - phar_add_file(&(phar_obj->arc.archive), fname, fname_len, NULL, 0, zresource TSRMLS_CC); - efree(zresource); + php_stream_to_zval(resource, &zresource); + phar_add_file(&(phar_obj->arc.archive), fname, fname_len, NULL, 0, &zresource TSRMLS_CC); + zval_ptr_dtor(&zresource); php_stream_close(resource); } /* }}} */ @@ -3911,7 +3869,7 @@ PHP_METHOD(Phar, getStub) if (phar_obj->arc.archive->is_tar || phar_obj->arc.archive->is_zip) { - if (SUCCESS == zend_hash_find(&(phar_obj->arc.archive->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1, (void **)&stub)) { + if (NULL != (stub = zend_hash_str_find_ptr(&(phar_obj->arc.archive->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1))) { if (phar_obj->arc.archive->fp && !phar_obj->arc.archive->is_brandnew && !(stub->flags & PHAR_ENT_COMPRESSION_MASK)) { fp = phar_obj->arc.archive->fp; } else { @@ -3945,7 +3903,7 @@ PHP_METHOD(Phar, getStub) len = stub->uncompressed_filesize; goto carry_on; } else { - RETURN_STRINGL("", 0, 1); + RETURN_EMPTY_STRING(); } } len = phar_obj->arc.archive->halt_offset; @@ -3986,7 +3944,9 @@ carry_on: } buf[len] = '\0'; - RETURN_STRINGL(buf, len, 0); + // TODO: avoid reallocation ??? + RETVAL_STRINGL(buf, len); + efree(buf); } /* }}}*/ @@ -3997,7 +3957,7 @@ PHP_METHOD(Phar, hasMetadata) { PHAR_ARCHIVE_OBJECT(); - RETURN_BOOL(phar_obj->arc.archive->metadata != NULL); + RETURN_BOOL(Z_TYPE(phar_obj->arc.archive->metadata) != IS_UNDEF); } /* }}} */ @@ -4012,16 +3972,16 @@ PHP_METHOD(Phar, getMetadata) return; } - if (phar_obj->arc.archive->metadata) { + if (Z_TYPE(phar_obj->arc.archive->metadata) != IS_UNDEF) { if (phar_obj->arc.archive->is_persistent) { - zval *ret; - char *buf = estrndup((char *) phar_obj->arc.archive->metadata, phar_obj->arc.archive->metadata_len); + zval ret; + char *buf = estrndup((char *) Z_PTR(phar_obj->arc.archive->metadata), phar_obj->arc.archive->metadata_len); /* assume success, we would have failed before */ phar_parse_metadata(&buf, &ret, phar_obj->arc.archive->metadata_len TSRMLS_CC); efree(buf); - RETURN_ZVAL(ret, 0, 1); + RETURN_ZVAL(&ret, 0, 1); } - RETURN_ZVAL(phar_obj->arc.archive->metadata, 1, 0); + RETURN_ZVAL(&phar_obj->arc.archive->metadata, 1, 0); } } /* }}} */ @@ -4049,13 +4009,12 @@ PHP_METHOD(Phar, setMetadata) zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname); return; } - if (phar_obj->arc.archive->metadata) { + if (Z_TYPE(phar_obj->arc.archive->metadata) != IS_UNDEF) { zval_ptr_dtor(&phar_obj->arc.archive->metadata); - phar_obj->arc.archive->metadata = NULL; + ZVAL_UNDEF(&phar_obj->arc.archive->metadata); } - MAKE_STD_ZVAL(phar_obj->arc.archive->metadata); - ZVAL_ZVAL(phar_obj->arc.archive->metadata, metadata, 1, 0); + ZVAL_ZVAL(&phar_obj->arc.archive->metadata, metadata, 1, 0); phar_obj->arc.archive->is_modified = 1; phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC); @@ -4080,9 +4039,9 @@ PHP_METHOD(Phar, delMetadata) return; } - if (phar_obj->arc.archive->metadata) { + if (Z_TYPE(phar_obj->arc.archive->metadata) != IS_UNDEF) { zval_ptr_dtor(&phar_obj->arc.archive->metadata); - phar_obj->arc.archive->metadata = NULL; + ZVAL_UNDEF(&phar_obj->arc.archive->metadata); phar_obj->arc.archive->is_modified = 1; phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC); @@ -4325,9 +4284,9 @@ PHP_METHOD(Phar, extractTo) RETURN_FALSE; } for (i = 0; i < nelems; i++) { - zval **zval_file; - if (zend_hash_index_find(Z_ARRVAL_P(zval_files), i, (void **) &zval_file) == SUCCESS) { - switch (Z_TYPE_PP(zval_file)) { + zval *zval_file; + if ((zval_file = zend_hash_index_find(Z_ARRVAL_P(zval_files), i)) != NULL) { + switch (Z_TYPE_P(zval_file)) { case IS_STRING: break; default: @@ -4335,9 +4294,9 @@ PHP_METHOD(Phar, extractTo) "Invalid argument, array of filenames to extract contains non-string value"); return; } - if (FAILURE == zend_hash_find(&phar_obj->arc.archive->manifest, Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file), (void **)&entry)) { + if (NULL == (entry = zend_hash_find_ptr(&phar_obj->arc.archive->manifest, Z_STR_P(zval_file)))) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, - "Phar Error: attempted to extract non-existent file \"%s\" from phar \"%s\"", Z_STRVAL_PP(zval_file), phar_obj->arc.archive->fname); + "Phar Error: attempted to extract non-existent file \"%s\" from phar \"%s\"", Z_STRVAL_P(zval_file), phar_obj->arc.archive->fname); } if (FAILURE == phar_extract_file(overwrite, entry, pathto, pathto_len, &error TSRMLS_CC)) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, @@ -4354,7 +4313,7 @@ PHP_METHOD(Phar, extractTo) return; } - if (FAILURE == zend_hash_find(&phar_obj->arc.archive->manifest, filename, filename_len, (void **)&entry)) { + if (NULL == (entry = zend_hash_str_find_ptr(&phar_obj->arc.archive->manifest, filename, filename_len))) { zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Phar Error: attempted to extract non-existent file \"%s\" from phar \"%s\"", filename, phar_obj->arc.archive->fname); return; @@ -4379,7 +4338,7 @@ all_files: zend_hash_has_more_elements(&phar->manifest) == SUCCESS; zend_hash_move_forward(&phar->manifest)) { - if (zend_hash_get_current_data(&phar->manifest, (void **)&entry) == FAILURE) { + if ((entry = zend_hash_get_current_data_ptr(&phar->manifest)) == NULL) { continue; } @@ -4412,7 +4371,7 @@ PHP_METHOD(PharFileInfo, __construct) return; } - entry_obj = (phar_entry_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + entry_obj = (phar_entry_object*)Z_OBJ_P(getThis()); if (entry_obj->ent.entry) { zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot call constructor twice"); @@ -4452,16 +4411,17 @@ PHP_METHOD(PharFileInfo, __construct) entry_obj->ent.entry = entry_info; - INIT_PZVAL(&arg1); - ZVAL_STRINGL(&arg1, fname, fname_len, 0); + ZVAL_STRINGL(&arg1, fname, fname_len); - zend_call_method_with_1_params(&zobj, Z_OBJCE_P(zobj), + zend_call_method_with_1_params(zobj, Z_OBJCE_P(zobj), &spl_ce_SplFileInfo->constructor, "__construct", NULL, &arg1); + + zval_ptr_dtor(&arg1); } /* }}} */ #define PHAR_ENTRY_OBJECT() \ - phar_entry_object *entry_obj = (phar_entry_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \ + phar_entry_object *entry_obj = (phar_entry_object*)Z_OBJ_P(getThis()); \ if (!entry_obj->ent.entry) { \ zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \ "Cannot call method on an uninitialized PharFileInfo object"); \ @@ -4473,7 +4433,7 @@ PHP_METHOD(PharFileInfo, __construct) */ PHP_METHOD(PharFileInfo, __destruct) { - phar_entry_object *entry_obj = (phar_entry_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \ + phar_entry_object *entry_obj = (phar_entry_object*)Z_OBJ_P(getThis()); if (entry_obj->ent.entry && entry_obj->ent.entry->is_temp_dir) { if (entry_obj->ent.entry->filename) { @@ -4617,7 +4577,7 @@ PHP_METHOD(PharFileInfo, chmod) return; } /* re-populate after copy-on-write */ - zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry); + entry_obj->ent.entry = zend_hash_str_find_ptr(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len); } /* clear permissions */ entry_obj->ent.entry->flags &= ~PHAR_ENT_PERM_MASK; @@ -4659,7 +4619,7 @@ PHP_METHOD(PharFileInfo, hasMetadata) return; } - RETURN_BOOL(entry_obj->ent.entry->metadata != NULL); + RETURN_BOOL(Z_TYPE(entry_obj->ent.entry->metadata) != IS_UNDEF); } /* }}} */ @@ -4674,16 +4634,16 @@ PHP_METHOD(PharFileInfo, getMetadata) return; } - if (entry_obj->ent.entry->metadata) { + if (Z_TYPE(entry_obj->ent.entry->metadata) != IS_UNDEF) { if (entry_obj->ent.entry->is_persistent) { - zval *ret; - char *buf = estrndup((char *) entry_obj->ent.entry->metadata, entry_obj->ent.entry->metadata_len); + zval ret; + char *buf = estrndup((char *) Z_PTR(entry_obj->ent.entry->metadata), entry_obj->ent.entry->metadata_len); /* assume success, we would have failed before */ phar_parse_metadata(&buf, &ret, entry_obj->ent.entry->metadata_len TSRMLS_CC); efree(buf); - RETURN_ZVAL(ret, 0, 1); + RETURN_ZVAL(&ret, 0, 1); } - RETURN_ZVAL(entry_obj->ent.entry->metadata, 1, 0); + RETURN_ZVAL(&entry_obj->ent.entry->metadata, 1, 0); } } /* }}} */ @@ -4721,15 +4681,14 @@ PHP_METHOD(PharFileInfo, setMetadata) return; } /* re-populate after copy-on-write */ - zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry); + entry_obj->ent.entry = zend_hash_str_find_ptr(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len); } - if (entry_obj->ent.entry->metadata) { + if (Z_TYPE(entry_obj->ent.entry->metadata) != IS_UNDEF) { zval_ptr_dtor(&entry_obj->ent.entry->metadata); - entry_obj->ent.entry->metadata = NULL; + ZVAL_UNDEF(&entry_obj->ent.entry->metadata); } - MAKE_STD_ZVAL(entry_obj->ent.entry->metadata); - ZVAL_ZVAL(entry_obj->ent.entry->metadata, metadata, 1, 0); + ZVAL_ZVAL(&entry_obj->ent.entry->metadata, metadata, 1, 0); entry_obj->ent.entry->is_modified = 1; entry_obj->ent.entry->phar->is_modified = 1; @@ -4766,7 +4725,7 @@ PHP_METHOD(PharFileInfo, delMetadata) return; } - if (entry_obj->ent.entry->metadata) { + if (Z_TYPE(entry_obj->ent.entry->metadata) != IS_UNDEF) { if (entry_obj->ent.entry->is_persistent) { phar_archive_data *phar = entry_obj->ent.entry->phar; @@ -4775,10 +4734,10 @@ PHP_METHOD(PharFileInfo, delMetadata) return; } /* re-populate after copy-on-write */ - zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry); + entry_obj->ent.entry = zend_hash_str_find_ptr(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len); } zval_ptr_dtor(&entry_obj->ent.entry->metadata); - entry_obj->ent.entry->metadata = NULL; + ZVAL_UNDEF(&entry_obj->ent.entry->metadata); entry_obj->ent.entry->is_modified = 1; entry_obj->ent.entry->phar->is_modified = 1; @@ -4806,6 +4765,7 @@ PHP_METHOD(PharFileInfo, getContent) char *error; php_stream *fp; phar_entry_info *link; + zend_string *str; PHAR_ENTRY_OBJECT(); @@ -4839,11 +4799,11 @@ PHP_METHOD(PharFileInfo, getContent) } phar_seek_efp(link, 0, SEEK_SET, 0, 0 TSRMLS_CC); - Z_TYPE_P(return_value) = IS_STRING; - Z_STRLEN_P(return_value) = php_stream_copy_to_mem(fp, &(Z_STRVAL_P(return_value)), link->uncompressed_filesize, 0); - - if (!Z_STRVAL_P(return_value)) { - Z_STRVAL_P(return_value) = estrndup("", 0); + str = php_stream_copy_to_mem(fp, link->uncompressed_filesize, 0); + if (str) { + RETURN_STR(str); + } else { + RETURN_EMPTY_STRING(); } } /* }}} */ @@ -4893,7 +4853,7 @@ PHP_METHOD(PharFileInfo, compress) return; } /* re-populate after copy-on-write */ - zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry); + entry_obj->ent.entry = zend_hash_str_find_ptr(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len); } switch (method) { case PHAR_ENT_COMPRESSED_GZ: @@ -5029,7 +4989,7 @@ PHP_METHOD(PharFileInfo, decompress) return; } /* re-populate after copy-on-write */ - zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry); + entry_obj->ent.entry = zend_hash_str_find_ptr(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len); } if (!entry_obj->ent.entry->fp) { if (FAILURE == phar_open_archive_fp(entry_obj->ent.entry->phar TSRMLS_CC)) { diff --git a/ext/phar/stream.c b/ext/phar/stream.c index c38c20d635..44ee853f65 100644 --- a/ext/phar/stream.c +++ b/ext/phar/stream.c @@ -101,12 +101,12 @@ php_url* phar_parse_url(php_stream_wrapper *wrapper, const char *filename, const } #endif if (mode[0] == 'w' || (mode[0] == 'r' && mode[1] == '+')) { - phar_archive_data **pphar = NULL, *phar; + phar_archive_data *pphar = NULL, *phar; - if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arHash && FAILURE == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **)&pphar)) { + if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arHash && NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len))) { pphar = NULL; } - if (PHAR_G(readonly) && (!pphar || !(*pphar)->is_data)) { + if (PHAR_G(readonly) && (!pphar || !pphar->is_data)) { if (!(options & PHP_STREAM_URL_STAT_QUIET)) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: write operations disabled by the php.ini setting phar.readonly"); } @@ -164,7 +164,7 @@ static php_stream * phar_wrapper_open_url(php_stream_wrapper *wrapper, const cha HashTable *pharcontext; php_url *resource = NULL; php_stream *fpf; - zval **pzoption, *metadata; + zval *pzoption, *metadata; uint host_len; if ((resource = phar_parse_url(wrapper, path, mode, options TSRMLS_CC)) == NULL) { @@ -208,26 +208,25 @@ static php_stream * phar_wrapper_open_url(php_stream_wrapper *wrapper, const cha php_url_free(resource); efree(internal_file); - if (context && context->options && zend_hash_find(HASH_OF(context->options), "phar", sizeof("phar"), (void**)&pzoption) == SUCCESS) { - pharcontext = HASH_OF(*pzoption); + if (context && Z_TYPE(context->options) != IS_UNDEF && (pzoption = zend_hash_str_find(HASH_OF(&context->options), "phar", sizeof("phar")-1)) != NULL) { + pharcontext = HASH_OF(pzoption); if (idata->internal_file->uncompressed_filesize == 0 && idata->internal_file->compressed_filesize == 0 - && zend_hash_find(pharcontext, "compress", sizeof("compress"), (void**)&pzoption) == SUCCESS - && Z_TYPE_PP(pzoption) == IS_LONG - && (Z_LVAL_PP(pzoption) & ~PHAR_ENT_COMPRESSION_MASK) == 0 + && (pzoption = zend_hash_str_find(pharcontext, "compress", sizeof("compress")-1)) != NULL + && Z_TYPE_P(pzoption) == IS_LONG + && (Z_LVAL_P(pzoption) & ~PHAR_ENT_COMPRESSION_MASK) == 0 ) { idata->internal_file->flags &= ~PHAR_ENT_COMPRESSION_MASK; - idata->internal_file->flags |= Z_LVAL_PP(pzoption); + idata->internal_file->flags |= Z_LVAL_P(pzoption); } - if (zend_hash_find(pharcontext, "metadata", sizeof("metadata"), (void**)&pzoption) == SUCCESS) { - if (idata->internal_file->metadata) { + if ((pzoption = zend_hash_str_find(pharcontext, "metadata", sizeof("metadata")-1)) != NULL) { + if (Z_TYPE(idata->internal_file->metadata) != IS_UNDEF) { zval_ptr_dtor(&idata->internal_file->metadata); - idata->internal_file->metadata = NULL; + ZVAL_UNDEF(&idata->internal_file->metadata); } - MAKE_STD_ZVAL(idata->internal_file->metadata); - metadata = *pzoption; - ZVAL_ZVAL(idata->internal_file->metadata, metadata, 1, 0); + metadata = pzoption; + ZVAL_ZVAL(&idata->internal_file->metadata, metadata, 1, 0); idata->phar->is_modified = 1; } } @@ -615,41 +614,35 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int f } internal_file_len = strlen(internal_file); /* search through the manifest of files, and if we have an exact match, it's a file */ - if (SUCCESS == zend_hash_find(&phar->manifest, internal_file, internal_file_len, (void**)&entry)) { + if (NULL != (entry = zend_hash_str_find_ptr(&phar->manifest, internal_file, internal_file_len))) { phar_dostat(phar, entry, ssb, 0 TSRMLS_CC); php_url_free(resource); return SUCCESS; } - if (zend_hash_exists(&(phar->virtual_dirs), internal_file, internal_file_len)) { + if (zend_hash_str_exists(&(phar->virtual_dirs), internal_file, internal_file_len)) { phar_dostat(phar, NULL, ssb, 1 TSRMLS_CC); php_url_free(resource); return SUCCESS; } /* check for mounted directories */ if (phar->mounted_dirs.arHash && zend_hash_num_elements(&phar->mounted_dirs)) { - char *str_key; - ulong unused; - uint keylen; - HashPosition pos; + zend_string *str_key; - for (zend_hash_internal_pointer_reset_ex(&phar->mounted_dirs, &pos); - HASH_KEY_NON_EXISTENT != zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &keylen, &unused, 0, &pos); - zend_hash_move_forward_ex(&phar->mounted_dirs, &pos) - ) { - if ((int)keylen >= internal_file_len || strncmp(str_key, internal_file, keylen)) { + ZEND_HASH_FOREACH_STR_KEY(&phar->mounted_dirs, str_key) { + if ((int)str_key->len >= internal_file_len || strncmp(str_key->val, internal_file, str_key->len)) { continue; } else { char *test; int test_len; php_stream_statbuf ssbi; - if (SUCCESS != zend_hash_find(&phar->manifest, str_key, keylen, (void **) &entry)) { + if (NULL == (entry = zend_hash_find_ptr(&phar->manifest, str_key))) { goto free_resource; } if (!entry->tmp || !entry->is_mounted) { goto free_resource; } - test_len = spprintf(&test, MAXPATHLEN, "%s%s", entry->tmp, internal_file + keylen); + test_len = spprintf(&test, MAXPATHLEN, "%s%s", entry->tmp, internal_file + str_key->len); if (SUCCESS != php_stream_stat_path(test, &ssbi)) { efree(test); continue; @@ -660,14 +653,14 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int f goto free_resource; } efree(test); - if (SUCCESS != zend_hash_find(&phar->manifest, internal_file, internal_file_len, (void**)&entry)) { + if (NULL == (entry = zend_hash_str_find_ptr(&phar->manifest, internal_file, internal_file_len))) { goto free_resource; } phar_dostat(phar, entry, ssb, 0 TSRMLS_CC); php_url_free(resource); return SUCCESS; } - } + } ZEND_HASH_FOREACH_END(); } free_resource: php_url_free(resource); @@ -708,9 +701,7 @@ static int phar_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int host_len = strlen(resource->host); phar_request_initialize(TSRMLS_C); - if (FAILURE == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), resource->host, host_len, (void **) &pphar)) { - pphar = NULL; - } + pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), resource->host, host_len); if (PHAR_G(readonly) && (!pphar || !(*pphar)->is_data)) { php_url_free(resource); php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: write operations disabled by the php.ini setting phar.readonly"); @@ -852,7 +843,7 @@ static int phar_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from return 0; } - if (SUCCESS == zend_hash_find(&(phar->manifest), resource_from->path+1, strlen(resource_from->path)-1, (void **)&entry)) { + if (NULL != (entry = zend_hash_str_find_ptr(&(phar->manifest), resource_from->path+1, strlen(resource_from->path)-1))) { phar_entry_info new, *source; /* perform rename magic */ @@ -867,12 +858,12 @@ static int phar_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from /* mark the old one for deletion */ entry->is_deleted = 1; entry->fp = NULL; - entry->metadata = 0; + ZVAL_UNDEF(&entry->metadata); entry->link = entry->tmp = NULL; source = entry; /* add to the manifest, and then store the pointer to the new guy in entry */ - zend_hash_add(&(phar->manifest), resource_to->path+1, strlen(resource_to->path)-1, (void **)&new, sizeof(phar_entry_info), (void **) &entry); + entry = zend_hash_str_add_mem(&(phar->manifest), resource_to->path+1, strlen(resource_to->path)-1, (void **)&new, sizeof(phar_entry_info)); entry->filename = estrdup(resource_to->path+1); if (FAILURE == phar_copy_entry_fp(source, entry, &error TSRMLS_CC)) { @@ -880,7 +871,7 @@ static int phar_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from php_url_free(resource_to); php_error_docref(NULL TSRMLS_CC, E_WARNING, "phar error: cannot rename \"%s\" to \"%s\": %s", url_from, url_to, error); efree(error); - zend_hash_del(&(phar->manifest), entry->filename, strlen(entry->filename)); + zend_hash_str_del(&(phar->manifest), entry->filename, strlen(entry->filename)); return 0; } is_modified = 1; @@ -888,7 +879,7 @@ static int phar_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from entry->filename_len = strlen(entry->filename); is_dir = entry->is_dir; } else { - is_dir = zend_hash_exists(&(phar->virtual_dirs), resource_from->path+1, strlen(resource_from->path)-1); + is_dir = zend_hash_str_exists(&(phar->virtual_dirs), resource_from->path+1, strlen(resource_from->path)-1); if (!is_dir) { /* file does not exist */ php_url_free(resource_from); @@ -902,74 +893,73 @@ static int phar_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from /* Rename directory. Update all nested paths */ if (is_dir) { int key_type; - char *str_key, *new_str_key; - uint key_len, new_key_len; + zend_string *str_key; + zend_string *new_str_key; ulong unused; uint from_len = strlen(resource_from->path+1); uint to_len = strlen(resource_to->path+1); for (zend_hash_internal_pointer_reset(&phar->manifest); - HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->manifest, &str_key, &key_len, &unused, 0, NULL)) && - SUCCESS == zend_hash_get_current_data(&phar->manifest, (void **) &entry); + HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->manifest, &str_key, &unused, 0, &phar->manifest.nInternalPointer)) && + NULL != (entry = zend_hash_get_current_data_ptr(&phar->manifest)); zend_hash_move_forward(&phar->manifest) ) { if (!entry->is_deleted && - key_len > from_len && - memcmp(str_key, resource_from->path+1, from_len) == 0 && - IS_SLASH(str_key[from_len])) { + str_key->len > from_len && + memcmp(str_key->val, resource_from->path+1, from_len) == 0 && + IS_SLASH(str_key->val[from_len])) { - new_key_len = key_len + to_len - from_len; - new_str_key = emalloc(new_key_len+1); - memcpy(new_str_key, resource_to->path + 1, to_len); - memcpy(new_str_key + to_len, str_key + from_len, key_len - from_len); - new_str_key[new_key_len] = 0; + new_str_key = STR_ALLOC(str_key->len + to_len - from_len, 0); + memcpy(new_str_key->val, resource_to->path + 1, to_len); + memcpy(new_str_key->val + to_len, str_key->val + from_len, str_key->len - from_len); + new_str_key->val[new_str_key->len] = 0; is_modified = 1; entry->is_modified = 1; efree(entry->filename); - entry->filename = new_str_key; - entry->filename_len = new_key_len; + // TODO: avoid reallocation (make entry->filename zend_string*) + entry->filename = estrndup(new_str_key->val, new_str_key->len); + entry->filename_len = new_str_key->len; - zend_hash_update_current_key_ex(&phar->manifest, key_type, new_str_key, new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL); + zend_hash_update_current_key_ex(&phar->manifest, key_type, new_str_key, 0, HASH_UPDATE_KEY_ANYWAY); + STR_RELEASE(new_str_key); } } for (zend_hash_internal_pointer_reset(&phar->virtual_dirs); - HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->virtual_dirs, &str_key, &key_len, &unused, 0, NULL)); + HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->virtual_dirs, &str_key, &unused, 0, &phar->virtual_dirs.nInternalPointer)); zend_hash_move_forward(&phar->virtual_dirs) ) { - if (key_len >= from_len && - memcmp(str_key, resource_from->path+1, from_len) == 0 && - (key_len == from_len || IS_SLASH(str_key[from_len]))) { - - new_key_len = key_len + to_len - from_len; - new_str_key = emalloc(new_key_len+1); - memcpy(new_str_key, resource_to->path + 1, to_len); - memcpy(new_str_key + to_len, str_key + from_len, key_len - from_len); - new_str_key[new_key_len] = 0; - - zend_hash_update_current_key_ex(&phar->virtual_dirs, key_type, new_str_key, new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL); - efree(new_str_key); + if (str_key->len >= from_len && + memcmp(str_key->val, resource_from->path+1, from_len) == 0 && + (str_key->len == from_len || IS_SLASH(str_key->val[from_len]))) { + + new_str_key = STR_ALLOC(str_key->len + to_len - from_len, 0); + memcpy(new_str_key->val, resource_to->path + 1, to_len); + memcpy(new_str_key->val + to_len, str_key->val + from_len, str_key->len - from_len); + new_str_key->val[new_str_key->len] = 0; + + zend_hash_update_current_key_ex(&phar->virtual_dirs, key_type, new_str_key, 0, HASH_UPDATE_KEY_ANYWAY); + STR_RELEASE(new_str_key); } } for (zend_hash_internal_pointer_reset(&phar->mounted_dirs); - HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &key_len, &unused, 0, NULL)) && - SUCCESS == zend_hash_get_current_data(&phar->mounted_dirs, (void **) &entry); + HASH_KEY_NON_EXISTENT != (key_type = zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &unused, 0, &phar->mounted_dirs.nInternalPointer)) && + NULL != (entry = zend_hash_get_current_data_ptr(&phar->mounted_dirs)); zend_hash_move_forward(&phar->mounted_dirs) ) { - if (key_len >= from_len && - memcmp(str_key, resource_from->path+1, from_len) == 0 && - (key_len == from_len || IS_SLASH(str_key[from_len]))) { - - new_key_len = key_len + to_len - from_len; - new_str_key = emalloc(new_key_len+1); - memcpy(new_str_key, resource_to->path + 1, to_len); - memcpy(new_str_key + to_len, str_key + from_len, key_len - from_len); - new_str_key[new_key_len] = 0; - - zend_hash_update_current_key_ex(&phar->mounted_dirs, key_type, new_str_key, new_key_len, 0, HASH_UPDATE_KEY_ANYWAY, NULL); - efree(new_str_key); + if (str_key->len >= from_len && + memcmp(str_key->val, resource_from->path+1, from_len) == 0 && + (str_key->len == from_len || IS_SLASH(str_key->val[from_len]))) { + + new_str_key = STR_ALLOC(str_key->len + to_len - from_len, 0); + memcpy(new_str_key->val, resource_to->path + 1, to_len); + memcpy(new_str_key->val + to_len, str_key->val + from_len, str_key->len - from_len); + new_str_key->val[new_str_key->len] = 0; + + zend_hash_update_current_key_ex(&phar->mounted_dirs, key_type, new_str_key, 0, HASH_UPDATE_KEY_ANYWAY); + STR_RELEASE(new_str_key); } } } diff --git a/ext/phar/tar.c b/ext/phar/tar.c index 17b537dae0..c22b1df1d8 100644 --- a/ext/phar/tar.c +++ b/ext/phar/tar.c @@ -179,11 +179,12 @@ static int phar_tar_process_metadata(phar_entry_info *entry, php_stream *fp TSRM if (entry->filename_len == sizeof(".phar/.metadata.bin")-1 && !memcmp(entry->filename, ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1)) { entry->phar->metadata = entry->metadata; - entry->metadata = NULL; - } else if (entry->filename_len >= sizeof(".phar/.metadata/") + sizeof("/.metadata.bin") - 1 && SUCCESS == zend_hash_find(&(entry->phar->manifest), entry->filename + sizeof(".phar/.metadata/") - 1, entry->filename_len - (sizeof("/.metadata.bin") - 1 + sizeof(".phar/.metadata/") - 1), (void *)&mentry)) { + ZVAL_UNDEF(&entry->metadata); +// ??? len ??? + } else if (entry->filename_len >= sizeof(".phar/.metadata/") + sizeof("/.metadata.bin") - 1 && NULL != (mentry = zend_hash_str_find_ptr(&(entry->phar->manifest), entry->filename + sizeof(".phar/.metadata/") - 1, entry->filename_len - (sizeof("/.metadata.bin") - 1 + sizeof(".phar/.metadata/") - 1)))) { /* transfer this metadata to the entry it refers */ mentry->metadata = entry->metadata; - entry->metadata = NULL; + ZVAL_UNDEF(&entry->metadata); } efree(metadata); @@ -467,7 +468,7 @@ bail: entry.link = NULL; if (entry.tar_type == TAR_LINK) { - if (!zend_hash_exists(&myphar->manifest, hdr->linkname, strlen(hdr->linkname))) { + if (!zend_hash_str_exists(&myphar->manifest, hdr->linkname, strlen(hdr->linkname))) { if (error) { spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file - hard link to non-existent file \"%s\"", fname, hdr->linkname); } @@ -481,7 +482,7 @@ bail: entry.link = estrdup(hdr->linkname); } phar_set_inode(&entry TSRMLS_CC); - zend_hash_add(&myphar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), (void **) &newentry); + newentry = zend_hash_str_add_mem(&myphar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info)); if (entry.is_persistent) { ++entry.manifest_pos; @@ -572,7 +573,7 @@ bail: } } while (read != 0); - if (zend_hash_exists(&(myphar->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1)) { + if (zend_hash_str_exists(&(myphar->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1)) { myphar->is_data = 0; } else { myphar->is_data = 1; @@ -608,7 +609,7 @@ bail: phar_request_initialize(TSRMLS_C); - if (SUCCESS != zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len, (void*)&myphar, sizeof(phar_archive_data*), (void **)&actual)) { + if (NULL == (actual = zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len, myphar))) { if (error) { spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\" to phar registry", fname); } @@ -620,35 +621,35 @@ bail: myphar = *actual; if (actual_alias) { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; myphar->is_temporary_alias = 0; - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, (void **)&fd_ptr)) { - if (SUCCESS != phar_free_alias(*fd_ptr, actual_alias, myphar->alias_len TSRMLS_CC)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len))) { + if (SUCCESS != phar_free_alias(fd_ptr, actual_alias, myphar->alias_len TSRMLS_CC)) { if (error) { spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname); } - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len); return FAILURE; } } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, (void*)&myphar, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, myphar); } else { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; if (alias_len) { - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void **)&fd_ptr)) { - if (SUCCESS != phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { + if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len TSRMLS_CC)) { if (error) { spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname); } - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len); return FAILURE; } } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&myphar, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, myphar); myphar->alias = pestrndup(alias, alias_len, myphar->is_persistent); myphar->alias_len = alias_len; } else { @@ -828,16 +829,15 @@ int phar_tar_setmetadata(zval *metadata, phar_entry_info *entry, char **error TS { php_serialize_data_t metadata_hash; - if (entry->metadata_str.c) { + if (entry->metadata_str.s) { smart_str_free(&entry->metadata_str); } - entry->metadata_str.c = 0; - entry->metadata_str.len = 0; + entry->metadata_str.s = NULL; PHP_VAR_SERIALIZE_INIT(metadata_hash); - php_var_serialize(&entry->metadata_str, &metadata, &metadata_hash TSRMLS_CC); + php_var_serialize(&entry->metadata_str, metadata, &metadata_hash TSRMLS_CC); PHP_VAR_SERIALIZE_DESTROY(metadata_hash); - entry->uncompressed_filesize = entry->compressed_filesize = entry->metadata_str.len; + entry->uncompressed_filesize = entry->compressed_filesize = entry->metadata_str.s ? entry->metadata_str.s->len : 0; if (entry->fp && entry->fp_type == PHAR_MOD) { php_stream_close(entry->fp); @@ -851,9 +851,9 @@ int phar_tar_setmetadata(zval *metadata, phar_entry_info *entry, char **error TS spprintf(error, 0, "phar error: unable to create temporary file"); return -1; } - if (entry->metadata_str.len != php_stream_write(entry->fp, entry->metadata_str.c, entry->metadata_str.len)) { + if (entry->metadata_str.s->len != php_stream_write(entry->fp, entry->metadata_str.s->val, entry->metadata_str.s->len)) { spprintf(error, 0, "phar tar error: unable to write metadata to magic metadata file \"%s\"", entry->filename); - zend_hash_del(&(entry->phar->manifest), entry->filename, entry->filename_len); + zend_hash_str_del(&(entry->phar->manifest), entry->filename, entry->filename_len); return ZEND_HASH_APPLY_STOP; } @@ -870,10 +870,11 @@ static int phar_tar_setupmetadata(void *pDest, void *argument TSRMLS_DC) /* {{{ if (entry->filename_len >= sizeof(".phar/.metadata") && !memcmp(entry->filename, ".phar/.metadata", sizeof(".phar/.metadata")-1)) { if (entry->filename_len == sizeof(".phar/.metadata.bin")-1 && !memcmp(entry->filename, ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1)) { - return phar_tar_setmetadata(entry->phar->metadata, entry, error TSRMLS_CC); + return phar_tar_setmetadata(&entry->phar->metadata, entry, error TSRMLS_CC); } /* search for the file this metadata entry references */ - if (entry->filename_len >= sizeof(".phar/.metadata/") + sizeof("/.metadata.bin") - 1 && !zend_hash_exists(&(entry->phar->manifest), entry->filename + sizeof(".phar/.metadata/") - 1, entry->filename_len - (sizeof("/.metadata.bin") - 1 + sizeof(".phar/.metadata/") - 1))) { +//??? len ??? + if (entry->filename_len >= sizeof(".phar/.metadata/") + sizeof("/.metadata.bin") - 1 && !zend_hash_str_exists(&(entry->phar->manifest), entry->filename + sizeof(".phar/.metadata/") - 1, entry->filename_len - (sizeof("/.metadata.bin") - 1 + sizeof(".phar/.metadata/") - 1))) { /* this is orphaned metadata, erase it */ return ZEND_HASH_APPLY_REMOVE; } @@ -888,15 +889,15 @@ static int phar_tar_setupmetadata(void *pDest, void *argument TSRMLS_DC) /* {{{ /* now we are dealing with regular files, so look for metadata */ lookfor_len = spprintf(&lookfor, 0, ".phar/.metadata/%s/.metadata.bin", entry->filename); - if (!entry->metadata) { - zend_hash_del(&(entry->phar->manifest), lookfor, lookfor_len); + if (Z_TYPE(entry->metadata) == IS_UNDEF) { + zend_hash_str_del(&(entry->phar->manifest), lookfor, lookfor_len); efree(lookfor); return ZEND_HASH_APPLY_KEEP; } - if (SUCCESS == zend_hash_find(&(entry->phar->manifest), lookfor, lookfor_len, (void **)&metadata)) { + if (NULL != (metadata = zend_hash_str_find_ptr(&(entry->phar->manifest), lookfor, lookfor_len))) { int ret; - ret = phar_tar_setmetadata(entry->metadata, metadata, error TSRMLS_CC); + ret = phar_tar_setmetadata(&entry->metadata, metadata, error TSRMLS_CC); efree(lookfor); return ret; } @@ -907,13 +908,13 @@ static int phar_tar_setupmetadata(void *pDest, void *argument TSRMLS_DC) /* {{{ newentry.tar_type = TAR_FILE; newentry.is_tar = 1; - if (SUCCESS != zend_hash_add(&(entry->phar->manifest), lookfor, lookfor_len, (void *)&newentry, sizeof(phar_entry_info), (void **)&metadata)) { + if (NULL == (metadata = zend_hash_str_add_mem(&(entry->phar->manifest), lookfor, lookfor_len, (void *)&newentry, sizeof(phar_entry_info)))) { efree(lookfor); spprintf(error, 0, "phar tar error: unable to add magic metadata file to manifest for file \"%s\"", entry->filename); return ZEND_HASH_APPLY_STOP; } - return phar_tar_setmetadata(entry->metadata, metadata, error TSRMLS_CC); + return phar_tar_setmetadata(&entry->metadata, metadata, error TSRMLS_CC); } /* }}} */ @@ -965,14 +966,14 @@ int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defau entry.uncompressed_filesize = phar->alias_len; - if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL == zend_hash_str_update_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { if (error) { spprintf(error, 0, "unable to set alias in tar-based phar \"%s\"", phar->fname); } return EOF; } } else { - zend_hash_del(&phar->manifest, ".phar/alias.txt", sizeof(".phar/alias.txt")-1); + zend_hash_str_del(&phar->manifest, ".phar/alias.txt", sizeof(".phar/alias.txt")-1); } /* set stub */ @@ -980,7 +981,7 @@ int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defau char *pos; if (len < 0) { /* resource passed in */ - if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) { + if (!(php_stream_from_zval_no_verify(stubfile, (zval *)user_stub))) { if (error) { spprintf(error, 0, "unable to access resource to copy stub to new tar-based phar \"%s\"", phar->fname); } @@ -993,7 +994,21 @@ int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defau } user_stub = 0; - if (!(len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0)) || !user_stub) { + // TODO: refactor to avoid reallocation ??? +//??? len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0) + { + zend_string *str = php_stream_copy_to_mem(stubfile, len, 0); + if (str) { + len = str->len; + user_stub = estrndup(str->val, str->len); + STR_RELEASE(str); + } else { + user_stub = NULL; + len = 0; + } + } + + if (!len || !user_stub) { if (error) { spprintf(error, 0, "unable to read resource to copy stub to new tar-based phar \"%s\"", phar->fname); } @@ -1040,7 +1055,7 @@ int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defau entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1); entry.filename_len = sizeof(".phar/stub.php")-1; - zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL); + zend_hash_str_update_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info)); if (free_user_stub) { efree(user_stub); @@ -1065,8 +1080,8 @@ int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defau entry.filename_len = sizeof(".phar/stub.php")-1; if (!defaultstub) { - if (!zend_hash_exists(&phar->manifest, ".phar/stub.php", sizeof(".phar/stub.php")-1)) { - if (SUCCESS != zend_hash_add(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (!zend_hash_str_exists(&phar->manifest, ".phar/stub.php", sizeof(".phar/stub.php")-1)) { + if (NULL == zend_hash_str_add_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { php_stream_close(entry.fp); efree(entry.filename); if (error) { @@ -1079,7 +1094,7 @@ int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defau efree(entry.filename); } } else { - if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL == zend_hash_str_update_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { php_stream_close(entry.fp); efree(entry.filename); if (error) { @@ -1116,10 +1131,10 @@ nostub: pass.free_fp = 1; pass.free_ufp = 1; - if (phar->metadata) { + if (Z_TYPE(phar->metadata) != IS_UNDEF) { phar_entry_info *mentry; - if (SUCCESS == zend_hash_find(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1, (void **)&mentry)) { - if (ZEND_HASH_APPLY_KEEP != phar_tar_setmetadata(phar->metadata, mentry, error TSRMLS_CC)) { + if (NULL != (mentry = zend_hash_str_find_ptr(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1))) { + if (ZEND_HASH_APPLY_KEEP != phar_tar_setmetadata(&phar->metadata, mentry, error TSRMLS_CC)) { if (closeoldfile) { php_stream_close(oldfile); } @@ -1134,7 +1149,7 @@ nostub: newentry.tar_type = TAR_FILE; newentry.is_tar = 1; - if (SUCCESS != zend_hash_add(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1, (void *)&newentry, sizeof(phar_entry_info), (void **)&mentry)) { + if (NULL == (mentry = zend_hash_str_add_mem(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1, (void *)&newentry, sizeof(phar_entry_info)))) { spprintf(error, 0, "phar tar error: unable to add magic metadata file to manifest for phar archive \"%s\"", phar->fname); if (closeoldfile) { php_stream_close(oldfile); @@ -1142,8 +1157,8 @@ nostub: return EOF; } - if (ZEND_HASH_APPLY_KEEP != phar_tar_setmetadata(phar->metadata, mentry, error TSRMLS_CC)) { - zend_hash_del(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1); + if (ZEND_HASH_APPLY_KEEP != phar_tar_setmetadata(&phar->metadata, mentry, error TSRMLS_CC)) { + zend_hash_str_del(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1); if (closeoldfile) { php_stream_close(oldfile); } diff --git a/ext/phar/util.c b/ext/phar/util.c index 8aa0cf8ae0..2cbc0b1716 100644 --- a/ext/phar/util.c +++ b/ext/phar/util.c @@ -71,8 +71,8 @@ phar_entry_info *phar_get_link_source(phar_entry_info *entry TSRMLS_DC) /* {{{ * } link = phar_get_link_location(entry TSRMLS_CC); - if (SUCCESS == zend_hash_find(&(entry->phar->manifest), entry->link, strlen(entry->link), (void **)&link_entry) || - SUCCESS == zend_hash_find(&(entry->phar->manifest), link, strlen(link), (void **)&link_entry)) { + if (NULL != (link_entry = zend_hash_str_find_ptr(&(entry->phar->manifest), entry->link, strlen(entry->link))) || + NULL != (link_entry = zend_hash_str_find_ptr(&(entry->phar->manifest), link, strlen(link)))) { if (link != entry->link) { efree(link); } @@ -227,7 +227,7 @@ int phar_mount_entry(phar_archive_data *phar, char *filename, int filename_len, if (ssb.sb.st_mode & S_IFDIR) { entry.is_dir = 1; - if (SUCCESS != zend_hash_add(&phar->mounted_dirs, entry.filename, path_len, (void *)&(entry.filename), sizeof(char *), NULL)) { + if (NULL != zend_hash_str_add_ptr(&phar->mounted_dirs, entry.filename, path_len, entry.filename)) { /* directory already mounted */ efree(entry.tmp); efree(entry.filename); @@ -240,7 +240,7 @@ int phar_mount_entry(phar_archive_data *phar, char *filename, int filename_len, entry.flags = ssb.sb.st_mode; - if (SUCCESS == zend_hash_add(&phar->manifest, entry.filename, path_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL != zend_hash_str_add_mem(&phar->manifest, entry.filename, path_len, (void*)&entry, sizeof(phar_entry_info))) { return SUCCESS; } @@ -298,14 +298,14 @@ splitted: test = phar_fix_filepath(estrndup(filename, filename_len), &try_len, 1 TSRMLS_CC); if (*test == '/') { - if (zend_hash_exists(&(phar->manifest), test + 1, try_len - 1)) { + if (zend_hash_str_exists(&(phar->manifest), test + 1, try_len - 1)) { spprintf(&ret, 0, "phar://%s%s", arch, test); efree(arch); efree(test); return ret; } } else { - if (zend_hash_exists(&(phar->manifest), test, try_len)) { + if (zend_hash_str_exists(&(phar->manifest), test, try_len)) { spprintf(&ret, 0, "phar://%s/%s", arch, test); efree(arch); efree(test); @@ -328,10 +328,10 @@ splitted: return ret; } - zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **) &pphar); + *pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len); - if (!pphar && PHAR_G(manifest_cached)) { - zend_hash_find(&cached_phars, arch, arch_len, (void **) &pphar); + if (!*pphar && PHAR_G(manifest_cached)) { + *pphar = zend_hash_str_find_ptr(&cached_phars, arch, arch_len); } efree(arch); @@ -592,7 +592,7 @@ phar_entry_data *phar_get_or_create_entry_data(char *fname, int fname_len, char etemp.tar_type = etemp.is_dir ? TAR_DIR : TAR_FILE; } - if (FAILURE == zend_hash_add(&phar->manifest, etemp.filename, path_len, (void*)&etemp, sizeof(phar_entry_info), (void **) &entry)) { + if (NULL == (entry = zend_hash_str_add_mem(&phar->manifest, etemp.filename, path_len, (void*)&etemp, sizeof(phar_entry_info)))) { php_stream_close(etemp.fp); if (error) { spprintf(error, 0, "phar error: unable to add new entry \"%s\" to phar \"%s\"", etemp.filename, phar->fname); @@ -924,11 +924,11 @@ phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry, /* }}} */ PHP_PHAR_API int phar_resolve_alias(char *alias, int alias_len, char **filename, int *filename_len TSRMLS_DC) /* {{{ */ { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; if (PHAR_GLOBALS->phar_alias_map.arHash - && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void**)&fd_ptr)) { - *filename = (*fd_ptr)->fname; - *filename_len = (*fd_ptr)->fname_len; + && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { + *filename = fd_ptr->fname; + *filename_len = fd_ptr->fname_len; return SUCCESS; } return FAILURE; @@ -942,7 +942,7 @@ int phar_free_alias(phar_archive_data *phar, char *alias, int alias_len TSRMLS_D } /* this archive has no open references, so emit an E_STRICT and remove it */ - if (zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) { + if (zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) { return FAILURE; } @@ -960,10 +960,9 @@ int phar_free_alias(phar_archive_data *phar, char *alias, int alias_len TSRMLS_D */ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, char *alias, int alias_len, char **error TSRMLS_DC) /* {{{ */ { - phar_archive_data *fd, **fd_ptr; + phar_archive_data *fd, *fd_ptr; char *my_realpath, *save; int save_len; - ulong fhash, ahash = 0; phar_request_initialize(TSRMLS_C); @@ -985,11 +984,11 @@ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, ch return FAILURE; } - if (PHAR_G(last_phar)->alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len, (void**)&fd_ptr)) { - zend_hash_del(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len); + if (PHAR_G(last_phar)->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len))) { + zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len); } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&(*archive), sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, *archive); PHAR_G(last_alias) = alias; PHAR_G(last_alias_len) = alias_len; } @@ -999,19 +998,18 @@ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, ch if (alias && alias_len && PHAR_G(last_phar) && alias_len == PHAR_G(last_alias_len) && !memcmp(alias, PHAR_G(last_alias), alias_len)) { fd = PHAR_G(last_phar); - fd_ptr = &fd; + fd_ptr = fd; goto alias_success; } if (alias && alias_len) { - ahash = zend_inline_hash_func(alias, alias_len); - if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, ahash, (void**)&fd_ptr)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { alias_success: - if (fname && (fname_len != (*fd_ptr)->fname_len || strncmp(fname, (*fd_ptr)->fname, fname_len))) { + if (fname && (fname_len != fd_ptr->fname_len || strncmp(fname, fd_ptr->fname, fname_len))) { if (error) { - spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, (*fd_ptr)->fname, fname); + spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, fd_ptr->fname, fname); } - if (SUCCESS == phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) { + if (SUCCESS == phar_free_alias(fd_ptr, alias, alias_len TSRMLS_CC)) { if (error) { efree(*error); *error = NULL; @@ -1020,8 +1018,8 @@ alias_success: return FAILURE; } - *archive = *fd_ptr; - fd = *fd_ptr; + *archive = fd_ptr; + fd = fd_ptr; PHAR_G(last_phar) = fd; PHAR_G(last_phar_name) = fd->fname; PHAR_G(last_phar_name_len) = fd->fname_len; @@ -1031,34 +1029,33 @@ alias_success: return SUCCESS; } - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_alias, alias, alias_len, ahash, (void **)&fd_ptr)) { + if (PHAR_G(manifest_cached) && NULL != (fd_ptr = zend_hash_str_find_ptr(&cached_alias, alias, alias_len))) { goto alias_success; } } - fhash = zend_inline_hash_func(fname, fname_len); my_realpath = NULL; save = fname; save_len = fname_len; if (fname && fname_len) { - if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, fhash, (void**)&fd_ptr)) { - *archive = *fd_ptr; - fd = *fd_ptr; + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) { + *archive = fd_ptr; + fd = fd_ptr; if (alias && alias_len) { if (!fd->is_temporary_alias && (alias_len != fd->alias_len || memcmp(fd->alias, alias, alias_len))) { if (error) { - spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, (*fd_ptr)->fname, fname); + spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, fd_ptr->fname, fname); } return FAILURE; } - if (fd->alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len, (void**)&fd_ptr)) { - zend_hash_del(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len); + if (fd->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len))) { + zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len); } - zend_hash_quick_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, ahash, (void*)&fd, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, fd); } PHAR_G(last_phar) = fd; @@ -1070,16 +1067,16 @@ alias_success: return SUCCESS; } - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_phars, fname, fname_len, fhash, (void**)&fd_ptr)) { - *archive = *fd_ptr; - fd = *fd_ptr; + if (PHAR_G(manifest_cached) && NULL != (fd_ptr = zend_hash_str_find_ptr(&cached_phars, fname, fname_len))) { + *archive = fd_ptr; + fd = fd_ptr; /* this could be problematic - alias should never be different from manifest alias for cached phars */ if (!fd->is_temporary_alias && alias && alias_len) { if (alias_len != fd->alias_len || memcmp(fd->alias, alias, alias_len)) { if (error) { - spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, (*fd_ptr)->fname, fname); + spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, fd_ptr->fname, fname); } return FAILURE; } @@ -1094,8 +1091,8 @@ alias_success: return SUCCESS; } - if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_alias_map), save, save_len, fhash, (void**)&fd_ptr)) { - fd = *archive = *fd_ptr; + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), save, save_len))) { + fd = *archive = fd_ptr; PHAR_G(last_phar) = fd; PHAR_G(last_phar_name) = fd->fname; @@ -1106,8 +1103,8 @@ alias_success: return SUCCESS; } - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_alias, save, save_len, fhash, (void**)&fd_ptr)) { - fd = *archive = *fd_ptr; + if (PHAR_G(manifest_cached) && NULL != (fd_ptr = zend_hash_str_find_ptr(&cached_alias, save, save_len))) { + fd = *archive = fd_ptr; PHAR_G(last_phar) = fd; PHAR_G(last_phar_name) = fd->fname; @@ -1130,15 +1127,14 @@ alias_success: #ifdef PHP_WIN32 phar_unixify_path_separators(fname, fname_len); #endif - fhash = zend_inline_hash_func(fname, fname_len); - if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, fhash, (void**)&fd_ptr)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) { realpath_success: - *archive = *fd_ptr; - fd = *fd_ptr; + *archive = fd_ptr; + fd = fd_ptr; if (alias && alias_len) { - zend_hash_quick_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, ahash, (void*)&fd, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, fd); } efree(my_realpath); @@ -1152,7 +1148,7 @@ realpath_success: return SUCCESS; } - if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_phars, fname, fname_len, fhash, (void**)&fd_ptr)) { + if (PHAR_G(manifest_cached) && NULL != (fd_ptr = zend_hash_str_find_ptr(&cached_phars, fname, fname_len))) { goto realpath_success; } @@ -1264,7 +1260,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in path_len--; } - if (SUCCESS == zend_hash_find(&phar->manifest, path, path_len, (void**)&entry)) { + if (NULL != (entry = zend_hash_str_find_ptr(&phar->manifest, path, path_len))) { if (entry->is_deleted) { /* entry is deleted, but has not been flushed to disk yet */ return NULL; @@ -1286,7 +1282,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in } if (dir) { - if (zend_hash_exists(&phar->virtual_dirs, path, path_len)) { + if (zend_hash_str_exists(&phar->virtual_dirs, path, path_len)) { /* a file or directory exists in a sub-directory of this path */ entry = (phar_entry_info *) ecalloc(1, sizeof(phar_entry_info)); /* this next line tells PharFileInfo->__destruct() to efree the filename */ @@ -1299,38 +1295,31 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in } if (phar->mounted_dirs.arHash && zend_hash_num_elements(&phar->mounted_dirs)) { - char *str_key; - ulong unused; - uint keylen; - - zend_hash_internal_pointer_reset(&phar->mounted_dirs); - while (FAILURE != zend_hash_has_more_elements(&phar->mounted_dirs)) { - if (HASH_KEY_NON_EXISTENT == zend_hash_get_current_key_ex(&phar->mounted_dirs, &str_key, &keylen, &unused, 0, NULL)) { - break; - } + zend_string *str_key; - if ((int)keylen >= path_len || strncmp(str_key, path, keylen)) { + ZEND_HASH_FOREACH_STR_KEY(&phar->mounted_dirs, str_key) { + if ((int)str_key->len >= path_len || strncmp(str_key->val, path, str_key->len)) { continue; } else { char *test; int test_len; php_stream_statbuf ssb; - if (SUCCESS != zend_hash_find(&phar->manifest, str_key, keylen, (void **) &entry)) { + if (NULL == (entry = zend_hash_find_ptr(&phar->manifest, str_key))) { if (error) { - spprintf(error, 4096, "phar internal error: mounted path \"%s\" could not be retrieved from manifest", str_key); + spprintf(error, 4096, "phar internal error: mounted path \"%s\" could not be retrieved from manifest", str_key->val); } return NULL; } if (!entry->tmp || !entry->is_mounted) { if (error) { - spprintf(error, 4096, "phar internal error: mounted path \"%s\" is not properly initialized as a mounted path", str_key); + spprintf(error, 4096, "phar internal error: mounted path \"%s\" is not properly initialized as a mounted path", str_key->val); } return NULL; } - test_len = spprintf(&test, MAXPATHLEN, "%s%s", entry->tmp, path + keylen); + test_len = spprintf(&test, MAXPATHLEN, "%s%s", entry->tmp, path + str_key->len); if (SUCCESS != php_stream_stat_path(test, &ssb)) { efree(test); @@ -1365,7 +1354,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in efree(test); - if (SUCCESS != zend_hash_find(&phar->manifest, path, path_len, (void**)&entry)) { + if (NULL == (entry = zend_hash_str_find_ptr(&phar->manifest, path, path_len))) { if (error) { spprintf(error, 4096, "phar error: path \"%s\" exists as file \"%s\" and could not be retrieved after being mounted", path, test); } @@ -1373,7 +1362,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in } return entry; } - } + } ZEND_HASH_FOREACH_END(); } return NULL; @@ -1403,109 +1392,77 @@ static int phar_call_openssl_signverify(int is_sign, php_stream *fp, off_t end, { zend_fcall_info fci; zend_fcall_info_cache fcc; - zval *zdata, *zsig, *zkey, *retval_ptr, **zp[3], *openssl; - - MAKE_STD_ZVAL(zdata); - MAKE_STD_ZVAL(openssl); - ZVAL_STRINGL(openssl, is_sign ? "openssl_sign" : "openssl_verify", is_sign ? sizeof("openssl_sign")-1 : sizeof("openssl_verify")-1, 1); - MAKE_STD_ZVAL(zsig); - ZVAL_STRINGL(zsig, *signature, *signature_len, 1); - MAKE_STD_ZVAL(zkey); - ZVAL_STRINGL(zkey, key, key_len, 1); - zp[0] = &zdata; - zp[1] = &zsig; - zp[2] = &zkey; - - php_stream_rewind(fp); - Z_TYPE_P(zdata) = IS_STRING; - Z_STRLEN_P(zdata) = end; - - if (end != (off_t) php_stream_copy_to_mem(fp, &(Z_STRVAL_P(zdata)), (size_t) end, 0)) { - zval_dtor(zdata); - zval_dtor(zsig); - zval_dtor(zkey); - zval_dtor(openssl); - efree(openssl); - efree(zdata); - efree(zkey); - efree(zsig); + zval retval, zp[3], openssl; + + ZVAL_STRINGL(&openssl, is_sign ? "openssl_sign" : "openssl_verify", is_sign ? sizeof("openssl_sign")-1 : sizeof("openssl_verify")-1); + ZVAL_STRINGL(&zp[1], *signature, *signature_len); + ZVAL_STRINGL(&zp[2], key, key_len); + ZVAL_STR(&zp[0], php_stream_copy_to_mem(fp, (size_t) end, 0)); + + if (end != Z_STRLEN(zp[0])) { + zval_dtor(&zp[0]); + zval_dtor(&zp[1]); + zval_dtor(&zp[2]); + zval_dtor(&openssl); return FAILURE; } - if (FAILURE == zend_fcall_info_init(openssl, 0, &fci, &fcc, NULL, NULL TSRMLS_CC)) { - zval_dtor(zdata); - zval_dtor(zsig); - zval_dtor(zkey); - zval_dtor(openssl); - efree(openssl); - efree(zdata); - efree(zkey); - efree(zsig); + if (FAILURE == zend_fcall_info_init(&openssl, 0, &fci, &fcc, NULL, NULL TSRMLS_CC)) { + zval_dtor(&zp[0]); + zval_dtor(&zp[1]); + zval_dtor(&zp[2]); + zval_dtor(&openssl); return FAILURE; } fci.param_count = 3; fci.params = zp; - Z_ADDREF_P(zdata); + Z_ADDREF(zp[0]); if (is_sign) { - Z_SET_ISREF_P(zsig); + ZVAL_NEW_REF(&zp[1], &zp[1]); } else { - Z_ADDREF_P(zsig); + Z_ADDREF(zp[1]); } - Z_ADDREF_P(zkey); + Z_ADDREF(zp[2]); - fci.retval_ptr_ptr = &retval_ptr; + fci.retval = &retval; if (FAILURE == zend_call_function(&fci, &fcc TSRMLS_CC)) { - zval_dtor(zdata); - zval_dtor(zsig); - zval_dtor(zkey); - zval_dtor(openssl); - efree(openssl); - efree(zdata); - efree(zkey); - efree(zsig); + zval_dtor(&zp[0]); + zval_dtor(&zp[1]); + zval_dtor(&zp[2]); + zval_dtor(&openssl); return FAILURE; } - zval_dtor(openssl); - efree(openssl); - Z_DELREF_P(zdata); + zval_dtor(&openssl); + Z_DELREF(zp[0]); if (is_sign) { - Z_UNSET_ISREF_P(zsig); + ZVAL_UNREF(&zp[1]); } else { - Z_DELREF_P(zsig); + Z_DELREF(zp[1]); } - Z_DELREF_P(zkey); + Z_DELREF(zp[2]); - zval_dtor(zdata); - efree(zdata); - zval_dtor(zkey); - efree(zkey); + zval_dtor(&zp[0]); + zval_dtor(&zp[1]); - switch (Z_TYPE_P(retval_ptr)) { + switch (Z_TYPE(retval)) { default: case IS_LONG: - zval_dtor(zsig); - efree(zsig); - if (1 == Z_LVAL_P(retval_ptr)) { - efree(retval_ptr); + zval_dtor(&zp[1]); + if (1 == Z_LVAL(retval)) { return SUCCESS; } - efree(retval_ptr); return FAILURE; - case IS_BOOL: - efree(retval_ptr); - if (Z_BVAL_P(retval_ptr)) { - *signature = estrndup(Z_STRVAL_P(zsig), Z_STRLEN_P(zsig)); - *signature_len = Z_STRLEN_P(zsig); - zval_dtor(zsig); - efree(zsig); - return SUCCESS; - } - zval_dtor(zsig); - efree(zsig); + case IS_TRUE: + *signature = estrndup(Z_STRVAL(zp[1]), Z_STRLEN(zp[1])); + *signature_len = Z_STRLEN(zp[1]); + zval_dtor(&zp[1]); + return SUCCESS; + case IS_FALSE: + zval_dtor(&zp[1]); return FAILURE; } } @@ -1530,11 +1487,11 @@ int phar_verify_signature(php_stream *fp, size_t end_of_phar, php_uint32 sig_typ #else int tempsig; #endif - php_uint32 pubkey_len; - char *pubkey = NULL, *pfile; + zend_string *pubkey = NULL; + char *pfile; php_stream *pfp; #ifndef PHAR_HAVE_OPENSSL - if (!zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) { + if (!zend_hash_str_exists(&module_registry, "openssl", sizeof("openssl")-1)) { if (error) { spprintf(error, 0, "openssl not loaded"); } @@ -1546,11 +1503,12 @@ int phar_verify_signature(php_stream *fp, size_t end_of_phar, php_uint32 sig_typ pfp = php_stream_open_wrapper(pfile, "rb", 0, NULL); efree(pfile); -#if PHP_MAJOR_VERSION > 5 - if (!pfp || !(pubkey_len = php_stream_copy_to_mem(pfp, (void **) &pubkey, PHP_STREAM_COPY_ALL, 0)) || !pubkey) { -#else - if (!pfp || !(pubkey_len = php_stream_copy_to_mem(pfp, &pubkey, PHP_STREAM_COPY_ALL, 0)) || !pubkey) { -#endif +//???#if PHP_MAJOR_VERSION > 5 +//??? if (!pfp || !(pubkey_len = php_stream_copy_to_mem(pfp, (void **) &pubkey, PHP_STREAM_COPY_ALL, 0)) || !pubkey) { +//???#else +//??? if (!pfp || !(pubkey_len = php_stream_copy_to_mem(pfp, &pubkey, PHP_STREAM_COPY_ALL, 0)) || !pubkey) { +//???#endif + if (!pfp || !(pubkey = php_stream_copy_to_mem(pfp, PHP_STREAM_COPY_ALL, 0)) || !pubkey->len) { if (pfp) { php_stream_close(pfp); } @@ -1564,9 +1522,9 @@ int phar_verify_signature(php_stream *fp, size_t end_of_phar, php_uint32 sig_typ #ifndef PHAR_HAVE_OPENSSL tempsig = sig_len; - if (FAILURE == phar_call_openssl_signverify(0, fp, end_of_phar, pubkey, pubkey_len, &sig, &tempsig TSRMLS_CC)) { + if (FAILURE == phar_call_openssl_signverify(0, fp, end_of_phar, pubkey ? pubkey->val : NULL, pubkey ? pubkey->len : 0, &sig, &tempsig TSRMLS_CC)) { if (pubkey) { - efree(pubkey); + STR_RELEASE(pubkey); } if (error) { @@ -1577,15 +1535,15 @@ int phar_verify_signature(php_stream *fp, size_t end_of_phar, php_uint32 sig_typ } if (pubkey) { - efree(pubkey); + STR_RELEASE(pubkey); } sig_len = tempsig; #else - in = BIO_new_mem_buf(pubkey, pubkey_len); + in = BIO_new_mem_buf(pubkey ? pubkey->val : NULL, pubkey ? pubkey->len : 0); if (NULL == in) { - efree(pubkey); + STR_RELEASE(pubkey); if (error) { spprintf(error, 0, "openssl signature could not be processed"); } @@ -1594,7 +1552,7 @@ int phar_verify_signature(php_stream *fp, size_t end_of_phar, php_uint32 sig_typ key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL); BIO_free(in); - efree(pubkey); + STR_RELEASE(pubkey); if (NULL == key) { if (error) { @@ -1965,16 +1923,16 @@ void phar_add_virtual_dirs(phar_archive_data *phar, char *filename, int filename while ((s = zend_memrchr(filename, '/', filename_len))) { filename_len = s - filename; - if (FAILURE == zend_hash_add_empty_element(&phar->virtual_dirs, filename, filename_len)) { + if (NULL == zend_hash_str_add_empty_element(&phar->virtual_dirs, filename, filename_len)) { break; } } } /* }}} */ -static int phar_update_cached_entry(void *data, void *argument) /* {{{ */ +static int phar_update_cached_entry(zval *data, void *argument) /* {{{ */ { - phar_entry_info *entry = (phar_entry_info *)data; + phar_entry_info *entry = (phar_entry_info *)Z_PTR_P(data); TSRMLS_FETCH(); entry->phar = (phar_archive_data *)argument; @@ -1987,26 +1945,19 @@ static int phar_update_cached_entry(void *data, void *argument) /* {{{ */ entry->tmp = estrdup(entry->tmp); } - entry->metadata_str.c = 0; + entry->metadata_str.s = NULL; entry->filename = estrndup(entry->filename, entry->filename_len); entry->is_persistent = 0; - if (entry->metadata) { + if (Z_TYPE(entry->metadata) != IS_UNDEF) { if (entry->metadata_len) { - char *buf = estrndup((char *) entry->metadata, entry->metadata_len); + char *buf = estrndup((char *) Z_PTR(entry->metadata), entry->metadata_len); /* assume success, we would have failed before */ phar_parse_metadata((char **) &buf, &entry->metadata, entry->metadata_len TSRMLS_CC); efree(buf); } else { - zval *t; - - t = entry->metadata; - ALLOC_ZVAL(entry->metadata); - *entry->metadata = *t; - zval_copy_ctor(entry->metadata); - Z_SET_REFCOUNT_P(entry->metadata, 1); - entry->metadata_str.c = NULL; - entry->metadata_str.len = 0; + zval_copy_ctor(&entry->metadata); + entry->metadata_str.s = NULL; } } return ZEND_HASH_APPLY_KEEP; @@ -2018,7 +1969,7 @@ static void phar_copy_cached_phar(phar_archive_data **pphar TSRMLS_DC) /* {{{ */ phar_archive_data *phar; HashTable newmanifest; char *fname; - phar_archive_object **objphar; + phar_archive_object *objphar; phar = (phar_archive_data *) emalloc(sizeof(phar_archive_data)); *phar = **pphar; @@ -2035,66 +1986,58 @@ static void phar_copy_cached_phar(phar_archive_data **pphar TSRMLS_DC) /* {{{ */ phar->signature = estrdup(phar->signature); } - if (phar->metadata) { + if (Z_TYPE(phar->metadata) != IS_UNDEF) { /* assume success, we would have failed before */ if (phar->metadata_len) { - char *buf = estrndup((char *) phar->metadata, phar->metadata_len); + char *buf = estrndup((char *) Z_PTR(phar->metadata), phar->metadata_len); phar_parse_metadata(&buf, &phar->metadata, phar->metadata_len TSRMLS_CC); efree(buf); } else { - zval *t; - - t = phar->metadata; - ALLOC_ZVAL(phar->metadata); - *phar->metadata = *t; - zval_copy_ctor(phar->metadata); - Z_SET_REFCOUNT_P(phar->metadata, 1); + zval_copy_ctor(&phar->metadata); } } zend_hash_init(&newmanifest, sizeof(phar_entry_info), zend_get_hash_value, destroy_phar_manifest_entry, 0); - zend_hash_copy(&newmanifest, &(*pphar)->manifest, NULL, NULL, sizeof(phar_entry_info)); +//??? zend_hash_copy(&newmanifest, &(*pphar)->manifest, NULL, NULL, sizeof(phar_entry_info)); + zend_hash_copy(&newmanifest, &(*pphar)->manifest, NULL); zend_hash_apply_with_argument(&newmanifest, (apply_func_arg_t) phar_update_cached_entry, (void *)phar TSRMLS_CC); phar->manifest = newmanifest; zend_hash_init(&phar->mounted_dirs, sizeof(char *), zend_get_hash_value, NULL, 0); zend_hash_init(&phar->virtual_dirs, sizeof(char *), zend_get_hash_value, NULL, 0); - zend_hash_copy(&phar->virtual_dirs, &(*pphar)->virtual_dirs, NULL, NULL, sizeof(void *)); + zend_hash_copy(&phar->virtual_dirs, &(*pphar)->virtual_dirs, NULL); *pphar = phar; /* now, scan the list of persistent Phar objects referencing this phar and update the pointers */ - for (zend_hash_internal_pointer_reset(&PHAR_GLOBALS->phar_persist_map); - SUCCESS == zend_hash_get_current_data(&PHAR_GLOBALS->phar_persist_map, (void **) &objphar); - zend_hash_move_forward(&PHAR_GLOBALS->phar_persist_map)) { - if (objphar[0]->arc.archive->fname_len == phar->fname_len && !memcmp(objphar[0]->arc.archive->fname, phar->fname, phar->fname_len)) { - objphar[0]->arc.archive = phar; + ZEND_HASH_FOREACH_PTR(&PHAR_GLOBALS->phar_persist_map, objphar) { + if (objphar->arc.archive->fname_len == phar->fname_len && !memcmp(objphar->arc.archive->fname, phar->fname, phar->fname_len)) { + objphar->arc.archive = phar; } - } + } ZEND_HASH_FOREACH_END(); } /* }}} */ int phar_copy_on_write(phar_archive_data **pphar TSRMLS_DC) /* {{{ */ { - phar_archive_data **newpphar, *newphar = NULL; + phar_archive_data *newpphar; - if (SUCCESS != zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len, (void *)&newphar, sizeof(phar_archive_data *), (void **)&newpphar)) { + if (NULL == (newpphar = zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len, *pphar))) { return FAILURE; } - *newpphar = *pphar; - phar_copy_cached_phar(newpphar TSRMLS_CC); + phar_copy_cached_phar(&newpphar TSRMLS_CC); /* invalidate phar cache */ PHAR_G(last_phar) = NULL; PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL; - if (newpphar[0]->alias_len && FAILURE == zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), newpphar[0]->alias, newpphar[0]->alias_len, (void*)newpphar, sizeof(phar_archive_data*), NULL)) { - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len); + if (newpphar->alias_len && NULL == zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), newpphar->alias, newpphar->alias_len, newpphar)) { + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len); return FAILURE; } - *pphar = *newpphar; + *pphar = newpphar; return SUCCESS; } /* }}} */ diff --git a/ext/phar/zip.c b/ext/phar/zip.c index 2fc692c33e..bbd7126d8a 100644 --- a/ext/phar/zip.c +++ b/ext/phar/zip.c @@ -241,18 +241,10 @@ int phar_parse_zipfile(php_stream *fp, char *fname, int fname_len, char *alias, mydata->metadata_len = 0; /* if not valid serialized data, it is a regular string */ - if (entry.is_persistent) { - ALLOC_PERMANENT_ZVAL(mydata->metadata); - } else { - ALLOC_ZVAL(mydata->metadata); - } - - INIT_ZVAL(*mydata->metadata); - metadata = pestrndup(metadata, PHAR_GET_16(locator.comment_len), mydata->is_persistent); - ZVAL_STRINGL(mydata->metadata, metadata, PHAR_GET_16(locator.comment_len), 0); + ZVAL_STR(&mydata->metadata, STR_INIT(metadata, PHAR_GET_16(locator.comment_len), mydata->is_persistent)); } } else { - mydata->metadata = NULL; + ZVAL_UNDEF(&mydata->metadata); } goto foundit; @@ -307,9 +299,7 @@ foundit: zend_hash_destroy(&mydata->virtual_dirs); \ mydata->virtual_dirs.arHash = 0; \ php_stream_close(fp); \ - if (mydata->metadata) { \ - zval_dtor(mydata->metadata); \ - } \ + zval_dtor(&mydata->metadata); \ if (mydata->signature) { \ efree(mydata->signature); \ } \ @@ -331,9 +321,7 @@ foundit: zend_hash_destroy(&mydata->virtual_dirs); \ mydata->virtual_dirs.arHash = 0; \ php_stream_close(fp); \ - if (mydata->metadata) { \ - zval_dtor(mydata->metadata); \ - } \ + zval_dtor(&mydata->metadata); \ if (mydata->signature) { \ efree(mydata->signature); \ } \ @@ -541,17 +529,10 @@ foundit: entry.metadata_len = 0; /* if not valid serialized data, it is a regular string */ - if (entry.is_persistent) { - ALLOC_PERMANENT_ZVAL(entry.metadata); - } else { - ALLOC_ZVAL(entry.metadata); - } - - INIT_ZVAL(*entry.metadata); - ZVAL_STRINGL(entry.metadata, pestrndup(buf, PHAR_GET_16(zipentry.comment_len), entry.is_persistent), PHAR_GET_16(zipentry.comment_len), 0); + ZVAL_STR(&entry.metadata, STR_INIT(buf, PHAR_GET_16(zipentry.comment_len), entry.is_persistent)); } } else { - entry.metadata = NULL; + ZVAL_UNDEF(&entry.metadata); } if (!actual_alias && entry.filename_len == sizeof(".phar/alias.txt")-1 && !strncmp(entry.filename, ".phar/alias.txt", sizeof(".phar/alias.txt")-1)) { @@ -588,7 +569,6 @@ foundit: /* the above lines should be for php < 5.2.6 after 5.3 filters are fixed */ mydata->alias_len = entry.uncompressed_filesize; - if (entry.flags & PHAR_ENT_COMPRESSED_GZ) { filter = php_stream_filter_create("zlib.inflate", NULL, php_stream_is_persistent(fp) TSRMLS_CC); @@ -599,7 +579,21 @@ foundit: php_stream_filter_append(&fp->readfilters, filter); - if (!(entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0)) || !actual_alias) { + // TODO: refactor to avoid reallocation ??? +//??? entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0) + { + zend_string *str = php_stream_copy_to_mem(fp, entry.uncompressed_filesize, 0); + if (str) { + entry.uncompressed_filesize = str->len; + actual_alias = estrndup(str->val, str->len); + STR_RELEASE(str); + } else { + actual_alias = NULL; + entry.uncompressed_filesize = 0; + } + } + + if (!entry.uncompressed_filesize || !actual_alias) { pefree(entry.filename, entry.is_persistent); PHAR_ZIP_FAIL("unable to read in alias, truncated"); } @@ -617,7 +611,21 @@ foundit: php_stream_filter_append(&fp->readfilters, filter); - if (!(entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0)) || !actual_alias) { + // TODO: refactor to avoid reallocation ??? +//??? entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0) + { + zend_string *str = php_stream_copy_to_mem(fp, entry.uncompressed_filesize, 0); + if (str) { + entry.uncompressed_filesize = str->len; + actual_alias = estrndup(str->val, str->len); + STR_RELEASE(str); + } else { + actual_alias = NULL; + entry.uncompressed_filesize = 0; + } + } + + if (!entry.uncompressed_filesize || !actual_alias) { pefree(entry.filename, entry.is_persistent); PHAR_ZIP_FAIL("unable to read in alias, truncated"); } @@ -625,7 +633,21 @@ foundit: php_stream_filter_flush(filter, 1); php_stream_filter_remove(filter, 1 TSRMLS_CC); } else { - if (!(entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0)) || !actual_alias) { + // TODO: refactor to avoid reallocation ??? +//??? entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0) + { + zend_string *str = php_stream_copy_to_mem(fp, entry.uncompressed_filesize, 0); + if (str) { + entry.uncompressed_filesize = str->len; + actual_alias = estrndup(str->val, str->len); + STR_RELEASE(str); + } else { + actual_alias = NULL; + entry.uncompressed_filesize = 0; + } + } + + if (!entry.uncompressed_filesize || !actual_alias) { pefree(entry.filename, entry.is_persistent); PHAR_ZIP_FAIL("unable to read in alias, truncated"); } @@ -636,40 +658,40 @@ foundit: } phar_set_inode(&entry TSRMLS_CC); - zend_hash_add(&mydata->manifest, entry.filename, entry.filename_len, (void *)&entry,sizeof(phar_entry_info), NULL); + zend_hash_str_add_mem(&mydata->manifest, entry.filename, entry.filename_len, (void *)&entry, sizeof(phar_entry_info)); } mydata->fp = fp; - if (zend_hash_exists(&(mydata->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1)) { + if (zend_hash_str_exists(&(mydata->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1)) { mydata->is_data = 0; } else { mydata->is_data = 1; } - zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, (void*)&mydata, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata); if (actual_alias) { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; if (!phar_validate_alias(actual_alias, mydata->alias_len)) { if (error) { spprintf(error, 4096, "phar error: invalid alias \"%s\" in zip-based phar \"%s\"", actual_alias, fname); } efree(actual_alias); - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); return FAILURE; } mydata->is_temporary_alias = 0; - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, (void **)&fd_ptr)) { - if (SUCCESS != phar_free_alias(*fd_ptr, actual_alias, mydata->alias_len TSRMLS_CC)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len))) { + if (SUCCESS != phar_free_alias(fd_ptr, actual_alias, mydata->alias_len TSRMLS_CC)) { if (error) { spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with implicit alias, alias is already in use", fname); } efree(actual_alias); - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); return FAILURE; } } @@ -680,22 +702,22 @@ foundit: efree(actual_alias); } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, (void*)&mydata, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, mydata); } else { - phar_archive_data **fd_ptr; + phar_archive_data *fd_ptr; if (alias_len) { - if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void **)&fd_ptr)) { - if (SUCCESS != phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) { + if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) { + if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len TSRMLS_CC)) { if (error) { spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with explicit alias, alias is already in use", fname); } - zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); + zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len); return FAILURE; } } - zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, (void*)&mydata, sizeof(phar_archive_data*), NULL); + zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, mydata); mydata->alias = pestrndup(alias, alias_len, mydata->is_persistent); mydata->alias_len = alias_len; } else { @@ -761,7 +783,7 @@ struct _phar_zip_pass { char **error; }; /* perform final modification of zip contents for each file in the manifest before saving */ -static int phar_zip_changed_apply(void *data, void *arg TSRMLS_DC) /* {{{ */ +static int phar_zip_changed_apply(zval *zv, void *arg TSRMLS_DC) /* {{{ */ { phar_entry_info *entry; phar_zip_file_header local; @@ -771,7 +793,7 @@ static int phar_zip_changed_apply(void *data, void *arg TSRMLS_DC) /* {{{ */ php_uint32 newcrc32; off_t offset; int not_really_modified = 0; - entry = (phar_entry_info *)data; + entry = (phar_entry_info *)Z_PTR_P(zv); p = (struct _phar_zip_pass*) arg; if (entry->is_mounted) { @@ -939,18 +961,17 @@ not_compressed: PHAR_SET_32(local.crc32, entry->crc32); continue_dir: /* set file metadata */ - if (entry->metadata) { + if (Z_TYPE(entry->metadata) != IS_UNDEF) { php_serialize_data_t metadata_hash; - if (entry->metadata_str.c) { + if (entry->metadata_str.s) { smart_str_free(&entry->metadata_str); } - entry->metadata_str.c = 0; - entry->metadata_str.len = 0; + entry->metadata_str.s = NULL; PHP_VAR_SERIALIZE_INIT(metadata_hash); php_var_serialize(&entry->metadata_str, &entry->metadata, &metadata_hash TSRMLS_CC); PHP_VAR_SERIALIZE_DESTROY(metadata_hash); - PHAR_SET_16(central.comment_len, entry->metadata_str.len); + PHAR_SET_16(central.comment_len, entry->metadata_str.s->len); } entry->header_offset = php_stream_tell(p->filefp); @@ -1060,8 +1081,8 @@ continue_dir: entry->offset = entry->offset_abs = offset; entry->fp_type = PHAR_FP; - if (entry->metadata_str.c) { - if (entry->metadata_str.len != php_stream_write(p->centralfp, entry->metadata_str.c, entry->metadata_str.len)) { + if (entry->metadata_str.s) { + if (entry->metadata_str.s->len != php_stream_write(p->centralfp, entry->metadata_str.s->val, entry->metadata_str.s->len)) { spprintf(p->error, 0, "unable to write metadata as file comment for file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname); smart_str_free(&entry->metadata_str); return ZEND_HASH_APPLY_STOP; @@ -1097,8 +1118,8 @@ static int phar_zip_applysignature(phar_archive_data *phar, struct _phar_zip_pas tell = php_stream_tell(pass->centralfp); php_stream_seek(pass->centralfp, 0, SEEK_SET); php_stream_copy_to_stream_ex(pass->centralfp, newfile, tell, NULL); - if (metadata->c) { - php_stream_write(newfile, metadata->c, metadata->len); + if (metadata->s) { + php_stream_write(newfile, metadata->s->val, metadata->s->len); } if (FAILURE == phar_create_signature(phar, newfile, &signature, &signature_length, pass->error TSRMLS_CC)) { @@ -1206,14 +1227,14 @@ int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defau entry.filename = estrndup(".phar/alias.txt", sizeof(".phar/alias.txt")-1); entry.filename_len = sizeof(".phar/alias.txt")-1; - if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL == zend_hash_str_update_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { if (error) { spprintf(error, 0, "unable to set alias in zip-based phar \"%s\"", phar->fname); } return EOF; } } else { - zend_hash_del(&phar->manifest, ".phar/alias.txt", sizeof(".phar/alias.txt")-1); + zend_hash_str_del(&phar->manifest, ".phar/alias.txt", sizeof(".phar/alias.txt")-1); } /* register alias */ @@ -1227,7 +1248,7 @@ int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defau if (user_stub && !defaultstub) { if (len < 0) { /* resource passed in */ - if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) { + if (!(php_stream_from_zval_no_verify(stubfile, (zval *)user_stub))) { if (error) { spprintf(error, 0, "unable to access resource to copy stub to new zip-based phar \"%s\"", phar->fname); } @@ -1242,7 +1263,21 @@ int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defau user_stub = 0; - if (!(len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0)) || !user_stub) { + // TODO: refactor to avoid reallocation ??? +//??? len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0) + { + zend_string *str = php_stream_copy_to_mem(stubfile, len, 0); + if (str) { + len = str->len; + user_stub = estrndup(str->val, str->len); + STR_RELEASE(str); + } else { + user_stub = NULL; + len = 0; + } + } + + if (!len || !user_stub) { if (error) { spprintf(error, 0, "unable to read resource to copy stub to new zip-based phar \"%s\"", phar->fname); } @@ -1290,7 +1325,7 @@ int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defau entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1); entry.filename_len = sizeof(".phar/stub.php")-1; - if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL == zend_hash_str_update_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { if (free_user_stub) { efree(user_stub); } @@ -1323,8 +1358,8 @@ int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defau entry.filename_len = sizeof(".phar/stub.php")-1; if (!defaultstub) { - if (!zend_hash_exists(&phar->manifest, ".phar/stub.php", sizeof(".phar/stub.php")-1)) { - if (SUCCESS != zend_hash_add(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (!zend_hash_str_exists(&phar->manifest, ".phar/stub.php", sizeof(".phar/stub.php")-1)) { + if (NULL == zend_hash_str_add_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { php_stream_close(entry.fp); efree(entry.filename); if (error) { @@ -1337,7 +1372,7 @@ int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defau efree(entry.filename); } } else { - if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) { + if (NULL == zend_hash_str_update_mem(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info))) { php_stream_close(entry.fp); efree(entry.filename); if (error) { @@ -1394,7 +1429,7 @@ fperror: } zend_hash_apply_with_argument(&phar->manifest, phar_zip_changed_apply, (void *) &pass TSRMLS_CC); - if (phar->metadata) { + if (Z_TYPE(phar->metadata) != IS_UNDEF) { /* set phar metadata */ PHP_VAR_SERIALIZE_INIT(metadata_hash); php_var_serialize(&main_metadata_str, &phar->metadata, &metadata_hash TSRMLS_CC); @@ -1408,7 +1443,7 @@ fperror: temperror: php_stream_close(pass.centralfp); nocentralerror: - if (phar->metadata) { + if (Z_TYPE(phar->metadata) != IS_UNDEF) { smart_str_free(&main_metadata_str); } php_stream_close(pass.filefp); @@ -1442,9 +1477,9 @@ nocentralerror: php_stream_close(pass.centralfp); - if (phar->metadata) { + if (Z_TYPE(phar->metadata) != IS_UNDEF) { /* set phar metadata */ - PHAR_SET_16(eocd.comment_len, main_metadata_str.len); + PHAR_SET_16(eocd.comment_len, main_metadata_str.s->len); if (sizeof(eocd) != php_stream_write(pass.filefp, (char *)&eocd, sizeof(eocd))) { if (error) { @@ -1453,7 +1488,7 @@ nocentralerror: goto nocentralerror; } - if (main_metadata_str.len != php_stream_write(pass.filefp, main_metadata_str.c, main_metadata_str.len)) { + if (main_metadata_str.s->len != php_stream_write(pass.filefp, main_metadata_str.s->val, main_metadata_str.s->len)) { if (error) { spprintf(error, 4096, "phar zip flush of \"%s\" failed: unable to write metadata to zip comment", phar->fname); } -- 2.40.0