/*

+----------------------------------------------------------------------+

| PHP Version 7 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2018 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Author: Marcus Boerger <helly@php.net> |

+----------------------------------------------------------------------+

*/

/* $Id$ */

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include "php.h"

#include "php_ini.h"

#include "ext/standard/info.h"

#include "ext/standard/file.h"

#include "ext/standard/php_string.h"

#include "zend_compile.h"

#include "zend_exceptions.h"

#include "zend_interfaces.h"

#include "php_spl.h"

#include "spl_functions.h"

#include "spl_engine.h"

#include "spl_iterators.h"

#include "spl_directory.h"

#include "spl_exceptions.h"

#include "php.h"

#include "fopen_wrappers.h"

#include "ext/standard/basic_functions.h"

#include "ext/standard/php_filestat.h"

#define SPL_HAS_FLAG(flags, test_flag) ((flags & test_flag) ? 1 : 0)

/* declare the class handlers */

static zend_object_handlers spl_filesystem_object_handlers;

/* includes handler to validate object state when retrieving methods */

static zend_object_handlers spl_filesystem_object_check_handlers;

/* decalre the class entry */

PHPAPI zend_class_entry *spl_ce_SplFileInfo;

PHPAPI zend_class_entry *spl_ce_DirectoryIterator;

PHPAPI zend_class_entry *spl_ce_FilesystemIterator;

PHPAPI zend_class_entry *spl_ce_RecursiveDirectoryIterator;

PHPAPI zend_class_entry *spl_ce_GlobIterator;

PHPAPI zend_class_entry *spl_ce_SplFileObject;

PHPAPI zend_class_entry *spl_ce_SplTempFileObject;

static void spl_filesystem_file_free_line(spl_filesystem_object *intern) /* {{{ */

{

if (intern->u.file.current_line) {

efree(intern->u.file.current_line);

intern->u.file.current_line = NULL;

}

if (!Z_ISUNDEF(intern->u.file.current_zval)) {

zval_ptr_dtor(&intern->u.file.current_zval);

ZVAL_UNDEF(&intern->u.file.current_zval);

}

} /* }}} */

static void spl_filesystem_object_destroy_object(zend_object *object) /* {{{ */

{

spl_filesystem_object *intern = spl_filesystem_from_obj(object);

zend_objects_destroy_object(object);

switch(intern->type) {

case SPL_FS_DIR:

if (intern->u.dir.dirp) {

php_stream_close(intern->u.dir.dirp);

intern->u.dir.dirp = NULL;

}

break;

case SPL_FS_FILE:

if (intern->u.file.stream) {

/*

if (intern->u.file.zcontext) {

zend_list_delref(Z_RESVAL_P(intern->zcontext));

}

*/

if (!intern->u.file.stream->is_persistent) {

php_stream_close(intern->u.file.stream);

} else {

php_stream_pclose(intern->u.file.stream);

}

}

break;

default:

break;

}

} /* }}} */

static void spl_filesystem_object_free_storage(zend_object *object) /* {{{ */

{

spl_filesystem_object *intern = spl_filesystem_from_obj(object);

if (intern->oth_handler && intern->oth_handler->dtor) {

intern->oth_handler->dtor(intern);

}

zend_object_std_dtor(&intern->std);

if (intern->_path) {

efree(intern->_path);

}

if (intern->file_name) {

efree(intern->file_name);

}

switch(intern->type) {

case SPL_FS_INFO:

break;

case SPL_FS_DIR:

if (intern->u.dir.sub_path) {

efree(intern->u.dir.sub_path);

}

break;

case SPL_FS_FILE:

if (intern->u.file.stream) {

if (intern->u.file.open_mode) {

efree(intern->u.file.open_mode);

}

if (intern->orig_path) {

efree(intern->orig_path);

}

}

spl_filesystem_file_free_line(intern);

break;

}

} /* }}} */

/* {{{ spl_ce_dir_object_new */

/* creates the object by

- allocating memory

- initializing the object members

- storing the object

- setting it's handlers

called from

- clone

- new

*/

static zend_object *spl_filesystem_object_new_ex(zend_class_entry *class_type)

{

spl_filesystem_object *intern;

intern = zend_object_alloc(sizeof(spl_filesystem_object), class_type);

/* intern->type = SPL_FS_INFO; done by set 0 */

intern->file_class = spl_ce_SplFileObject;

intern->info_class = spl_ce_SplFileInfo;

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

intern->std.handlers = &spl_filesystem_object_handlers;

return &intern->std;

}

/* }}} */

/* {{{ spl_filesystem_object_new */

/* See spl_filesystem_object_new_ex */

static zend_object *spl_filesystem_object_new(zend_class_entry *class_type)

{

return spl_filesystem_object_new_ex(class_type);

}

/* }}} */

/* {{{ spl_filesystem_object_new_check */

static zend_object *spl_filesystem_object_new_check(zend_class_entry *class_type)

{

spl_filesystem_object *ret = spl_filesystem_from_obj(spl_filesystem_object_new_ex(class_type));

ret->std.handlers = &spl_filesystem_object_check_handlers;

return &ret->std;

}

/* }}} */

PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, size_t *len) /* {{{ */

{

#ifdef HAVE_GLOB

if (intern->type == SPL_FS_DIR) {

if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {

return php_glob_stream_get_path(intern->u.dir.dirp, 0, len);

}

}

#endif

if (len) {

*len = intern->_path_len;

}

return intern->_path;

} /* }}} */

static inline void spl_filesystem_object_get_file_name(spl_filesystem_object *intern) /* {{{ */

{

char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;

switch (intern->type) {

case SPL_FS_INFO:

case SPL_FS_FILE:

if (!intern->file_name) {

php_error_docref(NULL, E_ERROR, "Object not initialized");

}

break;

case SPL_FS_DIR:

if (intern->file_name) {

efree(intern->file_name);

}

intern->file_name_len = spprintf(&intern->file_name, 0, "%s%c%s",

spl_filesystem_object_get_path(intern, NULL),

slash, intern->u.dir.entry.d_name);

break;

}

} /* }}} */

static int spl_filesystem_dir_read(spl_filesystem_object *intern) /* {{{ */

{

if (!intern->u.dir.dirp || !php_stream_readdir(intern->u.dir.dirp, &intern->u.dir.entry)) {

intern->u.dir.entry.d_name[0] = '\0';

return 0;

} else {

return 1;

}

}

/* }}} */

#define IS_SLASH_AT(zs, pos) (IS_SLASH(zs[pos]))

static inline int spl_filesystem_is_dot(const char * d_name) /* {{{ */

{

return !strcmp(d_name, ".") || !strcmp(d_name, "..");

}

/* }}} */

/* {{{ spl_filesystem_dir_open */

/* open a directory resource */

static void spl_filesystem_dir_open(spl_filesystem_object* intern, char *path)

{

int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);

intern->type = SPL_FS_DIR;

intern->_path_len = strlen(path);

intern->u.dir.dirp = php_stream_opendir(path, REPORT_ERRORS, FG(default_context));

if (intern->_path_len > 1 && IS_SLASH_AT(path, intern->_path_len-1)) {

intern->_path = estrndup(path, --intern->_path_len);

} else {

intern->_path = estrndup(path, intern->_path_len);

}

intern->u.dir.index = 0;

if (EG(exception) || intern->u.dir.dirp == NULL) {

intern->u.dir.entry.d_name[0] = '\0';

if (!EG(exception)) {

/* open failed w/out notice (turned to exception due to EH_THROW) */

zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0,

"Failed to open directory \"%s\"", path);

}

} else {

do {

spl_filesystem_dir_read(intern);

} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));

}

}

/* }}} */

static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_include_path, int silent) /* {{{ */

{

zval tmp;

intern->type = SPL_FS_FILE;

php_stat(intern->file_name, intern->file_name_len, FS_IS_DIR, &tmp);

if (Z_TYPE(tmp) == IS_TRUE) {

intern->u.file.open_mode = NULL;

intern->file_name = NULL;

zend_throw_exception_ex(spl_ce_LogicException, 0, "Cannot use SplFileObject with directories");

return FAILURE;

}

intern->u.file.context = php_stream_context_from_zval(intern->u.file.zcontext, 0);

intern->u.file.stream = php_stream_open_wrapper_ex(intern->file_name, intern->u.file.open_mode, (use_include_path ? USE_PATH : 0) | REPORT_ERRORS, NULL, intern->u.file.context);

if (!intern->file_name_len || !intern->u.file.stream) {

if (!EG(exception)) {

zend_throw_exception_ex(spl_ce_RuntimeException, 0, "Cannot open file '%s'", intern->file_name_len ? intern->file_name : "");

}

intern->file_name = NULL; /* until here it is not a copy */

intern->u.file.open_mode = NULL;

return FAILURE;

}

/*

if (intern->u.file.zcontext) {

//zend_list_addref(Z_RES_VAL(intern->u.file.zcontext));

Z_ADDREF_P(intern->u.file.zcontext);

}

*/

if (intern->file_name_len > 1 && IS_SLASH_AT(intern->file_name, intern->file_name_len-1)) {

intern->file_name_len--;

}

intern->orig_path = estrndup(intern->u.file.stream->orig_path, strlen(intern->u.file.stream->orig_path));

intern->file_name = estrndup(intern->file_name, intern->file_name_len);

intern->u.file.open_mode = estrndup(intern->u.file.open_mode, intern->u.file.open_mode_len);

/* avoid reference counting in debug mode, thus do it manually */

ZVAL_RES(&intern->u.file.zresource, intern->u.file.stream->res);

/*!!! TODO: maybe bug?

Z_SET_REFCOUNT(intern->u.file.zresource, 1);

*/

intern->u.file.delimiter = ',';

intern->u.file.enclosure = '"';

intern->u.file.escape = '\\';

intern->u.file.func_getCurr = zend_hash_str_find_ptr(&intern->std.ce->function_table, "getcurrentline", sizeof("getcurrentline") - 1);

return SUCCESS;

} /* }}} */

/* {{{ spl_filesystem_object_clone */

/* Local zend_object creation (on stack)

Load the 'other' object

Create a new empty object (See spl_filesystem_object_new_ex)

Open the directory

Clone other members (properties)

*/

static zend_object *spl_filesystem_object_clone(zval *zobject)

{

zend_object *old_object;

zend_object *new_object;

spl_filesystem_object *intern;

spl_filesystem_object *source;

int index, skip_dots;

old_object = Z_OBJ_P(zobject);

source = spl_filesystem_from_obj(old_object);

new_object = spl_filesystem_object_new_ex(old_object->ce);

intern = spl_filesystem_from_obj(new_object);

intern->flags = source->flags;

switch (source->type) {

case SPL_FS_INFO:

intern->_path_len = source->_path_len;

intern->_path = estrndup(source->_path, source->_path_len);

intern->file_name_len = source->file_name_len;

intern->file_name = estrndup(source->file_name, intern->file_name_len);

break;

case SPL_FS_DIR:

spl_filesystem_dir_open(intern, source->_path);

/* read until we hit the position in which we were before */

skip_dots = SPL_HAS_FLAG(source->flags, SPL_FILE_DIR_SKIPDOTS);

for(index = 0; index < source->u.dir.index; ++index) {

do {

spl_filesystem_dir_read(intern);

} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));

}

intern->u.dir.index = index;

break;

case SPL_FS_FILE:

zend_throw_error(NULL, "An object of class %s cannot be cloned", ZSTR_VAL(old_object->ce->name));

return new_object;

}

intern->file_class = source->file_class;

intern->info_class = source->info_class;

intern->oth = source->oth;

intern->oth_handler = source->oth_handler;

zend_objects_clone_members(new_object, old_object);

if (intern->oth_handler && intern->oth_handler->clone) {

intern->oth_handler->clone(source, intern);

}

return new_object;

}

/* }}} */

void spl_filesystem_info_set_filename(spl_filesystem_object *intern, char *path, size_t len, size_t use_copy) /* {{{ */

{

char *p1, *p2;

if (intern->file_name) {

efree(intern->file_name);

}

intern->file_name = use_copy ? estrndup(path, len) : path;

intern->file_name_len = len;

while (intern->file_name_len > 1 && IS_SLASH_AT(intern->file_name, intern->file_name_len-1)) {

intern->file_name[intern->file_name_len-1] = 0;

intern->file_name_len--;

}

p1 = strrchr(intern->file_name, '/');

#if defined(PHP_WIN32)

p2 = strrchr(intern->file_name, '\\');

#else

p2 = 0;

#endif

if (p1 || p2) {

intern->_path_len = ((p1 > p2 ? p1 : p2) - intern->file_name);

} else {

intern->_path_len = 0;

}

if (intern->_path) {

efree(intern->_path);

}

intern->_path = estrndup(path, intern->_path_len);

} /* }}} */

static spl_filesystem_object *spl_filesystem_object_create_info(spl_filesystem_object *source, char *file_path, size_t file_path_len, int use_copy, zend_class_entry *ce, zval *return_value) /* {{{ */

{

spl_filesystem_object *intern;

zval arg1;

zend_error_handling error_handling;

if (!file_path || !file_path_len) {

#if defined(PHP_WIN32)

zend_throw_exception_ex(spl_ce_RuntimeException, 0, "Cannot create SplFileInfo for empty path");

if (file_path && !use_copy) {

efree(file_path);

}

#else

if (file_path && !use_copy) {

efree(file_path);

}

file_path_len = 1;

file_path = "/";

#endif

return NULL;

}

zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling);

ce = ce ? ce : source->info_class;

zend_update_class_constants(ce);

intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce));

ZVAL_OBJ(return_value, &intern->std);

if (ce->constructor->common.scope != spl_ce_SplFileInfo) {

ZVAL_STRINGL(&arg1, file_path, file_path_len);

zend_call_method_with_1_params(return_value, ce, &ce->constructor, "__construct", NULL, &arg1);

zval_ptr_dtor(&arg1);

} else {

spl_filesystem_info_set_filename(intern, file_path, file_path_len, use_copy);

}

zend_restore_error_handling(&error_handling);

return intern;

} /* }}} */

static spl_filesystem_object *spl_filesystem_object_create_type(int ht, spl_filesystem_object *source, int type, zend_class_entry *ce, zval *return_value) /* {{{ */

{

spl_filesystem_object *intern;

zend_bool use_include_path = 0;

zval arg1, arg2;

zend_error_handling error_handling;

zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling);

switch (source->type) {

case SPL_FS_INFO:

case SPL_FS_FILE:

break;

case SPL_FS_DIR:

if (!source->u.dir.entry.d_name[0]) {

zend_throw_exception_ex(spl_ce_RuntimeException, 0, "Could not open file");

zend_restore_error_handling(&error_handling);

return NULL;

}

}

switch (type) {

case SPL_FS_INFO:

ce = ce ? ce : source->info_class;

if (UNEXPECTED(zend_update_class_constants(ce) != SUCCESS)) {

break;

}

intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce));

ZVAL_OBJ(return_value, &intern->std);

spl_filesystem_object_get_file_name(source);

if (ce->constructor->common.scope != spl_ce_SplFileInfo) {

ZVAL_STRINGL(&arg1, source->file_name, source->file_name_len);

zend_call_method_with_1_params(return_value, ce, &ce->constructor, "__construct", NULL, &arg1);

zval_ptr_dtor(&arg1);

} else {

intern->file_name = estrndup(source->file_name, source->file_name_len);

intern->file_name_len = source->file_name_len;

intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len);

intern->_path = estrndup(intern->_path, intern->_path_len);

}

break;

case SPL_FS_FILE:

ce = ce ? ce : source->file_class;

if (UNEXPECTED(zend_update_class_constants(ce) != SUCCESS)) {

break;

}

intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce));

ZVAL_OBJ(return_value, &intern->std);

spl_filesystem_object_get_file_name(source);

if (ce->constructor->common.scope != spl_ce_SplFileObject) {

ZVAL_STRINGL(&arg1, source->file_name, source->file_name_len);

ZVAL_STRINGL(&arg2, "r", 1);

zend_call_method_with_2_params(return_value, ce, &ce->constructor, "__construct", NULL, &arg1, &arg2);

zval_ptr_dtor(&arg1);

zval_ptr_dtor(&arg2);

} else {

intern->file_name = source->file_name;

intern->file_name_len = source->file_name_len;

intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len);

intern->_path = estrndup(intern->_path, intern->_path_len);

intern->u.file.open_mode = "r";

intern->u.file.open_mode_len = 1;

if (ht && zend_parse_parameters(ht, "|sbr",

&intern->u.file.open_mode, &intern->u.file.open_mode_len,

&use_include_path, &intern->u.file.zcontext) == FAILURE) {

zend_restore_error_handling(&error_handling);

intern->u.file.open_mode = NULL;

intern->file_name = NULL;

zval_ptr_dtor(return_value);

ZVAL_NULL(return_value);

return NULL;

}

if (spl_filesystem_file_open(intern, use_include_path, 0) == FAILURE) {

zend_restore_error_handling(&error_handling);

zval_ptr_dtor(return_value);

ZVAL_NULL(return_value);

return NULL;

}

}

break;

case SPL_FS_DIR:

zend_restore_error_handling(&error_handling);

zend_throw_exception_ex(spl_ce_RuntimeException, 0, "Operation not supported");

return NULL;

}

zend_restore_error_handling(&error_handling);

return NULL;

} /* }}} */

static int spl_filesystem_is_invalid_or_dot(const char * d_name) /* {{{ */

{

return d_name[0] == '\0' || spl_filesystem_is_dot(d_name);

}

/* }}} */

static char *spl_filesystem_object_get_pathname(spl_filesystem_object *intern, size_t *len) { /* {{{ */

switch (intern->type) {

case SPL_FS_INFO:

case SPL_FS_FILE:

*len = intern->file_name_len;

return intern->file_name;

case SPL_FS_DIR:

if (intern->u.dir.entry.d_name[0]) {

spl_filesystem_object_get_file_name(intern);

*len = intern->file_name_len;

return intern->file_name;

}

}

*len = 0;

return NULL;

}

/* }}} */

static HashTable *spl_filesystem_object_get_debug_info(zval *object, int *is_temp) /* {{{ */

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(object);

zval tmp;

HashTable *rv;

zend_string *pnstr;

char *path;

size_t path_len;

char stmp[2];

*is_temp = 1;

if (!intern->std.properties) {

rebuild_object_properties(&intern->std);

}

rv = zend_array_dup(intern->std.properties);

pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "pathName", sizeof("pathName")-1);

path = spl_filesystem_object_get_pathname(intern, &path_len);

ZVAL_STRINGL(&tmp, path, path_len);

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

if (intern->file_name) {

pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "fileName", sizeof("fileName")-1);

spl_filesystem_object_get_path(intern, &path_len);

if (path_len && path_len < intern->file_name_len) {

ZVAL_STRINGL(&tmp, intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1));

} else {

ZVAL_STRINGL(&tmp, intern->file_name, intern->file_name_len);

}

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

}

if (intern->type == SPL_FS_DIR) {

#ifdef HAVE_GLOB

pnstr = spl_gen_private_prop_name(spl_ce_DirectoryIterator, "glob", sizeof("glob")-1);

if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {

ZVAL_STRINGL(&tmp, intern->_path, intern->_path_len);

} else {

ZVAL_FALSE(&tmp);

}

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

#endif

pnstr = spl_gen_private_prop_name(spl_ce_RecursiveDirectoryIterator, "subPathName", sizeof("subPathName")-1);

if (intern->u.dir.sub_path) {

ZVAL_STRINGL(&tmp, intern->u.dir.sub_path, intern->u.dir.sub_path_len);

} else {

ZVAL_EMPTY_STRING(&tmp);

}

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

}

if (intern->type == SPL_FS_FILE) {

pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "openMode", sizeof("openMode")-1);

ZVAL_STRINGL(&tmp, intern->u.file.open_mode, intern->u.file.open_mode_len);

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

stmp[1] = '\0';

stmp[0] = intern->u.file.delimiter;

pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "delimiter", sizeof("delimiter")-1);

ZVAL_STRINGL(&tmp, stmp, 1);

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

stmp[0] = intern->u.file.enclosure;

pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "enclosure", sizeof("enclosure")-1);

ZVAL_STRINGL(&tmp, stmp, 1);

zend_symtable_update(rv, pnstr, &tmp);

zend_string_release(pnstr);

}

return rv;

}

/* }}} */

zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend_string *method, const zval *key) /* {{{ */

{

spl_filesystem_object *fsobj = spl_filesystem_from_obj(*object);

if (fsobj->u.dir.dirp == NULL && fsobj->orig_path == NULL) {

zend_function *func;

zend_string *tmp = zend_string_init("_bad_state_ex", sizeof("_bad_state_ex") - 1, 0);

func = zend_get_std_object_handlers()->get_method(object, tmp, NULL);

zend_string_release(tmp);

return func;

}

return zend_get_std_object_handlers()->get_method(object, method, key);

}

/* }}} */

#define DIT_CTOR_FLAGS 0x00000001

#define DIT_CTOR_GLOB 0x00000002

void spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAMETERS, zend_long ctor_flags) /* {{{ */

{

spl_filesystem_object *intern;

char *path;

int parsed;

size_t len;

zend_long flags;

zend_error_handling error_handling;

zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling);

if (SPL_HAS_FLAG(ctor_flags, DIT_CTOR_FLAGS)) {

flags = SPL_FILE_DIR_KEY_AS_PATHNAME|SPL_FILE_DIR_CURRENT_AS_FILEINFO;

parsed = zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &path, &len, &flags);

} else {

flags = SPL_FILE_DIR_KEY_AS_PATHNAME|SPL_FILE_DIR_CURRENT_AS_SELF;

parsed = zend_parse_parameters(ZEND_NUM_ARGS(), "s", &path, &len);

}

if (SPL_HAS_FLAG(ctor_flags, SPL_FILE_DIR_SKIPDOTS)) {

flags |= SPL_FILE_DIR_SKIPDOTS;

}

if (SPL_HAS_FLAG(ctor_flags, SPL_FILE_DIR_UNIXPATHS)) {

flags |= SPL_FILE_DIR_UNIXPATHS;

}

if (parsed == FAILURE) {

zend_restore_error_handling(&error_handling);

return;

}

if (!len) {

zend_throw_exception_ex(spl_ce_RuntimeException, 0, "Directory name must not be empty.");

zend_restore_error_handling(&error_handling);

return;

}

intern = Z_SPLFILESYSTEM_P(getThis());

if (intern->_path) {

/* object is alreay initialized */

zend_restore_error_handling(&error_handling);

php_error_docref(NULL, E_WARNING, "Directory object is already initialized");

return;

}

intern->flags = flags;

#ifdef HAVE_GLOB

if (SPL_HAS_FLAG(ctor_flags, DIT_CTOR_GLOB) && strstr(path, "glob://") != path) {

spprintf(&path, 0, "glob://%s", path);

spl_filesystem_dir_open(intern, path);

efree(path);

} else

#endif

{

spl_filesystem_dir_open(intern, path);

}

intern->u.dir.is_recursive = instanceof_function(intern->std.ce, spl_ce_RecursiveDirectoryIterator) ? 1 : 0;

zend_restore_error_handling(&error_handling);

}

/* }}} */

/* {{{ proto void DirectoryIterator::__construct(string path)

Cronstructs a new dir iterator from a path. */

SPL_METHOD(DirectoryIterator, __construct)

{

spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);

}

/* }}} */

/* {{{ proto void DirectoryIterator::rewind()

Rewind dir back to the start */

SPL_METHOD(DirectoryIterator, rewind)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

if (zend_parse_parameters_none() == FAILURE) {

return;

}

intern->u.dir.index = 0;

if (intern->u.dir.dirp) {

php_stream_rewinddir(intern->u.dir.dirp);

}

spl_filesystem_dir_read(intern);

}

/* }}} */

/* {{{ proto string DirectoryIterator::key()

Return current dir entry */

SPL_METHOD(DirectoryIterator, key)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

if (zend_parse_parameters_none() == FAILURE) {

return;

}

if (intern->u.dir.dirp) {

RETURN_LONG(intern->u.dir.index);

} else {

RETURN_FALSE;

}

}

/* }}} */

/* {{{ proto DirectoryIterator DirectoryIterator::current()

Return this (needed for Iterator interface) */

SPL_METHOD(DirectoryIterator, current)

{

if (zend_parse_parameters_none() == FAILURE) {

return;

}

ZVAL_OBJ(return_value, Z_OBJ_P(getThis()));

Z_ADDREF_P(return_value);

}

/* }}} */

/* {{{ proto void DirectoryIterator::next()

Move to next entry */

SPL_METHOD(DirectoryIterator, next)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);

if (zend_parse_parameters_none() == FAILURE) {

return;

}

intern->u.dir.index++;

do {

spl_filesystem_dir_read(intern);

} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));

if (intern->file_name) {

efree(intern->file_name);

intern->file_name = NULL;

}

}

/* }}} */

/* {{{ proto void DirectoryIterator::seek(int position)

Seek to the given position */

SPL_METHOD(DirectoryIterator, seek)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

zval retval;

zend_long pos;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &pos) == FAILURE) {

return;

}

if (intern->u.dir.index > pos) {

/* we first rewind */

zend_call_method_with_0_params(&EX(This), Z_OBJCE(EX(This)), &intern->u.dir.func_rewind, "rewind", NULL);

}

while (intern->u.dir.index < pos) {

int valid = 0;

zend_call_method_with_0_params(&EX(This), Z_OBJCE(EX(This)), &intern->u.dir.func_valid, "valid", &retval);

if (!Z_ISUNDEF(retval)) {

valid = zend_is_true(&retval);

zval_ptr_dtor(&retval);

}

if (!valid) {

zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0, "Seek position " ZEND_LONG_FMT " is out of range", pos);

return;

}

zend_call_method_with_0_params(&EX(This), Z_OBJCE(EX(This)), &intern->u.dir.func_next, "next", NULL);

}

} /* }}} */

/* {{{ proto string DirectoryIterator::valid()

Check whether dir contains more entries */

SPL_METHOD(DirectoryIterator, valid)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

if (zend_parse_parameters_none() == FAILURE) {

return;

}

RETURN_BOOL(intern->u.dir.entry.d_name[0] != '\0');

}

/* }}} */

/* {{{ proto string SplFileInfo::getPath()

Return the path */

SPL_METHOD(SplFileInfo, getPath)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

char *path;

size_t path_len;

if (zend_parse_parameters_none() == FAILURE) {

return;

}

path = spl_filesystem_object_get_path(intern, &path_len);

RETURN_STRINGL(path, path_len);

}

/* }}} */

/* {{{ proto string SplFileInfo::getFilename()

Return filename only */

SPL_METHOD(SplFileInfo, getFilename)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

size_t path_len;

if (zend_parse_parameters_none() == FAILURE) {

return;

}

spl_filesystem_object_get_path(intern, &path_len);

if (path_len && path_len < intern->file_name_len) {

RETURN_STRINGL(intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1));

} else {

RETURN_STRINGL(intern->file_name, intern->file_name_len);

}

}

/* }}} */

/* {{{ proto string DirectoryIterator::getFilename()

Return filename of current dir entry */

SPL_METHOD(DirectoryIterator, getFilename)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

if (zend_parse_parameters_none() == FAILURE) {

return;

}

RETURN_STRING(intern->u.dir.entry.d_name);

}

/* }}} */

/* {{{ proto string SplFileInfo::getExtension()

Returns file extension component of path */

SPL_METHOD(SplFileInfo, getExtension)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

char *fname = NULL;

const char *p;

size_t flen;

size_t path_len;

size_t idx;

zend_string *ret;

if (zend_parse_parameters_none() == FAILURE) {

return;

}

spl_filesystem_object_get_path(intern, &path_len);

if (path_len && path_len < intern->file_name_len) {

fname = intern->file_name + path_len + 1;

flen = intern->file_name_len - (path_len + 1);

} else {

fname = intern->file_name;

flen = intern->file_name_len;

}

ret = php_basename(fname, flen, NULL, 0);

p = zend_memrchr(ZSTR_VAL(ret), '.', ZSTR_LEN(ret));

if (p) {

idx = p - ZSTR_VAL(ret);

RETVAL_STRINGL(ZSTR_VAL(ret) + idx + 1, ZSTR_LEN(ret) - idx - 1);

zend_string_release(ret);

return;

} else {

zend_string_release(ret);

RETURN_EMPTY_STRING();

}

}

/* }}}*/

/* {{{ proto string DirectoryIterator::getExtension()

Returns the file extension component of path */

SPL_METHOD(DirectoryIterator, getExtension)

{

spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());

const char *p;

size_t idx;

zend_string *fname;

if (zend_parse_parameters_none() == FAILURE) {

return;

}

fname = php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), NULL, 0);

p = zend_memrchr(ZSTR_VAL(fname), '.', ZSTR_LEN(fname));

if (p) {

idx = p - ZSTR_VAL(fname);

RETVAL_STRINGL(ZSTR_VAL(fname) + idx + 1, ZSTR_LEN(fname) - idx - 1);

zend_string_release(fname);

} else {

zend_string_release(fname);

RETURN_EMPTY_STRING();

}

}

/* }}} */

/* {{{ proto string SplFileInfo::getBasename([string $suffix])

Returns filename component of path */

SPL_METHOD(SplFileInfo, getBasename)

{