2005-12-05 04:35:38 +08:00
/*
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2005-12-05 06:50:54 +08:00
| phar php single - file executable PHP extension |
2005-12-05 04:35:38 +08:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2008-01-09 04:31:54 +08:00
| Copyright ( c ) 2005 - 2008 The PHP Group |
2005-12-05 04:35:38 +08:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2005-12-05 06:50:54 +08:00
| This source file is subject to version 3.01 of the PHP license , |
2005-12-05 04:35:38 +08:00
| that is bundled with this package in the file LICENSE , and is |
| available through the world - wide - web at the following url : |
2005-12-05 06:50:54 +08:00
| http : //www.php.net/license/3_01.txt. |
2005-12-05 04:35:38 +08:00
| 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 . |
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
2006-01-04 21:18:31 +08:00
| Authors : Gregory Beaver < cellog @ php . net > |
| Marcus Boerger < helly @ php . net > |
2005-12-05 04:35:38 +08:00
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
*/
/* $Id$ */
2008-01-09 04:31:54 +08:00
# define PHAR_MAIN 1
2007-01-21 23:25:50 +08:00
# include "phar_internal.h"
2007-03-26 03:03:38 +08:00
# include "SAPI.h"
2008-01-11 15:30:03 +08:00
# include "func_interceptors.h"
2006-01-10 14:46:17 +08:00
2005-12-05 04:35:38 +08:00
ZEND_DECLARE_MODULE_GLOBALS ( phar )
2007-01-21 06:40:47 +08:00
/* if the original value is 0 (disabled), then allow setting/unsetting at will
otherwise , only allow 1 ( enabled ) , and error on disabling */
2007-01-24 07:31:14 +08:00
ZEND_INI_MH ( phar_ini_modify_handler ) /* {{{ */
2007-01-21 06:40:47 +08:00
{
2007-02-07 06:41:39 +08:00
zend_bool old , ini ;
2007-01-21 06:40:47 +08:00
2007-02-07 06:41:39 +08:00
if ( entry - > name_length = = 14 ) {
old = PHAR_G ( readonly_orig ) ;
} else {
old = PHAR_G ( require_hash_orig ) ;
}
2007-01-21 06:40:47 +08:00
2007-02-07 06:41:39 +08:00
if ( new_value_length = = 2 & & ! strcasecmp ( " on " , new_value ) ) {
ini = ( zend_bool ) 1 ;
2007-01-21 06:40:47 +08:00
}
2007-02-07 06:41:39 +08:00
else if ( new_value_length = = 3 & & ! strcasecmp ( " yes " , new_value ) ) {
ini = ( zend_bool ) 1 ;
2007-01-21 06:40:47 +08:00
}
2007-02-07 06:41:39 +08:00
else if ( new_value_length = = 4 & & ! strcasecmp ( " true " , new_value ) ) {
ini = ( zend_bool ) 1 ;
2007-01-21 06:40:47 +08:00
}
else {
2007-02-07 06:41:39 +08:00
ini = ( zend_bool ) atoi ( new_value ) ;
2007-01-21 06:40:47 +08:00
}
2007-02-07 06:41:39 +08:00
/* do not allow unsetting in runtime */
if ( stage = = ZEND_INI_STAGE_STARTUP ) {
if ( entry - > name_length = = 14 ) {
PHAR_G ( readonly_orig ) = ini ;
} else {
PHAR_G ( require_hash_orig ) = ini ;
2007-01-21 06:40:47 +08:00
}
2007-02-07 06:41:39 +08:00
} else if ( old & & ! ini ) {
return FAILURE ;
2007-01-21 06:40:47 +08:00
}
2007-02-07 06:41:39 +08:00
if ( entry - > name_length = = 14 ) {
PHAR_G ( readonly ) = ini ;
} else {
PHAR_G ( require_hash ) = ini ;
}
2007-01-21 06:40:47 +08:00
return SUCCESS ;
}
2007-01-24 07:31:14 +08:00
/* }}}*/
2007-01-21 06:40:47 +08:00
2007-03-26 03:03:38 +08:00
static void phar_split_extract_list ( TSRMLS_D )
{
char * tmp = estrdup ( PHAR_GLOBALS - > extract_list ) ;
char * key ;
char * lasts ;
char * q ;
int keylen ;
zend_hash_clean ( & ( PHAR_GLOBALS - > phar_plain_map ) ) ;
for ( key = php_strtok_r ( tmp , " , " , & lasts ) ;
key ;
key = php_strtok_r ( NULL , " , " , & lasts ) )
{
char * val = strchr ( key , ' = ' ) ;
if ( val ) {
* val + + = ' \0 ' ;
for ( q = key ; * q ; q + + ) {
* q = tolower ( * q ) ;
}
keylen = q - key + 1 ;
zend_hash_add ( & ( PHAR_GLOBALS - > phar_plain_map ) , key , keylen , val , strlen ( val ) + 1 , NULL ) ;
}
}
efree ( tmp ) ;
}
/* }}} */
ZEND_INI_MH ( phar_ini_extract_list ) /* {{{ */
{
PHAR_G ( extract_list ) = new_value ;
if ( stage = = ZEND_INI_STAGE_RUNTIME ) {
phar_split_extract_list ( TSRMLS_C ) ;
}
return SUCCESS ;
}
/* }}} */
ZEND_INI_DISP ( phar_ini_extract_list_disp ) /*void name(zend_ini_entry *ini_entry, int type) {{{ */
{
char * value ;
if ( type = = ZEND_INI_DISPLAY_ORIG & & ini_entry - > modified ) {
value = ini_entry - > orig_value ;
} else if ( ini_entry - > value ) {
value = ini_entry - > value ;
} else {
value = NULL ;
}
if ( value ) {
char * tmp = strdup ( value ) ;
char * key ;
char * lasts ;
char * q ;
if ( ! sapi_module . phpinfo_as_text ) {
php_printf ( " <ul> " ) ;
}
for ( key = php_strtok_r ( tmp , " , " , & lasts ) ;
key ;
key = php_strtok_r ( NULL , " , " , & lasts ) )
{
char * val = strchr ( key , ' = ' ) ;
if ( val ) {
* val + + = ' \0 ' ;
2008-03-23 06:11:49 +08:00
for ( q = key ; * q ; + + q ) {
2007-03-26 03:03:38 +08:00
* q = tolower ( * q ) ;
}
if ( sapi_module . phpinfo_as_text ) {
php_printf ( " %s => %s " , key , val ) ;
} else {
php_printf ( " <li>%s => %s</li> " , key , val ) ;
}
}
}
if ( ! sapi_module . phpinfo_as_text ) {
php_printf ( " </ul> " ) ;
}
free ( tmp ) ;
}
}
/* }}} */
2007-01-08 00:01:35 +08:00
PHP_INI_BEGIN ( )
2007-03-26 03:03:38 +08:00
STD_PHP_INI_BOOLEAN ( " phar.readonly " , " 1 " , PHP_INI_ALL , phar_ini_modify_handler , readonly , zend_phar_globals , phar_globals )
STD_PHP_INI_BOOLEAN ( " phar.require_hash " , " 1 " , PHP_INI_ALL , phar_ini_modify_handler , require_hash , zend_phar_globals , phar_globals )
STD_PHP_INI_ENTRY_EX ( " phar.extract_list " , " " , PHP_INI_ALL , phar_ini_extract_list , extract_list , zend_phar_globals , phar_globals , phar_ini_extract_list_disp )
2007-01-08 00:01:35 +08:00
PHP_INI_END ( )
2007-01-02 08:04:30 +08:00
/**
* When all uses of a phar have been concluded , this frees the manifest
* and the phar slot
*/
2008-01-28 16:52:08 +08:00
static void phar_destroy_phar_data ( phar_archive_data * phar TSRMLS_DC ) /* { { { */
2005-12-05 04:35:38 +08:00
{
2008-01-28 16:52:08 +08:00
if ( phar - > alias & & phar - > alias ! = phar - > fname ) {
efree ( phar - > alias ) ;
phar - > alias = NULL ;
2008-01-04 09:45:37 +08:00
}
2008-01-28 16:52:08 +08:00
if ( phar - > fname ) {
efree ( phar - > fname ) ;
phar - > fname = NULL ;
2006-01-12 05:19:46 +08:00
}
2008-01-28 16:52:08 +08:00
if ( phar - > signature ) {
efree ( phar - > signature ) ;
2007-02-03 12:04:18 +08:00
}
2008-01-28 16:52:08 +08:00
if ( phar - > manifest . arBuckets ) {
zend_hash_destroy ( & phar - > manifest ) ;
phar - > manifest . arBuckets = NULL ;
2007-01-09 08:27:13 +08:00
}
2008-02-18 12:45:42 +08:00
if ( phar - > mounted_dirs . arBuckets ) {
zend_hash_destroy ( & phar - > mounted_dirs ) ;
phar - > mounted_dirs . arBuckets = NULL ;
}
2008-01-28 16:52:08 +08:00
if ( phar - > metadata ) {
zval_ptr_dtor ( & phar - > metadata ) ;
phar - > metadata = 0 ;
2007-01-03 23:43:07 +08:00
}
2008-01-28 16:52:08 +08:00
if ( phar - > fp ) {
php_stream_close ( phar - > fp ) ;
phar - > fp = 0 ;
2007-01-29 11:59:55 +08:00
}
2008-01-28 16:52:08 +08:00
if ( phar - > ufp ) {
php_stream_close ( phar - > ufp ) ;
phar - > fp = 0 ;
2006-01-10 14:46:17 +08:00
}
2008-01-28 16:52:08 +08:00
efree ( phar ) ;
2005-12-05 04:35:38 +08:00
}
2006-01-04 23:50:45 +08:00
/* }}}*/
2005-12-05 04:35:38 +08:00
2007-01-27 03:58:22 +08:00
/**
* Delete refcount and destruct if needed . On destruct return 1 else 0.
*/
int phar_archive_delref ( phar_archive_data * phar TSRMLS_DC ) /* { { { */
{
if ( - - phar - > refcount < 0 ) {
2007-01-27 23:31:24 +08:00
if ( PHAR_GLOBALS - > request_done
| | zend_hash_del ( & ( PHAR_GLOBALS - > phar_fname_map ) , phar - > fname , phar - > fname_len ) ! = SUCCESS ) {
2007-01-27 03:58:22 +08:00
phar_destroy_phar_data ( phar TSRMLS_CC ) ;
}
return 1 ;
2008-02-12 01:13:18 +08:00
} else if ( ! phar - > refcount ) {
2008-02-12 13:28:06 +08:00
if ( phar - > fp & & ! ( phar - > flags & PHAR_FILE_COMPRESSION_MASK ) ) {
2008-02-12 01:13:18 +08:00
/* close open file handle - allows removal or rename of
2008-02-12 13:28:06 +08:00
the file on windows , which has greedy locking
only close if the archive was not already compressed . If it
was compressed , then the fp does not refer to the original file */
2008-02-12 01:13:18 +08:00
php_stream_close ( phar - > fp ) ;
phar - > fp = NULL ;
}
2007-01-27 03:58:22 +08:00
}
return 0 ;
}
/* }}}*/
2007-01-10 08:38:17 +08:00
/**
* Destroy phar ' s in shutdown , here we don ' t care about aliases
*/
static void destroy_phar_data_only ( void * pDest ) /* { { { */
{
phar_archive_data * phar_data = * ( phar_archive_data * * ) pDest ;
TSRMLS_FETCH ( ) ;
2007-02-03 12:04:18 +08:00
if ( EG ( exception ) | | - - phar_data - > refcount < 0 ) {
2007-01-10 08:38:17 +08:00
phar_destroy_phar_data ( phar_data TSRMLS_CC ) ;
}
}
/* }}}*/
/**
* Delete aliases to phar ' s that got kicked out of the global table
*/
2007-01-09 10:27:12 +08:00
static int phar_unalias_apply ( void * pDest , void * argument TSRMLS_DC ) /* { { { */
{
return * ( void * * ) pDest = = argument ? ZEND_HASH_APPLY_REMOVE : ZEND_HASH_APPLY_KEEP ;
}
/* }}} */
2007-01-02 08:04:30 +08:00
/**
* Filename map destructor
*/
2006-03-08 08:56:31 +08:00
static void destroy_phar_data ( void * pDest ) /* { { { */
{
2006-03-09 04:07:25 +08:00
phar_archive_data * phar_data = * ( phar_archive_data * * ) pDest ;
2007-01-09 10:27:12 +08:00
TSRMLS_FETCH ( ) ;
2007-01-09 03:30:52 +08:00
2007-03-28 05:28:22 +08:00
if ( PHAR_GLOBALS - > request_ends ) {
2007-10-19 03:47:24 +08:00
destroy_phar_data_only ( pDest ) ;
return ;
2007-03-28 05:28:22 +08:00
}
2007-01-09 10:27:12 +08:00
zend_hash_apply_with_argument ( & ( PHAR_GLOBALS - > phar_alias_map ) , phar_unalias_apply , phar_data TSRMLS_CC ) ;
if ( - - phar_data - > refcount < 0 ) {
2006-03-09 04:07:25 +08:00
phar_destroy_phar_data ( phar_data TSRMLS_CC ) ;
}
2006-03-08 08:56:31 +08:00
}
/* }}}*/
2007-01-02 08:04:30 +08:00
/**
* destructor for the manifest hash , frees each file ' s entry
*/
2008-01-09 11:47:22 +08:00
void destroy_phar_manifest_entry ( void * pDest ) /* { { { */
2005-12-05 04:35:38 +08:00
{
2006-02-28 09:36:30 +08:00
phar_entry_info * entry = ( phar_entry_info * ) pDest ;
2007-01-10 08:07:45 +08:00
TSRMLS_FETCH ( ) ;
2006-01-04 23:27:18 +08:00
2007-01-27 23:31:24 +08:00
if ( entry - > cfp ) {
php_stream_close ( entry - > cfp ) ;
entry - > cfp = 0 ;
}
2006-01-10 14:46:17 +08:00
if ( entry - > fp ) {
2008-01-28 16:52:08 +08:00
php_stream_close ( entry - > fp ) ;
2007-01-26 22:52:10 +08:00
entry - > fp = 0 ;
2007-01-03 05:21:18 +08:00
}
2007-01-21 14:30:55 +08:00
if ( entry - > metadata ) {
2007-01-21 23:28:56 +08:00
zval_ptr_dtor ( & entry - > metadata ) ;
2007-01-21 14:30:55 +08:00
entry - > metadata = 0 ;
}
2007-05-15 03:14:00 +08:00
if ( entry - > metadata_str . c ) {
smart_str_free ( & entry - > metadata_str ) ;
entry - > metadata_str . c = 0 ;
}
2006-01-04 23:27:18 +08:00
efree ( entry - > filename ) ;
2008-01-04 02:13:27 +08:00
if ( entry - > link ) {
efree ( entry - > link ) ;
entry - > link = 0 ;
2008-01-03 12:45:00 +08:00
}
2005-12-05 04:35:38 +08:00
}
2006-01-04 23:50:45 +08:00
/* }}} */
2005-12-05 04:35:38 +08:00
2007-01-27 23:31:24 +08:00
int phar_entry_delref ( phar_entry_data * idata TSRMLS_DC ) /* { { { */
{
int ret = 0 ;
2007-08-17 12:47:50 +08:00
if ( idata - > internal_file ) {
2008-01-04 02:13:27 +08:00
if ( - - idata - > internal_file - > fp_refcount < 0 ) {
2007-08-17 12:47:50 +08:00
idata - > internal_file - > fp_refcount = 0 ;
}
2008-01-28 16:52:08 +08:00
if ( idata - > fp & & idata - > fp ! = idata - > phar - > fp & & idata - > fp ! = idata - > phar - > ufp & & idata - > fp ! = idata - > internal_file - > fp ) {
2007-08-17 12:47:50 +08:00
php_stream_close ( idata - > fp ) ;
}
2007-01-27 23:31:24 +08:00
}
2007-08-17 12:47:50 +08:00
phar_archive_delref ( idata - > phar TSRMLS_CC ) ;
2007-01-27 23:31:24 +08:00
efree ( idata ) ;
return ret ;
}
2007-02-07 05:04:22 +08:00
/* }}} */
2007-01-27 23:31:24 +08:00
2007-01-26 22:52:10 +08:00
/**
2007-06-01 11:48:17 +08:00
* Removes an entry , either by actually removing it or by marking it .
2007-01-26 22:52:10 +08:00
*/
2007-01-29 14:02:19 +08:00
void phar_entry_remove ( phar_entry_data * idata , char * * error TSRMLS_DC ) /* { { { */
2007-01-26 22:52:10 +08:00
{
2007-08-17 12:47:50 +08:00
phar_archive_data * phar ;
phar = idata - > phar ;
2007-01-27 23:31:24 +08:00
if ( idata - > internal_file - > fp_refcount < 2 ) {
2008-01-28 16:52:08 +08:00
if ( idata - > fp & & idata - > fp ! = idata - > phar - > fp & & idata - > fp ! = idata - > phar - > ufp & & idata - > fp ! = idata - > internal_file - > fp ) {
2007-01-27 23:31:24 +08:00
php_stream_close ( idata - > fp ) ;
2007-01-26 22:52:10 +08:00
}
2007-01-28 01:27:48 +08:00
zend_hash_del ( & idata - > phar - > manifest , idata - > internal_file - > filename , idata - > internal_file - > filename_len ) ;
2007-01-28 06:23:52 +08:00
idata - > phar - > refcount - - ;
2007-01-26 22:52:10 +08:00
efree ( idata ) ;
2007-01-27 23:31:24 +08:00
} else {
idata - > internal_file - > is_deleted = 1 ;
phar_entry_delref ( idata TSRMLS_CC ) ;
2007-01-26 22:52:10 +08:00
}
2007-08-17 12:47:50 +08:00
if ( ! phar - > donotflush ) {
2008-02-25 06:29:06 +08:00
phar_flush ( phar , 0 , 0 , 0 , error TSRMLS_CC ) ;
2007-08-17 12:47:50 +08:00
}
2005-12-05 04:35:38 +08:00
}
2006-01-04 23:50:45 +08:00
/* }}} */
2005-12-05 04:35:38 +08:00
2006-01-04 10:26:15 +08:00
# define MAPPHAR_ALLOC_FAIL(msg) \
php_stream_close ( fp ) ; \
2007-01-29 14:02:19 +08:00
if ( error ) { \
spprintf ( error , 0 , msg , fname ) ; \
} \
2006-01-04 10:26:15 +08:00
return FAILURE ;
# define MAPPHAR_FAIL(msg) \
efree ( savebuf ) ; \
2007-01-09 08:27:13 +08:00
if ( mydata ) { \
2007-02-03 12:04:18 +08:00
phar_destroy_phar_data ( mydata TSRMLS_CC ) ; \
2007-01-09 08:27:13 +08:00
} \
if ( signature ) { \
efree ( signature ) ; \
} \
2006-01-04 10:26:15 +08:00
MAPPHAR_ALLOC_FAIL ( msg )
2006-01-05 08:39:31 +08:00
# ifdef WORDS_BIGENDIAN
2006-01-10 14:46:17 +08:00
# define PHAR_GET_32(buffer, var) \
2007-02-07 05:43:46 +08:00
var = ( ( ( ( unsigned char * ) ( buffer ) ) [ 3 ] ) < < 24 ) \
| ( ( ( ( unsigned char * ) ( buffer ) ) [ 2 ] ) < < 16 ) \
| ( ( ( ( unsigned char * ) ( buffer ) ) [ 1 ] ) < < 8 ) \
| ( ( ( unsigned char * ) ( buffer ) ) [ 0 ] ) ; \
2007-01-21 14:30:55 +08:00
( buffer ) + = 4
# define PHAR_GET_16(buffer, var) \
2007-02-07 05:43:46 +08:00
var = ( ( ( ( unsigned char * ) ( buffer ) ) [ 1 ] ) < < 8 ) \
| ( ( ( unsigned char * ) ( buffer ) ) [ 0 ] ) ; \
2007-01-21 14:30:55 +08:00
( buffer ) + = 2
2006-01-05 08:39:31 +08:00
# else
2006-01-10 14:46:17 +08:00
# define PHAR_GET_32(buffer, var) \
2006-01-06 06:24:41 +08:00
var = * ( php_uint32 * ) ( buffer ) ; \
2006-01-05 08:39:31 +08:00
buffer + = 4
2007-01-21 14:30:55 +08:00
# define PHAR_GET_16(buffer, var) \
var = * ( php_uint16 * ) ( buffer ) ; \
buffer + = 2
2006-01-05 08:39:31 +08:00
# endif
2007-01-02 08:04:30 +08:00
/**
2007-01-11 09:04:47 +08:00
* Open an already loaded phar
*/
2008-02-28 05:34:26 +08:00
int phar_open_loaded ( char * fname , int fname_len , char * alias , int alias_len , int is_data , int options , phar_archive_data * * pphar , char * * error TSRMLS_DC ) /* { { { */
2007-01-11 09:04:47 +08:00
{
phar_archive_data * phar ;
2007-12-15 02:42:57 +08:00
# ifdef PHP_WIN32
char * unixfname ;
# endif
2007-01-11 09:04:47 +08:00
2007-01-29 15:59:19 +08:00
if ( error ) {
* error = NULL ;
}
2007-12-15 02:42:57 +08:00
# ifdef PHP_WIN32
unixfname = estrndup ( fname , fname_len ) ;
phar_unixify_path_separators ( unixfname , fname_len ) ;
if ( SUCCESS = = phar_get_archive ( & phar , unixfname , fname_len , alias , alias_len , error TSRMLS_CC )
& & ( ( alias & & fname_len = = phar - > fname_len
& & ! strncmp ( unixfname , phar - > fname , fname_len ) ) | | ! alias )
) {
2008-03-03 16:41:15 +08:00
phar_entry_info * stub ;
2007-12-15 02:42:57 +08:00
efree ( unixfname ) ;
# else
2007-01-29 14:02:19 +08:00
if ( SUCCESS = = phar_get_archive ( & phar , fname , fname_len , alias , alias_len , error TSRMLS_CC )
2007-11-20 13:34:35 +08:00
& & ( ( alias & & fname_len = = phar - > fname_len
& & ! strncmp ( fname , phar - > fname , fname_len ) ) | | ! alias )
2007-01-26 22:52:10 +08:00
) {
2008-03-03 16:41:15 +08:00
phar_entry_info * stub ;
2007-12-15 02:42:57 +08:00
# endif
2007-11-20 13:34:35 +08:00
/* logic above is as follows:
If an explicit alias was requested , ensure the filename passed in
matches the phar ' s filename .
If no alias was passed in , then it can match either and be valid
*/
2008-03-03 16:41:15 +08:00
if ( ! is_data ) {
/* prevent any ".phar" without a stub getting through */
if ( ! phar - > halt_offset & & ! phar - > is_brandnew ) {
2008-03-23 14:59:59 +08:00
if ( PHAR_G ( readonly ) & & FAILURE = = zend_hash_find ( & ( phar - > manifest ) , " .phar/stub.php " , sizeof ( " .phar/stub.php " ) - 1 , ( void * * ) & stub ) ) {
2008-03-03 16:41:15 +08:00
spprintf ( error , 0 , " '%s' is not a phar archive. Use PharData::__construct() for a standard zip or tar archive " , fname ) ;
return FAILURE ;
}
}
}
phar - > is_data = is_data ;
2007-01-11 09:04:47 +08:00
if ( pphar ) {
* pphar = phar ;
}
return SUCCESS ;
} else {
2007-12-15 02:42:57 +08:00
# ifdef PHP_WIN32
efree ( unixfname ) ;
# endif
2007-01-11 09:04:47 +08:00
if ( pphar ) {
* pphar = NULL ;
}
if ( phar & & alias & & ( options & REPORT_ERRORS ) ) {
2007-01-29 14:02:19 +08:00
if ( error ) {
2007-01-29 15:59:19 +08:00
spprintf ( error , 0 , " alias \" %s \" is already used for archive \" %s \" cannot be overloaded with \" %s \" " , alias , phar - > fname , fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-11 09:04:47 +08:00
}
return FAILURE ;
}
}
/* }}}*/
2007-01-21 14:30:55 +08:00
/**
* Parse out metadata from the manifest for a single file
*
* Meta - data is in this format :
2007-01-22 04:12:50 +08:00
* [ len32 ] [ data . . . ]
2007-01-21 14:30:55 +08:00
*
2007-01-22 04:12:50 +08:00
* data is the serialized zval
2007-01-21 14:30:55 +08:00
*/
2008-01-09 03:40:23 +08:00
int phar_parse_metadata ( char * * buffer , zval * * metadata , int is_zip TSRMLS_DC ) /* { { { */
2007-01-21 14:30:55 +08:00
{
2007-01-22 04:12:50 +08:00
const unsigned char * p ;
php_uint32 buf_len ;
php_unserialize_data_t var_hash ;
2008-01-01 06:42:40 +08:00
if ( ! is_zip ) {
PHAR_GET_32 ( * buffer , buf_len ) ;
} else {
buf_len = is_zip ;
}
2007-01-22 04:12:50 +08:00
if ( buf_len ) {
ALLOC_INIT_ZVAL ( * 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 ;
2007-01-21 14:30:55 +08:00
return FAILURE ;
}
2007-01-22 04:12:50 +08:00
PHP_VAR_UNSERIALIZE_DESTROY ( var_hash ) ;
2007-02-07 07:19:10 +08:00
} else {
* metadata = NULL ;
2007-01-22 04:12:50 +08:00
}
* buffer + = buf_len ;
2007-01-21 14:30:55 +08:00
return SUCCESS ;
}
/* }}}*/
2007-02-24 10:08:08 +08:00
static const char hexChars [ ] = " 0123456789ABCDEF " ;
static int phar_hex_str ( const char * digest , size_t digest_len , char * * signature )
{
int pos = - 1 ;
size_t len ;
* signature = ( char * ) safe_emalloc ( digest_len , 2 , 1 ) ;
for ( len = 0 ; len < digest_len ; + + len ) {
( * signature ) [ + + pos ] = hexChars [ ( ( const unsigned char * ) digest ) [ len ] > > 4 ] ;
( * signature ) [ + + pos ] = hexChars [ ( ( const unsigned char * ) digest ) [ len ] & 0x0F ] ;
}
( * signature ) [ + + pos ] = ' \0 ' ;
return pos ;
}
2007-01-11 09:04:47 +08:00
/**
* Does not check for a previously opened phar in the cache .
*
* Parse a new one and add it to the cache , returning either SUCCESS or
* FAILURE , and setting pphar to the pointer to the manifest entry
2007-01-02 08:04:30 +08:00
*
* This is used by phar_open_filename to process the manifest , but can be called
* directly .
*/
2008-01-09 15:09:04 +08:00
int phar_open_file ( php_stream * fp , char * fname , int fname_len , char * alias , int alias_len , long halt_offset , phar_archive_data * * pphar , php_uint32 compression , char * * error TSRMLS_DC ) /* { { { */
2005-12-05 04:35:38 +08:00
{
2006-01-10 14:46:17 +08:00
char b32 [ 4 ] , * buffer , * endbuffer , * savebuf ;
2007-01-09 08:27:13 +08:00
phar_archive_data * mydata = NULL ;
2006-02-28 09:36:30 +08:00
phar_entry_info entry ;
2007-01-14 00:17:04 +08:00
php_uint32 manifest_len , manifest_count , manifest_flags , manifest_index , tmp_len , sig_flags ;
php_uint16 manifest_ver ;
2006-01-10 14:46:17 +08:00
long offset ;
2008-02-11 14:46:44 +08:00
int register_alias , sig_len , temp_alias = 0 ;
2007-01-09 08:27:13 +08:00
char * signature = NULL ;
2005-12-05 04:35:38 +08:00
2007-01-04 13:32:45 +08:00
if ( pphar ) {
2006-02-28 09:36:30 +08:00
* pphar = NULL ;
}
2007-01-29 14:02:19 +08:00
if ( error ) {
* error = NULL ;
}
2006-02-28 09:36:30 +08:00
2005-12-08 15:38:44 +08:00
/* check for ?>\n and increment accordingly */
2005-12-08 15:08:49 +08:00
if ( - 1 = = php_stream_seek ( fp , halt_offset , SEEK_SET ) ) {
2005-12-08 15:34:16 +08:00
MAPPHAR_ALLOC_FAIL ( " cannot seek to __HALT_COMPILER(); location in phar \" %s \" " )
2005-12-08 14:46:02 +08:00
}
2006-01-10 14:46:17 +08:00
buffer = b32 ;
2005-12-07 14:39:03 +08:00
if ( 3 ! = php_stream_read ( fp , buffer , 3 ) ) {
2007-06-01 11:48:17 +08:00
MAPPHAR_ALLOC_FAIL ( " internal corruption of phar \" %s \" (truncated manifest at stub end) " )
2005-12-05 04:35:38 +08:00
}
2007-01-29 05:26:54 +08:00
if ( ( * buffer = = ' ' | | * buffer = = ' \n ' ) & & * ( buffer + 1 ) = = ' ? ' & & * ( buffer + 2 ) = = ' > ' ) {
2005-12-05 04:35:38 +08:00
int nextchar ;
2005-12-07 09:18:54 +08:00
halt_offset + = 3 ;
2005-12-07 14:39:03 +08:00
if ( EOF = = ( nextchar = php_stream_getc ( fp ) ) ) {
2007-06-01 11:48:17 +08:00
MAPPHAR_ALLOC_FAIL ( " internal corruption of phar \" %s \" (truncated manifest at stub end) " )
2005-12-07 14:39:03 +08:00
}
2005-12-05 04:35:38 +08:00
if ( ( char ) nextchar = = ' \r ' ) {
2007-05-28 00:54:37 +08:00
/* if we have an \r we require an \n as well */
if ( EOF = = ( nextchar = php_stream_getc ( fp ) ) | | ( char ) nextchar ! = ' \n ' ) {
2007-06-01 11:48:17 +08:00
MAPPHAR_ALLOC_FAIL ( " internal corruption of phar \" %s \" (truncated manifest at stub end) " )
2005-12-07 14:39:03 +08:00
}
2008-03-23 06:11:49 +08:00
+ + halt_offset ;
2005-12-05 04:35:38 +08:00
}
if ( ( char ) nextchar = = ' \n ' ) {
2008-03-23 06:11:49 +08:00
+ + halt_offset ;
2005-12-05 04:35:38 +08:00
}
}
2005-12-08 15:38:44 +08:00
/* make sure we are at the right location to read the manifest */
2005-12-08 15:08:49 +08:00
if ( - 1 = = php_stream_seek ( fp , halt_offset , SEEK_SET ) ) {
2006-01-10 14:46:17 +08:00
MAPPHAR_ALLOC_FAIL ( " cannot seek to __HALT_COMPILER(); location in phar \" %s \" " )
2005-12-08 15:08:49 +08:00
}
2005-12-05 04:35:38 +08:00
2005-12-08 15:38:44 +08:00
/* read in manifest */
2006-01-10 14:46:17 +08:00
buffer = b32 ;
2005-12-07 14:39:03 +08:00
if ( 4 ! = php_stream_read ( fp , buffer , 4 ) ) {
2007-05-27 23:47:52 +08:00
MAPPHAR_ALLOC_FAIL ( " internal corruption of phar \" %s \" (truncated manifest at manifest length) " )
2005-12-07 14:39:03 +08:00
}
2006-01-10 14:46:17 +08:00
PHAR_GET_32 ( buffer , manifest_len ) ;
2008-02-08 13:56:26 +08:00
if ( manifest_len > 1048576 * 100 ) {
/* prevent serious memory issues by limiting manifest to at most 100 MB in length */
MAPPHAR_ALLOC_FAIL ( " manifest cannot be larger than 100 MB in phar \" %s \" " )
2005-12-07 14:39:03 +08:00
}
2006-01-10 14:46:17 +08:00
buffer = ( char * ) emalloc ( manifest_len ) ;
2005-12-05 04:35:38 +08:00
savebuf = buffer ;
endbuffer = buffer + manifest_len ;
2007-05-27 23:47:52 +08:00
if ( manifest_len < 10 | | manifest_len ! = php_stream_read ( fp , buffer , manifest_len ) ) {
2006-01-11 08:50:07 +08:00
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (truncated manifest header) " )
}
2006-01-10 14:46:17 +08:00
2005-12-08 15:38:44 +08:00
/* extract the number of entries */
2006-01-10 14:46:17 +08:00
PHAR_GET_32 ( buffer , manifest_count ) ;
if ( manifest_count = = 0 ) {
MAPPHAR_FAIL ( " in phar \" %s \" , manifest claims to have zero entries. Phars must have at least 1 entry " ) ;
2006-01-05 08:39:31 +08:00
}
2006-01-10 14:46:17 +08:00
2007-01-14 00:17:04 +08:00
/* extract API version, lowest nibble currently unused */
manifest_ver = ( ( ( unsigned char ) buffer [ 0 ] ) < < 8 )
+ ( ( unsigned char ) buffer [ 1 ] ) ;
2006-01-10 14:46:17 +08:00
buffer + = 2 ;
2007-01-14 00:44:54 +08:00
if ( ( manifest_ver & PHAR_API_VER_MASK ) < PHAR_API_MIN_READ ) {
2006-01-10 14:46:17 +08:00
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" is API version %1.u.%1.u.%1.u, and cannot be processed " , fname , manifest_ver > > 12 , ( manifest_ver > > 8 ) & 0xF , ( manifest_ver > > 4 ) & 0x0F ) ;
}
2006-01-10 14:46:17 +08:00
return FAILURE ;
}
2007-01-09 07:03:41 +08:00
2007-01-14 00:17:04 +08:00
PHAR_GET_32 ( buffer , manifest_flags ) ;
2008-01-09 15:09:04 +08:00
manifest_flags & = ~ PHAR_HDR_COMPRESSION_MASK ;
manifest_flags & = ~ PHAR_FILE_COMPRESSION_MASK ;
/* remember whether this entire phar was compressed with gz/bzip2 */
manifest_flags | = compression ;
2007-01-14 00:17:04 +08:00
2007-01-20 13:28:48 +08:00
/* The lowest nibble contains the phar wide flags. The compression flags can */
2006-01-13 05:16:29 +08:00
/* be ignored on reading because it is being generated anyways. */
2007-01-14 00:17:04 +08:00
if ( manifest_flags & PHAR_HDR_SIGNATURE ) {
2007-01-09 07:03:41 +08:00
unsigned char buf [ 1024 ] ;
int read_size , len ;
char sig_buf [ 8 ] , * sig_ptr = sig_buf ;
off_t read_len ;
if ( - 1 = = php_stream_seek ( fp , - 8 , SEEK_END )
| | ( read_len = php_stream_tell ( fp ) ) < 20
| | 8 ! = php_stream_read ( fp , sig_buf , 8 )
| | memcmp ( sig_buf + 4 , " GBMB " , 4 ) ) {
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" has a broken signature " , fname ) ;
}
2007-01-09 07:03:41 +08:00
return FAILURE ;
}
PHAR_GET_32 ( sig_ptr , sig_flags ) ;
switch ( sig_flags ) {
2007-03-26 05:43:49 +08:00
# if HAVE_HASH_EXT
case PHAR_SIG_SHA512 : {
unsigned char digest [ 64 ] , saved [ 64 ] ;
PHP_SHA512_CTX context ;
php_stream_rewind ( fp ) ;
PHP_SHA512Init ( & context ) ;
read_len - = sizeof ( digest ) ;
if ( read_len > sizeof ( buf ) ) {
read_size = sizeof ( buf ) ;
} else {
read_size = ( int ) read_len ;
}
while ( ( len = php_stream_read ( fp , ( char * ) buf , read_size ) ) > 0 ) {
PHP_SHA512Update ( & context , buf , len ) ;
read_len - = ( off_t ) len ;
if ( read_len < read_size ) {
read_size = ( int ) read_len ;
}
}
PHP_SHA512Final ( digest , & context ) ;
if ( read_len > 0
| | php_stream_read ( fp , ( char * ) saved , sizeof ( saved ) ) ! = sizeof ( saved )
| | memcmp ( digest , saved , sizeof ( digest ) ) ) {
efree ( savebuf ) ;
php_stream_close ( fp ) ;
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" has a broken signature " , fname ) ;
}
return FAILURE ;
}
sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & signature ) ;
break ;
}
case PHAR_SIG_SHA256 : {
unsigned char digest [ 32 ] , saved [ 32 ] ;
PHP_SHA256_CTX context ;
php_stream_rewind ( fp ) ;
PHP_SHA256Init ( & context ) ;
read_len - = sizeof ( digest ) ;
if ( read_len > sizeof ( buf ) ) {
read_size = sizeof ( buf ) ;
} else {
read_size = ( int ) read_len ;
}
while ( ( len = php_stream_read ( fp , ( char * ) buf , read_size ) ) > 0 ) {
PHP_SHA256Update ( & context , buf , len ) ;
read_len - = ( off_t ) len ;
if ( read_len < read_size ) {
read_size = ( int ) read_len ;
}
}
PHP_SHA256Final ( digest , & context ) ;
if ( read_len > 0
| | php_stream_read ( fp , ( char * ) saved , sizeof ( saved ) ) ! = sizeof ( saved )
| | memcmp ( digest , saved , sizeof ( digest ) ) ) {
efree ( savebuf ) ;
php_stream_close ( fp ) ;
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" has a broken signature " , fname ) ;
}
return FAILURE ;
}
sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & signature ) ;
break ;
}
# else
case PHAR_SIG_SHA512 :
case PHAR_SIG_SHA256 :
efree ( savebuf ) ;
php_stream_close ( fp ) ;
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" has a unsupported signature " , fname ) ;
}
return FAILURE ;
# endif
2007-01-09 07:03:41 +08:00
case PHAR_SIG_SHA1 : {
unsigned char digest [ 20 ] , saved [ 20 ] ;
PHP_SHA1_CTX context ;
php_stream_rewind ( fp ) ;
PHP_SHA1Init ( & context ) ;
read_len - = sizeof ( digest ) ;
if ( read_len > sizeof ( buf ) ) {
read_size = sizeof ( buf ) ;
} else {
read_size = ( int ) read_len ;
}
while ( ( len = php_stream_read ( fp , ( char * ) buf , read_size ) ) > 0 ) {
PHP_SHA1Update ( & context , buf , len ) ;
read_len - = ( off_t ) len ;
if ( read_len < read_size ) {
read_size = ( int ) read_len ;
}
}
PHP_SHA1Final ( digest , & context ) ;
if ( read_len > 0
| | php_stream_read ( fp , ( char * ) saved , sizeof ( saved ) ) ! = sizeof ( saved )
| | memcmp ( digest , saved , sizeof ( digest ) ) ) {
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" has a broken signature " , fname ) ;
}
2007-01-09 07:03:41 +08:00
return FAILURE ;
}
2006-01-10 14:46:17 +08:00
2007-03-26 03:03:38 +08:00
sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & signature ) ;
2007-01-09 07:03:41 +08:00
break ;
}
case PHAR_SIG_MD5 : {
unsigned char digest [ 16 ] , saved [ 16 ] ;
PHP_MD5_CTX context ;
php_stream_rewind ( fp ) ;
PHP_MD5Init ( & context ) ;
read_len - = sizeof ( digest ) ;
if ( read_len > sizeof ( buf ) ) {
read_size = sizeof ( buf ) ;
} else {
read_size = ( int ) read_len ;
}
while ( ( len = php_stream_read ( fp , ( char * ) buf , read_size ) ) > 0 ) {
PHP_MD5Update ( & context , buf , len ) ;
read_len - = ( off_t ) len ;
if ( read_len < read_size ) {
read_size = ( int ) read_len ;
}
}
PHP_MD5Final ( digest , & context ) ;
if ( read_len > 0
| | php_stream_read ( fp , ( char * ) saved , sizeof ( saved ) ) ! = sizeof ( saved )
| | memcmp ( digest , saved , sizeof ( digest ) ) ) {
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" has a broken signature " , fname ) ;
}
2007-01-09 07:03:41 +08:00
return FAILURE ;
}
2007-03-26 03:03:38 +08:00
sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & signature ) ;
2007-01-09 07:03:41 +08:00
break ;
}
default :
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2007-03-26 05:43:49 +08:00
spprintf ( error , 0 , " phar \" %s \" has a broken or unsupported signature " , fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-09 07:03:41 +08:00
return FAILURE ;
}
} else if ( PHAR_G ( require_hash ) ) {
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " phar \" %s \" does not have a signature " , fname ) ;
}
2007-01-09 07:03:41 +08:00
return FAILURE ;
2007-01-09 08:27:13 +08:00
} else {
sig_flags = 0 ;
sig_len = 0 ;
2007-01-09 07:03:41 +08:00
}
2006-01-10 14:46:17 +08:00
/* extract alias */
PHAR_GET_32 ( buffer , tmp_len ) ;
2006-01-11 08:50:07 +08:00
if ( buffer + tmp_len > endbuffer ) {
2006-01-10 14:46:17 +08:00
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (buffer overrun) " ) ;
}
2006-01-11 08:50:07 +08:00
if ( manifest_len < 10 + tmp_len ) {
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (truncated manifest header) " )
}
/* tmp_len = 0 says alias length is 0, which means the alias is not stored in the phar */
2006-01-10 14:46:17 +08:00
if ( tmp_len ) {
/* if the alias is stored we enforce it (implicit overrides explicit) */
2007-02-06 04:34:23 +08:00
if ( alias & & alias_len & & ( alias_len ! = ( int ) tmp_len | | strncmp ( alias , buffer , tmp_len ) ) )
2006-01-10 14:46:17 +08:00
{
buffer [ tmp_len ] = ' \0 ' ;
efree ( savebuf ) ;
2007-01-11 09:04:47 +08:00
php_stream_close ( fp ) ;
2007-01-09 08:27:13 +08:00
if ( signature ) {
efree ( signature ) ;
}
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " cannot load phar \" %s \" with implicit alias \" %s \" under different alias \" %s \" " , fname , buffer , alias ) ;
}
2006-01-10 14:46:17 +08:00
return FAILURE ;
}
alias_len = tmp_len ;
alias = buffer ;
buffer + = tmp_len ;
2006-01-12 05:19:46 +08:00
register_alias = 1 ;
2006-01-10 14:46:17 +08:00
} else if ( ! alias_len | | ! alias ) {
/* if we neither have an explicit nor an implicit alias, we use the filename */
2006-01-12 05:19:46 +08:00
alias = NULL ;
alias_len = 0 ;
register_alias = 0 ;
2008-02-11 14:46:44 +08:00
} else if ( alias_len ) {
2006-01-12 05:19:46 +08:00
register_alias = 1 ;
2008-02-11 14:46:44 +08:00
temp_alias = 1 ;
2006-01-10 14:46:17 +08:00
}
2006-01-11 08:50:07 +08:00
/* we have 5 32-bit items plus 1 byte at least */
if ( manifest_count > ( ( manifest_len - 10 - tmp_len ) / ( 5 * 4 + 1 ) ) ) {
/* prevent serious memory issues */
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (too many manifest entries for size of manifest) " )
}
2007-01-10 02:54:37 +08:00
mydata = ecalloc ( sizeof ( phar_archive_data ) , 1 ) ;
2007-02-07 07:19:10 +08:00
2007-03-22 01:14:46 +08:00
/* check whether we have meta data, zero check works regardless of byte order */
2008-01-01 06:42:40 +08:00
if ( phar_parse_metadata ( & buffer , & mydata - > metadata , 0 TSRMLS_CC ) = = FAILURE ) {
2007-02-07 07:19:10 +08:00
MAPPHAR_FAIL ( " unable to read phar metadata in .phar file \" %s \" " ) ;
2007-01-29 11:59:55 +08:00
}
2008-01-01 06:42:40 +08:00
2007-01-29 11:59:55 +08:00
/* set up our manifest */
2006-03-09 04:07:25 +08:00
zend_hash_init ( & mydata - > manifest , sizeof ( phar_entry_info ) ,
2008-01-09 11:47:22 +08:00
zend_get_hash_value , destroy_phar_manifest_entry , 0 ) ;
2008-02-18 12:45:42 +08:00
zend_hash_init ( & mydata - > mounted_dirs , sizeof ( char * ) ,
zend_get_hash_value , NULL , 0 ) ;
2008-01-28 16:52:08 +08:00
offset = halt_offset + manifest_len + 4 ;
memset ( & entry , 0 , sizeof ( phar_entry_info ) ) ;
entry . phar = mydata ;
entry . fp_type = PHAR_FP ;
2008-03-23 06:11:49 +08:00
for ( manifest_index = 0 ; manifest_index < manifest_count ; + + manifest_index ) {
2006-01-05 08:39:31 +08:00
if ( buffer + 4 > endbuffer ) {
2006-01-11 08:50:07 +08:00
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (truncated manifest entry) " )
2005-12-07 14:39:03 +08:00
}
2006-01-10 14:46:17 +08:00
PHAR_GET_32 ( buffer , entry . filename_len ) ;
if ( entry . filename_len = = 0 ) {
MAPPHAR_FAIL ( " zero-length filename encountered in phar \" %s \" " ) ;
}
2007-01-14 00:17:04 +08:00
if ( buffer + entry . filename_len + 20 > endbuffer ) {
2006-01-11 08:50:07 +08:00
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (truncated manifest entry) " ) ;
2006-01-05 08:39:31 +08:00
}
2008-01-20 02:30:30 +08:00
if ( ( manifest_ver & PHAR_API_VER_MASK ) > = PHAR_API_MIN_DIR & & buffer [ entry . filename_len - 1 ] = = ' / ' ) {
2008-01-09 06:14:16 +08:00
entry . is_dir = 1 ;
} else {
entry . is_dir = 0 ;
}
2006-01-04 23:27:18 +08:00
entry . filename = estrndup ( buffer , entry . filename_len ) ;
2008-01-28 16:52:08 +08:00
buffer + = entry . filename_len ;
2006-01-10 14:46:17 +08:00
PHAR_GET_32 ( buffer , entry . uncompressed_filesize ) ;
PHAR_GET_32 ( buffer , entry . timestamp ) ;
2008-01-28 22:39:17 +08:00
if ( offset = = halt_offset + ( int ) manifest_len + 4 ) {
2006-03-09 04:07:25 +08:00
mydata - > min_timestamp = entry . timestamp ;
mydata - > max_timestamp = entry . timestamp ;
2006-03-03 06:44:39 +08:00
} else {
2006-03-09 04:07:25 +08:00
if ( mydata - > min_timestamp > entry . timestamp ) {
mydata - > min_timestamp = entry . timestamp ;
} else if ( mydata - > max_timestamp < entry . timestamp ) {
mydata - > max_timestamp = entry . timestamp ;
2006-03-03 06:44:39 +08:00
}
}
2006-01-10 14:46:17 +08:00
PHAR_GET_32 ( buffer , entry . compressed_filesize ) ;
PHAR_GET_32 ( buffer , entry . crc32 ) ;
2007-01-14 00:17:04 +08:00
PHAR_GET_32 ( buffer , entry . flags ) ;
2008-01-28 16:52:08 +08:00
if ( entry . is_dir ) {
entry . filename_len - - ;
entry . flags | = PHAR_ENT_PERM_DEF_DIR ;
}
2008-01-01 06:42:40 +08:00
if ( phar_parse_metadata ( & buffer , & entry . metadata , 0 TSRMLS_CC ) = = FAILURE ) {
2007-02-07 07:19:10 +08:00
efree ( entry . filename ) ;
MAPPHAR_FAIL ( " unable to read file metadata in .phar file \" %s \" " ) ;
2007-01-21 14:30:55 +08:00
}
2008-01-28 16:52:08 +08:00
entry . offset = entry . offset_abs = offset ;
2006-01-10 14:46:17 +08:00
offset + = entry . compressed_filesize ;
2006-01-13 05:16:29 +08:00
switch ( entry . flags & PHAR_ENT_COMPRESSION_MASK ) {
case PHAR_ENT_COMPRESSED_GZ :
2007-12-19 01:01:24 +08:00
if ( ! phar_has_zlib ) {
2007-11-25 13:04:40 +08:00
if ( entry . metadata ) {
zval_ptr_dtor ( & entry . metadata ) ;
}
efree ( entry . filename ) ;
MAPPHAR_FAIL ( " zlib extension is required for gz compressed .phar file \" %s \" " ) ;
}
2006-01-13 05:16:29 +08:00
break ;
case PHAR_ENT_COMPRESSED_BZ2 :
2007-12-19 01:01:24 +08:00
if ( ! phar_has_bz2 ) {
2007-11-25 13:04:40 +08:00
if ( entry . metadata ) {
zval_ptr_dtor ( & entry . metadata ) ;
}
efree ( entry . filename ) ;
2007-11-24 12:06:44 +08:00
MAPPHAR_FAIL ( " bz2 extension is required for bzip2 compressed .phar file \" %s \" " ) ;
}
2006-01-13 05:16:29 +08:00
break ;
default :
if ( entry . uncompressed_filesize ! = entry . compressed_filesize ) {
2007-02-03 12:04:18 +08:00
if ( entry . metadata ) {
zval_ptr_dtor ( & entry . metadata ) ;
}
efree ( entry . filename ) ;
2006-01-13 05:16:29 +08:00
MAPPHAR_FAIL ( " internal corruption of phar \" %s \" (compressed and uncompressed size does not match for uncompressed entry) " ) ;
}
break ;
2006-01-06 06:24:41 +08:00
}
2007-01-14 00:17:04 +08:00
manifest_flags | = ( entry . flags & PHAR_ENT_COMPRESSION_MASK ) ;
2007-08-30 10:30:16 +08:00
/* if signature matched, no need to check CRC32 for each file */
entry . is_crc_checked = ( manifest_flags & PHAR_HDR_SIGNATURE ? 1 : 0 ) ;
2006-03-09 04:07:25 +08:00
zend_hash_add ( & mydata - > manifest , entry . filename , entry . filename_len , ( void * ) & entry , sizeof ( phar_entry_info ) , NULL ) ;
}
2007-01-14 00:17:04 +08:00
snprintf ( mydata - > version , sizeof ( mydata - > version ) , " %u.%u.%u " , manifest_ver > > 12 , ( manifest_ver > > 8 ) & 0xF , ( manifest_ver > > 4 ) & 0xF ) ;
2006-03-09 04:07:25 +08:00
mydata - > internal_file_start = halt_offset + manifest_len + 4 ;
2007-01-03 02:15:17 +08:00
mydata - > halt_offset = halt_offset ;
2007-01-14 00:17:04 +08:00
mydata - > flags = manifest_flags ;
2006-03-09 04:07:25 +08:00
mydata - > fp = fp ;
2007-01-04 13:32:45 +08:00
mydata - > fname = estrndup ( fname , fname_len ) ;
2007-11-20 07:10:05 +08:00
# ifdef PHP_WIN32
phar_unixify_path_separators ( mydata - > fname , fname_len ) ;
# endif
2007-01-04 13:32:45 +08:00
mydata - > fname_len = fname_len ;
2008-01-14 14:19:43 +08:00
mydata - > alias = alias ? estrndup ( alias , alias_len ) : estrndup ( mydata - > fname , fname_len ) ;
2007-01-04 13:32:45 +08:00
mydata - > alias_len = alias ? alias_len : fname_len ;
2007-01-09 08:27:13 +08:00
mydata - > sig_flags = sig_flags ;
mydata - > sig_len = sig_len ;
mydata - > signature = signature ;
2007-05-17 07:16:51 +08:00
phar_request_initialize ( TSRMLS_C ) ;
2007-11-20 07:10:05 +08:00
zend_hash_add ( & ( PHAR_GLOBALS - > phar_fname_map ) , mydata - > fname , fname_len , ( void * ) & mydata , sizeof ( phar_archive_data * ) , NULL ) ;
2007-01-04 13:32:45 +08:00
if ( register_alias ) {
2008-02-11 14:46:44 +08:00
mydata - > is_temporary_alias = temp_alias ;
2007-01-04 13:32:45 +08:00
zend_hash_add ( & ( PHAR_GLOBALS - > phar_alias_map ) , alias , alias_len , ( void * ) & mydata , sizeof ( phar_archive_data * ) , NULL ) ;
2007-01-05 12:45:52 +08:00
} else {
2008-02-11 14:46:44 +08:00
mydata - > is_temporary_alias = 1 ;
2006-01-12 05:19:46 +08:00
}
2005-12-05 04:35:38 +08:00
efree ( savebuf ) ;
2006-01-04 10:26:15 +08:00
2007-01-04 13:32:45 +08:00
if ( pphar ) {
2006-03-09 04:07:25 +08:00
* pphar = mydata ;
2006-02-28 09:36:30 +08:00
}
2006-01-04 10:26:15 +08:00
return SUCCESS ;
}
/* }}} */
2008-01-01 06:42:40 +08:00
/**
* Create or open a phar for writing
*/
2008-02-28 05:34:26 +08:00
int phar_open_or_create_filename ( char * fname , int fname_len , char * alias , int alias_len , char * objname , int options , phar_archive_data * * pphar , char * * error TSRMLS_DC ) /* { { { */
2008-01-01 06:42:40 +08:00
{
2008-03-22 08:11:43 +08:00
const char * ext_str ;
2008-02-28 05:34:26 +08:00
int ext_len , is_data = 0 , zip = 0 , tar = 0 ;
2008-01-01 06:42:40 +08:00
2007-01-29 14:02:19 +08:00
if ( error ) {
* error = NULL ;
}
2007-01-14 08:32:38 +08:00
2008-02-28 05:34:26 +08:00
if ( phar_detect_phar_fname_ext ( fname , 1 , & ext_str , & ext_len ) = = SUCCESS ) {
if ( ext_len > = sizeof ( " .zip " ) - 1 & & ! memcmp ( ( void * ) ext_str , ( void * ) " .zip " , sizeof ( " .zip " ) - 1 ) ) {
zip = 1 ;
}
2008-03-03 16:41:15 +08:00
if ( ( ext_len > = sizeof ( " .tar " ) - 1 & & ! memcmp ( ( void * ) ext_str , ( void * ) " .tar " , sizeof ( " .tar " ) - 1 ) ) | | ( ext_len > = sizeof ( " .tgz " ) - 1 & & ! memcmp ( ( void * ) ext_str , ( void * ) " .tgz " , sizeof ( " .tgz " ) - 1 ) ) ) {
2008-02-28 05:34:26 +08:00
tar = 1 ;
}
if ( tar | | zip ) {
if ( objname & & strncmp ( objname , " PharData " , 8 ) ! = 0 ) {
2008-03-03 16:41:15 +08:00
/* Nested exception causes memleak here */
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Cannot open '%s' as a Phar object. Use PharData::__construct() for a standard %s archive " , fname , tar ? " tar " : " zip " ) ;
2008-02-28 05:34:26 +08:00
return FAILURE ;
}
is_data = 1 ;
} else {
if ( objname & & strncmp ( objname , " PharData " , 8 ) = = 0 ) {
2008-03-03 16:41:15 +08:00
/* Nested exception causes memleak here */
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Cannot open '%s' as a PharData object. Use Phar::__construct() for archives named other than .zip or .tar " , fname ) ;
2008-02-28 05:34:26 +08:00
return FAILURE ;
}
}
} else {
2008-03-03 16:41:15 +08:00
/* Nested exception causes memleak here */
php_error_docref ( NULL TSRMLS_CC , E_WARNING , " Cannot open '%s' as a %s object, file extension (or combination) not recognised " , fname , objname ) ;
2008-02-28 05:34:26 +08:00
return FAILURE ;
}
if ( phar_open_loaded ( fname , fname_len , alias , alias_len , is_data , options , pphar , 0 TSRMLS_CC ) = = SUCCESS ) {
if ( pphar & & ( ! PHAR_G ( readonly ) | | is_data ) ) {
2007-01-28 18:32:45 +08:00
( * pphar ) - > is_writeable = 1 ;
}
2007-01-11 09:04:47 +08:00
return SUCCESS ;
2007-01-03 02:15:17 +08:00
}
2007-01-03 03:59:38 +08:00
2008-02-28 05:34:26 +08:00
if ( ( ext_len > = sizeof ( " .phar.zip " ) - 1 & & ! memcmp ( ( void * ) ext_str , ( void * ) " .phar.zip " , sizeof ( " .phar.zip " ) - 1 ) ) | | zip ) {
// assume zip-based phar
return phar_open_or_create_zip ( fname , fname_len , alias , alias_len , is_data , options , pphar , error TSRMLS_CC ) ;
2008-01-01 06:42:40 +08:00
}
2008-02-28 05:34:26 +08:00
if ( ( ext_len > = sizeof ( " .phar.tar " ) - 1 & & ! memcmp ( ( void * ) ext_str , ( void * ) " .phar.tar " , sizeof ( " .phar.tar " ) - 1 ) ) | | tar ) {
// assume tar-based phar
return phar_open_or_create_tar ( fname , fname_len , alias , alias_len , is_data , options , pphar , error TSRMLS_CC ) ;
}
2008-03-03 16:41:15 +08:00
return phar_create_or_parse_filename ( fname , fname_len , alias , alias_len , is_data , options , pphar , error TSRMLS_CC ) ;
2008-02-28 05:34:26 +08:00
2008-01-01 06:42:40 +08:00
}
2008-03-03 16:41:15 +08:00
int phar_create_or_parse_filename ( char * fname , int fname_len , char * alias , int alias_len , int is_data , int options , phar_archive_data * * pphar , char * * error TSRMLS_DC ) /* { { { */
2008-01-01 06:42:40 +08:00
{
phar_archive_data * mydata ;
int register_alias ;
php_stream * fp ;
2008-01-28 16:52:08 +08:00
char * actual = NULL ;
2008-01-01 06:42:40 +08:00
if ( ! pphar ) {
pphar = & mydata ;
}
2007-01-03 03:59:38 +08:00
# if PHP_MAJOR_VERSION < 6
if ( PG ( safe_mode ) & & ( ! php_checkuid ( fname , NULL , CHECKUID_ALLOW_ONLY_FILE ) ) ) {
return FAILURE ;
}
# endif
if ( php_check_open_basedir ( fname TSRMLS_CC ) ) {
return FAILURE ;
}
2008-01-06 06:46:54 +08:00
/* first open readonly so it won't be created if not present */
2008-01-28 16:52:08 +08:00
fp = php_stream_open_wrapper ( fname , " rb " , IGNORE_URL | STREAM_MUST_SEEK | 0 , & actual ) ;
if ( actual ) {
fname = actual ;
fname_len = strlen ( actual ) ;
}
2007-01-03 03:59:38 +08:00
2008-01-06 06:46:54 +08:00
if ( fp ) {
if ( phar_open_fp ( fp , fname , fname_len , alias , alias_len , options , pphar , error TSRMLS_CC ) = = SUCCESS ) {
2008-03-03 16:41:15 +08:00
if ( is_data | | ! PHAR_G ( readonly ) ) {
2008-01-06 06:46:54 +08:00
( * pphar ) - > is_writeable = 1 ;
}
2008-01-28 16:52:08 +08:00
if ( actual ) {
efree ( actual ) ;
}
2008-01-06 06:46:54 +08:00
return SUCCESS ;
} else {
/* file exists, but is either corrupt or not a phar archive */
2008-01-28 16:52:08 +08:00
if ( actual ) {
efree ( actual ) ;
}
2008-01-06 06:46:54 +08:00
return FAILURE ;
2007-01-28 18:32:45 +08:00
}
2008-01-28 16:52:08 +08:00
}
if ( actual ) {
efree ( actual ) ;
2007-01-08 00:01:35 +08:00
}
2008-03-03 16:41:15 +08:00
if ( PHAR_G ( readonly ) & & ! is_data ) {
2007-01-08 00:01:35 +08:00
if ( options & REPORT_ERRORS ) {
2007-01-29 15:59:19 +08:00
if ( error ) {
2007-01-29 14:02:19 +08:00
spprintf ( error , 0 , " creating archive \" %s \" disabled by INI setting " , fname ) ;
}
2007-01-08 00:01:35 +08:00
}
return FAILURE ;
2007-01-03 03:59:38 +08:00
}
2007-01-10 02:54:37 +08:00
2007-01-03 02:15:17 +08:00
/* set up our manifest */
2007-01-10 02:54:37 +08:00
mydata = ecalloc ( sizeof ( phar_archive_data ) , 1 ) ;
2008-01-08 15:08:46 +08:00
2008-02-11 14:53:56 +08:00
mydata - > fname = expand_filepath ( fname , NULL TSRMLS_CC ) ;
2008-02-11 15:33:20 +08:00
fname_len = strlen ( mydata - > fname ) ;
2007-11-15 13:21:11 +08:00
# ifdef PHP_WIN32
2008-02-11 15:33:20 +08:00
phar_unixify_path_separators ( mydata - > fname , fname_len ) ;
2007-11-15 13:21:11 +08:00
# endif
2008-01-08 15:08:46 +08:00
if ( pphar ) {
* pphar = mydata ;
}
zend_hash_init ( & mydata - > manifest , sizeof ( phar_entry_info ) ,
2008-01-09 11:47:22 +08:00
zend_get_hash_value , destroy_phar_manifest_entry , 0 ) ;
2008-02-25 12:23:36 +08:00
zend_hash_init ( & mydata - > mounted_dirs , sizeof ( char * ) ,
zend_get_hash_value , NULL , 0 ) ;
2007-01-03 02:15:17 +08:00
mydata - > fname_len = fname_len ;
2008-03-03 16:41:15 +08:00
if ( is_data ) {
alias = NULL ;
alias_len = 0 ;
} else {
mydata - > alias = alias ? estrndup ( alias , alias_len ) : estrndup ( mydata - > fname , fname_len ) ;
mydata - > alias_len = alias ? alias_len : fname_len ;
}
2008-03-23 01:09:24 +08:00
snprintf ( mydata - > version , sizeof ( mydata - > version ) , " %s " , PHP_PHAR_API_VERSION ) ;
2008-02-11 14:46:44 +08:00
mydata - > is_temporary_alias = alias ? 0 : 1 ;
2007-01-03 02:15:17 +08:00
mydata - > internal_file_start = - 1 ;
2008-02-11 14:53:56 +08:00
mydata - > fp = NULL ;
2007-01-14 08:32:38 +08:00
mydata - > is_writeable = 1 ;
2007-01-29 05:26:54 +08:00
mydata - > is_brandnew = 1 ;
2007-01-03 02:15:17 +08:00
if ( ! alias_len | | ! alias ) {
/* if we neither have an explicit nor an implicit alias, we use the filename */
alias = NULL ;
alias_len = 0 ;
register_alias = 0 ;
} else {
register_alias = 1 ;
}
2007-05-17 07:16:51 +08:00
phar_request_initialize ( TSRMLS_C ) ;
2007-11-20 07:10:05 +08:00
zend_hash_add ( & ( PHAR_GLOBALS - > phar_fname_map ) , mydata - > fname , fname_len , ( void * ) & mydata , sizeof ( phar_archive_data * ) , NULL ) ;
2007-01-03 02:15:17 +08:00
if ( register_alias ) {
zend_hash_add ( & ( PHAR_GLOBALS - > phar_alias_map ) , alias , alias_len , ( void * ) & mydata , sizeof ( phar_archive_data * ) , NULL ) ;
}
return SUCCESS ;
}
2007-01-24 07:31:14 +08:00
/* }}}*/
2007-01-03 02:15:17 +08:00
2007-01-02 08:04:30 +08:00
/**
2007-01-11 09:04:47 +08:00
* Return an already opened filename .
*
* Or scan a phar file for the required __HALT_COMPILER ( ) ; ? > token and verify
2007-01-02 08:04:30 +08:00
* that the manifest is proper , then pass it to phar_open_file ( ) . SUCCESS
* or FAILURE is returned and pphar is set to a pointer to the phar ' s manifest
*/
2007-01-29 14:02:19 +08:00
int phar_open_filename ( char * fname , int fname_len , char * alias , int alias_len , int options , phar_archive_data * * pphar , char * * error TSRMLS_DC ) /* { { { */
2006-01-04 10:26:15 +08:00
{
php_stream * fp ;
2008-01-28 16:52:08 +08:00
char * actual ;
2008-03-03 16:41:15 +08:00
int ret , is_data = 0 ;
2007-01-29 14:02:19 +08:00
if ( error ) {
* error = NULL ;
}
2008-03-03 16:41:15 +08:00
if ( ! strstr ( fname , " .phar " ) ) {
is_data = 1 ;
}
if ( phar_open_loaded ( fname , fname_len , alias , alias_len , is_data , options , pphar , error TSRMLS_CC ) = = SUCCESS ) {
2007-01-11 09:04:47 +08:00
return SUCCESS ;
2008-01-06 13:16:20 +08:00
} else if ( error & & * error ) {
2007-01-29 14:02:19 +08:00
return FAILURE ;
2006-02-28 09:36:30 +08:00
}
2006-01-04 10:26:15 +08:00
2006-03-09 04:31:23 +08:00
# if PHP_MAJOR_VERSION < 6
2006-01-05 19:32:05 +08:00
if ( PG ( safe_mode ) & & ( ! php_checkuid ( fname , NULL , CHECKUID_ALLOW_ONLY_FILE ) ) ) {
return FAILURE ;
}
2006-03-09 04:31:23 +08:00
# endif
2006-01-05 19:32:05 +08:00
if ( php_check_open_basedir ( fname TSRMLS_CC ) ) {
return FAILURE ;
}
2008-01-28 16:52:08 +08:00
fp = php_stream_open_wrapper ( fname , " rb " , IGNORE_URL | STREAM_MUST_SEEK , & actual ) ;
2006-01-04 10:26:15 +08:00
if ( ! fp ) {
2007-01-08 00:01:35 +08:00
if ( options & REPORT_ERRORS ) {
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " unable to open phar for reading \" %s \" " , fname ) ;
}
2007-01-08 00:01:35 +08:00
}
2008-01-28 16:52:08 +08:00
if ( actual ) {
efree ( actual ) ;
}
2006-01-04 10:26:15 +08:00
return FAILURE ;
}
2008-01-28 16:52:08 +08:00
if ( actual ) {
fname = actual ;
fname_len = strlen ( actual ) ;
}
ret = phar_open_fp ( fp , fname , fname_len , alias , alias_len , options , pphar , error TSRMLS_CC ) ;
if ( actual ) {
efree ( actual ) ;
}
return ret ;
2007-01-11 09:04:47 +08:00
}
/* }}}*/
/**
* Scan an open fp for the required __HALT_COMPILER ( ) ; ? > token and verify
* that the manifest is proper , then pass it to phar_open_file ( ) . SUCCESS
* or FAILURE is returned and pphar is set to a pointer to the phar ' s manifest
*/
2007-01-29 14:02:19 +08:00
static int phar_open_fp ( php_stream * fp , char * fname , int fname_len , char * alias , int alias_len , int options , phar_archive_data * * pphar , char * * error TSRMLS_DC ) /* { { { */
2007-01-11 09:04:47 +08:00
{
const char token [ ] = " __HALT_COMPILER(); " ;
2008-01-01 06:42:40 +08:00
const char zip_magic [ ] = " PK \x03 \x04 " ;
2008-01-09 15:09:04 +08:00
const char gz_magic [ ] = " \x1f \x8b \x08 " ;
const char bz_magic [ ] = " BZh " ;
2008-01-01 06:42:40 +08:00
char * pos , buffer [ 1024 + sizeof ( token ) ] , test = ' \0 ' ;
2007-01-11 09:04:47 +08:00
const long readsize = sizeof ( buffer ) - sizeof ( token ) ;
const long tokenlen = sizeof ( token ) - 1 ;
long halt_offset ;
2007-02-07 06:12:21 +08:00
size_t got ;
2008-01-09 15:09:04 +08:00
php_uint32 compression = PHAR_FILE_COMPRESSED_NONE ;
2006-01-04 10:26:15 +08:00
2007-01-29 14:02:19 +08:00
if ( error ) {
* error = NULL ;
}
2007-01-11 09:04:47 +08:00
if ( - 1 = = php_stream_rewind ( fp ) ) {
2006-01-05 08:39:31 +08:00
MAPPHAR_ALLOC_FAIL ( " cannot rewind phar \" %s \" " )
2006-01-04 10:26:15 +08:00
}
buffer [ sizeof ( buffer ) - 1 ] = ' \0 ' ;
memset ( buffer , 32 , sizeof ( token ) ) ;
halt_offset = 0 ;
2008-01-09 15:09:04 +08:00
/* Maybe it's better to compile the file instead of just searching, */
/* but we only want the offset. So we want a .re scanner to find it. */
2006-01-04 10:26:15 +08:00
while ( ! php_stream_eof ( fp ) ) {
2007-12-14 13:39:20 +08:00
if ( ( got = php_stream_read ( fp , buffer + tokenlen , readsize ) ) < ( size_t ) tokenlen ) {
2007-05-27 23:47:52 +08:00
MAPPHAR_ALLOC_FAIL ( " internal corruption of phar \" %s \" (truncated entry) " )
2006-01-04 10:26:15 +08:00
}
2008-01-01 06:42:40 +08:00
if ( ! test ) {
test = ' \1 ' ;
pos = buffer + tokenlen ;
2008-01-09 15:09:04 +08:00
if ( ! memcmp ( pos , gz_magic , 3 ) ) {
char err = 0 ;
php_stream_filter * filter ;
php_stream * temp ;
/* to properly decompress, we have to tell zlib to look for a zlib or gzip header */
zval filterparams ;
2008-01-11 05:21:38 +08:00
if ( ! phar_has_zlib ) {
MAPPHAR_ALLOC_FAIL ( " unable to decompress gzipped phar archive \" %s \" to temporary file, enable zlib extension in php.ini " )
}
2008-01-09 15:09:04 +08:00
array_init ( & filterparams ) ;
2008-02-08 13:41:59 +08:00
2008-01-13 00:15:17 +08:00
/* this is defined in zlib's zconf.h */
# ifndef MAX_WBITS
# define MAX_WBITS 15
# endif
2008-01-09 15:09:04 +08:00
add_assoc_long ( & filterparams , " window " , MAX_WBITS + 32 ) ;
/* entire file is gzip-compressed, uncompress to temporary file */
if ( ! ( temp = php_stream_fopen_tmpfile ( ) ) ) {
MAPPHAR_ALLOC_FAIL ( " unable to create temporary file for decompression of gzipped phar archive \" %s \" " )
}
php_stream_rewind ( fp ) ;
filter = php_stream_filter_create ( " zlib.inflate " , & filterparams , php_stream_is_persistent ( fp ) TSRMLS_CC ) ;
if ( ! filter ) {
err = 1 ;
add_assoc_long ( & filterparams , " window " , MAX_WBITS ) ;
filter = php_stream_filter_create ( " zlib.inflate " , & filterparams , php_stream_is_persistent ( fp ) TSRMLS_CC ) ;
2008-02-08 13:41:59 +08:00
zval_dtor ( & filterparams ) ;
2008-01-11 05:21:38 +08:00
if ( ! filter ) {
php_stream_close ( temp ) ;
MAPPHAR_ALLOC_FAIL ( " unable to decompress gzipped phar archive \" %s \" , ext/zlib is buggy in PHP versions older than 5.2.6 " )
}
2008-02-08 13:41:59 +08:00
} else {
zval_dtor ( & filterparams ) ;
2008-01-09 15:09:04 +08:00
}
php_stream_filter_append ( & temp - > writefilters , filter ) ;
if ( 0 = = php_stream_copy_to_stream ( fp , temp , PHP_STREAM_COPY_ALL ) ) {
if ( err ) {
2008-01-11 05:21:38 +08:00
php_stream_close ( temp ) ;
2008-01-09 15:09:04 +08:00
MAPPHAR_ALLOC_FAIL ( " unable to decompress gzipped phar archive \" %s \" , ext/zlib is buggy in PHP versions older than 5.2.6 " )
}
php_stream_close ( temp ) ;
MAPPHAR_ALLOC_FAIL ( " unable to decompress gzipped phar archive \" %s \" to temporary file " )
}
php_stream_filter_flush ( filter , 1 ) ;
php_stream_filter_remove ( filter , 1 TSRMLS_CC ) ;
php_stream_close ( fp ) ;
fp = temp ;
php_stream_rewind ( fp ) ;
compression = PHAR_FILE_COMPRESSED_GZ ;
/* now, start over */
test = ' \0 ' ;
continue ;
} else if ( ! memcmp ( pos , bz_magic , 3 ) ) {
php_stream_filter * filter ;
php_stream * temp ;
2008-01-11 05:21:38 +08:00
if ( ! phar_has_bz2 ) {
2008-01-17 11:48:29 +08:00
MAPPHAR_ALLOC_FAIL ( " unable to decompress bzipped phar archive \" %s \" to temporary file, enable bz2 extension in php.ini " )
2008-01-11 05:21:38 +08:00
}
2008-01-09 15:09:04 +08:00
/* entire file is bzip-compressed, uncompress to temporary file */
if ( ! ( temp = php_stream_fopen_tmpfile ( ) ) ) {
MAPPHAR_ALLOC_FAIL ( " unable to create temporary file for decompression of bzipped phar archive \" %s \" " )
}
php_stream_rewind ( fp ) ;
filter = php_stream_filter_create ( " bzip2.decompress " , NULL , php_stream_is_persistent ( fp ) TSRMLS_CC ) ;
2008-01-11 05:21:38 +08:00
if ( ! filter ) {
php_stream_close ( temp ) ;
MAPPHAR_ALLOC_FAIL ( " unable to decompress bzipped phar archive \" %s \" , filter creation failed " )
}
2008-01-09 15:09:04 +08:00
php_stream_filter_append ( & temp - > writefilters , filter ) ;
if ( 0 = = php_stream_copy_to_stream ( fp , temp , PHP_STREAM_COPY_ALL ) ) {
php_stream_close ( temp ) ;
2008-01-11 05:21:38 +08:00
MAPPHAR_ALLOC_FAIL ( " unable to decompress bzipped phar archive \" %s \" to temporary file " )
2008-01-09 15:09:04 +08:00
}
php_stream_filter_flush ( filter , 1 ) ;
php_stream_filter_remove ( filter , 1 TSRMLS_CC ) ;
php_stream_close ( fp ) ;
fp = temp ;
php_stream_rewind ( fp ) ;
compression = PHAR_FILE_COMPRESSED_BZ2 ;
/* now, start over */
test = ' \0 ' ;
continue ;
}
2008-01-01 06:42:40 +08:00
if ( ! memcmp ( pos , zip_magic , 4 ) ) {
2008-01-28 16:52:08 +08:00
php_stream_seek ( fp , 0 , SEEK_END ) ;
return phar_open_zipfile ( fp , fname , fname_len , alias , alias_len , pphar , error TSRMLS_CC ) ;
2008-01-01 06:42:40 +08:00
}
2008-01-03 12:45:00 +08:00
if ( got > 512 ) {
if ( phar_is_tar ( pos ) ) {
2008-01-09 15:09:04 +08:00
php_stream_rewind ( fp ) ;
return phar_open_tarfile ( fp , fname , fname_len , alias , alias_len , options , pphar , compression , error TSRMLS_CC ) ;
2008-01-03 12:45:00 +08:00
}
}
2008-01-01 06:42:40 +08:00
}
2006-01-04 10:26:15 +08:00
if ( ( pos = strstr ( buffer , token ) ) ! = NULL ) {
2006-01-05 08:39:31 +08:00
halt_offset + = ( pos - buffer ) ; /* no -tokenlen+tokenlen here */
2008-01-09 15:09:04 +08:00
return phar_open_file ( fp , fname , fname_len , alias , alias_len , halt_offset , pphar , compression , error TSRMLS_CC ) ;
2006-01-04 10:26:15 +08:00
}
2007-02-07 06:12:21 +08:00
halt_offset + = got ;
memmove ( buffer , buffer + tokenlen , got + 1 ) ;
2006-01-04 10:26:15 +08:00
}
MAPPHAR_ALLOC_FAIL ( " internal corruption of phar \" %s \" (__HALT_COMPILER(); not found) " )
}
/* }}} */
2008-03-22 08:11:43 +08:00
int phar_detect_phar_fname_ext ( const char * filename , int check_length , const char * * ext_str , int * ext_len ) /* { { { */
2007-05-16 04:21:19 +08:00
{
2008-03-22 08:15:45 +08:00
int i ;
2007-05-16 04:21:19 +08:00
char end ;
2008-03-22 08:15:45 +08:00
const char * pos ;
# define EXTINF(check, ext) { check, ext, sizeof(ext)-1 }
const struct {
int check ;
const char * const ext ;
int len ;
} ext_info [ ] = {
/* longer exts must be specified later */
EXTINF ( 1 , " .php " ) ,
EXTINF ( 0 , " .phar " ) ,
EXTINF ( 0 , " .tgz " ) ,
EXTINF ( 0 , " .zip " ) ,
EXTINF ( 0 , " .tar " ) ,
EXTINF ( 0 , " .tar.gz " ) ,
EXTINF ( 0 , " .tar.bz2 " ) ,
EXTINF ( 0 , " .phar.gz " ) ,
EXTINF ( 0 , " .phar.bz2 " ) ,
EXTINF ( 0 , " .phar.php " ) ,
EXTINF ( 0 , " .phar.tar " ) ,
EXTINF ( 0 , " .phar.zip " ) ,
EXTINF ( 0 , " .phar.tar.gz " ) ,
EXTINF ( 0 , " .phar.tar.bz2 " ) ,
EXTINF ( 0 , " .phar.tar.php " ) ,
EXTINF ( 0 , " .phar.zip.php " ) } ;
* ext_str = NULL ;
for ( i = 0 ; i < sizeof ( ext_info ) / sizeof ( ext_info [ 0 ] ) ; + + i ) {
pos = strstr ( filename , ext_info [ i ] . ext ) ;
if ( pos & & ( ! ext_info [ i ] . check | | pos [ ext_info [ i ] . len ] ! = ' \0 ' ) & & ( ! * ext_str | | pos < = * ext_str ) ) {
* ext_str = pos ;
* ext_len = ext_info [ i ] . len ;
}
}
if ( ! * ext_str ) {
2007-11-20 13:34:35 +08:00
/* We have an alias with no extension, so locate the first / and fail */
* ext_str = strstr ( filename , " / " ) ;
2007-11-22 13:47:28 +08:00
if ( * ext_str ) {
* ext_len = - 1 ;
}
2007-05-16 04:21:19 +08:00
return FAILURE ;
}
if ( check_length & & ( * ext_str ) [ * ext_len ] ! = ' \0 ' ) {
return FAILURE ;
}
end = ( * ext_str ) [ * ext_len ] ;
if ( end ! = ' \0 ' & & end ! = ' / ' & & end ! = ' \\ ' ) {
return FAILURE ;
}
return SUCCESS ;
}
/* }}} */
2007-12-21 07:12:40 +08:00
static int php_check_dots ( const char * element , int n )
{
2007-12-22 15:46:53 +08:00
for ( n - - ; n > = 0 ; - - n ) {
if ( element [ n ] ! = ' . ' ) {
return 1 ;
}
}
return 0 ;
2007-12-21 07:12:40 +08:00
}
# define IS_DIRECTORY_UP(element, len) \
( len > = 2 & & ! php_check_dots ( element , len ) )
# define IS_DIRECTORY_CURRENT(element, len) \
( len = = 1 & & element [ 0 ] = = ' . ' )
# define IS_BACKSLASH(c) ((c) == ' / ')
2008-01-14 10:47:55 +08:00
# ifdef COMPILE_DL_PHAR
2007-12-25 05:40:54 +08:00
/* stupid-ass non-extern declaration in tsrm_strtok.h breaks dumbass MS compiler */
static inline int in_character_class ( char ch , const char * delim )
{
while ( * delim ) {
if ( * delim = = ch ) {
return 1 ;
}
2008-03-23 06:11:49 +08:00
+ + delim ;
2007-12-25 05:40:54 +08:00
}
return 0 ;
}
char * tsrm_strtok_r ( char * s , const char * delim , char * * last )
{
char * token ;
if ( s = = NULL ) {
s = * last ;
}
while ( * s & & in_character_class ( * s , delim ) ) {
2008-03-23 06:11:49 +08:00
+ + s ;
2007-12-25 05:40:54 +08:00
}
if ( ! * s ) {
return NULL ;
}
token = s ;
while ( * s & & ! in_character_class ( * s , delim ) ) {
2008-03-23 06:11:49 +08:00
+ + s ;
2007-12-25 05:40:54 +08:00
}
if ( ! * s ) {
* last = s ;
} else {
* s = ' \0 ' ;
* last = s + 1 ;
}
return token ;
}
# endif
2007-12-21 07:12:40 +08:00
/**
* Remove . . and . references within a phar filename
*/
2008-01-11 15:30:03 +08:00
char * phar_fix_filepath ( char * path , int * new_len , int use_cwd TSRMLS_DC ) /* { { { */
2007-12-21 07:12:40 +08:00
{
char * ptr , * free_path , * new_phar ;
char * tok ;
int ptr_length , new_phar_len = 1 , path_length = * new_len ;
2008-02-13 23:00:31 +08:00
if ( PHAR_G ( cwd_len ) & & use_cwd & & path_length > 2 & & path [ 0 ] = = ' . ' & & path [ 1 ] = = ' / ' ) {
2008-01-10 23:13:00 +08:00
free_path = path = estrndup ( path , path_length ) ;
new_phar_len = PHAR_G ( cwd_len ) ;
new_phar = estrndup ( PHAR_G ( cwd ) , new_phar_len ) ;
} else {
free_path = path ;
new_phar = estrndup ( " / \0 " , 2 ) ;
}
2007-12-21 07:12:40 +08:00
tok = NULL ;
ptr = tsrm_strtok_r ( path , " / " , & tok ) ;
while ( ptr ) {
ptr_length = strlen ( ptr ) ;
if ( IS_DIRECTORY_UP ( ptr , ptr_length ) ) {
char save ;
save = ' / ' ;
# define PREVIOUS new_phar[new_phar_len - 1]
while ( new_phar_len > 1 & &
! IS_BACKSLASH ( PREVIOUS ) ) {
save = PREVIOUS ;
PREVIOUS = ' \0 ' ;
new_phar_len - - ;
}
if ( new_phar [ 0 ] ! = ' / ' ) {
new_phar [ new_phar_len + + ] = save ;
new_phar [ new_phar_len ] = ' \0 ' ;
} else if ( new_phar_len > 1 ) {
PREVIOUS = ' \0 ' ;
new_phar_len - - ;
}
} else if ( ! IS_DIRECTORY_CURRENT ( ptr , ptr_length ) ) {
if ( new_phar_len > 1 ) {
new_phar = ( char * ) erealloc ( new_phar , new_phar_len + ptr_length + 1 + 1 ) ;
new_phar [ new_phar_len + + ] = ' / ' ;
memcpy ( & new_phar [ new_phar_len ] , ptr , ptr_length + 1 ) ;
} else {
new_phar = ( char * ) erealloc ( new_phar , new_phar_len + ptr_length + 1 ) ;
memcpy ( & new_phar [ new_phar_len ] , ptr , ptr_length + 1 ) ;
}
new_phar_len + = ptr_length ;
}
ptr = tsrm_strtok_r ( NULL , " / " , & tok ) ;
}
2007-12-22 15:46:53 +08:00
if ( path [ path_length - 1 ] = = ' / ' & & new_phar_len > 1 ) {
2007-12-21 07:12:40 +08:00
new_phar = ( char * ) erealloc ( new_phar , new_phar_len + 2 ) ;
new_phar [ new_phar_len + + ] = ' / ' ;
new_phar [ new_phar_len ] = 0 ;
}
2008-02-01 19:25:11 +08:00
efree ( free_path ) ;
2007-12-21 07:12:40 +08:00
if ( new_phar_len = = 0 ) {
new_phar = ( char * ) erealloc ( new_phar , new_phar_len + 1 + 1 ) ;
new_phar [ new_phar_len ] = ' / ' ;
2008-03-23 06:11:49 +08:00
new_phar [ + + new_phar_len ] = ' \0 ' ;
2007-12-21 07:12:40 +08:00
}
* new_len = new_phar_len ;
return new_phar ;
}
/* }}} */
2007-01-02 08:04:30 +08:00
/**
* Process a phar stream name , ensuring we can handle any of :
*
* - whatever . phar
* - whatever . phar . gz
* - whatever . phar . bz2
2007-05-16 04:21:19 +08:00
* - whatever . phar . php
*
* Optionally the name might start with ' phar : //'
2007-01-02 08:04:30 +08:00
*
* This is used by phar_open_url ( )
*/
2007-01-21 23:25:50 +08:00
int phar_split_fname ( char * filename , int filename_len , char * * arch , int * arch_len , char * * entry , int * entry_len TSRMLS_DC ) /* { { { */
2006-01-04 10:26:15 +08:00
{
2008-03-22 08:11:43 +08:00
const char * ext_str ;
2006-02-28 09:36:30 +08:00
int ext_len ;
2006-01-04 10:26:15 +08:00
if ( ! strncasecmp ( filename , " phar:// " , 7 ) ) {
filename + = 7 ;
2006-02-28 09:36:30 +08:00
filename_len - = 7 ;
}
2007-11-20 13:34:35 +08:00
ext_len = 0 ;
2007-05-16 04:21:19 +08:00
if ( phar_detect_phar_fname_ext ( filename , 0 , & ext_str , & ext_len ) = = FAILURE ) {
2007-11-20 13:34:35 +08:00
if ( ext_len ! = - 1 ) {
2007-11-22 13:47:28 +08:00
if ( ! ext_str ) {
/* no / detected, restore arch for error message */
* arch = filename ;
}
2007-11-20 13:34:35 +08:00
return FAILURE ;
}
ext_len = 0 ;
/* no extension detected - instead we are dealing with an alias */
2006-02-28 09:36:30 +08:00
}
2007-05-16 04:21:19 +08:00
2006-02-28 09:36:30 +08:00
* arch_len = ext_str - filename + ext_len ;
* arch = estrndup ( filename , * arch_len ) ;
2007-11-20 07:10:05 +08:00
# ifdef PHP_WIN32
phar_unixify_path_separators ( * arch , * arch_len ) ;
# endif
2006-02-28 09:36:30 +08:00
if ( ext_str [ ext_len ] ) {
* entry_len = filename_len - * arch_len ;
* entry = estrndup ( ext_str + ext_len , * entry_len ) ;
2007-11-20 07:10:05 +08:00
# ifdef PHP_WIN32
phar_unixify_path_separators ( * entry , * entry_len ) ;
# endif
2008-01-11 05:21:38 +08:00
* entry = phar_fix_filepath ( * entry , entry_len , 0 TSRMLS_CC ) ;
2006-02-28 09:36:30 +08:00
} else {
* entry_len = 1 ;
* entry = estrndup ( " / " , 1 ) ;
}
return SUCCESS ;
}
/* }}} */
2005-12-05 04:35:38 +08:00
2007-01-02 08:04:30 +08:00
/**
* Invoked when a user calls Phar : : mapPhar ( ) from within an executing . phar
* to set up its manifest directly
*/
2007-01-29 14:02:19 +08:00
int phar_open_compiled_file ( char * alias , int alias_len , char * * error TSRMLS_DC ) /* { { { */
2006-01-04 10:26:15 +08:00
{
char * fname ;
long halt_offset ;
zval * halt_constant ;
php_stream * fp ;
2008-03-03 16:41:15 +08:00
int fname_len , is_data = 0 ;
2006-01-04 10:26:15 +08:00
2007-01-29 14:02:19 +08:00
if ( error ) {
* error = NULL ;
}
2006-01-04 10:26:15 +08:00
fname = zend_get_executed_filename ( TSRMLS_C ) ;
2007-01-11 09:04:47 +08:00
fname_len = strlen ( fname ) ;
2008-03-03 16:41:15 +08:00
if ( ! strstr ( fname , " .phar " ) ) {
is_data = 1 ;
}
if ( phar_open_loaded ( fname , fname_len , alias , alias_len , is_data , REPORT_ERRORS , NULL , 0 TSRMLS_CC ) = = SUCCESS ) {
2007-01-11 09:04:47 +08:00
return SUCCESS ;
}
2006-01-04 10:26:15 +08:00
if ( ! strcmp ( fname , " [no active file] " ) ) {
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " cannot initialize a phar outside of PHP execution " ) ;
}
2006-01-04 10:26:15 +08:00
return FAILURE ;
}
MAKE_STD_ZVAL ( halt_constant ) ;
if ( 0 = = zend_get_constant ( " __COMPILER_HALT_OFFSET__ " , 24 , halt_constant TSRMLS_CC ) ) {
2006-01-07 04:43:19 +08:00
FREE_ZVAL ( halt_constant ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " __HALT_COMPILER(); must be declared in a phar " ) ;
}
2006-01-04 10:26:15 +08:00
return FAILURE ;
}
halt_offset = Z_LVAL ( * halt_constant ) ;
2007-01-11 09:04:47 +08:00
FREE_ZVAL ( halt_constant ) ;
2006-01-04 10:26:15 +08:00
fp = php_stream_open_wrapper ( fname , " rb " , IGNORE_URL | STREAM_MUST_SEEK | REPORT_ERRORS , NULL ) ;
if ( ! fp ) {
2007-01-29 14:02:19 +08:00
if ( error ) {
spprintf ( error , 0 , " unable to open phar for reading \" %s \" " , fname ) ;
}
2006-01-04 10:26:15 +08:00
return FAILURE ;
}
2008-01-09 15:09:04 +08:00
return phar_open_file ( fp , fname , fname_len , alias , alias_len , halt_offset , NULL , PHAR_FILE_COMPRESSED_NONE , error TSRMLS_CC ) ;
2006-01-04 10:26:15 +08:00
}
/* }}} */
2007-01-02 08:04:30 +08:00
/**
* Validate the CRC32 of a file opened from within the phar
*/
2008-01-28 16:52:08 +08:00
int phar_postprocess_file ( php_stream_wrapper * wrapper , int options , phar_entry_data * idata , php_uint32 crc32 , char * * error TSRMLS_DC ) /* { { { */
2005-12-05 04:35:38 +08:00
{
2007-01-08 03:05:12 +08:00
php_uint32 crc = ~ 0 ;
2006-01-06 06:24:41 +08:00
int len = idata - > internal_file - > uncompressed_filesize ;
2007-01-10 07:57:03 +08:00
php_stream * fp = idata - > fp ;
2008-01-28 16:52:08 +08:00
phar_entry_info * entry = idata - > internal_file ;
2007-08-17 12:47:50 +08:00
if ( error ) {
* error = NULL ;
}
2008-01-01 06:42:40 +08:00
if ( entry - > is_zip ) {
2008-01-28 16:52:08 +08:00
/* verify local file header */
phar_zip_file_header local ;
2008-01-01 06:42:40 +08:00
2008-01-28 16:52:08 +08:00
if ( SUCCESS ! = phar_open_archive_fp ( idata - > phar TSRMLS_CC ) ) {
spprintf ( error , 0 , " phar error: unable to open zip-based phar archive \" %s \" to verify local file header for file \" %s \" " , idata - > phar - > fname , entry - > filename ) ;
return FAILURE ;
2008-01-01 06:42:40 +08:00
}
2008-01-28 16:52:08 +08:00
php_stream_seek ( idata - > phar - > fp , entry - > header_offset , SEEK_SET ) ;
2008-01-01 06:42:40 +08:00
2008-01-28 16:52:08 +08:00
if ( sizeof ( local ) ! = php_stream_read ( idata - > phar - > fp , ( char * ) & local , sizeof ( local ) ) ) {
2007-08-17 12:47:50 +08:00
2008-01-28 16:52:08 +08:00
spprintf ( error , 0 , " phar error: internal corruption of zip-based phar \" %s \" (cannot read local file header for file \" %s \" ) " , idata - > phar - > fname , entry - > filename ) ;
return FAILURE ;
2007-08-17 12:47:50 +08:00
}
2008-01-28 16:52:08 +08:00
/* fix up for big-endian systems */
/* verify local header if not yet verified */
if ( entry - > filename_len ! = local . filename_len | | entry - > crc32 ! = local . crc32 | | entry - > uncompressed_filesize ! = local . uncompsize | | entry - > compressed_filesize ! = local . compsize ) {
spprintf ( error , 0 , " phar error: internal corruption of zip-based phar \" %s \" (local head of file \" %s \" does not match central directory) " , idata - > phar - > fname , entry - > filename ) ;
return FAILURE ;
2007-12-12 03:21:01 +08:00
}
2008-01-28 16:52:08 +08:00
if ( - 1 = = php_stream_seek ( idata - > phar - > fp , local . filename_len + local . extra_len , SEEK_CUR ) ) {
spprintf ( error , 0 , " phar error: internal corruption of zip-based phar \" %s \" (cannot seek to start of file data for file \" %s \" ) " , idata - > phar - > fname , entry - > filename ) ;
return FAILURE ;
2007-08-17 12:47:50 +08:00
}
}
2008-01-28 16:52:08 +08:00
php_stream_seek ( fp , idata - > zero , SEEK_SET ) ;
while ( len - - ) {
CRC32 ( crc , php_stream_getc ( fp ) ) ;
}
php_stream_seek ( fp , idata - > zero , SEEK_SET ) ;
if ( ~ crc = = crc32 ) {
entry - > is_crc_checked = 1 ;
return SUCCESS ;
} else {
php_stream_wrapper_log_error ( wrapper , options TSRMLS_CC , " phar error: internal corruption of phar \" %s \" (crc32 mismatch on file \" %s \" ) " , idata - > phar - > fname , entry - > filename ) ;
return FAILURE ;
}
2007-08-17 12:47:50 +08:00
}
2008-01-28 16:52:08 +08:00
/* }}} */
2007-08-17 12:47:50 +08:00
2007-01-03 04:25:04 +08:00
static inline void phar_set_32 ( char * buffer , int var ) /* { { { */
{
# ifdef WORDS_BIGENDIAN
2007-01-03 06:57:47 +08:00
* ( ( buffer ) + 3 ) = ( unsigned char ) ( ( ( var ) > > 24 ) & 0xFF ) ;
* ( ( buffer ) + 2 ) = ( unsigned char ) ( ( ( var ) > > 16 ) & 0xFF ) ;
* ( ( buffer ) + 1 ) = ( unsigned char ) ( ( ( var ) > > 8 ) & 0xFF ) ;
2007-01-03 04:25:04 +08:00
* ( ( buffer ) + 0 ) = ( unsigned char ) ( ( var ) & 0xFF ) ;
# else
2007-01-03 05:01:44 +08:00
* ( php_uint32 * ) ( buffer ) = ( php_uint32 ) ( var ) ;
2007-01-03 04:25:04 +08:00
# endif
} /* }}} */
2007-01-03 06:57:47 +08:00
/**
* The only purpose of this is to store the API version , which was stored bigendian for some reason
* in the original PHP_Archive , so we will do the same
*/
2007-01-03 04:25:04 +08:00
static inline void phar_set_16 ( char * buffer , int var ) /* { { { */
{
2007-01-03 02:15:17 +08:00
# ifdef WORDS_BIGENDIAN
2007-01-03 06:57:47 +08:00
* ( ( buffer ) + 1 ) = ( unsigned char ) ( ( ( var ) > > 8 ) & 0xFF ) ; \
2007-01-03 02:15:17 +08:00
* ( buffer ) = ( unsigned char ) ( ( var ) & 0xFF ) ;
# else
2007-01-03 05:01:44 +08:00
* ( php_uint16 * ) ( buffer ) = ( php_uint16 ) ( var ) ;
2007-01-03 02:15:17 +08:00
# endif
2007-01-03 04:25:04 +08:00
} /* }}} */
2007-01-03 02:15:17 +08:00
2007-01-28 07:02:42 +08:00
static int phar_flush_clean_deleted_apply ( void * data TSRMLS_DC ) /* { { { */
{
phar_entry_info * entry = ( phar_entry_info * ) data ;
if ( entry - > fp_refcount < = 0 & & entry - > is_deleted ) {
return ZEND_HASH_APPLY_REMOVE ;
} else {
return ZEND_HASH_APPLY_KEEP ;
}
}
/* }}} */
2008-01-19 12:26:22 +08:00
# include "stub.h"
2008-01-20 08:49:45 +08:00
char * phar_create_default_stub ( const char * index_php , const char * web_index , size_t * len , char * * error TSRMLS_DC )
{
2008-01-19 12:26:22 +08:00
char * stub = NULL ;
2008-02-19 05:45:02 +08:00
int index_len , web_len ;
2008-01-19 12:26:22 +08:00
size_t dummy ;
if ( ! len ) {
len = & dummy ;
}
if ( error ) {
* error = NULL ;
}
2008-02-19 05:45:02 +08:00
2008-02-21 08:24:38 +08:00
if ( ! index_php ) {
2008-02-19 05:45:02 +08:00
index_php = " index.php " ;
}
if ( ! web_index ) {
web_index = " index.php " ;
}
index_len = strlen ( index_php ) ;
web_len = strlen ( web_index ) ;
if ( index_len > 400 ) {
/* ridiculous size not allowed for index.php startup filename */
2008-01-19 12:26:22 +08:00
if ( error ) {
2008-02-19 05:45:02 +08:00
spprintf ( error , 0 , " Illegal filename passed in for stub creation, was %d characters long, and only 400 or less is allowed " , index_len ) ;
2008-01-19 12:26:22 +08:00
return NULL ;
}
}
2008-02-19 05:45:02 +08:00
if ( web_len > 400 ) {
/* ridiculous size not allowed for index.php startup filename */
2008-01-20 08:49:45 +08:00
if ( error ) {
spprintf ( error , 0 , " Illegal web filename passed in for stub creation, was %d characters long, and only 400 or less is allowed " , web_len ) ;
return NULL ;
}
}
2008-02-19 05:45:02 +08:00
phar_get_stub ( index_php , web_index , len , & stub , index_len + 1 , web_len + 1 TSRMLS_CC ) ;
2008-01-19 12:26:22 +08:00
return stub ;
}
2007-01-22 07:22:57 +08:00
/**
* Save phar contents to disk
*
* user_stub contains either a string , or a resource pointer , if len is a negative length .
* user_stub and len should be both 0 if the default or existing stub should be used
*/
2008-02-25 06:29:06 +08:00
int phar_flush ( phar_archive_data * phar , char * user_stub , long len , int convert , char * * error TSRMLS_DC ) /* { { { */
2007-01-08 03:45:31 +08:00
{
2008-01-18 13:42:16 +08:00
/* static const char newstub[] = "<?php __HALT_COMPILER(); ?>\r\n"; */
2008-01-19 12:26:22 +08:00
char * newstub ;
2007-08-17 12:47:50 +08:00
phar_entry_info * entry , * newentry ;
2007-02-06 04:34:23 +08:00
int halt_offset , restore_alias_len , global_flags = 0 , closeoldfile ;
2008-01-28 16:52:08 +08:00
char * pos , has_dirs = 0 ;
2007-01-21 14:30:55 +08:00
char manifest [ 18 ] , entry_buffer [ 24 ] ;
2007-01-10 07:57:03 +08:00
off_t manifest_ftell ;
2007-01-04 13:32:45 +08:00
long offset ;
2007-05-27 23:47:52 +08:00
size_t wrote ;
2007-01-27 23:31:24 +08:00
php_uint32 manifest_len , mytime , loc , new_manifest_count ;
2007-10-04 11:33:21 +08:00
php_uint32 newcrc32 ;
2007-01-27 23:31:24 +08:00
php_stream * file , * oldfile , * newfile , * stubfile ;
2007-01-03 02:15:17 +08:00
php_stream_filter * filter ;
2007-01-22 04:12:50 +08:00
php_serialize_data_t metadata_hash ;
2007-05-15 03:36:09 +08:00
smart_str main_metadata_str = { 0 } ;
2007-05-28 00:54:37 +08:00
int free_user_stub ;
2007-01-03 02:15:17 +08:00
2007-02-07 01:09:37 +08:00
if ( error ) {
* error = NULL ;
}
2007-01-08 00:01:35 +08:00
if ( PHAR_G ( readonly ) ) {
return EOF ;
}
2007-01-10 06:30:56 +08:00
2008-01-09 15:09:04 +08:00
if ( phar - > is_zip ) {
2008-02-25 06:29:06 +08:00
return phar_zip_flush ( phar , user_stub , len , convert , error TSRMLS_CC ) ;
2008-01-01 06:42:40 +08:00
}
2008-01-09 15:09:04 +08:00
if ( phar - > is_tar ) {
2008-02-25 06:29:06 +08:00
return phar_tar_flush ( phar , user_stub , len , convert , error TSRMLS_CC ) ;
2008-01-03 12:45:00 +08:00
}
2008-02-25 06:29:06 +08:00
2008-01-09 15:09:04 +08:00
if ( phar - > fp & & ! phar - > is_brandnew ) {
oldfile = phar - > fp ;
2007-01-29 05:26:54 +08:00
closeoldfile = 0 ;
php_stream_rewind ( oldfile ) ;
2007-01-29 03:56:09 +08:00
} else {
2008-01-09 15:09:04 +08:00
oldfile = php_stream_open_wrapper ( phar - > fname , " rb " , 0 , NULL ) ;
2007-01-29 05:26:54 +08:00
closeoldfile = oldfile ! = NULL ;
2007-01-26 22:52:10 +08:00
}
2007-01-03 02:15:17 +08:00
newfile = php_stream_fopen_tmpfile ( ) ;
2007-02-06 06:11:27 +08:00
if ( ! newfile ) {
if ( error ) {
spprintf ( error , 0 , " unable to create temporary file " ) ;
}
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
return EOF ;
}
2007-01-03 02:15:17 +08:00
2007-01-27 23:31:24 +08:00
if ( user_stub ) {
2007-01-22 07:22:57 +08:00
if ( len < 0 ) {
/* resource passed in */
if ( ! ( php_stream_from_zval_no_verify ( stubfile , ( zval * * ) user_stub ) ) ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-22 07:22:57 +08:00
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to access resource to copy stub to new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-22 07:22:57 +08:00
return EOF ;
}
if ( len = = - 1 ) {
len = PHP_STREAM_COPY_ALL ;
} else {
len = - len ;
}
2007-05-28 00:54:37 +08:00
user_stub = 0 ;
if ( ! ( len = php_stream_copy_to_mem ( stubfile , & user_stub , len , 0 ) ) | | ! user_stub ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-22 07:22:57 +08:00
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to read resource to copy stub to new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-22 07:22:57 +08:00
return EOF ;
}
2007-05-28 00:54:37 +08:00
free_user_stub = 1 ;
2007-01-22 07:22:57 +08:00
} else {
2007-05-28 00:54:37 +08:00
free_user_stub = 0 ;
}
if ( ( pos = strstr ( user_stub , " __HALT_COMPILER(); " ) ) = = NULL )
{
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
2007-02-06 04:47:20 +08:00
}
2007-05-28 00:54:37 +08:00
php_stream_close ( newfile ) ;
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " illegal stub for phar \" %s \" " , phar - > fname ) ;
2007-05-28 00:54:37 +08:00
}
if ( free_user_stub ) {
efree ( user_stub ) ;
2007-01-10 02:54:37 +08:00
}
2007-05-28 00:54:37 +08:00
return EOF ;
}
len = pos - user_stub + 18 ;
if ( ( size_t ) len ! = php_stream_write ( newfile , user_stub , len )
| | 5 ! = php_stream_write ( newfile , " ?> \r \n " , 5 ) ) {
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to create stub from string in new phar \" %s \" " , phar - > fname ) ;
2007-05-28 00:54:37 +08:00
}
if ( free_user_stub ) {
efree ( user_stub ) ;
}
return EOF ;
}
2008-01-09 15:09:04 +08:00
phar - > halt_offset = len + 5 ;
2007-05-28 00:54:37 +08:00
if ( free_user_stub ) {
efree ( user_stub ) ;
2007-01-03 02:15:17 +08:00
}
2007-01-05 11:04:56 +08:00
} else {
2008-02-25 06:29:06 +08:00
if ( ! user_stub & & phar - > halt_offset & & oldfile & & ! phar - > is_brandnew ) {
if ( phar - > halt_offset ! = php_stream_copy_to_stream ( oldfile , newfile , phar - > halt_offset ) ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
2007-01-22 07:22:57 +08:00
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to copy stub of old phar to new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-22 07:22:57 +08:00
return EOF ;
}
} else {
2008-02-25 06:29:06 +08:00
/* this is either a brand new phar or a default stub overwrite */
2008-01-20 08:49:45 +08:00
newstub = phar_create_default_stub ( NULL , NULL , & ( phar - > halt_offset ) , NULL TSRMLS_CC ) ;
2008-01-19 12:26:22 +08:00
if ( phar - > halt_offset ! = php_stream_write ( newfile , newstub , phar - > halt_offset ) ) {
efree ( newstub ) ;
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-22 07:22:57 +08:00
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to create stub in new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-22 07:22:57 +08:00
return EOF ;
2007-01-10 02:54:37 +08:00
}
2008-01-19 12:26:22 +08:00
efree ( newstub ) ;
2007-01-05 11:04:56 +08:00
}
2007-01-03 02:15:17 +08:00
}
2007-01-03 03:59:38 +08:00
manifest_ftell = php_stream_tell ( newfile ) ;
2007-01-22 07:22:57 +08:00
halt_offset = manifest_ftell ;
2007-01-28 07:02:42 +08:00
/* Check whether we can get rid of some of the deleted entries which are
* unused . However some might still be in use so even after this clean - up
* we need to skip entries marked is_deleted . */
2008-01-09 15:09:04 +08:00
zend_hash_apply ( & phar - > manifest , phar_flush_clean_deleted_apply TSRMLS_CC ) ;
2007-01-28 07:02:42 +08:00
2007-01-29 11:59:55 +08:00
/* compress as necessary, calculate crcs, serialize meta-data, manifest size, and file sizes */
2007-05-15 03:36:09 +08:00
main_metadata_str . c = 0 ;
2008-01-09 15:09:04 +08:00
if ( phar - > metadata ) {
2007-01-29 11:59:55 +08:00
PHP_VAR_SERIALIZE_INIT ( metadata_hash ) ;
2008-01-09 15:09:04 +08:00
php_var_serialize ( & main_metadata_str , & phar - > metadata , & metadata_hash TSRMLS_CC ) ;
2007-01-29 11:59:55 +08:00
PHP_VAR_SERIALIZE_DESTROY ( metadata_hash ) ;
} else {
2007-05-15 03:36:09 +08:00
main_metadata_str . len = 0 ;
2007-01-29 11:59:55 +08:00
}
2007-01-04 13:32:45 +08:00
new_manifest_count = 0 ;
offset = 0 ;
2008-01-09 15:09:04 +08:00
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 ) {
2007-01-03 02:15:17 +08:00
continue ;
}
2007-01-27 23:31:24 +08:00
if ( entry - > cfp ) {
/* did we forget to get rid of cfp last time? */
php_stream_close ( entry - > cfp ) ;
entry - > cfp = 0 ;
}
2007-01-14 01:10:18 +08:00
if ( entry - > is_deleted ) {
2007-01-03 02:15:17 +08:00
/* remove this from the new phar */
continue ;
}
2007-01-04 13:32:45 +08:00
/* after excluding deleted files, calculate manifest size in bytes and number of entries */
+ + new_manifest_count ;
2008-01-20 02:30:30 +08:00
if ( entry - > is_dir ) {
/* we use this to calculate API version, 1.1.1 is used for phars with directories */
has_dirs = 1 ;
}
2007-05-15 02:59:04 +08:00
if ( entry - > metadata ) {
2007-05-15 03:14:00 +08:00
if ( entry - > metadata_str . c ) {
smart_str_free ( & entry - > metadata_str ) ;
}
2007-05-15 03:36:09 +08:00
entry - > metadata_str . c = 0 ;
entry - > metadata_str . len = 0 ;
2007-05-15 02:59:04 +08:00
PHP_VAR_SERIALIZE_INIT ( metadata_hash ) ;
2007-05-15 03:14:00 +08:00
php_var_serialize ( & entry - > metadata_str , & entry - > metadata , & metadata_hash TSRMLS_CC ) ;
2007-05-15 02:59:04 +08:00
PHP_VAR_SERIALIZE_DESTROY ( metadata_hash ) ;
2007-05-15 03:14:00 +08:00
} else {
2008-01-28 16:52:08 +08:00
if ( entry - > metadata_str . c ) {
smart_str_free ( & entry - > metadata_str ) ;
}
2007-05-15 03:36:09 +08:00
entry - > metadata_str . c = 0 ;
2007-05-15 03:14:00 +08:00
entry - > metadata_str . len = 0 ;
2007-05-15 02:59:04 +08:00
}
2008-01-09 11:47:22 +08:00
/* 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 ) ;
2007-05-15 03:14:00 +08:00
2007-01-27 23:31:24 +08:00
/* compress and rehash as necessary */
2007-01-29 05:26:54 +08:00
if ( oldfile & & ! entry - > is_modified ) {
2007-01-22 11:41:41 +08:00
continue ;
}
2008-02-18 12:42:04 +08:00
if ( ! phar_get_efp ( entry TSRMLS_CC ) ) {
2007-08-17 12:47:50 +08:00
/* re-open internal file pointer just-in-time */
2008-01-09 15:09:04 +08:00
newentry = phar_open_jit ( phar , entry , oldfile , error , 0 TSRMLS_CC ) ;
2007-08-17 12:47:50 +08:00
if ( ! newentry ) {
/* major problem re-opening, so we ignore this file and the error */
efree ( * error ) ;
* error = NULL ;
continue ;
}
entry = newentry ;
2007-01-22 11:41:41 +08:00
}
2008-02-18 12:42:04 +08:00
file = phar_get_efp ( entry TSRMLS_CC ) ;
2008-01-28 16:52:08 +08:00
if ( - 1 = = phar_seek_efp ( entry , 0 , SEEK_SET , 0 TSRMLS_CC ) ) {
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
2007-08-30 10:30:16 +08:00
}
2008-01-28 16:52:08 +08:00
php_stream_close ( newfile ) ;
if ( error ) {
spprintf ( error , 0 , " unable to seek to start of file \" %s \" while creating new phar \" %s \" " , entry - > filename , phar - > fname ) ;
}
return EOF ;
2007-08-30 10:30:16 +08:00
}
2007-01-22 11:41:41 +08:00
newcrc32 = ~ 0 ;
mytime = entry - > uncompressed_filesize ;
2008-03-23 06:11:49 +08:00
for ( loc = 0 ; loc < mytime ; + + loc ) {
2007-01-22 11:41:41 +08:00
CRC32 ( newcrc32 , php_stream_getc ( file ) ) ;
}
entry - > crc32 = ~ newcrc32 ;
entry - > is_crc_checked = 1 ;
if ( ! ( entry - > flags & PHAR_ENT_COMPRESSION_MASK ) ) {
2007-01-27 23:31:24 +08:00
/* not compressed */
2007-05-27 23:47:52 +08:00
entry - > compressed_filesize = entry - > uncompressed_filesize ;
2007-01-22 11:41:41 +08:00
continue ;
}
filter = php_stream_filter_create ( phar_compress_filter ( entry , 0 ) , NULL , 0 TSRMLS_CC ) ;
if ( ! filter ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-22 10:04:51 +08:00
php_stream_close ( oldfile ) ;
2007-01-03 05:01:44 +08:00
}
2007-01-22 11:41:41 +08:00
php_stream_close ( newfile ) ;
if ( entry - > flags & PHAR_ENT_COMPRESSED_GZ ) {
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to gzip compress file \" %s \" to new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-22 11:41:41 +08:00
} else {
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to bzip2 compress file \" %s \" to new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-22 11:41:41 +08:00
}
return EOF ;
2007-01-03 02:15:17 +08:00
}
2007-01-22 11:41:41 +08:00
/* create new file that holds the compressed version */
/* work around inability to specify freedom in write and strictness
in read count */
2007-01-27 23:31:24 +08:00
entry - > cfp = php_stream_fopen_tmpfile ( ) ;
2007-02-06 06:11:27 +08:00
if ( ! entry - > cfp ) {
if ( error ) {
spprintf ( error , 0 , " unable to create temporary file " ) ;
}
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
return EOF ;
}
2007-05-27 23:47:52 +08:00
php_stream_flush ( file ) ;
2008-01-28 16:52:08 +08:00
if ( - 1 = = phar_seek_efp ( entry , 0 , SEEK_SET , 0 TSRMLS_CC ) ) {
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
2007-08-30 10:30:16 +08:00
}
2008-01-28 16:52:08 +08:00
php_stream_close ( newfile ) ;
if ( error ) {
spprintf ( error , 0 , " unable to seek to start of file \" %s \" while creating new phar \" %s \" " , entry - > filename , phar - > fname ) ;
}
return EOF ;
}
php_stream_filter_append ( ( & entry - > cfp - > writefilters ) , filter ) ;
if ( entry - > uncompressed_filesize ! = php_stream_copy_to_stream ( file , entry - > cfp , entry - > uncompressed_filesize ) ) {
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
if ( error ) {
spprintf ( error , 0 , " unable to copy compressed file contents of file \" %s \" while creating new phar \" %s \" " , entry - > filename , phar - > fname ) ;
}
return EOF ;
2007-08-30 10:30:16 +08:00
}
2007-12-14 13:39:20 +08:00
php_stream_filter_flush ( filter , 1 ) ;
2008-01-28 16:52:08 +08:00
php_stream_flush ( entry - > cfp ) ;
2007-01-22 11:41:41 +08:00
php_stream_filter_remove ( filter , 1 TSRMLS_CC ) ;
2008-01-28 16:52:08 +08:00
php_stream_seek ( entry - > cfp , 0 , SEEK_END ) ;
entry - > compressed_filesize = ( php_uint32 ) php_stream_tell ( entry - > cfp ) ;
2007-01-22 11:41:41 +08:00
/* generate crc on compressed file */
2007-01-27 23:31:24 +08:00
php_stream_rewind ( entry - > cfp ) ;
2007-08-17 12:47:50 +08:00
entry - > old_flags = entry - > flags ;
2007-01-22 11:41:41 +08:00
entry - > is_modified = 1 ;
global_flags | = ( entry - > flags & PHAR_ENT_COMPRESSION_MASK ) ;
2007-01-03 02:15:17 +08:00
}
2007-01-14 00:17:04 +08:00
global_flags | = PHAR_HDR_SIGNATURE ;
2007-01-04 13:32:45 +08:00
/* write out manifest pre-header */
2007-01-14 00:17:04 +08:00
/* 4: manifest length
* 4 : manifest entry count
* 2 : phar version
* 4 : phar global flags
2007-01-29 11:59:55 +08:00
* 4 : alias length
* ? : the alias itself
* 4 : phar metadata length
* ? : phar metadata
2007-01-14 00:17:04 +08:00
*/
2008-01-09 15:09:04 +08:00
restore_alias_len = phar - > alias_len ;
2008-02-11 14:46:44 +08:00
if ( phar - > is_temporary_alias ) {
2008-01-09 15:09:04 +08:00
phar - > alias_len = 0 ;
2007-01-05 12:45:52 +08:00
}
2007-01-09 07:03:41 +08:00
2008-01-09 15:09:04 +08:00
manifest_len = offset + phar - > alias_len + sizeof ( manifest ) + main_metadata_str . len ;
2007-01-27 23:31:24 +08:00
phar_set_32 ( manifest , manifest_len ) ;
2007-01-14 00:17:04 +08:00
phar_set_32 ( manifest + 4 , new_manifest_count ) ;
2008-01-20 02:30:30 +08:00
if ( has_dirs ) {
* ( manifest + 8 ) = ( unsigned char ) ( ( ( PHAR_API_VERSION ) > > 8 ) & 0xFF ) ;
* ( manifest + 9 ) = ( unsigned char ) ( ( ( PHAR_API_VERSION ) & 0xF0 ) ) ;
} else {
* ( manifest + 8 ) = ( unsigned char ) ( ( ( PHAR_API_VERSION_NODIR ) > > 8 ) & 0xFF ) ;
* ( manifest + 9 ) = ( unsigned char ) ( ( ( PHAR_API_VERSION_NODIR ) & 0xF0 ) ) ;
}
2007-01-14 00:17:04 +08:00
phar_set_32 ( manifest + 10 , global_flags ) ;
2008-01-09 15:09:04 +08:00
phar_set_32 ( manifest + 14 , phar - > alias_len ) ;
2007-01-04 13:32:45 +08:00
/* write the manifest header */
2007-01-14 00:17:04 +08:00
if ( sizeof ( manifest ) ! = php_stream_write ( newfile , manifest , sizeof ( manifest ) )
2008-01-09 15:09:04 +08:00
| | ( size_t ) phar - > alias_len ! = php_stream_write ( newfile , phar - > alias , phar - > alias_len ) ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-10 06:30:56 +08:00
php_stream_close ( oldfile ) ;
2007-01-10 02:54:37 +08:00
}
2007-01-03 23:43:07 +08:00
php_stream_close ( newfile ) ;
2008-01-09 15:09:04 +08:00
phar - > alias_len = restore_alias_len ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write manifest header of new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-08 00:01:35 +08:00
return EOF ;
2007-01-03 05:01:44 +08:00
}
2007-01-29 11:59:55 +08:00
2008-01-09 15:09:04 +08:00
phar - > alias_len = restore_alias_len ;
2007-01-04 13:32:45 +08:00
2007-05-15 03:36:09 +08:00
phar_set_32 ( manifest , main_metadata_str . len ) ;
if ( main_metadata_str . len ) {
2007-01-29 11:59:55 +08:00
if ( 4 ! = php_stream_write ( newfile , manifest , 4 ) | |
2007-05-15 03:36:09 +08:00
main_metadata_str . len ! = php_stream_write ( newfile , main_metadata_str . c , main_metadata_str . len ) ) {
smart_str_free ( & main_metadata_str ) ;
2007-01-29 11:59:55 +08:00
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
2008-01-09 15:09:04 +08:00
phar - > alias_len = restore_alias_len ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write manifest meta-data of new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-29 11:59:55 +08:00
return EOF ;
}
} else {
if ( 4 ! = php_stream_write ( newfile , manifest , 4 ) ) {
2007-05-15 03:36:09 +08:00
smart_str_free ( & main_metadata_str ) ;
2007-01-29 11:59:55 +08:00
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
2008-01-09 15:09:04 +08:00
phar - > alias_len = restore_alias_len ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write manifest header of new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-29 11:59:55 +08:00
return EOF ;
}
}
2007-05-15 03:36:09 +08:00
smart_str_free ( & main_metadata_str ) ;
2007-01-29 11:59:55 +08:00
2007-01-04 13:32:45 +08:00
/* re-calculate the manifest location to simplify later code */
manifest_ftell = php_stream_tell ( newfile ) ;
/* now write the manifest */
2008-01-09 15:09:04 +08:00
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 ) {
2007-01-03 02:15:17 +08:00
continue ;
}
2007-01-14 01:10:18 +08:00
if ( entry - > is_deleted ) {
2007-01-04 13:32:45 +08:00
/* remove this from the new phar */
2007-01-03 02:15:17 +08:00
continue ;
}
2008-01-09 11:47:22 +08:00
if ( entry - > is_dir ) {
/* add 1 for trailing slash */
phar_set_32 ( entry_buffer , entry - > filename_len + 1 ) ;
} else {
phar_set_32 ( entry_buffer , entry - > filename_len ) ;
}
2007-01-10 07:57:03 +08:00
if ( 4 ! = php_stream_write ( newfile , entry_buffer , 4 )
| | entry - > filename_len ! = php_stream_write ( newfile , entry - > filename , entry - > filename_len ) ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-10 06:30:56 +08:00
php_stream_close ( oldfile ) ;
2007-01-10 02:54:37 +08:00
}
2007-01-04 13:32:45 +08:00
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write filename of file \" %s \" to manifest of new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-08 00:01:35 +08:00
return EOF ;
2007-01-04 13:32:45 +08:00
}
2008-01-09 06:14:16 +08:00
if ( entry - > is_dir & & 1 ! = php_stream_write ( newfile , " / " , 1 ) ) {
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write filename of directory \" %s \" to manifest of new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2008-01-09 06:14:16 +08:00
}
return EOF ;
}
2007-01-04 13:32:45 +08:00
/* set the manifest meta-data:
2007-01-03 02:15:17 +08:00
4 : uncompressed filesize
4 : creation timestamp
4 : compressed filesize
4 : crc32
2007-01-14 00:17:04 +08:00
4 : flags
2007-01-22 04:12:50 +08:00
4 : metadata - len
+ : metadata
2007-01-03 02:15:17 +08:00
*/
2007-01-22 11:41:41 +08:00
mytime = time ( NULL ) ;
2007-01-10 07:57:03 +08:00
phar_set_32 ( entry_buffer , entry - > uncompressed_filesize ) ;
2007-01-22 11:41:41 +08:00
phar_set_32 ( entry_buffer + 4 , mytime ) ;
2007-01-10 07:57:03 +08:00
phar_set_32 ( entry_buffer + 8 , entry - > compressed_filesize ) ;
phar_set_32 ( entry_buffer + 12 , entry - > crc32 ) ;
2007-01-14 00:17:04 +08:00
phar_set_32 ( entry_buffer + 16 , entry - > flags ) ;
2007-05-15 03:14:00 +08:00
phar_set_32 ( entry_buffer + 20 , entry - > metadata_str . len ) ;
2007-01-22 04:12:50 +08:00
if ( sizeof ( entry_buffer ) ! = php_stream_write ( newfile , entry_buffer , sizeof ( entry_buffer ) )
2007-05-15 03:14:00 +08:00
| | entry - > metadata_str . len ! = php_stream_write ( newfile , entry - > metadata_str . c , entry - > metadata_str . len ) ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-10 06:30:56 +08:00
php_stream_close ( oldfile ) ;
2007-01-10 02:54:37 +08:00
}
2007-01-03 23:43:07 +08:00
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write temporary manifest of file \" %s \" to manifest of new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-08 00:01:35 +08:00
return EOF ;
2007-01-04 13:32:45 +08:00
}
}
/* now copy the actual file data to the new phar */
2008-01-28 16:52:08 +08:00
offset = php_stream_tell ( newfile ) ;
2008-01-09 15:09:04 +08:00
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 ) {
2007-01-04 13:32:45 +08:00
continue ;
}
2007-01-14 01:10:18 +08:00
if ( entry - > is_deleted ) {
2007-01-04 13:32:45 +08:00
continue ;
}
2007-01-27 23:31:24 +08:00
if ( entry - > cfp ) {
file = entry - > cfp ;
php_stream_rewind ( file ) ;
2007-01-04 13:32:45 +08:00
} else {
2008-02-18 12:42:04 +08:00
file = phar_get_efp ( entry TSRMLS_CC ) ;
2008-01-28 16:52:08 +08:00
if ( - 1 = = phar_seek_efp ( entry , 0 , SEEK_SET , 0 TSRMLS_CC ) ) {
2007-02-07 01:09:37 +08:00
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to seek to start of file \" %s \" while creating new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2007-02-07 01:09:37 +08:00
}
return EOF ;
}
2008-01-28 16:52:08 +08:00
}
if ( ! file ) {
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
2007-01-04 13:32:45 +08:00
}
2008-01-28 16:52:08 +08:00
php_stream_close ( newfile ) ;
if ( error ) {
spprintf ( error , 0 , " unable to seek to start of file \" %s \" while creating new phar \" %s \" " , entry - > filename , phar - > fname ) ;
}
return EOF ;
2007-01-04 13:32:45 +08:00
}
/* this will have changed for all files that have either
changed compression or been modified */
2008-01-28 16:52:08 +08:00
entry - > offset = entry - > offset_abs = offset ;
2007-01-04 13:32:45 +08:00
offset + = entry - > compressed_filesize ;
2007-01-27 23:31:24 +08:00
wrote = php_stream_copy_to_stream ( file , newfile , entry - > compressed_filesize ) ;
if ( entry - > compressed_filesize ! = wrote ) {
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-10 06:30:56 +08:00
php_stream_close ( oldfile ) ;
2007-01-10 02:54:37 +08:00
}
2007-01-04 13:32:45 +08:00
php_stream_close ( newfile ) ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write contents of file \" %s \" to new phar \" %s \" " , entry - > filename , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-08 00:01:35 +08:00
return EOF ;
2007-01-04 13:32:45 +08:00
}
2007-01-26 22:52:10 +08:00
entry - > is_modified = 0 ;
2007-01-27 23:31:24 +08:00
if ( entry - > cfp ) {
php_stream_close ( entry - > cfp ) ;
2008-01-28 16:52:08 +08:00
entry - > cfp = NULL ;
2007-01-27 23:31:24 +08:00
}
2008-01-28 16:52:08 +08:00
if ( entry - > fp_type = = PHAR_MOD ) {
/* this fp is in use by a phar_entry_data returned by phar_get_entry_data, it will be closed
when the phar_entry_data is phar_entry_delref ' ed */
if ( entry - > fp_refcount = = 0 & & entry - > fp ! = phar - > fp & & entry - > fp ! = phar - > ufp ) {
2007-08-30 10:30:16 +08:00
php_stream_close ( entry - > fp ) ;
}
2008-01-28 16:52:08 +08:00
entry - > fp = NULL ;
entry - > fp_type = PHAR_FP ;
} else if ( entry - > fp_type = = PHAR_UFP ) {
entry - > fp_type = PHAR_FP ;
2007-08-17 12:47:50 +08:00
}
2007-01-03 02:15:17 +08:00
}
2007-01-04 13:32:45 +08:00
2007-01-09 07:03:41 +08:00
/* append signature */
if ( global_flags & PHAR_HDR_SIGNATURE ) {
unsigned char buf [ 1024 ] ;
2007-02-24 10:08:08 +08:00
int sig_flags = 0 , sig_len ;
2007-01-09 07:03:41 +08:00
char sig_buf [ 4 ] ;
php_stream_rewind ( newfile ) ;
2008-01-09 15:09:04 +08:00
if ( phar - > signature ) {
efree ( phar - > signature ) ;
2007-01-27 23:31:24 +08:00
}
2008-01-09 15:09:04 +08:00
switch ( phar - > sig_flags ) {
2007-03-26 05:43:49 +08:00
# if HAVE_HASH_EXT
case PHAR_SIG_SHA512 : {
unsigned char digest [ 64 ] ;
PHP_SHA512_CTX context ;
PHP_SHA512Init ( & context ) ;
while ( ( sig_len = php_stream_read ( newfile , ( char * ) buf , sizeof ( buf ) ) ) > 0 ) {
PHP_SHA512Update ( & context , buf , sig_len ) ;
}
PHP_SHA512Final ( digest , & context ) ;
php_stream_write ( newfile , ( char * ) digest , sizeof ( digest ) ) ;
sig_flags | = PHAR_SIG_SHA512 ;
2008-01-09 15:09:04 +08:00
phar - > sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & phar - > signature ) ;
2007-03-26 05:43:49 +08:00
break ;
}
case PHAR_SIG_SHA256 : {
unsigned char digest [ 32 ] ;
PHP_SHA256_CTX context ;
PHP_SHA256Init ( & context ) ;
while ( ( sig_len = php_stream_read ( newfile , ( char * ) buf , sizeof ( buf ) ) ) > 0 ) {
PHP_SHA256Update ( & context , buf , sig_len ) ;
}
PHP_SHA256Final ( digest , & context ) ;
php_stream_write ( newfile , ( char * ) digest , sizeof ( digest ) ) ;
sig_flags | = PHAR_SIG_SHA256 ;
2008-01-09 15:09:04 +08:00
phar - > sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & phar - > signature ) ;
2007-03-26 05:43:49 +08:00
break ;
}
# else
case PHAR_SIG_SHA512 :
case PHAR_SIG_SHA256 :
if ( closeoldfile ) {
php_stream_close ( oldfile ) ;
}
php_stream_close ( newfile ) ;
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to write contents of file \" %s \" to new phar \" %s \" with requested hash type " , entry - > filename , phar - > fname ) ;
2007-03-26 05:43:49 +08:00
}
return EOF ;
# endif
2007-03-26 08:00:56 +08:00
case PHAR_SIG_PGP :
/* TODO: currently fall back to sha1,later do both */
2007-03-26 07:42:49 +08:00
default :
2007-01-09 07:03:41 +08:00
case PHAR_SIG_SHA1 : {
unsigned char digest [ 20 ] ;
PHP_SHA1_CTX context ;
PHP_SHA1Init ( & context ) ;
2007-01-27 23:31:24 +08:00
while ( ( sig_len = php_stream_read ( newfile , ( char * ) buf , sizeof ( buf ) ) ) > 0 ) {
PHP_SHA1Update ( & context , buf , sig_len ) ;
2007-01-09 07:03:41 +08:00
}
PHP_SHA1Final ( digest , & context ) ;
2007-01-20 13:28:48 +08:00
php_stream_write ( newfile , ( char * ) digest , sizeof ( digest ) ) ;
2007-01-09 07:03:41 +08:00
sig_flags | = PHAR_SIG_SHA1 ;
2008-01-09 15:09:04 +08:00
phar - > sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & phar - > signature ) ;
2007-01-09 07:03:41 +08:00
break ;
}
case PHAR_SIG_MD5 : {
unsigned char digest [ 16 ] ;
PHP_MD5_CTX context ;
PHP_MD5Init ( & context ) ;
2007-01-27 23:31:24 +08:00
while ( ( sig_len = php_stream_read ( newfile , ( char * ) buf , sizeof ( buf ) ) ) > 0 ) {
PHP_MD5Update ( & context , buf , sig_len ) ;
2007-01-09 07:03:41 +08:00
}
PHP_MD5Final ( digest , & context ) ;
2007-01-20 13:28:48 +08:00
php_stream_write ( newfile , ( char * ) digest , sizeof ( digest ) ) ;
2007-01-09 07:03:41 +08:00
sig_flags | = PHAR_SIG_MD5 ;
2008-01-09 15:09:04 +08:00
phar - > sig_len = phar_hex_str ( ( const char * ) digest , sizeof ( digest ) , & phar - > signature ) ;
2007-01-09 07:03:41 +08:00
break ;
}
}
phar_set_32 ( sig_buf , sig_flags ) ;
php_stream_write ( newfile , sig_buf , 4 ) ;
php_stream_write ( newfile , " GBMB " , 4 ) ;
2008-01-09 15:09:04 +08:00
phar - > sig_flags = sig_flags ;
2007-01-09 07:03:41 +08:00
}
2007-01-03 02:15:17 +08:00
/* finally, close the temp file, rename the original phar,
move the temp to the old phar , unlink the old phar , and reload it into memory
*/
2008-01-09 15:09:04 +08:00
if ( phar - > fp ) {
php_stream_close ( phar - > fp ) ;
2007-01-27 23:31:24 +08:00
}
2008-01-28 16:52:08 +08:00
if ( phar - > ufp ) {
php_stream_close ( phar - > ufp ) ;
phar - > ufp = NULL ;
}
2007-01-29 05:26:54 +08:00
if ( closeoldfile ) {
2007-01-29 03:56:09 +08:00
php_stream_close ( oldfile ) ;
2007-01-03 02:15:17 +08:00
}
2007-01-29 03:56:09 +08:00
2008-01-09 15:09:04 +08:00
phar - > internal_file_start = halt_offset + manifest_len + 4 ;
2008-01-28 16:52:08 +08:00
phar - > halt_offset = halt_offset ;
2008-01-09 15:09:04 +08:00
phar - > is_brandnew = 0 ;
2007-01-29 05:26:54 +08:00
php_stream_rewind ( newfile ) ;
2007-01-03 02:15:17 +08:00
2008-01-09 15:09:04 +08:00
if ( phar - > donotflush ) {
2007-01-29 03:56:09 +08:00
/* deferred flush */
2008-01-09 15:09:04 +08:00
phar - > fp = newfile ;
2007-01-29 03:56:09 +08:00
} else {
2008-01-09 15:09:04 +08:00
phar - > fp = php_stream_open_wrapper ( phar - > fname , " w+b " , IGNORE_URL | STREAM_MUST_SEEK | REPORT_ERRORS , NULL ) ;
if ( ! phar - > fp ) {
phar - > fp = newfile ;
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 16:45:00 +08:00
spprintf ( error , 4096 , " unable to open new phar \" %s \" for writing " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-29 03:56:09 +08:00
return EOF ;
}
2008-01-09 15:09:04 +08:00
if ( phar - > flags & PHAR_FILE_COMPRESSED_GZ ) {
php_stream_filter * filter ;
/* to properly compress, we have to tell zlib to add a zlib header */
zval filterparams ;
array_init ( & filterparams ) ;
2008-01-09 16:45:00 +08:00
add_assoc_long ( & filterparams , " window " , MAX_WBITS + 16 ) ;
2008-01-09 15:09:04 +08:00
filter = php_stream_filter_create ( " zlib.deflate " , & filterparams , php_stream_is_persistent ( phar - > fp ) TSRMLS_CC ) ;
2008-02-08 13:41:59 +08:00
zval_dtor ( & filterparams ) ;
2008-01-09 16:45:00 +08:00
if ( ! filter ) {
if ( error ) {
spprintf ( error , 4096 , " unable to compress all contents of phar \" %s \" using zlib, PHP versions older than 5.2.6 have a buggy zlib " , phar - > fname ) ;
}
return EOF ;
}
2008-01-09 15:09:04 +08:00
php_stream_filter_append ( & phar - > fp - > writefilters , filter ) ;
php_stream_copy_to_stream ( newfile , phar - > fp , PHP_STREAM_COPY_ALL ) ;
php_stream_filter_flush ( filter , 1 ) ;
php_stream_filter_remove ( filter , 1 TSRMLS_CC ) ;
php_stream_close ( phar - > fp ) ;
/* use the temp stream as our base */
phar - > fp = newfile ;
} else if ( phar - > flags & PHAR_FILE_COMPRESSED_BZ2 ) {
php_stream_filter * filter ;
filter = php_stream_filter_create ( " bzip2.compress " , NULL , php_stream_is_persistent ( phar - > fp ) TSRMLS_CC ) ;
php_stream_filter_append ( & phar - > fp - > writefilters , filter ) ;
php_stream_copy_to_stream ( newfile , phar - > fp , PHP_STREAM_COPY_ALL ) ;
php_stream_filter_flush ( filter , 1 ) ;
php_stream_filter_remove ( filter , 1 TSRMLS_CC ) ;
php_stream_close ( phar - > fp ) ;
/* use the temp stream as our base */
phar - > fp = newfile ;
} else {
php_stream_copy_to_stream ( newfile , phar - > fp , PHP_STREAM_COPY_ALL ) ;
/* we could also reopen the file in "rb" mode but there is no need for that */
php_stream_close ( newfile ) ;
}
2007-01-03 02:15:17 +08:00
}
2008-01-09 15:09:04 +08:00
if ( - 1 = = php_stream_seek ( phar - > fp , phar - > halt_offset , SEEK_SET ) ) {
2007-01-29 14:02:19 +08:00
if ( error ) {
2008-01-09 15:09:04 +08:00
spprintf ( error , 0 , " unable to seek to __HALT_COMPILER(); in new phar \" %s \" " , phar - > fname ) ;
2007-01-29 14:02:19 +08:00
}
2007-01-08 00:01:35 +08:00
return EOF ;
2007-01-03 02:15:17 +08:00
}
2007-01-05 11:04:56 +08:00
2007-01-03 02:15:17 +08:00
return EOF ;
}
/* }}} */
2006-01-03 23:50:46 +08:00
# ifdef COMPILE_DL_PHAR
ZEND_GET_MODULE ( phar )
# endif
/* {{{ phar_functions[]
*
* Every user visible function must have an entry in phar_functions [ ] .
*/
function_entry phar_functions [ ] = {
2007-01-21 23:25:50 +08:00
{ NULL , NULL , NULL } /* Must be the last line in phar_functions[] */
2006-02-28 09:36:30 +08:00
} ;
2007-01-24 07:31:14 +08:00
/* }}}*/
2006-01-03 23:50:46 +08:00
/* {{{ php_phar_init_globals
*/
static void php_phar_init_globals_module ( zend_phar_globals * phar_globals )
{
memset ( phar_globals , 0 , sizeof ( zend_phar_globals ) ) ;
2007-01-08 00:01:35 +08:00
phar_globals - > readonly = 1 ;
2006-01-03 23:50:46 +08:00
}
/* }}} */
2007-12-22 15:46:53 +08:00
2008-03-17 05:06:54 +08:00
# if PHP_VERSION_ID >= 50300
static size_t phar_zend_stream_reader ( void * handle , char * buf , size_t len TSRMLS_DC ) /* { { { */
{
return php_stream_read ( ( ( phar_archive_data * ) handle ) - > fp , buf , len ) ;
}
/* }}} */
static size_t phar_zend_stream_fsizer ( void * handle TSRMLS_DC ) /* { { { */
{
return ( ( phar_archive_data * ) handle ) - > halt_offset + 32 ;
} /* }}} */
# else /* PHP_VERSION_ID */
2008-01-09 16:45:00 +08:00
static long stream_fteller_for_zend ( void * handle TSRMLS_DC ) /* { { { */
{
return ( long ) php_stream_tell ( ( php_stream * ) handle ) ;
}
/* }}} */
2008-03-17 05:06:54 +08:00
# endif
2008-01-09 16:45:00 +08:00
2008-01-12 12:32:19 +08:00
zend_op_array * ( * phar_orig_compile_file ) ( zend_file_handle * file_handle , int type TSRMLS_DC ) ;
2008-03-12 11:55:12 +08:00
# if PHP_VERSION_ID >= 50300
# define phar_orig_zend_open zend_stream_open_function
char * phar_resolve_path ( const char * filename , int filename_len TSRMLS_DC )
{
2008-03-21 07:59:07 +08:00
return phar_find_in_include_path ( ( char * ) filename , filename_len , NULL TSRMLS_CC ) ;
2008-03-12 11:55:12 +08:00
}
2008-03-23 05:54:55 +08:00
# else
int ( * phar_orig_zend_open ) ( const char * filename , zend_file_handle * handle TSRMLS_DC ) ;
# endif
2008-01-12 12:32:19 +08:00
2007-12-10 05:57:44 +08:00
static zend_op_array * phar_compile_file ( zend_file_handle * file_handle , int type TSRMLS_DC ) /* { { { */
{
zend_op_array * res ;
2008-01-01 06:42:40 +08:00
char * name = NULL ;
2008-01-10 23:13:00 +08:00
int failed ;
2008-01-07 13:41:09 +08:00
phar_archive_data * phar ;
2007-12-10 05:57:44 +08:00
2008-01-08 15:08:46 +08:00
if ( strstr ( file_handle - > filename , " .phar " ) & & ! strstr ( file_handle - > filename , " :// " ) ) {
2008-01-07 13:41:09 +08:00
if ( SUCCESS = = phar_open_filename ( file_handle - > filename , strlen ( file_handle - > filename ) , NULL , 0 , 0 , & phar , NULL TSRMLS_CC ) ) {
if ( phar - > is_zip | | phar - > is_tar ) {
2008-01-08 06:21:10 +08:00
zend_file_handle f = * file_handle ;
/* zip or tar-based phar */
2008-01-07 13:41:09 +08:00
spprintf ( & name , 4096 , " phar://%s/%s " , file_handle - > filename , " .phar/stub.php " ) ;
2008-01-10 23:13:00 +08:00
if ( SUCCESS = = phar_orig_zend_open ( ( const char * ) name , file_handle TSRMLS_CC ) ) {
2008-01-08 06:21:10 +08:00
efree ( name ) ;
name = NULL ;
file_handle - > filename = f . filename ;
2008-03-12 11:55:12 +08:00
if ( file_handle - > opened_path ) {
efree ( file_handle - > opened_path ) ;
}
2008-01-08 06:21:10 +08:00
file_handle - > opened_path = f . opened_path ;
file_handle - > free_filename = f . free_filename ;
} else {
* file_handle = f ;
2008-01-07 13:41:09 +08:00
}
2008-01-09 16:45:00 +08:00
} else if ( phar - > flags & PHAR_FILE_COMPRESSION_MASK ) {
/* compressed phar */
2008-03-17 05:06:54 +08:00
# if PHP_VERSION_ID >= 50300
file_handle - > type = ZEND_HANDLE_STREAM ;
file_handle - > free_filename = 0 ;
file_handle - > handle . stream . handle = phar ;
file_handle - > handle . stream . reader = phar_zend_stream_reader ;
file_handle - > handle . stream . closer = NULL ;
file_handle - > handle . stream . fsizer = phar_zend_stream_fsizer ;
file_handle - > handle . stream . isatty = 0 ;
php_stream_rewind ( phar - > fp ) ;
memset ( & file_handle - > handle . stream . mmap , 0 , sizeof ( file_handle - > handle . stream . mmap ) ) ;
# else /* PHP_VERSION_ID */
2008-01-09 16:45:00 +08:00
file_handle - > type = ZEND_HANDLE_STREAM ;
file_handle - > free_filename = 0 ;
file_handle - > handle . stream . handle = phar - > fp ;
file_handle - > handle . stream . reader = ( zend_stream_reader_t ) _php_stream_read ;
file_handle - > handle . stream . closer = NULL ; /* don't close - let phar handle this one */
file_handle - > handle . stream . fteller = stream_fteller_for_zend ;
file_handle - > handle . stream . interactive = 0 ;
php_stream_rewind ( phar - > fp ) ;
2008-03-17 05:06:54 +08:00
# endif
2008-01-04 09:45:37 +08:00
}
2008-01-03 12:45:00 +08:00
}
}
2008-01-10 23:13:00 +08:00
zend_try {
failed = 0 ;
2008-02-13 23:00:31 +08:00
res = phar_orig_compile_file ( file_handle , type TSRMLS_CC ) ;
2008-01-10 23:13:00 +08:00
} zend_catch {
failed = 1 ;
} zend_end_try ( ) ;
if ( name ) {
efree ( name ) ;
}
if ( failed ) {
zend_bailout ( ) ;
}
return res ;
}
/* }}} */
2008-03-12 11:55:12 +08:00
# if PHP_VERSION_ID < 50300
2008-01-12 12:32:19 +08:00
int phar_zend_open ( const char * filename , zend_file_handle * handle TSRMLS_DC ) /* { { { */
2008-01-10 23:13:00 +08:00
{
char * arch , * entry ;
2008-03-12 11:55:12 +08:00
int arch_len , entry_len ;
2008-01-10 23:13:00 +08:00
2008-03-12 11:55:12 +08:00
/* this code is obsoleted in php 5.3 */
2008-01-10 23:13:00 +08:00
entry = ( char * ) filename ;
2008-03-12 11:55:12 +08:00
if ( ! IS_ABSOLUTE_PATH ( entry , strlen ( entry ) ) ) {
phar_archive_data * * pphar = NULL ;
char * fname ;
int fname_len ;
fname = zend_get_executed_filename ( TSRMLS_C ) ;
fname_len = strlen ( fname ) ;
if ( fname_len > 7 & & ! strncasecmp ( fname , " phar:// " , 7 ) ) {
if ( SUCCESS = = phar_split_fname ( fname , fname_len , & arch , & arch_len , & entry , & entry_len TSRMLS_CC ) ) {
zend_hash_find ( & ( PHAR_GLOBALS - > phar_fname_map ) , arch , arch_len , ( void * * ) & pphar ) ;
efree ( arch ) ;
efree ( entry ) ;
}
}
/* retrieving an include within the current directory, so use this if possible */
2008-03-23 13:39:58 +08:00
if ( ! ( entry = phar_find_in_include_path ( ( char * ) filename , strlen ( filename ) , NULL TSRMLS_CC ) ) ) {
2008-03-12 11:55:12 +08:00
/* this file is not in the phar, use the original path */
goto skip_phar ;
}
if ( SUCCESS = = phar_orig_zend_open ( entry , handle TSRMLS_CC ) ) {
if ( ! handle - > opened_path ) {
handle - > opened_path = entry ;
}
2008-03-23 05:54:55 +08:00
if ( entry ! = filename ) {
handle - > free_filename = 1 ;
}
2008-03-12 11:55:12 +08:00
return SUCCESS ;
}
if ( entry ! = filename ) {
efree ( entry ) ;
}
return FAILURE ;
}
if ( 0 & & zend_hash_num_elements ( & ( PHAR_GLOBALS - > phar_fname_map ) ) ) {
2008-01-10 23:13:00 +08:00
char * fname = NULL ;
int fname_len ;
fname = zend_get_executed_filename ( TSRMLS_C ) ;
2007-12-10 05:57:44 +08:00
if ( strncasecmp ( fname , " phar:// " , 7 ) ) {
goto skip_phar ;
}
fname_len = strlen ( fname ) ;
if ( SUCCESS = = phar_split_fname ( fname , fname_len , & arch , & arch_len , & entry , & entry_len TSRMLS_CC ) ) {
2008-02-13 23:00:31 +08:00
char * name , * old ;
2008-01-10 23:13:00 +08:00
2008-02-13 23:00:31 +08:00
old = entry ;
2008-01-10 23:13:00 +08:00
entry = ( char * ) filename ;
2007-12-10 05:57:44 +08:00
/* include within phar, if :// is not in the url, then prepend phar://<archive>/ */
2008-01-01 06:42:40 +08:00
if ( strstr ( entry , " :// " ) ) {
efree ( arch ) ;
2008-02-13 23:00:31 +08:00
efree ( old ) ;
2008-01-01 06:42:40 +08:00
goto skip_phar ;
2007-12-10 05:57:44 +08:00
}
2008-01-01 06:42:40 +08:00
entry_len = strlen ( entry ) ;
2008-01-10 23:13:00 +08:00
if ( ! IS_ABSOLUTE_PATH ( entry , entry_len ) ) {
2008-03-23 13:39:58 +08:00
phar_archive_data * pphar = NULL ;
2008-01-10 23:13:00 +08:00
/* retrieving an include within the current directory, so use this if possible */
if ( SUCCESS = = ( zend_hash_find ( & ( PHAR_GLOBALS - > phar_fname_map ) , arch , arch_len , ( void * * ) & pphar ) ) ) {
2008-03-23 13:39:58 +08:00
if ( ! ( entry = phar_find_in_include_path ( entry , entry_len , & phar TSRMLS_CC ) ) ) {
2008-02-13 23:00:31 +08:00
/* this file is not in the phar, use the original path */
2008-02-18 11:37:51 +08:00
if ( SUCCESS = = phar_orig_zend_open ( filename , handle TSRMLS_CC ) ) {
2008-03-23 13:39:58 +08:00
if ( SUCCESS = = phar_mount_entry ( phar , handle - > opened_path ? handle - > opened_path : ( char * ) filename , strlen ( handle - > opened_path ? handle - > opened_path : filename ) , ( char * ) filename , strlen ( filename ) TSRMLS_CC ) ) {
2008-02-24 03:44:51 +08:00
if ( handle - > opened_path ) {
efree ( handle - > opened_path ) ;
}
2008-02-18 11:37:51 +08:00
entry = ( char * ) filename ;
goto dopharthing ;
}
}
2008-02-13 23:00:31 +08:00
efree ( old ) ;
efree ( arch ) ;
2008-02-24 03:26:18 +08:00
return FAILURE ;
2008-01-10 23:13:00 +08:00
}
}
}
2008-02-18 11:37:51 +08:00
dopharthing :
2008-02-13 23:00:31 +08:00
efree ( old ) ;
2007-12-10 05:57:44 +08:00
/* auto-convert to phar:// */
spprintf ( & name , 4096 , " phar://%s/%s " , arch , entry ) ;
efree ( arch ) ;
2008-02-13 23:00:31 +08:00
if ( entry ! = filename ) {
efree ( entry ) ;
}
2008-01-10 23:13:00 +08:00
if ( SUCCESS = = phar_orig_zend_open ( name , handle TSRMLS_CC ) ) {
if ( ! handle - > opened_path ) {
handle - > opened_path = name ;
}
return SUCCESS ;
2008-01-08 06:21:10 +08:00
}
2008-01-10 23:13:00 +08:00
return FAILURE ;
2007-12-10 05:57:44 +08:00
}
}
skip_phar :
2008-01-10 23:13:00 +08:00
return phar_orig_zend_open ( filename , handle TSRMLS_CC ) ;
}
/* }}} */
2008-03-12 11:55:12 +08:00
# endif
2008-01-10 23:13:00 +08:00
2006-03-08 08:56:31 +08:00
PHP_MINIT_FUNCTION ( phar ) /* {{{ */
2006-01-03 23:50:46 +08:00
{
ZEND_INIT_MODULE_GLOBALS ( phar , php_phar_init_globals_module , NULL ) ;
2007-01-08 00:01:35 +08:00
REGISTER_INI_ENTRIES ( ) ;
2006-01-03 23:50:46 +08:00
2007-12-19 01:01:24 +08:00
phar_has_bz2 = zend_hash_exists ( & module_registry , " bz2 " , sizeof ( " bz2 " ) ) ;
phar_has_zlib = zend_hash_exists ( & module_registry , " zlib " , sizeof ( " zlib " ) ) ;
2008-03-12 11:55:12 +08:00
# if PHP_VERSION_ID >= 50300
phar_save_resolve_path = zend_resolve_path ;
zend_resolve_path = phar_resolve_path ;
# else
2008-01-10 23:13:00 +08:00
phar_orig_zend_open = zend_stream_open_function ;
zend_stream_open_function = phar_zend_open ;
2008-03-12 11:55:12 +08:00
# endif
phar_orig_compile_file = zend_compile_file ;
zend_compile_file = phar_compile_file ;
2008-01-10 23:13:00 +08:00
2007-01-21 23:25:50 +08:00
phar_object_init ( TSRMLS_C ) ;
2006-01-04 10:26:15 +08:00
2006-01-03 23:50:46 +08:00
return php_register_url_stream_wrapper ( " phar " , & php_stream_phar_wrapper TSRMLS_CC ) ;
}
/* }}} */
2006-03-08 08:56:31 +08:00
PHP_MSHUTDOWN_FUNCTION ( phar ) /* {{{ */
2006-01-03 23:50:46 +08:00
{
return php_unregister_url_stream_wrapper ( " phar " TSRMLS_CC ) ;
2007-12-12 03:28:35 +08:00
if ( zend_compile_file = = phar_compile_file ) {
2007-12-19 01:01:24 +08:00
zend_compile_file = phar_orig_compile_file ;
2007-12-12 03:28:35 +08:00
}
2008-03-12 11:55:12 +08:00
# if PHP_VERSION_ID < 50300
2008-01-10 23:13:00 +08:00
if ( zend_stream_open_function = = phar_zend_open ) {
zend_stream_open_function = phar_orig_zend_open ;
}
2008-03-12 11:55:12 +08:00
# endif
2006-01-03 23:50:46 +08:00
}
/* }}} */
2007-05-17 07:16:51 +08:00
void phar_request_initialize ( TSRMLS_D ) /* { { { */
{
if ( ! PHAR_GLOBALS - > request_init )
{
PHAR_GLOBALS - > request_init = 1 ;
2007-05-21 05:46:54 +08:00
PHAR_GLOBALS - > request_ends = 0 ;
PHAR_GLOBALS - > request_done = 0 ;
2007-05-17 07:16:51 +08:00
zend_hash_init ( & ( PHAR_GLOBALS - > phar_fname_map ) , sizeof ( phar_archive_data * ) , zend_get_hash_value , destroy_phar_data , 0 ) ;
zend_hash_init ( & ( PHAR_GLOBALS - > phar_alias_map ) , sizeof ( phar_archive_data * ) , zend_get_hash_value , NULL , 0 ) ;
zend_hash_init ( & ( PHAR_GLOBALS - > phar_plain_map ) , sizeof ( const char * ) , zend_get_hash_value , NULL , 0 ) ;
2008-01-04 12:57:11 +08:00
zend_hash_init ( & ( PHAR_GLOBALS - > phar_SERVER_mung_list ) , sizeof ( const char * ) , zend_get_hash_value , NULL , 0 ) ;
2007-05-17 07:16:51 +08:00
phar_split_extract_list ( TSRMLS_C ) ;
2008-01-11 05:21:38 +08:00
PHAR_G ( cwd ) = NULL ;
PHAR_G ( cwd_len ) = 0 ;
2008-02-13 23:00:31 +08:00
PHAR_G ( cwd_init ) = 0 ;
2008-01-11 15:30:03 +08:00
phar_intercept_functions ( TSRMLS_C ) ;
2007-05-17 07:16:51 +08:00
}
}
2006-01-03 23:50:46 +08:00
/* }}} */
2006-03-08 08:56:31 +08:00
PHP_RSHUTDOWN_FUNCTION ( phar ) /* {{{ */
2006-01-03 23:50:46 +08:00
{
2007-03-28 05:28:22 +08:00
PHAR_GLOBALS - > request_ends = 1 ;
2007-05-17 07:16:51 +08:00
if ( PHAR_GLOBALS - > request_init )
{
2008-01-11 15:30:03 +08:00
phar_release_functions ( TSRMLS_C ) ;
2007-05-17 07:16:51 +08:00
zend_hash_destroy ( & ( PHAR_GLOBALS - > phar_alias_map ) ) ;
2008-01-04 09:45:37 +08:00
PHAR_GLOBALS - > phar_alias_map . arBuckets = NULL ;
2007-05-17 07:16:51 +08:00
zend_hash_destroy ( & ( PHAR_GLOBALS - > phar_fname_map ) ) ;
2008-01-04 09:45:37 +08:00
PHAR_GLOBALS - > phar_fname_map . arBuckets = NULL ;
2007-05-17 07:16:51 +08:00
zend_hash_destroy ( & ( PHAR_GLOBALS - > phar_plain_map ) ) ;
2008-01-04 09:45:37 +08:00
PHAR_GLOBALS - > phar_plain_map . arBuckets = NULL ;
2008-01-04 12:57:11 +08:00
zend_hash_destroy ( & ( PHAR_GLOBALS - > phar_SERVER_mung_list ) ) ;
PHAR_GLOBALS - > phar_SERVER_mung_list . arBuckets = NULL ;
2007-05-21 06:14:07 +08:00
PHAR_GLOBALS - > request_init = 0 ;
2008-01-10 23:13:00 +08:00
if ( PHAR_G ( cwd ) ) {
efree ( PHAR_G ( cwd ) ) ;
}
PHAR_G ( cwd ) = NULL ;
PHAR_G ( cwd_len ) = 0 ;
2008-02-13 23:00:31 +08:00
PHAR_G ( cwd_init ) = 0 ;
2007-05-17 07:16:51 +08:00
}
2007-01-27 23:31:24 +08:00
PHAR_GLOBALS - > request_done = 1 ;
2006-01-03 23:50:46 +08:00
return SUCCESS ;
}
/* }}} */
2006-03-08 08:56:31 +08:00
PHP_MINFO_FUNCTION ( phar ) /* {{{ */
2006-01-03 23:50:46 +08:00
{
php_info_print_table_start ( ) ;
2006-01-13 05:16:29 +08:00
php_info_print_table_header ( 2 , " Phar: PHP Archive support " , " enabled " ) ;
2008-03-23 01:09:24 +08:00
php_info_print_table_row ( 2 , " Phar EXT version " , PHP_PHAR_VERSION ) ;
php_info_print_table_row ( 2 , " Phar API version " , PHP_PHAR_API_VERSION ) ;
2006-01-03 23:50:46 +08:00
php_info_print_table_row ( 2 , " CVS revision " , " $Revision$ " ) ;
2008-01-05 00:10:49 +08:00
php_info_print_table_row ( 2 , " Phar-based phar archives " , " enabled " ) ;
php_info_print_table_row ( 2 , " Tar-based phar archives " , " enabled " ) ;
2008-01-28 16:52:08 +08:00
php_info_print_table_row ( 2 , " ZIP-based phar archives " , " enabled " ) ;
2007-12-19 01:01:24 +08:00
if ( phar_has_zlib ) {
2008-01-05 00:10:49 +08:00
php_info_print_table_row ( 2 , " gzip compression " , " enabled " ) ;
2007-11-25 13:04:40 +08:00
} else {
2008-01-12 13:17:12 +08:00
php_info_print_table_row ( 2 , " gzip compression " , " disabled (install ext/zlib) " ) ;
2007-11-25 13:04:40 +08:00
}
2008-01-05 00:10:49 +08:00
if ( phar_has_bz2 ) {
php_info_print_table_row ( 2 , " bzip2 compression " , " enabled " ) ;
2007-11-24 12:06:44 +08:00
} else {
2008-01-05 00:10:49 +08:00
php_info_print_table_row ( 2 , " bzip2 compression " , " disabled (install pecl/bz2) " ) ;
2007-11-24 12:06:44 +08:00
}
2006-01-03 23:50:46 +08:00
php_info_print_table_end ( ) ;
2007-03-26 03:03:38 +08:00
php_info_print_box_start ( 0 ) ;
PUTS ( " Phar based on pear/PHP_Archive, original concept by Davey Shafik. " ) ;
PUTS ( ! sapi_module . phpinfo_as_text ? " <br /> " : " \n " ) ;
PUTS ( " Phar fully realized by Gregory Beaver and Marcus Boerger. " ) ;
2008-01-12 13:17:12 +08:00
PUTS ( ! sapi_module . phpinfo_as_text ? " <br /> " : " \n " ) ;
2008-01-09 03:40:23 +08:00
PUTS ( " Portions of tar implementation Copyright (c) 2003-2007 Tim Kientzle. " ) ;
2007-03-26 03:03:38 +08:00
php_info_print_box_end ( ) ;
2007-01-08 00:01:35 +08:00
DISPLAY_INI_ENTRIES ( ) ;
2006-01-03 23:50:46 +08:00
}
/* }}} */
/* {{{ phar_module_entry
*/
2006-01-13 05:16:29 +08:00
static zend_module_dep phar_deps [ ] = {
2007-11-25 13:04:40 +08:00
ZEND_MOD_OPTIONAL ( " zlib " )
2007-11-24 12:06:44 +08:00
ZEND_MOD_OPTIONAL ( " bz2 " )
2007-01-21 23:25:50 +08:00
# if HAVE_SPL
2006-02-28 09:36:30 +08:00
ZEND_MOD_REQUIRED ( " spl " )
2007-01-21 23:25:50 +08:00
# endif
2006-01-13 05:16:29 +08:00
{ NULL , NULL , NULL }
} ;
zend_module_entry phar_module_entry = {
STANDARD_MODULE_HEADER_EX , NULL ,
phar_deps ,
2006-01-04 10:26:15 +08:00
" Phar " ,
2006-01-03 23:50:46 +08:00
phar_functions ,
PHP_MINIT ( phar ) ,
PHP_MSHUTDOWN ( phar ) ,
2007-05-17 07:20:31 +08:00
NULL ,
2006-01-03 23:50:46 +08:00
PHP_RSHUTDOWN ( phar ) ,
PHP_MINFO ( phar ) ,
2008-03-23 01:09:24 +08:00
PHP_PHAR_VERSION ,
2006-01-03 23:50:46 +08:00
STANDARD_MODULE_PROPERTIES
} ;
/* }}} */
2005-12-05 04:35:38 +08:00
/*
* Local variables :
* tab - width : 4
* c - basic - offset : 4
* End :
* vim600 : noet sw = 4 ts = 4 fdm = marker
* vim < 600 : noet sw = 4 ts = 4
*/