�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fphar%2F'>phar</a>/</p><hr><h3>✏️ Editing: stream.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
  +----------------------------------------------------------------------+
  | phar:// stream wrapper support                                       |
  +----------------------------------------------------------------------+
  | Copyright (c) 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:           |
  | https://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.               |
  +----------------------------------------------------------------------+
  | Authors: Gregory Beaver &lt;cellog@php.net&gt;                             |
  |          Marcus Boerger &lt;helly@php.net&gt;                              |
  +----------------------------------------------------------------------+
*/

#define PHAR_STREAM 1
#include &quot;phar_internal.h&quot;
#include &quot;stream.h&quot;
#include &quot;dirstream.h&quot;

static const php_stream_ops phar_ops = {
	phar_stream_write, /* write */
	phar_stream_read,  /* read */
	phar_stream_close, /* close */
	phar_stream_flush, /* flush */
	&quot;phar stream&quot;,
	phar_stream_seek,  /* seek */
	NULL,              /* cast */
	phar_stream_stat,  /* stat */
	NULL, /* set option */
};

static const php_stream_wrapper_ops phar_stream_wops = {
	phar_wrapper_open_url,
	NULL,                  /* phar_wrapper_close */
	NULL,                  /* phar_wrapper_stat, */
	phar_wrapper_stat,     /* stat_url */
	phar_wrapper_open_dir, /* opendir */
	&quot;phar&quot;,
	phar_wrapper_unlink,   /* unlink */
	phar_wrapper_rename,   /* rename */
	phar_wrapper_mkdir,    /* create directory */
	phar_wrapper_rmdir,    /* remove directory */
	NULL
};

const php_stream_wrapper php_stream_phar_wrapper = {
	&amp;phar_stream_wops,
	NULL,
	0 /* is_url */
};

/**
 * Open a phar file for streams API
 */
php_url* phar_parse_url(php_stream_wrapper *wrapper, const char *filename, const char *mode, int options) /* {{{ */
{
	php_url *resource;
	char *arch = NULL, *entry = NULL, *error;
	size_t arch_len, entry_len;

	if (strncasecmp(filename, &quot;phar://&quot;, 7)) {
		return NULL;
	}
	if (mode[0] == &#039;a&#039;) {
		if (!(options &amp; PHP_STREAM_URL_STAT_QUIET)) {
			php_stream_wrapper_log_error(wrapper, options, &quot;phar error: open mode append not supported&quot;);
		}
		return NULL;
	}
	if (phar_split_fname(filename, strlen(filename), &amp;arch, &amp;arch_len, &amp;entry, &amp;entry_len, 2, (mode[0] == &#039;w&#039; ? 2 : 0)) == FAILURE) {
		if (!(options &amp; PHP_STREAM_URL_STAT_QUIET)) {
			if (arch &amp;&amp; !entry) {
				php_stream_wrapper_log_error(wrapper, options, &quot;phar error: no directory in \&quot;%s\&quot;, must have at least phar://%s/ for root directory (always use full path to a new phar)&quot;, filename, arch);
				arch = NULL;
			} else {
				php_stream_wrapper_log_error(wrapper, options, &quot;phar error: invalid url or non-existent phar \&quot;%s\&quot;&quot;, filename);
			}
		}
		return NULL;
	}
	resource = ecalloc(1, sizeof(php_url));
	resource-&gt;scheme = ZSTR_INIT_LITERAL(&quot;phar&quot;, 0);
	resource-&gt;host = zend_string_init(arch, arch_len, 0);
	efree(arch);
	resource-&gt;path = zend_string_init(entry, entry_len, 0);
	efree(entry);

#ifdef MBO_0
		if (resource) {
			fprintf(stderr, &quot;Alias:     %s\n&quot;, alias);
			fprintf(stderr, &quot;Scheme:    %s\n&quot;, ZSTR_VAL(resource-&gt;scheme));
/*			fprintf(stderr, &quot;User:      %s\n&quot;, resource-&gt;user);*/
/*			fprintf(stderr, &quot;Pass:      %s\n&quot;, resource-&gt;pass ? &quot;***&quot; : NULL);*/
			fprintf(stderr, &quot;Host:      %s\n&quot;, ZSTR_VAL(resource-&gt;host));
/*			fprintf(stderr, &quot;Port:      %d\n&quot;, resource-&gt;port);*/
			fprintf(stderr, &quot;Path:      %s\n&quot;, ZSTR_VAL(resource-&gt;path));
/*			fprintf(stderr, &quot;Query:     %s\n&quot;, resource-&gt;query);*/
/*			fprintf(stderr, &quot;Fragment:  %s\n&quot;, resource-&gt;fragment);*/
		}
#endif
	if (mode[0] == &#039;w&#039; || (mode[0] == &#039;r&#039; &amp;&amp; mode[1] == &#039;+&#039;)) {
		phar_archive_data *pphar = NULL, *phar;

		if (PHAR_G(request_init) &amp;&amp; HT_IS_INITIALIZED(&amp;PHAR_G(phar_fname_map)) &amp;&amp; NULL == (pphar = zend_hash_find_ptr(&amp;(PHAR_G(phar_fname_map)), resource-&gt;host))) {
			pphar = NULL;
		}
		if (PHAR_G(readonly) &amp;&amp; (!pphar || !pphar-&gt;is_data)) {
			if (!(options &amp; PHP_STREAM_URL_STAT_QUIET)) {
				php_stream_wrapper_log_error(wrapper, options, &quot;phar error: write operations disabled by the php.ini setting phar.readonly&quot;);
			}
			php_url_free(resource);
			return NULL;
		}
		if (phar_open_or_create_filename(ZSTR_VAL(resource-&gt;host), ZSTR_LEN(resource-&gt;host), NULL, 0, 0, options, &amp;phar, &amp;error) == FAILURE)
		{
			if (error) {
				if (!(options &amp; PHP_STREAM_URL_STAT_QUIET)) {
					php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
				}
				efree(error);
			}
			php_url_free(resource);
			return NULL;
		}
		if (phar-&gt;is_persistent &amp;&amp; FAILURE == phar_copy_on_write(&amp;phar)) {
			if (error) {
				spprintf(&amp;error, 0, &quot;Cannot open cached phar &#039;%s&#039; as writeable, copy on write failed&quot;, ZSTR_VAL(resource-&gt;host));
				if (!(options &amp; PHP_STREAM_URL_STAT_QUIET)) {
					php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
				}
				efree(error);
			}
			php_url_free(resource);
			return NULL;
		}
	} else {
		if (phar_open_from_filename(ZSTR_VAL(resource-&gt;host), ZSTR_LEN(resource-&gt;host), NULL, 0, options, NULL, &amp;error) == FAILURE)
		{
			if (error) {
				if (!(options &amp; PHP_STREAM_URL_STAT_QUIET)) {
					php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
				}
				efree(error);
			}
			php_url_free(resource);
			return NULL;
		}
	}
	return resource;
}
/* }}} */

/**
 * used for fopen(&#039;phar://...&#039;) and company
 */
static php_stream * phar_wrapper_open_url(php_stream_wrapper *wrapper, const char *path, const char *mode, int options, zend_string **opened_path, php_stream_context *context STREAMS_DC) /* {{{ */
{
	phar_archive_data *phar;
	phar_entry_data *idata;
	char *internal_file;
	char *error;
	HashTable *pharcontext;
	php_url *resource = NULL;
	php_stream *fpf;
	zval *pzoption, *metadata;

	if ((resource = phar_parse_url(wrapper, path, mode, options)) == NULL) {
		return NULL;
	}

	/* we must have at the very least phar://alias.phar/internalfile.php */
	if (!resource-&gt;scheme || !resource-&gt;host || !resource-&gt;path) {
		php_url_free(resource);
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: invalid url \&quot;%s\&quot;&quot;, path);
		return NULL;
	}

	if (!zend_string_equals_literal_ci(resource-&gt;scheme, &quot;phar&quot;)) {
		php_url_free(resource);
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: not a phar stream url \&quot;%s\&quot;&quot;, path);
		return NULL;
	}

	size_t host_len = ZSTR_LEN(resource-&gt;host);
	phar_request_initialize();

	/* strip leading &quot;/&quot; */
	internal_file = estrndup(ZSTR_VAL(resource-&gt;path) + 1, ZSTR_LEN(resource-&gt;path) - 1);
	if (mode[0] == &#039;w&#039; || (mode[0] == &#039;r&#039; &amp;&amp; mode[1] == &#039;+&#039;)) {
		if (NULL == (idata = phar_get_or_create_entry_data(ZSTR_VAL(resource-&gt;host), host_len, internal_file, strlen(internal_file), mode, 0, &amp;error, 1))) {
			if (error) {
				php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
				efree(error);
			} else {
				php_stream_wrapper_log_error(wrapper, options, &quot;phar error: file \&quot;%s\&quot; could not be created in phar \&quot;%s\&quot;&quot;, internal_file, ZSTR_VAL(resource-&gt;host));
			}
			efree(internal_file);
			php_url_free(resource);
			return NULL;
		}
		if (error) {
			efree(error);
		}
		fpf = php_stream_alloc(&amp;phar_ops, idata, NULL, mode);
		php_url_free(resource);
		efree(internal_file);

		if (context &amp;&amp; Z_TYPE(context-&gt;options) != IS_UNDEF &amp;&amp; (pzoption = zend_hash_str_find(HASH_OF(&amp;context-&gt;options), &quot;phar&quot;, sizeof(&quot;phar&quot;)-1)) != NULL) {
			pharcontext = HASH_OF(pzoption);
			if (idata-&gt;internal_file-&gt;uncompressed_filesize == 0
				&amp;&amp; idata-&gt;internal_file-&gt;compressed_filesize == 0
				&amp;&amp; (pzoption = zend_hash_str_find(pharcontext, &quot;compress&quot;, sizeof(&quot;compress&quot;)-1)) != NULL
				&amp;&amp; Z_TYPE_P(pzoption) == IS_LONG
				&amp;&amp; (Z_LVAL_P(pzoption) &amp; ~PHAR_ENT_COMPRESSION_MASK) == 0
			) {
				idata-&gt;internal_file-&gt;flags &amp;= ~PHAR_ENT_COMPRESSION_MASK;
				idata-&gt;internal_file-&gt;flags |= Z_LVAL_P(pzoption);
			}
			if ((pzoption = zend_hash_str_find(pharcontext, &quot;metadata&quot;, sizeof(&quot;metadata&quot;)-1)) != NULL) {
				phar_metadata_tracker_free(&amp;idata-&gt;internal_file-&gt;metadata_tracker, idata-&gt;internal_file-&gt;is_persistent);

				metadata = pzoption;
				ZVAL_COPY_DEREF(&amp;idata-&gt;internal_file-&gt;metadata_tracker.val, metadata);
				idata-&gt;phar-&gt;is_modified = 1;
			}
		}
		if (opened_path) {
			*opened_path = strpprintf(MAXPATHLEN, &quot;phar://%s/%s&quot;, idata-&gt;phar-&gt;fname, idata-&gt;internal_file-&gt;filename);
		}
		return fpf;
	} else {
		if (!*internal_file &amp;&amp; (options &amp; STREAM_OPEN_FOR_INCLUDE)) {
			/* retrieve the stub */
			if (FAILURE == phar_get_archive(&amp;phar, ZSTR_VAL(resource-&gt;host), host_len, NULL, 0, NULL)) {
				php_stream_wrapper_log_error(wrapper, options, &quot;file %s is not a valid phar archive&quot;, ZSTR_VAL(resource-&gt;host));
				efree(internal_file);
				php_url_free(resource);
				return NULL;
			}
			if (phar-&gt;is_tar || phar-&gt;is_zip) {
				if ((FAILURE == phar_get_entry_data(&amp;idata, ZSTR_VAL(resource-&gt;host), host_len, &quot;.phar/stub.php&quot;, sizeof(&quot;.phar/stub.php&quot;)-1, &quot;r&quot;, 0, &amp;error, 0)) || !idata) {
					goto idata_error;
				}
				efree(internal_file);
				if (opened_path) {
					*opened_path = strpprintf(MAXPATHLEN, &quot;%s&quot;, phar-&gt;fname);
				}
				php_url_free(resource);
				goto phar_stub;
			} else {
				php_stream *stream = phar_get_pharfp(phar);
				if (stream == NULL) {
					if (UNEXPECTED(FAILURE == phar_open_archive_fp(phar))) {
						php_stream_wrapper_log_error(wrapper, options, &quot;phar error: could not reopen phar \&quot;%s\&quot;&quot;, ZSTR_VAL(resource-&gt;host));
						efree(internal_file);
						php_url_free(resource);
						return NULL;
					}
					stream = phar_get_pharfp(phar);
				}

				phar_entry_info *entry;

				entry = (phar_entry_info *) ecalloc(1, sizeof(phar_entry_info));
				entry-&gt;is_temp_dir = 1;
				entry-&gt;filename = estrndup(&quot;&quot;, 0);
				entry-&gt;filename_len = 0;
				entry-&gt;phar = phar;
				entry-&gt;offset = entry-&gt;offset_abs = 0;
				entry-&gt;compressed_filesize = entry-&gt;uncompressed_filesize = phar-&gt;halt_offset;
				entry-&gt;is_crc_checked = 1;

				idata = (phar_entry_data *) ecalloc(1, sizeof(phar_entry_data));
				idata-&gt;fp = stream;
				idata-&gt;phar = phar;
				idata-&gt;internal_file = entry;
				if (!phar-&gt;is_persistent) {
					++(entry-&gt;phar-&gt;refcount);
				}
				++(entry-&gt;fp_refcount);
				php_url_free(resource);
				if (opened_path) {
					*opened_path = strpprintf(MAXPATHLEN, &quot;%s&quot;, phar-&gt;fname);
				}
				efree(internal_file);
				goto phar_stub;
			}
		}
		/* read-only access is allowed to magic files in .phar directory */
		if ((FAILURE == phar_get_entry_data(&amp;idata, ZSTR_VAL(resource-&gt;host), host_len, internal_file, strlen(internal_file), &quot;r&quot;, 0, &amp;error, 0)) || !idata) {
idata_error:
			if (error) {
				php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
				efree(error);
			} else {
				php_stream_wrapper_log_error(wrapper, options, &quot;phar error: \&quot;%s\&quot; is not a file in phar \&quot;%s\&quot;&quot;, internal_file, ZSTR_VAL(resource-&gt;host));
			}
			efree(internal_file);
			php_url_free(resource);
			return NULL;
		}
	}
	php_url_free(resource);
#ifdef MBO_0
		fprintf(stderr, &quot;Pharname:   %s\n&quot;, idata-&gt;phar-&gt;filename);
		fprintf(stderr, &quot;Filename:   %s\n&quot;, internal_file);
		fprintf(stderr, &quot;Entry:      %s\n&quot;, idata-&gt;internal_file-&gt;filename);
		fprintf(stderr, &quot;Size:       %u\n&quot;, idata-&gt;internal_file-&gt;uncompressed_filesize);
		fprintf(stderr, &quot;Compressed: %u\n&quot;, idata-&gt;internal_file-&gt;flags);
		fprintf(stderr, &quot;Offset:     %u\n&quot;, idata-&gt;internal_file-&gt;offset_within_phar);
		fprintf(stderr, &quot;Cached:     %s\n&quot;, idata-&gt;internal_file-&gt;filedata ? &quot;yes&quot; : &quot;no&quot;);
#endif

	/* check length, crc32 */
	if (!idata-&gt;internal_file-&gt;is_crc_checked &amp;&amp; phar_postprocess_file(idata, idata-&gt;internal_file-&gt;crc32, &amp;error, 2) != SUCCESS) {
		php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
		efree(error);
		phar_entry_delref(idata);
		efree(internal_file);
		return NULL;
	}

	if (!PHAR_G(cwd_init) &amp;&amp; (options &amp; STREAM_OPEN_FOR_INCLUDE)) {
		char *entry = idata-&gt;internal_file-&gt;filename, *cwd;

		PHAR_G(cwd_init) = 1;
		if ((idata-&gt;phar-&gt;is_tar || idata-&gt;phar-&gt;is_zip) &amp;&amp; idata-&gt;internal_file-&gt;filename_len == sizeof(&quot;.phar/stub.php&quot;)-1 &amp;&amp; !strncmp(idata-&gt;internal_file-&gt;filename, &quot;.phar/stub.php&quot;, sizeof(&quot;.phar/stub.php&quot;)-1)) {
			/* we&#039;re executing the stub, which doesn&#039;t count as a file */
			PHAR_G(cwd_init) = 0;
		} else if ((cwd = strrchr(entry, &#039;/&#039;))) {
			PHAR_G(cwd_len) = cwd - entry;
			PHAR_G(cwd) = estrndup(entry, PHAR_G(cwd_len));
		} else {
			/* root directory */
			PHAR_G(cwd_len) = 0;
			PHAR_G(cwd) = NULL;
		}
	}
	if (opened_path) {
		*opened_path = strpprintf(MAXPATHLEN, &quot;phar://%s/%s&quot;, idata-&gt;phar-&gt;fname, idata-&gt;internal_file-&gt;filename);
	}
	efree(internal_file);
phar_stub:
	fpf = php_stream_alloc(&amp;phar_ops, idata, NULL, mode);
	return fpf;
}
/* }}} */

/**
 * Used for fclose($fp) where $fp is a phar archive
 */
static int phar_stream_close(php_stream *stream, int close_handle) /* {{{ */
{
	/* for some reasons phar needs to be flushed even if there is no write going on */
	phar_stream_flush(stream);

	phar_entry_delref((phar_entry_data *)stream-&gt;abstract);

	return 0;
}
/* }}} */

/**
 * used for fread($fp) and company on a fopen()ed phar file handle
 */
static ssize_t phar_stream_read(php_stream *stream, char *buf, size_t count) /* {{{ */
{
	phar_entry_data *data = (phar_entry_data *)stream-&gt;abstract;
	ssize_t got;
	phar_entry_info *entry;

	if (data-&gt;internal_file-&gt;link) {
		entry = phar_get_link_source(data-&gt;internal_file);
	} else {
		entry = data-&gt;internal_file;
	}

	if (entry-&gt;is_deleted) {
		stream-&gt;eof = 1;
		return -1;
	}

	/* use our proxy position */
	php_stream_seek(data-&gt;fp, data-&gt;position + data-&gt;zero, SEEK_SET);

	got = php_stream_read(data-&gt;fp, buf, MIN(count, (size_t)(entry-&gt;uncompressed_filesize - data-&gt;position)));
	data-&gt;position = php_stream_tell(data-&gt;fp) - data-&gt;zero;
	stream-&gt;eof = (data-&gt;position == (zend_off_t) entry-&gt;uncompressed_filesize);

	return got;
}
/* }}} */

/**
 * Used for fseek($fp) on a phar file handle
 */
static int phar_stream_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset) /* {{{ */
{
	phar_entry_data *data = (phar_entry_data *)stream-&gt;abstract;
	phar_entry_info *entry;
	int res;
	zend_off_t temp;

	if (data-&gt;internal_file-&gt;link) {
		entry = phar_get_link_source(data-&gt;internal_file);
	} else {
		entry = data-&gt;internal_file;
	}

	switch (whence) {
		case SEEK_END :
			temp = data-&gt;zero + entry-&gt;uncompressed_filesize + offset;
			break;
		case SEEK_CUR :
			temp = data-&gt;zero + data-&gt;position + offset;
			break;
		case SEEK_SET :
			temp = data-&gt;zero + offset;
			break;
		default:
			temp = 0;
	}
	if (temp &gt; data-&gt;zero + (zend_off_t) entry-&gt;uncompressed_filesize) {
		*newoffset = -1;
		return -1;
	}
	if (temp &lt; data-&gt;zero) {
		*newoffset = -1;
		return -1;
	}
	res = php_stream_seek(data-&gt;fp, temp, SEEK_SET);
	*newoffset = php_stream_tell(data-&gt;fp) - data-&gt;zero;
	data-&gt;position = *newoffset;
	return res;
}
/* }}} */

/**
 * Used for writing to a phar file
 */
static ssize_t phar_stream_write(php_stream *stream, const char *buf, size_t count) /* {{{ */
{
	phar_entry_data *data = (phar_entry_data *) stream-&gt;abstract;

	php_stream_seek(data-&gt;fp, data-&gt;position, SEEK_SET);
	if (count != php_stream_write(data-&gt;fp, buf, count)) {
		php_stream_wrapper_log_error(stream-&gt;wrapper, stream-&gt;flags, &quot;phar error: Could not write %d characters to \&quot;%s\&quot; in phar \&quot;%s\&quot;&quot;, (int) count, data-&gt;internal_file-&gt;filename, data-&gt;phar-&gt;fname);
		return -1;
	}
	data-&gt;position = php_stream_tell(data-&gt;fp);
	if (data-&gt;position &gt; (zend_off_t)data-&gt;internal_file-&gt;uncompressed_filesize) {
		data-&gt;internal_file-&gt;uncompressed_filesize = data-&gt;position;
	}
	data-&gt;internal_file-&gt;compressed_filesize = data-&gt;internal_file-&gt;uncompressed_filesize;
	data-&gt;internal_file-&gt;old_flags = data-&gt;internal_file-&gt;flags;
	data-&gt;internal_file-&gt;is_modified = 1;
	return count;
}
/* }}} */

/**
 * Used to save work done on a writeable phar
 */
static int phar_stream_flush(php_stream *stream) /* {{{ */
{
	char *error;
	phar_entry_data *data = (phar_entry_data *) stream-&gt;abstract;

	if (data-&gt;internal_file-&gt;is_modified) {
		data-&gt;internal_file-&gt;timestamp = time(0);
		phar_flush(data-&gt;phar, &amp;error);
		if (error) {
			php_stream_wrapper_log_error(stream-&gt;wrapper, REPORT_ERRORS, &quot;%s&quot;, error);
			efree(error);
		}
		return EOF;
	} else {
		return EOF;
	}
}
/* }}} */

 /* {{{ phar_dostat */
/**
 * stat an opened phar file handle stream, used by phar_stat()
 */
void phar_dostat(phar_archive_data *phar, phar_entry_info *data, php_stream_statbuf *ssb, bool is_temp_dir)
{
	memset(ssb, 0, sizeof(php_stream_statbuf));

	if (!is_temp_dir &amp;&amp; !data-&gt;is_dir) {
		ssb-&gt;sb.st_size = data-&gt;uncompressed_filesize;
		ssb-&gt;sb.st_mode = data-&gt;flags &amp; PHAR_ENT_PERM_MASK;
		ssb-&gt;sb.st_mode |= S_IFREG; /* regular file */
		/* timestamp is just the timestamp when this was added to the phar */
		ssb-&gt;sb.st_mtime = data-&gt;timestamp;
		ssb-&gt;sb.st_atime = data-&gt;timestamp;
		ssb-&gt;sb.st_ctime = data-&gt;timestamp;
	} else if (!is_temp_dir &amp;&amp; data-&gt;is_dir) {
		ssb-&gt;sb.st_size = 0;
		ssb-&gt;sb.st_mode = data-&gt;flags &amp; PHAR_ENT_PERM_MASK;
		ssb-&gt;sb.st_mode |= S_IFDIR; /* regular directory */
		/* timestamp is just the timestamp when this was added to the phar */
		ssb-&gt;sb.st_mtime = data-&gt;timestamp;
		ssb-&gt;sb.st_atime = data-&gt;timestamp;
		ssb-&gt;sb.st_ctime = data-&gt;timestamp;
	} else {
		ssb-&gt;sb.st_size = 0;
		ssb-&gt;sb.st_mode = 0777;
		ssb-&gt;sb.st_mode |= S_IFDIR; /* regular directory */
		ssb-&gt;sb.st_mtime = phar-&gt;max_timestamp;
		ssb-&gt;sb.st_atime = phar-&gt;max_timestamp;
		ssb-&gt;sb.st_ctime = phar-&gt;max_timestamp;
	}
	if (!phar-&gt;is_writeable) {
		ssb-&gt;sb.st_mode = (ssb-&gt;sb.st_mode &amp; 0555) | (ssb-&gt;sb.st_mode &amp; ~0777);
	}

	ssb-&gt;sb.st_nlink = 1;
	ssb-&gt;sb.st_rdev = -1;
	/* this is only for APC, so use /dev/null device - no chance of conflict there! */
	ssb-&gt;sb.st_dev = 0xc;
	/* generate unique inode number for alias/filename, so no phars will conflict */
	if (!is_temp_dir) {
		ssb-&gt;sb.st_ino = data-&gt;inode;
	}
#ifndef PHP_WIN32
	ssb-&gt;sb.st_blksize = -1;
	ssb-&gt;sb.st_blocks = -1;
#endif
}
/* }}}*/

/**
 * Stat an opened phar file handle
 */
static int phar_stream_stat(php_stream *stream, php_stream_statbuf *ssb) /* {{{ */
{
	phar_entry_data *data = (phar_entry_data *)stream-&gt;abstract;

	/* If ssb is NULL then someone is misbehaving */
	if (!ssb) {
		return -1;
	}

	phar_dostat(data-&gt;phar, data-&gt;internal_file, ssb, 0);
	return 0;
}
/* }}} */

/**
 * Stream wrapper stat implementation of stat()
 */
static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int flags,
				  php_stream_statbuf *ssb, php_stream_context *context) /* {{{ */
{
	php_url *resource = NULL;
	char *internal_file, *error;
	phar_archive_data *phar;
	phar_entry_info *entry;
	size_t internal_file_len;

	if ((resource = phar_parse_url(wrapper, url, &quot;r&quot;, flags|PHP_STREAM_URL_STAT_QUIET)) == NULL) {
		return FAILURE;
	}

	/* we must have at the very least phar://alias.phar/internalfile.php */
	if (!resource-&gt;scheme || !resource-&gt;host || !resource-&gt;path) {
		php_url_free(resource);
		return FAILURE;
	}

	if (!zend_string_equals_literal_ci(resource-&gt;scheme, &quot;phar&quot;)) {
		php_url_free(resource);
		return FAILURE;
	}

	size_t host_len = ZSTR_LEN(resource-&gt;host);
	phar_request_initialize();

	internal_file = ZSTR_VAL(resource-&gt;path) + 1; /* strip leading &quot;/&quot; */
	/* find the phar in our trusty global hash indexed by alias (host of phar://blah.phar/file.whatever) */
	if (FAILURE == phar_get_archive(&amp;phar, ZSTR_VAL(resource-&gt;host), host_len, NULL, 0, &amp;error)) {
		php_url_free(resource);
		if (error) {
			efree(error);
		}
		return FAILURE;
	}
	if (error) {
		efree(error);
	}
	if (*internal_file == &#039;\0&#039;) {
		/* root directory requested */
		phar_dostat(phar, NULL, ssb, 1);
		php_url_free(resource);
		return SUCCESS;
	}
	if (!HT_IS_INITIALIZED(&amp;phar-&gt;manifest)) {
		php_url_free(resource);
		return FAILURE;
	}
	internal_file_len = strlen(internal_file);
	/* search through the manifest of files, and if we have an exact match, it&#039;s a file */
	if (NULL != (entry = zend_hash_str_find_ptr(&amp;phar-&gt;manifest, internal_file, internal_file_len))) {
		phar_dostat(phar, entry, ssb, 0);
		php_url_free(resource);
		return SUCCESS;
	}
	if (zend_hash_str_exists(&amp;(phar-&gt;virtual_dirs), internal_file, internal_file_len)) {
		phar_dostat(phar, NULL, ssb, 1);
		php_url_free(resource);
		return SUCCESS;
	}
	/* check for mounted directories */
	if (HT_IS_INITIALIZED(&amp;phar-&gt;mounted_dirs) &amp;&amp; zend_hash_num_elements(&amp;phar-&gt;mounted_dirs)) {
		zend_string *str_key;

		ZEND_HASH_MAP_FOREACH_STR_KEY(&amp;phar-&gt;mounted_dirs, str_key) {
			if (ZSTR_LEN(str_key) &gt;= internal_file_len || strncmp(ZSTR_VAL(str_key), internal_file, ZSTR_LEN(str_key))) {
				continue;
			} else {
				char *test;
				size_t test_len;
				php_stream_statbuf ssbi;

				if (NULL == (entry = zend_hash_find_ptr(&amp;phar-&gt;manifest, str_key))) {
					goto free_resource;
				}
				if (!entry-&gt;tmp || !entry-&gt;is_mounted) {
					goto free_resource;
				}
				test_len = spprintf(&amp;test, MAXPATHLEN, &quot;%s%s&quot;, entry-&gt;tmp, internal_file + ZSTR_LEN(str_key));
				if (SUCCESS != php_stream_stat_path(test, &amp;ssbi)) {
					efree(test);
					continue;
				}
				/* mount the file/directory just in time */
				if (SUCCESS != phar_mount_entry(phar, test, test_len, internal_file, internal_file_len)) {
					efree(test);
					goto free_resource;
				}
				efree(test);
				if (NULL == (entry = zend_hash_str_find_ptr(&amp;phar-&gt;manifest, internal_file, internal_file_len))) {
					goto free_resource;
				}
				phar_dostat(phar, entry, ssb, 0);
				php_url_free(resource);
				return SUCCESS;
			}
		} ZEND_HASH_FOREACH_END();
	}
free_resource:
	php_url_free(resource);
	return FAILURE;
}
/* }}} */

/**
 * Unlink a file within a phar archive
 */
static int phar_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context) /* {{{ */
{
	php_url *resource;
	char *internal_file, *error;
	int internal_file_len;
	phar_entry_data *idata;
	phar_archive_data *pphar;

	if ((resource = phar_parse_url(wrapper, url, &quot;rb&quot;, options)) == NULL) {
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: unlink failed&quot;);
		return 0;
	}

	/* we must have at the very least phar://alias.phar/internalfile.php */
	if (!resource-&gt;scheme || !resource-&gt;host || !resource-&gt;path) {
		php_url_free(resource);
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: invalid url \&quot;%s\&quot;&quot;, url);
		return 0;
	}

	if (!zend_string_equals_literal_ci(resource-&gt;scheme, &quot;phar&quot;)) {
		php_url_free(resource);
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: not a phar stream url \&quot;%s\&quot;&quot;, url);
		return 0;
	}

	size_t host_len = ZSTR_LEN(resource-&gt;host);
	phar_request_initialize();

	pphar = zend_hash_find_ptr(&amp;(PHAR_G(phar_fname_map)), resource-&gt;host);
	if (PHAR_G(readonly) &amp;&amp; (!pphar || !pphar-&gt;is_data)) {
		php_url_free(resource);
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: write operations disabled by the php.ini setting phar.readonly&quot;);
		return 0;
	}

	/* need to copy to strip leading &quot;/&quot;, will get touched again */
	internal_file = estrndup(ZSTR_VAL(resource-&gt;path) + 1, ZSTR_LEN(resource-&gt;path) - 1);
	internal_file_len = ZSTR_LEN(resource-&gt;path) - 1;
	if (FAILURE == phar_get_entry_data(&amp;idata, ZSTR_VAL(resource-&gt;host), host_len, internal_file, internal_file_len, &quot;r&quot;, 0, &amp;error, 1)) {
		/* constraints of fp refcount were not met */
		if (error) {
			php_stream_wrapper_log_error(wrapper, options, &quot;unlink of \&quot;%s\&quot; failed: %s&quot;, url, error);
			efree(error);
		} else {
			php_stream_wrapper_log_error(wrapper, options, &quot;unlink of \&quot;%s\&quot; failed, file does not exist&quot;, url);
		}
		efree(internal_file);
		php_url_free(resource);
		return 0;
	}
	if (error) {
		efree(error);
	}
	if (idata-&gt;internal_file-&gt;fp_refcount &gt; 1) {
		/* more than just our fp resource is open for this file */
		php_stream_wrapper_log_error(wrapper, options, &quot;phar error: \&quot;%s\&quot; in phar \&quot;%s\&quot;, has open file pointers, cannot unlink&quot;, internal_file, ZSTR_VAL(resource-&gt;host));
		efree(internal_file);
		php_url_free(resource);
		phar_entry_delref(idata);
		return 0;
	}
	php_url_free(resource);
	efree(internal_file);
	phar_entry_remove(idata, &amp;error);
	if (error) {
		php_stream_wrapper_log_error(wrapper, options, &quot;%s&quot;, error);
		efree(error);
	}
	return 1;
}
/* }}} */

static int phar_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from, const char *url_to, int options, php_stream_context *context) /* {{{ */
{
	php_url *resource_from, *resource_to;
	char *error;
	phar_archive_data *phar, *pfrom, *pto;
	phar_entry_info *entry;
	int is_dir = 0;
	int is_modified = 0;

	error = NULL;

	if ((resource_from = phar_parse_url(wrapper, url_from, &quot;wb&quot;, options|PHP_STREAM_URL_STAT_QUIET)) == NULL) {
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: invalid or non-writable url \&quot;%s\&quot;&quot;, url_from, url_to, url_from);
		return 0;
	}
	if (SUCCESS != phar_get_archive(&amp;pfrom, ZSTR_VAL(resource_from-&gt;host), ZSTR_LEN(resource_from-&gt;host), NULL, 0, &amp;error)) {
		pfrom = NULL;
		if (error) {
			efree(error);
		}
	}
	if (PHAR_G(readonly) &amp;&amp; (!pfrom || !pfrom-&gt;is_data)) {
		php_url_free(resource_from);
		php_error_docref(NULL, E_WARNING, &quot;phar error: Write operations disabled by the php.ini setting phar.readonly&quot;);
		return 0;
	}

	if ((resource_to = phar_parse_url(wrapper, url_to, &quot;wb&quot;, options|PHP_STREAM_URL_STAT_QUIET)) == NULL) {
		php_url_free(resource_from);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: invalid or non-writable url \&quot;%s\&quot;&quot;, url_from, url_to, url_to);
		return 0;
	}
	if (SUCCESS != phar_get_archive(&amp;pto, ZSTR_VAL(resource_to-&gt;host), ZSTR_LEN(resource_to-&gt;host), NULL, 0, &amp;error)) {
		if (error) {
			efree(error);
		}
		pto = NULL;
	}
	if (PHAR_G(readonly) &amp;&amp; (!pto || !pto-&gt;is_data)) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: Write operations disabled by the php.ini setting phar.readonly&quot;);
		return 0;
	}

	if (!zend_string_equals(resource_from-&gt;host, resource_to-&gt;host)) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;, not within the same phar archive&quot;, url_from, url_to);
		return 0;
	}

	/* we must have at the very least phar://alias.phar/internalfile.php */
	if (!resource_from-&gt;scheme || !resource_from-&gt;host || !resource_from-&gt;path) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: invalid url \&quot;%s\&quot;&quot;, url_from, url_to, url_from);
		return 0;
	}

	if (!resource_to-&gt;scheme || !resource_to-&gt;host || !resource_to-&gt;path) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: invalid url \&quot;%s\&quot;&quot;, url_from, url_to, url_to);
		return 0;
	}

	if (!zend_string_equals_literal_ci(resource_from-&gt;scheme, &quot;phar&quot;)) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: not a phar stream url \&quot;%s\&quot;&quot;, url_from, url_to, url_from);
		return 0;
	}

	if (!zend_string_equals_literal_ci(resource_to-&gt;scheme, &quot;phar&quot;)) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: not a phar stream url \&quot;%s\&quot;&quot;, url_from, url_to, url_to);
		return 0;
	}

	size_t host_len = ZSTR_LEN(resource_from-&gt;host);

	if (SUCCESS != phar_get_archive(&amp;phar, ZSTR_VAL(resource_from-&gt;host), host_len, NULL, 0, &amp;error)) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: %s&quot;, url_from, url_to, error);
		efree(error);
		return 0;
	}

	if (phar-&gt;is_persistent &amp;&amp; FAILURE == phar_copy_on_write(&amp;phar)) {
		php_url_free(resource_from);
		php_url_free(resource_to);
		php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: could not make cached phar writeable&quot;, url_from, url_to);
		return 0;
	}

	if (NULL != (entry = zend_hash_str_find_ptr(&amp;(phar-&gt;manifest), ZSTR_VAL(resource_from-&gt;path)+1, ZSTR_LEN(resource_from-&gt;path)-1))) {
		phar_entry_info new, *source;

		/* perform rename magic */
		if (entry-&gt;is_deleted) {
			php_url_free(resource_from);
			php_url_free(resource_to);
			php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot; from extracted phar archive, source has been deleted&quot;, url_from, url_to);
			return 0;
		}
		/* transfer all data over to the new entry */
		memcpy((void *) &amp;new, (void *) entry, sizeof(phar_entry_info));
		/* mark the old one for deletion */
		entry-&gt;is_deleted = 1;
		entry-&gt;fp = NULL;
		ZVAL_UNDEF(&amp;entry-&gt;metadata_tracker.val);
		entry-&gt;link = entry-&gt;tmp = NULL;
		source = entry;

		/* add to the manifest, and then store the pointer to the new guy in entry
		 * if it already exists, we overwrite the destination like what copy(&#039;phar://...&#039;, &#039;phar://...&#039;) does. */
		entry = zend_hash_str_update_mem(&amp;(phar-&gt;manifest), ZSTR_VAL(resource_to-&gt;path)+1, ZSTR_LEN(resource_to-&gt;path)-1, (void **)&amp;new, sizeof(phar_entry_info));

		entry-&gt;filename = estrndup(ZSTR_VAL(resource_to-&gt;path)+1, ZSTR_LEN(resource_to-&gt;path)-1);
		if (FAILURE == phar_copy_entry_fp(source, entry, &amp;error)) {
			php_url_free(resource_from);
			php_url_free(resource_to);
			php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: %s&quot;, url_from, url_to, error);
			efree(error);
			zend_hash_str_del(&amp;(phar-&gt;manifest), entry-&gt;filename, strlen(entry-&gt;filename));
			return 0;
		}
		is_modified = 1;
		entry-&gt;is_modified = 1;
		entry-&gt;filename_len = strlen(entry-&gt;filename);
		is_dir = entry-&gt;is_dir;
	} else {
		is_dir = zend_hash_str_exists(&amp;(phar-&gt;virtual_dirs), ZSTR_VAL(resource_from-&gt;path)+1, ZSTR_LEN(resource_from-&gt;path)-1);
		if (!is_dir) {
			/* file does not exist */
			php_url_free(resource_from);
			php_url_free(resource_to);
			php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot; from extracted phar archive, source does not exist&quot;, url_from, url_to);
			return 0;

		}
	}

	/* Rename directory. Update all nested paths */
	if (is_dir) {
		Bucket *b;
		zend_string *str_key;
		zend_string *new_str_key;
		size_t from_len = ZSTR_LEN(resource_from-&gt;path) - 1;
		size_t to_len = ZSTR_LEN(resource_to-&gt;path) - 1;

		ZEND_HASH_MAP_FOREACH_BUCKET(&amp;phar-&gt;manifest, b) {
			str_key = b-&gt;key;
			entry = Z_PTR(b-&gt;val);
			if (!entry-&gt;is_deleted &amp;&amp;
				ZSTR_LEN(str_key) &gt; from_len &amp;&amp;
				memcmp(ZSTR_VAL(str_key), ZSTR_VAL(resource_from-&gt;path)+1, from_len) == 0 &amp;&amp;
				IS_SLASH(ZSTR_VAL(str_key)[from_len])) {

				new_str_key = zend_string_alloc(ZSTR_LEN(str_key) + to_len - from_len, 0);
				memcpy(ZSTR_VAL(new_str_key), ZSTR_VAL(resource_to-&gt;path) + 1, to_len);
				memcpy(ZSTR_VAL(new_str_key) + to_len, ZSTR_VAL(str_key) + from_len, ZSTR_LEN(str_key) - from_len);
				ZSTR_VAL(new_str_key)[ZSTR_LEN(new_str_key)] = 0;

				is_modified = 1;
				entry-&gt;is_modified = 1;
				efree(entry-&gt;filename);
				// TODO: avoid reallocation (make entry-&gt;filename zend_string*)
				entry-&gt;filename = estrndup(ZSTR_VAL(new_str_key), ZSTR_LEN(new_str_key));
				entry-&gt;filename_len = ZSTR_LEN(new_str_key);

				zend_string_release_ex(str_key, 0);
				b-&gt;h = zend_string_hash_val(new_str_key);
				b-&gt;key = new_str_key;
			}
		} ZEND_HASH_FOREACH_END();
		zend_hash_rehash(&amp;phar-&gt;manifest);

		ZEND_HASH_MAP_FOREACH_BUCKET(&amp;phar-&gt;virtual_dirs, b) {
			str_key = b-&gt;key;
			if (zend_string_starts_with_cstr(str_key, ZSTR_VAL(resource_from-&gt;path)+1, from_len) &amp;&amp;
				(ZSTR_LEN(str_key) == from_len || IS_SLASH(ZSTR_VAL(str_key)[from_len]))) {

				new_str_key = zend_string_alloc(ZSTR_LEN(str_key) + to_len - from_len, 0);
				memcpy(ZSTR_VAL(new_str_key), ZSTR_VAL(resource_to-&gt;path) + 1, to_len);
				memcpy(ZSTR_VAL(new_str_key) + to_len, ZSTR_VAL(str_key) + from_len, ZSTR_LEN(str_key) - from_len);
				ZSTR_VAL(new_str_key)[ZSTR_LEN(new_str_key)] = 0;

				zend_string_release_ex(str_key, 0);
				b-&gt;h = zend_string_hash_val(new_str_key);
				b-&gt;key = new_str_key;
			}
		} ZEND_HASH_FOREACH_END();
		zend_hash_rehash(&amp;phar-&gt;virtual_dirs);

		ZEND_HASH_MAP_FOREACH_BUCKET(&amp;phar-&gt;mounted_dirs, b) {
			str_key = b-&gt;key;
			if (zend_string_starts_with_cstr(str_key, ZSTR_VAL(resource_from-&gt;path)+1, from_len) &amp;&amp;
				(ZSTR_LEN(str_key) == from_len || IS_SLASH(ZSTR_VAL(str_key)[from_len]))) {

				new_str_key = zend_string_alloc(ZSTR_LEN(str_key) + to_len - from_len, 0);
				memcpy(ZSTR_VAL(new_str_key), ZSTR_VAL(resource_to-&gt;path) + 1, to_len);
				memcpy(ZSTR_VAL(new_str_key) + to_len, ZSTR_VAL(str_key) + from_len, ZSTR_LEN(str_key) - from_len);
				ZSTR_VAL(new_str_key)[ZSTR_LEN(new_str_key)] = 0;

				zend_string_release_ex(str_key, 0);
				b-&gt;h = zend_string_hash_val(new_str_key);
				b-&gt;key = new_str_key;
			}
		} ZEND_HASH_FOREACH_END();
		zend_hash_rehash(&amp;phar-&gt;mounted_dirs);
	}

	if (is_modified) {
		phar_flush(phar, &amp;error);
		if (error) {
			php_url_free(resource_from);
			php_url_free(resource_to);
			php_error_docref(NULL, E_WARNING, &quot;phar error: cannot rename \&quot;%s\&quot; to \&quot;%s\&quot;: %s&quot;, url_from, url_to, error);
			efree(error);
			return 0;
		}
	}

	php_url_free(resource_from);
	php_url_free(resource_to);

	return 1;
}
/* }}} */
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fphar'>🔙 Back</a></p>