PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/phar - tar.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 517 732 70.6 %
Date: 2014-04-19 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | TAR archive support for Phar                                         |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 2005-2014 The PHP Group                                |
       6             :   +----------------------------------------------------------------------+
       7             :   | This source file is subject to version 3.01 of the PHP license,      |
       8             :   | that is bundled with this package in the file LICENSE, and is        |
       9             :   | available through the world-wide-web at the following url:           |
      10             :   | http://www.php.net/license/3_01.txt.                                 |
      11             :   | If you did not receive a copy of the PHP license and are unable to   |
      12             :   | obtain it through the world-wide-web, please send a note to          |
      13             :   | license@php.net so we can mail you a copy immediately.               |
      14             :   +----------------------------------------------------------------------+
      15             :   | Authors: Dmitry Stogov <dmitry@zend.com>                             |
      16             :   |          Gregory Beaver <cellog@php.net>                             |
      17             :   +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : #include "phar_internal.h"
      21             : 
      22        1467 : static php_uint32 phar_tar_number(char *buf, int len) /* {{{ */
      23             : {
      24        1467 :         php_uint32 num = 0;
      25        1467 :         int i = 0;
      26             : 
      27        3924 :         while (i < len && buf[i] == ' ') {
      28         990 :                 ++i;
      29             :         }
      30             : 
      31       13463 :         while (i < len && buf[i] >= '0' && buf[i] <= '7') {
      32       10529 :                 num = num * 8 + (buf[i] - '0');
      33       10529 :                 ++i;
      34             :         }
      35             : 
      36        1467 :         return num;
      37             : }
      38             : /* }}} */
      39             : 
      40             : /* adapted from format_octal() in libarchive
      41             :  *
      42             :  * Copyright (c) 2003-2009 Tim Kientzle
      43             :  * All rights reserved.
      44             :  *
      45             :  * Redistribution and use in source and binary forms, with or without
      46             :  * modification, are permitted provided that the following conditions
      47             :  * are met:
      48             :  * 1. Redistributions of source code must retain the above copyright
      49             :  *    notice, this list of conditions and the following disclaimer.
      50             :  * 2. Redistributions in binary form must reproduce the above copyright
      51             :  *    notice, this list of conditions and the following disclaimer in the
      52             :  *    documentation and/or other materials provided with the distribution.
      53             :  *
      54             :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
      55             :  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      56             :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
      57             :  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
      58             :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      59             :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      60             :  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      61             :  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      62             :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
      63             :  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      64             :  */
      65        3504 : static int phar_tar_octal(char *buf, php_uint32 val, int len) /* {{{ */
      66             : {
      67        3504 :         char *p = buf;
      68        3504 :         int s = len;
      69             : 
      70        3504 :         p += len;               /* Start at the end and work backwards. */
      71       38544 :         while (s-- > 0) {
      72       31536 :                 *--p = (char)('0' + (val & 7));
      73       31536 :                 val >>= 3;
      74             :         }
      75             : 
      76        3504 :         if (val == 0)
      77        3504 :                 return SUCCESS;
      78             : 
      79             :         /* If it overflowed, fill field with max value. */
      80           0 :         while (len-- > 0)
      81           0 :                 *p++ = '7';
      82             : 
      83           0 :         return FAILURE;
      84             : }
      85             : /* }}} */
      86             : 
      87        1343 : static php_uint32 phar_tar_checksum(char *buf, int len) /* {{{ */
      88             : {
      89        1343 :         php_uint32 sum = 0;
      90        1343 :         char *end = buf + len;
      91             : 
      92      681122 :         while (buf != end) {
      93      678436 :                 sum += (unsigned char)*buf;
      94      678436 :                 ++buf;
      95             :         }
      96        1343 :         return sum;
      97             : }
      98             : /* }}} */
      99             : 
     100         155 : int phar_is_tar(char *buf, char *fname) /* {{{ */
     101             : {
     102         155 :         tar_header *header = (tar_header *) buf;
     103         155 :         php_uint32 checksum = phar_tar_number(header->checksum, sizeof(header->checksum));
     104             :         php_uint32 ret;
     105             :         char save[sizeof(header->checksum)];
     106             : 
     107             :         /* assume that the first filename in a tar won't begin with <?php */
     108         155 :         if (!strncmp(buf, "<?php", sizeof("<?php")-1)) {
     109          81 :                 return 0;
     110             :         }
     111             : 
     112          74 :         memcpy(save, header->checksum, sizeof(header->checksum));
     113          74 :         memset(header->checksum, ' ', sizeof(header->checksum));
     114          74 :         ret = (checksum == phar_tar_checksum(buf, 512));
     115          74 :         memcpy(header->checksum, save, sizeof(header->checksum));
     116          74 :         if (!ret && strstr(fname, ".tar")) {
     117             :                 /* probably a corrupted tar - so we will pretend it is one */
     118           1 :                 return 1;
     119             :         }
     120          73 :         return ret;
     121             : }
     122             : /* }}} */
     123             : 
     124          76 : int phar_open_or_create_tar(char *fname, int fname_len, char *alias, int alias_len, int is_data, int options, phar_archive_data** pphar, char **error TSRMLS_DC) /* {{{ */
     125             : {
     126             :         phar_archive_data *phar;
     127          76 :         int ret = phar_create_or_parse_filename(fname, fname_len, alias, alias_len, is_data, options, &phar, error TSRMLS_CC);
     128             : 
     129          76 :         if (FAILURE == ret) {
     130          12 :                 return FAILURE;
     131             :         }
     132             : 
     133          64 :         if (pphar) {
     134          64 :                 *pphar = phar;
     135             :         }
     136             : 
     137          64 :         phar->is_data = is_data;
     138             : 
     139          64 :         if (phar->is_tar) {
     140          29 :                 return ret;
     141             :         }
     142             : 
     143          35 :         if (phar->is_brandnew) {
     144          34 :                 phar->is_tar = 1;
     145          34 :                 phar->is_zip = 0;
     146          34 :                 phar->internal_file_start = 0;
     147          34 :                 return SUCCESS;
     148             :         }
     149             : 
     150             :         /* we've reached here - the phar exists and is a regular phar */
     151           1 :         if (error) {
     152           1 :                 spprintf(error, 4096, "phar tar error: \"%s\" already exists as a regular phar and must be deleted from disk prior to creating as a tar-based phar", fname);
     153             :         }
     154           1 :         return FAILURE;
     155             : }
     156             : /* }}} */
     157             : 
     158           3 : static int phar_tar_process_metadata(phar_entry_info *entry, php_stream *fp TSRMLS_DC) /* {{{ */
     159             : {
     160             :         char *metadata;
     161           3 :         size_t save = php_stream_tell(fp), read;
     162             :         phar_entry_info *mentry;
     163             : 
     164           3 :         metadata = (char *) safe_emalloc(1, entry->uncompressed_filesize, 1);
     165             : 
     166           3 :         read = php_stream_read(fp, metadata, entry->uncompressed_filesize);
     167           3 :         if (read != entry->uncompressed_filesize) {
     168           0 :                 efree(metadata);
     169           0 :                 php_stream_seek(fp, save, SEEK_SET);
     170           0 :                 return FAILURE;
     171             :         }
     172             : 
     173           3 :         if (phar_parse_metadata(&metadata, &entry->metadata, entry->uncompressed_filesize TSRMLS_CC) == FAILURE) {
     174             :                 /* if not valid serialized data, it is a regular string */
     175           0 :                 efree(metadata);
     176           0 :                 php_stream_seek(fp, save, SEEK_SET);
     177           0 :                 return FAILURE;
     178             :         }
     179             : 
     180           5 :         if (entry->filename_len == sizeof(".phar/.metadata.bin")-1 && !memcmp(entry->filename, ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1)) {
     181           2 :                 entry->phar->metadata = entry->metadata;
     182           2 :                 entry->metadata = NULL;
     183           1 :         } else if (entry->filename_len >= sizeof(".phar/.metadata/") + sizeof("/.metadata.bin") - 1 && SUCCESS == zend_hash_find(&(entry->phar->manifest), entry->filename + sizeof(".phar/.metadata/") - 1, entry->filename_len - (sizeof("/.metadata.bin") - 1 + sizeof(".phar/.metadata/") - 1), (void *)&mentry)) {
     184             :                 /* transfer this metadata to the entry it refers */
     185           1 :                 mentry->metadata = entry->metadata;
     186           1 :                 entry->metadata = NULL;
     187             :         }
     188             : 
     189           3 :         efree(metadata);
     190           3 :         php_stream_seek(fp, save, SEEK_SET);
     191           3 :         return SUCCESS;
     192             : }
     193             : /* }}} */
     194             : 
     195          72 : int phar_parse_tarfile(php_stream* fp, char *fname, int fname_len, char *alias, int alias_len, phar_archive_data** pphar, int is_data, php_uint32 compression, char **error TSRMLS_DC) /* {{{ */
     196             : {
     197          72 :         char buf[512], *actual_alias = NULL, *p;
     198          72 :         phar_entry_info entry = {0};
     199          72 :         size_t pos = 0, read, totalsize;
     200             :         tar_header *hdr;
     201             :         php_uint32 sum1, sum2, size, old;
     202             :         phar_archive_data *myphar, **actual;
     203          72 :         int last_was_longlink = 0;
     204             : 
     205          72 :         if (error) {
     206          47 :                 *error = NULL;
     207             :         }
     208             : 
     209          72 :         php_stream_seek(fp, 0, SEEK_END);
     210          72 :         totalsize = php_stream_tell(fp);
     211          72 :         php_stream_seek(fp, 0, SEEK_SET);
     212          72 :         read = php_stream_read(fp, buf, sizeof(buf));
     213             : 
     214          72 :         if (read != sizeof(buf)) {
     215           0 :                 if (error) {
     216           0 :                         spprintf(error, 4096, "phar error: \"%s\" is not a tar file or is truncated", fname);
     217             :                 }
     218           0 :                 php_stream_close(fp);
     219           0 :                 return FAILURE;
     220             :         }
     221             : 
     222          72 :         hdr = (tar_header*)buf;
     223          72 :         old = (memcmp(hdr->magic, "ustar", sizeof("ustar")-1) != 0);
     224             : 
     225          72 :         myphar = (phar_archive_data *) pecalloc(1, sizeof(phar_archive_data), PHAR_G(persist));
     226          72 :         myphar->is_persistent = PHAR_G(persist);
     227             :         /* estimate number of entries, can't be certain with tar files */
     228          72 :         zend_hash_init(&myphar->manifest, 2 + (totalsize >> 12),
     229             :                 zend_get_hash_value, destroy_phar_manifest_entry, (zend_bool)myphar->is_persistent);
     230          72 :         zend_hash_init(&myphar->mounted_dirs, 5,
     231             :                 zend_get_hash_value, NULL, (zend_bool)myphar->is_persistent);
     232          72 :         zend_hash_init(&myphar->virtual_dirs, 4 + (totalsize >> 11),
     233             :                 zend_get_hash_value, NULL, (zend_bool)myphar->is_persistent);
     234          72 :         myphar->is_tar = 1;
     235             :         /* remember whether this entire phar was compressed with gz/bzip2 */
     236          72 :         myphar->flags = compression;
     237             : 
     238          72 :         entry.is_tar = 1;
     239          72 :         entry.is_crc_checked = 1;
     240          72 :         entry.phar = myphar;
     241          72 :         pos += sizeof(buf);
     242             : 
     243             :         do {
     244             :                 phar_entry_info *newentry;
     245             : 
     246         357 :                 pos = php_stream_tell(fp);
     247         357 :                 hdr = (tar_header*) buf;
     248         357 :                 sum1 = phar_tar_number(hdr->checksum, sizeof(hdr->checksum));
     249         357 :                 if (sum1 == 0 && phar_tar_checksum(buf, sizeof(buf)) == 0) {
     250          24 :                         break;
     251             :                 }
     252         333 :                 memset(hdr->checksum, ' ', sizeof(hdr->checksum));
     253         333 :                 sum2 = phar_tar_checksum(buf, old?sizeof(old_tar_header):sizeof(tar_header));
     254             : 
     255         333 :                 size = entry.uncompressed_filesize = entry.compressed_filesize =
     256         333 :                         phar_tar_number(hdr->size, sizeof(hdr->size));
     257             : 
     258         333 :                 if (((!old && hdr->prefix[0] == 0) || old) && strlen(hdr->name) == sizeof(".phar/signature.bin")-1 && !strncmp(hdr->name, ".phar/signature.bin", sizeof(".phar/signature.bin")-1)) {
     259             :                         off_t curloc;
     260             : 
     261          36 :                         if (size > 511) {
     262           0 :                                 if (error) {
     263           0 :                                         spprintf(error, 4096, "phar error: tar-based phar \"%s\" has signature that is larger than 511 bytes, cannot process", fname);
     264             :                                 }
     265             : bail:
     266           0 :                                 php_stream_close(fp);
     267           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     268           0 :                                 return FAILURE;
     269             :                         }
     270          36 :                         curloc = php_stream_tell(fp);
     271          36 :                         read = php_stream_read(fp, buf, size);
     272          36 :                         if (read != size) {
     273           0 :                                 if (error) {
     274           0 :                                         spprintf(error, 4096, "phar error: tar-based phar \"%s\" signature cannot be read", fname);
     275             :                                 }
     276           0 :                                 goto bail;
     277             :                         }
     278             : #ifdef WORDS_BIGENDIAN
     279             : # define PHAR_GET_32(buffer) \
     280             :         (((((unsigned char*)(buffer))[3]) << 24) \
     281             :                 | ((((unsigned char*)(buffer))[2]) << 16) \
     282             :                 | ((((unsigned char*)(buffer))[1]) <<  8) \
     283             :                 | (((unsigned char*)(buffer))[0]))
     284             : #else
     285             : # define PHAR_GET_32(buffer) (php_uint32) *(buffer)
     286             : #endif
     287          36 :                         myphar->sig_flags = PHAR_GET_32(buf);
     288          36 :                         if (FAILURE == phar_verify_signature(fp, php_stream_tell(fp) - size - 512, myphar->sig_flags, buf + 8, size - 8, fname, &myphar->signature, &myphar->sig_len, error TSRMLS_CC)) {
     289           0 :                                 if (error) {
     290           0 :                                         char *save = *error;
     291           0 :                                         spprintf(error, 4096, "phar error: tar-based phar \"%s\" signature cannot be verified: %s", fname, save);
     292           0 :                                         efree(save);
     293             :                                 }
     294           0 :                                 goto bail;
     295             :                         }
     296          36 :                         php_stream_seek(fp, curloc + 512, SEEK_SET);
     297             :                         /* signature checked out, let's ensure this is the last file in the phar */
     298          36 :                         if (((hdr->typeflag == '\0') || (hdr->typeflag == TAR_FILE)) && size > 0) {
     299             :                                 /* this is not good enough - seek succeeds even on truncated tars */
     300          35 :                                 php_stream_seek(fp, 512, SEEK_CUR);
     301          35 :                                 if ((uint)php_stream_tell(fp) > totalsize) {
     302           0 :                                         if (error) {
     303           0 :                                                 spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     304             :                                         }
     305           0 :                                         php_stream_close(fp);
     306           0 :                                         phar_destroy_phar_data(myphar TSRMLS_CC);
     307           0 :                                         return FAILURE;
     308             :                                 }
     309             :                         }
     310             : 
     311          36 :                         read = php_stream_read(fp, buf, sizeof(buf));
     312             : 
     313          36 :                         if (read != sizeof(buf)) {
     314           0 :                                 if (error) {
     315           0 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     316             :                                 }
     317           0 :                                 php_stream_close(fp);
     318           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     319           0 :                                 return FAILURE;
     320             :                         }
     321             : 
     322          36 :                         hdr = (tar_header*) buf;
     323          36 :                         sum1 = phar_tar_number(hdr->checksum, sizeof(hdr->checksum));
     324             : 
     325          36 :                         if (sum1 == 0 && phar_tar_checksum(buf, sizeof(buf)) == 0) {
     326          36 :                                 break;
     327             :                         }
     328             : 
     329           0 :                         if (error) {
     330           0 :                                 spprintf(error, 4096, "phar error: \"%s\" has entries after signature, invalid phar", fname);
     331             :                         }
     332             : 
     333           0 :                         goto bail;
     334             :                 }
     335             : 
     336         297 :                 if (!last_was_longlink && hdr->typeflag == 'L') {
     337           3 :                         last_was_longlink = 1;
     338             :                         /* support the ././@LongLink system for storing long filenames */
     339           3 :                         entry.filename_len = entry.uncompressed_filesize;
     340             : 
     341             :                         /* Check for overflow - bug 61065 */
     342           3 :                         if (entry.filename_len == UINT_MAX) {
     343           0 :                                 if (error) {
     344           0 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (invalid entry size)", fname);
     345             :                                 }
     346           0 :                                 php_stream_close(fp);
     347           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     348           0 :                                 return FAILURE;
     349             :                         }
     350           3 :                         entry.filename = pemalloc(entry.filename_len+1, myphar->is_persistent);
     351             : 
     352           3 :                         read = php_stream_read(fp, entry.filename, entry.filename_len);
     353           3 :                         if (read != entry.filename_len) {
     354           0 :                                 efree(entry.filename);
     355           0 :                                 if (error) {
     356           0 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     357             :                                 }
     358           0 :                                 php_stream_close(fp);
     359           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     360           0 :                                 return FAILURE;
     361             :                         }
     362           3 :                         entry.filename[entry.filename_len] = '\0';
     363             : 
     364             :                         /* skip blank stuff */
     365           3 :                         size = ((size+511)&~511) - size;
     366             : 
     367             :                         /* this is not good enough - seek succeeds even on truncated tars */
     368           3 :                         php_stream_seek(fp, size, SEEK_CUR);
     369           3 :                         if ((uint)php_stream_tell(fp) > totalsize) {
     370           0 :                                 efree(entry.filename);
     371           0 :                                 if (error) {
     372           0 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     373             :                                 }
     374           0 :                                 php_stream_close(fp);
     375           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     376           0 :                                 return FAILURE;
     377             :                         }
     378             : 
     379           3 :                         read = php_stream_read(fp, buf, sizeof(buf));
     380             : 
     381           3 :                         if (read != sizeof(buf)) {
     382           0 :                                 efree(entry.filename);
     383           0 :                                 if (error) {
     384           0 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     385             :                                 }
     386           0 :                                 php_stream_close(fp);
     387           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     388           0 :                                 return FAILURE;
     389             :                         }
     390           3 :                         continue;
     391         298 :                 } else if (!last_was_longlink && !old && hdr->prefix[0] != 0) {
     392             :                         char name[256];
     393             :                         int i, j;
     394             : 
     395         415 :                         for (i = 0; i < 155; i++) {
     396         413 :                                 name[i] = hdr->prefix[i];
     397         413 :                                 if (name[i] == '\0') {
     398           2 :                                         break;
     399             :                                 }
     400             :                         }
     401           4 :                         name[i++] = '/';
     402         305 :                         for (j = 0; j < 100; j++) {
     403         302 :                                 name[i+j] = hdr->name[j];
     404         302 :                                 if (name[i+j] == '\0') {
     405           1 :                                         break;
     406             :                                 }
     407             :                         }
     408             : 
     409           4 :                         entry.filename_len = i+j;
     410             : 
     411           4 :                         if (name[entry.filename_len - 1] == '/') {
     412             :                                 /* some tar programs store directories with trailing slash */
     413           0 :                                 entry.filename_len--;
     414             :                         }
     415           4 :                         entry.filename = pestrndup(name, entry.filename_len, myphar->is_persistent);
     416         290 :                 } else if (!last_was_longlink) {
     417             :                         int i;
     418             : 
     419             :                         /* calculate strlen, which can be no longer than 100 */
     420        4678 :                         for (i = 0; i < 100; i++) {
     421        4678 :                                 if (hdr->name[i] == '\0') {
     422         287 :                                         break;
     423             :                                 }
     424             :                         }
     425         287 :                         entry.filename_len = i;
     426         287 :                         entry.filename = pestrndup(hdr->name, i, myphar->is_persistent);
     427             : 
     428         287 :                         if (entry.filename[entry.filename_len - 1] == '/') {
     429             :                                 /* some tar programs store directories with trailing slash */
     430          23 :                                 entry.filename[entry.filename_len - 1] = '\0';
     431          23 :                                 entry.filename_len--;
     432             :                         }
     433             :                 }
     434         294 :                 last_was_longlink = 0;
     435             : 
     436         294 :                 phar_add_virtual_dirs(myphar, entry.filename, entry.filename_len TSRMLS_CC);
     437             : 
     438         294 :                 if (sum1 != sum2) {
     439           1 :                         if (error) {
     440           1 :                                 spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (checksum mismatch of file \"%s\")", fname, entry.filename);
     441             :                         }
     442           1 :                         pefree(entry.filename, myphar->is_persistent);
     443           1 :                         php_stream_close(fp);
     444           1 :                         phar_destroy_phar_data(myphar TSRMLS_CC);
     445           1 :                         return FAILURE;
     446             :                 }
     447             : 
     448         293 :                 entry.tar_type = ((old & (hdr->typeflag == '\0')) ? TAR_FILE : hdr->typeflag);
     449         293 :                 entry.offset = entry.offset_abs = pos; /* header_offset unused in tar */
     450         293 :                 entry.fp_type = PHAR_FP;
     451         293 :                 entry.flags = phar_tar_number(hdr->mode, sizeof(hdr->mode)) & PHAR_ENT_PERM_MASK;
     452         293 :                 entry.timestamp = phar_tar_number(hdr->mtime, sizeof(hdr->mtime));
     453         293 :                 entry.is_persistent = myphar->is_persistent;
     454             : #ifndef S_ISDIR
     455             : #define S_ISDIR(mode)   (((mode)&S_IFMT) == S_IFDIR)
     456             : #endif
     457         293 :                 if (old && entry.tar_type == TAR_FILE && S_ISDIR(entry.flags)) {
     458           0 :                         entry.tar_type = TAR_DIR;
     459             :                 }
     460             : 
     461         293 :                 if (entry.tar_type == TAR_DIR) {
     462          40 :                         entry.is_dir = 1;
     463             :                 } else {
     464         253 :                         entry.is_dir = 0;
     465             :                 }
     466             : 
     467         293 :                 entry.link = NULL;
     468             : 
     469         293 :                 if (entry.tar_type == TAR_LINK) {
     470           3 :                         if (!zend_hash_exists(&myphar->manifest, hdr->linkname, strlen(hdr->linkname))) {
     471           1 :                                 if (error) {
     472           1 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file - hard link to non-existent file \"%s\"", fname, hdr->linkname);
     473             :                                 }
     474           1 :                                 pefree(entry.filename, entry.is_persistent);
     475           1 :                                 php_stream_close(fp);
     476           1 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     477           1 :                                 return FAILURE;
     478             :                         }
     479           2 :                         entry.link = estrdup(hdr->linkname);
     480         290 :                 } else if (entry.tar_type == TAR_SYMLINK) {
     481           7 :                         entry.link = estrdup(hdr->linkname);
     482             :                 }
     483         292 :                 phar_set_inode(&entry TSRMLS_CC);
     484         292 :                 zend_hash_add(&myphar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), (void **) &newentry);
     485             : 
     486         292 :                 if (entry.is_persistent) {
     487           0 :                         ++entry.manifest_pos;
     488             :                 }
     489             : 
     490         292 :                 if (entry.filename_len >= sizeof(".phar/.metadata")-1 && !memcmp(entry.filename, ".phar/.metadata", sizeof(".phar/.metadata")-1)) {
     491           3 :                         if (FAILURE == phar_tar_process_metadata(newentry, fp TSRMLS_CC)) {
     492           0 :                                 if (error) {
     493           0 :                                         spprintf(error, 4096, "phar error: tar-based phar \"%s\" has invalid metadata in magic file \"%s\"", fname, entry.filename);
     494             :                                 }
     495           0 :                                 php_stream_close(fp);
     496           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     497           0 :                                 return FAILURE;
     498             :                         }
     499             :                 }
     500             : 
     501         292 :                 if (!actual_alias && entry.filename_len == sizeof(".phar/alias.txt")-1 && !strncmp(entry.filename, ".phar/alias.txt", sizeof(".phar/alias.txt")-1)) {
     502             :                         /* found explicit alias */
     503          10 :                         if (size > 511) {
     504           1 :                                 if (error) {
     505           1 :                                         spprintf(error, 4096, "phar error: tar-based phar \"%s\" has alias that is larger than 511 bytes, cannot process", fname);
     506             :                                 }
     507           1 :                                 php_stream_close(fp);
     508           1 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     509           1 :                                 return FAILURE;
     510             :                         }
     511             : 
     512           9 :                         read = php_stream_read(fp, buf, size);
     513             : 
     514           9 :                         if (read == size) {
     515           9 :                                 buf[size] = '\0';
     516           9 :                                 if (!phar_validate_alias(buf, size)) {
     517           4 :                                         if (size > 50) {
     518           1 :                                                 buf[50] = '.';
     519           1 :                                                 buf[51] = '.';
     520           1 :                                                 buf[52] = '.';
     521           1 :                                                 buf[53] = '\0';
     522             :                                         }
     523             : 
     524           4 :                                         if (error) {
     525           4 :                                                 spprintf(error, 4096, "phar error: invalid alias \"%s\" in tar-based phar \"%s\"", buf, fname);
     526             :                                         }
     527             : 
     528           4 :                                         php_stream_close(fp);
     529           4 :                                         phar_destroy_phar_data(myphar TSRMLS_CC);
     530           4 :                                         return FAILURE;
     531             :                                 }
     532             : 
     533           5 :                                 actual_alias = pestrndup(buf, size, myphar->is_persistent);
     534           5 :                                 myphar->alias = actual_alias;
     535           5 :                                 myphar->alias_len = size;
     536           5 :                                 php_stream_seek(fp, pos, SEEK_SET);
     537             :                         } else {
     538           0 :                                 if (error) {
     539           0 :                                         spprintf(error, 4096, "phar error: Unable to read alias from tar-based phar \"%s\"", fname);
     540             :                                 }
     541             : 
     542           0 :                                 php_stream_close(fp);
     543           0 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     544           0 :                                 return FAILURE;
     545             :                         }
     546             :                 }
     547             : 
     548         287 :                 size = (size+511)&~511;
     549             : 
     550         287 :                 if (((hdr->typeflag == '\0') || (hdr->typeflag == TAR_FILE)) && size > 0) {
     551             :                         /* this is not good enough - seek succeeds even on truncated tars */
     552         235 :                         php_stream_seek(fp, size, SEEK_CUR);
     553         235 :                         if ((uint)php_stream_tell(fp) > totalsize) {
     554           1 :                                 if (error) {
     555           1 :                                         spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     556             :                                 }
     557           1 :                                 php_stream_close(fp);
     558           1 :                                 phar_destroy_phar_data(myphar TSRMLS_CC);
     559           1 :                                 return FAILURE;
     560             :                         }
     561             :                 }
     562             : 
     563         286 :                 read = php_stream_read(fp, buf, sizeof(buf));
     564             : 
     565         286 :                 if (read != sizeof(buf)) {
     566           4 :                         if (error) {
     567           4 :                                 spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file (truncated)", fname);
     568             :                         }
     569           4 :                         php_stream_close(fp);
     570           4 :                         phar_destroy_phar_data(myphar TSRMLS_CC);
     571           4 :                         return FAILURE;
     572             :                 }
     573         285 :         } while (read != 0);
     574             : 
     575          60 :         if (zend_hash_exists(&(myphar->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1)) {
     576          45 :                 myphar->is_data = 0;
     577             :         } else {
     578          15 :                 myphar->is_data = 1;
     579             :         }
     580             : 
     581             :         /* ensure signature set */
     582          60 :         if (!myphar->is_data && PHAR_G(require_hash) && !myphar->signature) {
     583           1 :                 php_stream_close(fp);
     584           1 :                 phar_destroy_phar_data(myphar TSRMLS_CC);
     585           1 :                 if (error) {
     586           1 :                         spprintf(error, 0, "tar-based phar \"%s\" does not have a signature", fname);
     587             :                 }
     588           1 :                 return FAILURE;
     589             :         }
     590             : 
     591          59 :         myphar->fname = pestrndup(fname, fname_len, myphar->is_persistent);
     592             : #ifdef PHP_WIN32
     593             :         phar_unixify_path_separators(myphar->fname, fname_len);
     594             : #endif
     595          59 :         myphar->fname_len = fname_len;
     596          59 :         myphar->fp = fp;
     597          59 :         p = strrchr(myphar->fname, '/');
     598             : 
     599          59 :         if (p) {
     600          59 :                 myphar->ext = memchr(p, '.', (myphar->fname + fname_len) - p);
     601          59 :                 if (myphar->ext == p) {
     602           0 :                         myphar->ext = memchr(p + 1, '.', (myphar->fname + fname_len) - p - 1);
     603             :                 }
     604          59 :                 if (myphar->ext) {
     605          59 :                         myphar->ext_len = (myphar->fname + fname_len) - myphar->ext;
     606             :                 }
     607             :         }
     608             : 
     609          59 :         phar_request_initialize(TSRMLS_C);
     610             : 
     611          59 :         if (SUCCESS != zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len, (void*)&myphar, sizeof(phar_archive_data*), (void **)&actual)) {
     612           0 :                 if (error) {
     613           0 :                         spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\" to phar registry", fname);
     614             :                 }
     615           0 :                 php_stream_close(fp);
     616           0 :                 phar_destroy_phar_data(myphar TSRMLS_CC);
     617           0 :                 return FAILURE;
     618             :         }
     619             : 
     620          59 :         myphar = *actual;
     621             : 
     622          59 :         if (actual_alias) {
     623             :                 phar_archive_data **fd_ptr;
     624             : 
     625           5 :                 myphar->is_temporary_alias = 0;
     626             : 
     627           5 :                 if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, (void **)&fd_ptr)) {
     628           1 :                         if (SUCCESS != phar_free_alias(*fd_ptr, actual_alias, myphar->alias_len TSRMLS_CC)) {
     629           1 :                                 if (error) {
     630           1 :                                         spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname);
     631             :                                 }
     632           1 :                                 zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len);
     633           1 :                                 return FAILURE;
     634             :                         }
     635             :                 }
     636             : 
     637           4 :                 zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, (void*)&myphar, sizeof(phar_archive_data*), NULL);
     638             :         } else {
     639             :                 phar_archive_data **fd_ptr;
     640             : 
     641          54 :                 if (alias_len) {
     642           0 :                         if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void **)&fd_ptr)) {
     643           0 :                                 if (SUCCESS != phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) {
     644           0 :                                         if (error) {
     645           0 :                                                 spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname);
     646             :                                         }
     647           0 :                                         zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len);
     648           0 :                                         return FAILURE;
     649             :                                 }
     650             :                         }
     651           0 :                         zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&myphar, sizeof(phar_archive_data*), NULL);
     652           0 :                         myphar->alias = pestrndup(alias, alias_len, myphar->is_persistent);
     653           0 :                         myphar->alias_len = alias_len;
     654             :                 } else {
     655          54 :                         myphar->alias = pestrndup(myphar->fname, fname_len, myphar->is_persistent);
     656          54 :                         myphar->alias_len = fname_len;
     657             :                 }
     658             : 
     659          54 :                 myphar->is_temporary_alias = 1;
     660             :         }
     661             : 
     662          58 :         if (pphar) {
     663          53 :                 *pphar = myphar;
     664             :         }
     665             : 
     666          58 :         return SUCCESS;
     667             : }
     668             : /* }}} */
     669             : 
     670             : struct _phar_pass_tar_info {
     671             :         php_stream *old;
     672             :         php_stream *new;
     673             :         int free_fp;
     674             :         int free_ufp;
     675             :         char **error;
     676             : };
     677             : 
     678         887 : static int phar_tar_writeheaders(void *pDest, void *argument TSRMLS_DC) /* {{{ */
     679             : {
     680             :         tar_header header;
     681             :         size_t pos;
     682         887 :         phar_entry_info *entry = (phar_entry_info *) pDest;
     683         887 :         struct _phar_pass_tar_info *fp = (struct _phar_pass_tar_info *)argument;
     684             :         char padding[512];
     685             : 
     686         887 :         if (entry->is_mounted) {
     687           4 :                 return ZEND_HASH_APPLY_KEEP;
     688             :         }
     689             : 
     690         883 :         if (entry->is_deleted) {
     691           4 :                 if (entry->fp_refcount <= 0) {
     692           4 :                         return ZEND_HASH_APPLY_REMOVE;
     693             :                 } else {
     694             :                         /* we can't delete this in-memory until it is closed */
     695           0 :                         return ZEND_HASH_APPLY_KEEP;
     696             :                 }
     697             :         }
     698             : 
     699         879 :         phar_add_virtual_dirs(entry->phar, entry->filename, entry->filename_len TSRMLS_CC);
     700         879 :         memset((char *) &header, 0, sizeof(header));
     701             : 
     702         879 :         if (entry->filename_len > 100) {
     703             :                 char *boundary;
     704           8 :                 if (entry->filename_len > 256) {
     705           1 :                         if (fp->error) {
     706           1 :                                 spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, filename \"%s\" is too long for tar file format", entry->phar->fname, entry->filename);
     707             :                         }
     708           1 :                         return ZEND_HASH_APPLY_STOP;
     709             :                 }
     710           7 :                 boundary = entry->filename + entry->filename_len - 101;
     711         422 :                 while (*boundary && *boundary != '/') {
     712         408 :                         ++boundary;
     713             :                 }
     714           7 :                 if (!*boundary || ((boundary - entry->filename) > 155)) {
     715           2 :                         if (fp->error) {
     716           2 :                                 spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, filename \"%s\" is too long for tar file format", entry->phar->fname, entry->filename);
     717             :                         }
     718           2 :                         return ZEND_HASH_APPLY_STOP;
     719             :                 }
     720           5 :                 memcpy(header.prefix, entry->filename, boundary - entry->filename);
     721           5 :                 memcpy(header.name, boundary + 1, entry->filename_len - (boundary + 1 - entry->filename));
     722             :         } else {
     723         871 :                 memcpy(header.name, entry->filename, entry->filename_len);
     724             :         }
     725             : 
     726         876 :         phar_tar_octal(header.mode, entry->flags & PHAR_ENT_PERM_MASK, sizeof(header.mode)-1);
     727             : 
     728         876 :         if (FAILURE == phar_tar_octal(header.size, entry->uncompressed_filesize, sizeof(header.size)-1)) {
     729           0 :                 if (fp->error) {
     730           0 :                         spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, filename \"%s\" is too large for tar file format", entry->phar->fname, entry->filename);
     731             :                 }
     732           0 :                 return ZEND_HASH_APPLY_STOP;
     733             :         }
     734             : 
     735         876 :         if (FAILURE == phar_tar_octal(header.mtime, entry->timestamp, sizeof(header.mtime)-1)) {
     736           0 :                 if (fp->error) {
     737           0 :                         spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, file modification time of file \"%s\" is too large for tar file format", entry->phar->fname, entry->filename);
     738             :                 }
     739           0 :                 return ZEND_HASH_APPLY_STOP;
     740             :         }
     741             : 
     742             :         /* calc checksum */
     743         876 :         header.typeflag = entry->tar_type;
     744             : 
     745         876 :         if (entry->link) {
     746           9 :                 strncpy(header.linkname, entry->link, strlen(entry->link));
     747             :         }
     748             : 
     749         876 :         strncpy(header.magic, "ustar", sizeof("ustar")-1);
     750         876 :         strncpy(header.version, "00", sizeof("00")-1);
     751         876 :         strncpy(header.checksum, "        ", sizeof("        ")-1);
     752         876 :         entry->crc32 = phar_tar_checksum((char *)&header, sizeof(header));
     753             : 
     754         876 :         if (FAILURE == phar_tar_octal(header.checksum, entry->crc32, sizeof(header.checksum)-1)) {
     755           0 :                 if (fp->error) {
     756           0 :                         spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, checksum of file \"%s\" is too large for tar file format", entry->phar->fname, entry->filename);
     757             :                 }
     758           0 :                 return ZEND_HASH_APPLY_STOP;
     759             :         }
     760             : 
     761             :         /* write header */
     762         876 :         entry->header_offset = php_stream_tell(fp->new);
     763             : 
     764         876 :         if (sizeof(header) != php_stream_write(fp->new, (char *) &header, sizeof(header))) {
     765           0 :                 if (fp->error) {
     766           0 :                         spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, header for  file \"%s\" could not be written", entry->phar->fname, entry->filename);
     767             :                 }
     768           0 :                 return ZEND_HASH_APPLY_STOP;
     769             :         }
     770             : 
     771         876 :         pos = php_stream_tell(fp->new); /* save start of file within tar */
     772             : 
     773             :         /* write contents */
     774         876 :         if (entry->uncompressed_filesize) {
     775         780 :                 if (FAILURE == phar_open_entry_fp(entry, fp->error, 0 TSRMLS_CC)) {
     776           0 :                         return ZEND_HASH_APPLY_STOP;
     777             :                 }
     778             : 
     779         780 :                 if (-1 == phar_seek_efp(entry, 0, SEEK_SET, 0, 0 TSRMLS_CC)) {
     780           0 :                         if (fp->error) {
     781           0 :                                 spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, contents of file \"%s\" could not be written, seek failed", entry->phar->fname, entry->filename);
     782             :                         }
     783           0 :                         return ZEND_HASH_APPLY_STOP;
     784             :                 }
     785             : 
     786         780 :                 if (SUCCESS != phar_stream_copy_to_stream(phar_get_efp(entry, 0 TSRMLS_CC), fp->new, entry->uncompressed_filesize, NULL)) {
     787           0 :                         if (fp->error) {
     788           0 :                                 spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, contents of file \"%s\" could not be written", entry->phar->fname, entry->filename);
     789             :                         }
     790           0 :                         return ZEND_HASH_APPLY_STOP;
     791             :                 }
     792             : 
     793         780 :                 memset(padding, 0, 512);
     794         780 :                 php_stream_write(fp->new, padding, ((entry->uncompressed_filesize +511)&~511) - entry->uncompressed_filesize);
     795             :         }
     796             : 
     797         876 :         if (!entry->is_modified && entry->fp_refcount) {
     798             :                 /* open file pointers refer to this fp, do not free the stream */
     799           0 :                 switch (entry->fp_type) {
     800             :                         case PHAR_FP:
     801           0 :                                 fp->free_fp = 0;
     802           0 :                                 break;
     803             :                         case PHAR_UFP:
     804           0 :                                 fp->free_ufp = 0;
     805             :                         default:
     806             :                                 break;
     807             :                 }
     808             :         }
     809             : 
     810         876 :         entry->is_modified = 0;
     811             : 
     812         876 :         if (entry->fp_type == PHAR_MOD && entry->fp != entry->phar->fp && entry->fp != entry->phar->ufp) {
     813         373 :                 if (!entry->fp_refcount) {
     814         367 :                         php_stream_close(entry->fp);
     815             :                 }
     816         373 :                 entry->fp = NULL;
     817             :         }
     818             : 
     819         876 :         entry->fp_type = PHAR_FP;
     820             : 
     821             :         /* note new location within tar */
     822         876 :         entry->offset = entry->offset_abs = pos;
     823         876 :         return ZEND_HASH_APPLY_KEEP;
     824             : }
     825             : /* }}} */
     826             : 
     827          22 : int phar_tar_setmetadata(zval *metadata, phar_entry_info *entry, char **error TSRMLS_DC) /* {{{ */
     828             : {
     829             :         php_serialize_data_t metadata_hash;
     830             : 
     831          22 :         if (entry->metadata_str.c) {
     832          16 :                 smart_str_free(&entry->metadata_str);
     833             :         }
     834             : 
     835          22 :         entry->metadata_str.c = 0;
     836          22 :         entry->metadata_str.len = 0;
     837          22 :         PHP_VAR_SERIALIZE_INIT(metadata_hash);
     838          22 :         php_var_serialize(&entry->metadata_str, &metadata, &metadata_hash TSRMLS_CC);
     839          22 :         PHP_VAR_SERIALIZE_DESTROY(metadata_hash);
     840          22 :         entry->uncompressed_filesize = entry->compressed_filesize = entry->metadata_str.len;
     841             : 
     842          22 :         if (entry->fp && entry->fp_type == PHAR_MOD) {
     843           9 :                 php_stream_close(entry->fp);
     844             :         }
     845             : 
     846          22 :         entry->fp_type = PHAR_MOD;
     847          22 :         entry->is_modified = 1;
     848          22 :         entry->fp = php_stream_fopen_tmpfile();
     849          22 :         entry->offset = entry->offset_abs = 0;
     850          22 :         if (entry->fp == NULL) {
     851           0 :                 spprintf(error, 0, "phar error: unable to create temporary file");
     852           0 :                 return -1;
     853             :         }
     854          22 :         if (entry->metadata_str.len != php_stream_write(entry->fp, entry->metadata_str.c, entry->metadata_str.len)) {
     855           0 :                 spprintf(error, 0, "phar tar error: unable to write metadata to magic metadata file \"%s\"", entry->filename);
     856           0 :                 zend_hash_del(&(entry->phar->manifest), entry->filename, entry->filename_len);
     857           0 :                 return ZEND_HASH_APPLY_STOP;
     858             :         }
     859             : 
     860          22 :         return ZEND_HASH_APPLY_KEEP;
     861             : }
     862             : /* }}} */
     863             : 
     864         712 : static int phar_tar_setupmetadata(void *pDest, void *argument TSRMLS_DC) /* {{{ */
     865             : {
     866             :         int lookfor_len;
     867         712 :         struct _phar_pass_tar_info *i = (struct _phar_pass_tar_info *)argument;
     868         712 :         char *lookfor, **error = i->error;
     869         712 :         phar_entry_info *entry = (phar_entry_info *)pDest, *metadata, newentry = {0};
     870             : 
     871         712 :         if (entry->filename_len >= sizeof(".phar/.metadata") && !memcmp(entry->filename, ".phar/.metadata", sizeof(".phar/.metadata")-1)) {
     872          18 :                 if (entry->filename_len == sizeof(".phar/.metadata.bin")-1 && !memcmp(entry->filename, ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1)) {
     873           9 :                         return phar_tar_setmetadata(entry->phar->metadata, entry, error TSRMLS_CC);
     874             :                 }
     875             :                 /* search for the file this metadata entry references */
     876           9 :                 if (entry->filename_len >= sizeof(".phar/.metadata/") + sizeof("/.metadata.bin") - 1 && !zend_hash_exists(&(entry->phar->manifest), entry->filename + sizeof(".phar/.metadata/") - 1, entry->filename_len - (sizeof("/.metadata.bin") - 1 + sizeof(".phar/.metadata/") - 1))) {
     877             :                         /* this is orphaned metadata, erase it */
     878           0 :                         return ZEND_HASH_APPLY_REMOVE;
     879             :                 }
     880             :                 /* we can keep this entry, the file that refers to it exists */
     881           9 :                 return ZEND_HASH_APPLY_KEEP;
     882             :         }
     883             : 
     884         694 :         if (!entry->is_modified) {
     885         393 :                 return ZEND_HASH_APPLY_KEEP;
     886             :         }
     887             : 
     888             :         /* now we are dealing with regular files, so look for metadata */
     889         301 :         lookfor_len = spprintf(&lookfor, 0, ".phar/.metadata/%s/.metadata.bin", entry->filename);
     890             : 
     891         301 :         if (!entry->metadata) {
     892         297 :                 zend_hash_del(&(entry->phar->manifest), lookfor, lookfor_len);
     893         297 :                 efree(lookfor);
     894         297 :                 return ZEND_HASH_APPLY_KEEP;
     895             :         }
     896             : 
     897           4 :         if (SUCCESS == zend_hash_find(&(entry->phar->manifest), lookfor, lookfor_len, (void **)&metadata)) {
     898             :                 int ret;
     899           2 :                 ret = phar_tar_setmetadata(entry->metadata, metadata, error TSRMLS_CC);
     900           2 :                 efree(lookfor);
     901           2 :                 return ret;
     902             :         }
     903             : 
     904           2 :         newentry.filename = lookfor;
     905           2 :         newentry.filename_len = lookfor_len;
     906           2 :         newentry.phar = entry->phar;
     907           2 :         newentry.tar_type = TAR_FILE;
     908           2 :         newentry.is_tar = 1;
     909             : 
     910           2 :         if (SUCCESS != zend_hash_add(&(entry->phar->manifest), lookfor, lookfor_len, (void *)&newentry, sizeof(phar_entry_info), (void **)&metadata)) {
     911           0 :                 efree(lookfor);
     912           0 :                 spprintf(error, 0, "phar tar error: unable to add magic metadata file to manifest for file \"%s\"", entry->filename);
     913           0 :                 return ZEND_HASH_APPLY_STOP;
     914             :         }
     915             : 
     916           2 :         return phar_tar_setmetadata(entry->metadata, metadata, error TSRMLS_CC);
     917             : }
     918             : /* }}} */
     919             : 
     920         193 : int phar_tar_flush(phar_archive_data *phar, char *user_stub, long len, int defaultstub, char **error TSRMLS_DC) /* {{{ */
     921             : {
     922         193 :         phar_entry_info entry = {0};
     923             :         static const char newstub[] = "<?php // tar-based phar archive stub file\n__HALT_COMPILER();";
     924             :         php_stream *oldfile, *newfile, *stubfile;
     925             :         int closeoldfile, free_user_stub, signature_length;
     926             :         struct _phar_pass_tar_info pass;
     927             :         char *buf, *signature, *tmp, sigbuf[8];
     928         193 :         char halt_stub[] = "__HALT_COMPILER();";
     929             : 
     930         193 :         entry.flags = PHAR_ENT_PERM_DEF_FILE;
     931         193 :         entry.timestamp = time(NULL);
     932         193 :         entry.is_modified = 1;
     933         193 :         entry.is_crc_checked = 1;
     934         193 :         entry.is_tar = 1;
     935         193 :         entry.tar_type = '0';
     936         193 :         entry.phar = phar;
     937         193 :         entry.fp_type = PHAR_MOD;
     938             : 
     939         193 :         if (phar->is_persistent) {
     940           0 :                 if (error) {
     941           0 :                         spprintf(error, 0, "internal error: attempt to flush cached tar-based phar \"%s\"", phar->fname);
     942             :                 }
     943           0 :                 return EOF;
     944             :         }
     945             : 
     946         193 :         if (phar->is_data) {
     947          18 :                 goto nostub;
     948             :         }
     949             : 
     950             :         /* set alias */
     951         215 :         if (!phar->is_temporary_alias && phar->alias_len) {
     952          40 :                 entry.filename = estrndup(".phar/alias.txt", sizeof(".phar/alias.txt")-1);
     953          40 :                 entry.filename_len = sizeof(".phar/alias.txt")-1;
     954          40 :                 entry.fp = php_stream_fopen_tmpfile();
     955          40 :                 if (entry.fp == NULL) {
     956           0 :                         spprintf(error, 0, "phar error: unable to create temporary file");
     957           0 :                         return -1;
     958             :                 }
     959          40 :                 if (phar->alias_len != (int)php_stream_write(entry.fp, phar->alias, phar->alias_len)) {
     960           0 :                         if (error) {
     961           0 :                                 spprintf(error, 0, "unable to set alias in tar-based phar \"%s\"", phar->fname);
     962             :                         }
     963           0 :                         return EOF;
     964             :                 }
     965             : 
     966          40 :                 entry.uncompressed_filesize = phar->alias_len;
     967             : 
     968          40 :                 if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
     969           0 :                         if (error) {
     970           0 :                                 spprintf(error, 0, "unable to set alias in tar-based phar \"%s\"", phar->fname);
     971             :                         }
     972           0 :                         return EOF;
     973             :                 }
     974             :         } else {
     975         135 :                 zend_hash_del(&phar->manifest, ".phar/alias.txt", sizeof(".phar/alias.txt")-1);
     976             :         }
     977             : 
     978             :         /* set stub */
     979         201 :         if (user_stub && !defaultstub) {
     980             :                 char *pos;
     981          27 :                 if (len < 0) {
     982             :                         /* resource passed in */
     983           2 :                         if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) {
     984           0 :                                 if (error) {
     985           0 :                                         spprintf(error, 0, "unable to access resource to copy stub to new tar-based phar \"%s\"", phar->fname);
     986             :                                 }
     987           0 :                                 return EOF;
     988             :                         }
     989           2 :                         if (len == -1) {
     990           1 :                                 len = PHP_STREAM_COPY_ALL;
     991             :                         } else {
     992           1 :                                 len = -len;
     993             :                         }
     994           2 :                         user_stub = 0;
     995             : 
     996           2 :                         if (!(len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0)) || !user_stub) {
     997           0 :                                 if (error) {
     998           0 :                                         spprintf(error, 0, "unable to read resource to copy stub to new tar-based phar \"%s\"", phar->fname);
     999             :                                 }
    1000           0 :                                 return EOF;
    1001             :                         }
    1002           2 :                         free_user_stub = 1;
    1003             :                 } else {
    1004          25 :                         free_user_stub = 0;
    1005             :                 }
    1006             : 
    1007          27 :                 tmp = estrndup(user_stub, len);
    1008          27 :                 if ((pos = php_stristr(tmp, halt_stub, len, sizeof(halt_stub) - 1)) == NULL) {
    1009           1 :                         efree(tmp);
    1010           1 :                         if (error) {
    1011           1 :                                 spprintf(error, 0, "illegal stub for tar-based phar \"%s\"", phar->fname);
    1012             :                         }
    1013           1 :                         if (free_user_stub) {
    1014           0 :                                 efree(user_stub);
    1015             :                         }
    1016           1 :                         return EOF;
    1017             :                 }
    1018          26 :                 pos = user_stub + (pos - tmp);
    1019          26 :                 efree(tmp);
    1020             : 
    1021          26 :                 len = pos - user_stub + 18;
    1022          26 :                 entry.fp = php_stream_fopen_tmpfile();
    1023          26 :                 if (entry.fp == NULL) {
    1024           0 :                         spprintf(error, 0, "phar error: unable to create temporary file");
    1025           0 :                         return EOF;
    1026             :                 }
    1027          26 :                 entry.uncompressed_filesize = len + 5;
    1028             : 
    1029          52 :                 if ((size_t)len != php_stream_write(entry.fp, user_stub, len)
    1030          52 :                 ||            5 != php_stream_write(entry.fp, " ?>\r\n", 5)) {
    1031           0 :                         if (error) {
    1032           0 :                                 spprintf(error, 0, "unable to create stub from string in new tar-based phar \"%s\"", phar->fname);
    1033             :                         }
    1034           0 :                         if (free_user_stub) {
    1035           0 :                                 efree(user_stub);
    1036             :                         }
    1037           0 :                         php_stream_close(entry.fp);
    1038           0 :                         return EOF;
    1039             :                 }
    1040             : 
    1041          26 :                 entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1);
    1042          26 :                 entry.filename_len = sizeof(".phar/stub.php")-1;
    1043          26 :                 zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL);
    1044             : 
    1045          26 :                 if (free_user_stub) {
    1046           2 :                         efree(user_stub);
    1047             :                 }
    1048             :         } else {
    1049             :                 /* Either this is a brand new phar (add the stub), or the default stub is required (overwrite the stub) */
    1050         148 :                 entry.fp = php_stream_fopen_tmpfile();
    1051         148 :                 if (entry.fp == NULL) {
    1052           0 :                         spprintf(error, 0, "phar error: unable to create temporary file");
    1053           0 :                         return EOF;
    1054             :                 }
    1055         148 :                 if (sizeof(newstub)-1 != php_stream_write(entry.fp, newstub, sizeof(newstub)-1)) {
    1056           0 :                         php_stream_close(entry.fp);
    1057           0 :                         if (error) {
    1058           0 :                                 spprintf(error, 0, "unable to %s stub in%star-based phar \"%s\", failed", user_stub ? "overwrite" : "create", user_stub ? " " : " new ", phar->fname);
    1059             :                         }
    1060           0 :                         return EOF;
    1061             :                 }
    1062             : 
    1063         148 :                 entry.uncompressed_filesize = entry.compressed_filesize = sizeof(newstub) - 1;
    1064         148 :                 entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1);
    1065         148 :                 entry.filename_len = sizeof(".phar/stub.php")-1;
    1066             : 
    1067         148 :                 if (!defaultstub) {
    1068         131 :                         if (!zend_hash_exists(&phar->manifest, ".phar/stub.php", sizeof(".phar/stub.php")-1)) {
    1069          21 :                                 if (SUCCESS != zend_hash_add(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
    1070           0 :                                         php_stream_close(entry.fp);
    1071           0 :                                         efree(entry.filename);
    1072           0 :                                         if (error) {
    1073           0 :                                                 spprintf(error, 0, "unable to create stub in tar-based phar \"%s\"", phar->fname);
    1074             :                                         }
    1075           0 :                                         return EOF;
    1076             :                                 }
    1077             :                         } else {
    1078         110 :                                 php_stream_close(entry.fp);
    1079         110 :                                 efree(entry.filename);
    1080             :                         }
    1081             :                 } else {
    1082          17 :                         if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
    1083           0 :                                 php_stream_close(entry.fp);
    1084           0 :                                 efree(entry.filename);
    1085           0 :                                 if (error) {
    1086           0 :                                         spprintf(error, 0, "unable to overwrite stub in tar-based phar \"%s\"", phar->fname);
    1087             :                                 }
    1088           0 :                                 return EOF;
    1089             :                         }
    1090             :                 }
    1091             :         }
    1092             : nostub:
    1093         347 :         if (phar->fp && !phar->is_brandnew) {
    1094         155 :                 oldfile = phar->fp;
    1095         155 :                 closeoldfile = 0;
    1096         155 :                 php_stream_rewind(oldfile);
    1097             :         } else {
    1098          37 :                 oldfile = php_stream_open_wrapper(phar->fname, "rb", 0, NULL);
    1099          37 :                 closeoldfile = oldfile != NULL;
    1100             :         }
    1101             : 
    1102         192 :         newfile = php_stream_fopen_tmpfile();
    1103         192 :         if (!newfile) {
    1104           0 :                 if (error) {
    1105           0 :                         spprintf(error, 0, "unable to create temporary file");
    1106             :                 }
    1107           0 :                 if (closeoldfile) {
    1108           0 :                         php_stream_close(oldfile);
    1109             :                 }
    1110           0 :                 return EOF;
    1111             :         }
    1112             : 
    1113         192 :         pass.old = oldfile;
    1114         192 :         pass.new = newfile;
    1115         192 :         pass.error = error;
    1116         192 :         pass.free_fp = 1;
    1117         192 :         pass.free_ufp = 1;
    1118             : 
    1119         192 :         if (phar->metadata) {
    1120             :                 phar_entry_info *mentry;
    1121           9 :                 if (SUCCESS == zend_hash_find(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1, (void **)&mentry)) {
    1122           7 :                         if (ZEND_HASH_APPLY_KEEP != phar_tar_setmetadata(phar->metadata, mentry, error TSRMLS_CC)) {
    1123           0 :                                 if (closeoldfile) {
    1124           0 :                                         php_stream_close(oldfile);
    1125             :                                 }
    1126           0 :                                 return EOF;
    1127             :                         }
    1128             :                 } else {
    1129           2 :                         phar_entry_info newentry = {0};
    1130             : 
    1131           2 :                         newentry.filename = estrndup(".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1);
    1132           2 :                         newentry.filename_len = sizeof(".phar/.metadata.bin")-1;
    1133           2 :                         newentry.phar = phar;
    1134           2 :                         newentry.tar_type = TAR_FILE;
    1135           2 :                         newentry.is_tar = 1;
    1136             : 
    1137           2 :                         if (SUCCESS != zend_hash_add(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1, (void *)&newentry, sizeof(phar_entry_info), (void **)&mentry)) {
    1138           0 :                                 spprintf(error, 0, "phar tar error: unable to add magic metadata file to manifest for phar archive \"%s\"", phar->fname);
    1139           0 :                                 if (closeoldfile) {
    1140           0 :                                         php_stream_close(oldfile);
    1141             :                                 }
    1142           0 :                                 return EOF;
    1143             :                         }
    1144             : 
    1145           2 :                         if (ZEND_HASH_APPLY_KEEP != phar_tar_setmetadata(phar->metadata, mentry, error TSRMLS_CC)) {
    1146           0 :                                 zend_hash_del(&(phar->manifest), ".phar/.metadata.bin", sizeof(".phar/.metadata.bin")-1);
    1147           0 :                                 if (closeoldfile) {
    1148           0 :                                         php_stream_close(oldfile);
    1149             :                                 }
    1150           0 :                                 return EOF;
    1151             :                         }
    1152             :                 }
    1153             :         }
    1154             : 
    1155         192 :         zend_hash_apply_with_argument(&phar->manifest, (apply_func_arg_t) phar_tar_setupmetadata, (void *) &pass TSRMLS_CC);
    1156             : 
    1157         192 :         if (error && *error) {
    1158           0 :                 if (closeoldfile) {
    1159           0 :                         php_stream_close(oldfile);
    1160             :                 }
    1161             : 
    1162             :                 /* on error in the hash iterator above, error is set */
    1163           0 :                 php_stream_close(newfile);
    1164           0 :                 return EOF;
    1165             :         }
    1166             : 
    1167         192 :         zend_hash_apply_with_argument(&phar->manifest, (apply_func_arg_t) phar_tar_writeheaders, (void *) &pass TSRMLS_CC);
    1168             : 
    1169             :         /* add signature for executable tars or tars explicitly set with setSignatureAlgorithm */
    1170         192 :         if (!phar->is_data || phar->sig_flags) {
    1171         175 :                 if (FAILURE == phar_create_signature(phar, newfile, &signature, &signature_length, error TSRMLS_CC)) {
    1172           0 :                         if (error) {
    1173           0 :                                 char *save = *error;
    1174           0 :                                 spprintf(error, 0, "phar error: unable to write signature to tar-based phar: %s", save);
    1175           0 :                                 efree(save);
    1176             :                         }
    1177             : 
    1178           0 :                         if (closeoldfile) {
    1179           0 :                                 php_stream_close(oldfile);
    1180             :                         }
    1181             : 
    1182           0 :                         php_stream_close(newfile);
    1183           0 :                         return EOF;
    1184             :                 }
    1185             : 
    1186         175 :                 entry.filename = ".phar/signature.bin";
    1187         175 :                 entry.filename_len = sizeof(".phar/signature.bin")-1;
    1188         175 :                 entry.fp = php_stream_fopen_tmpfile();
    1189         175 :                 if (entry.fp == NULL) {
    1190           0 :                         spprintf(error, 0, "phar error: unable to create temporary file");
    1191           0 :                         return EOF;
    1192             :                 }
    1193             : #ifdef WORDS_BIGENDIAN
    1194             : # define PHAR_SET_32(var, buffer) \
    1195             :         *(php_uint32 *)(var) = (((((unsigned char*)&(buffer))[3]) << 24) \
    1196             :                 | ((((unsigned char*)&(buffer))[2]) << 16) \
    1197             :                 | ((((unsigned char*)&(buffer))[1]) << 8) \
    1198             :                 | (((unsigned char*)&(buffer))[0]))
    1199             : #else
    1200             : # define PHAR_SET_32(var, buffer) *(php_uint32 *)(var) = (php_uint32) (buffer)
    1201             : #endif
    1202         175 :                 PHAR_SET_32(sigbuf, phar->sig_flags);
    1203         175 :                 PHAR_SET_32(sigbuf + 4, signature_length);
    1204             : 
    1205         175 :                 if (8 != (int)php_stream_write(entry.fp, sigbuf, 8) || signature_length != (int)php_stream_write(entry.fp, signature, signature_length)) {
    1206           0 :                         efree(signature);
    1207           0 :                         if (error) {
    1208           0 :                                 spprintf(error, 0, "phar error: unable to write signature to tar-based phar %s", phar->fname);
    1209             :                         }
    1210             : 
    1211           0 :                         if (closeoldfile) {
    1212           0 :                                 php_stream_close(oldfile);
    1213             :                         }
    1214           0 :                         php_stream_close(newfile);
    1215           0 :                         return EOF;
    1216             :                 }
    1217             : 
    1218         175 :                 efree(signature);
    1219         175 :                 entry.uncompressed_filesize = entry.compressed_filesize = signature_length + 8;
    1220             :                 /* throw out return value and write the signature */
    1221         175 :                 entry.filename_len = phar_tar_writeheaders((void *)&entry, (void *)&pass TSRMLS_CC);
    1222             : 
    1223         175 :                 if (error && *error) {
    1224           0 :                         if (closeoldfile) {
    1225           0 :                                 php_stream_close(oldfile);
    1226             :                         }
    1227             :                         /* error is set by writeheaders */
    1228           0 :                         php_stream_close(newfile);
    1229           0 :                         return EOF;
    1230             :                 }
    1231             :         } /* signature */
    1232             : 
    1233             :         /* add final zero blocks */
    1234         192 :         buf = (char *) ecalloc(1024, 1);
    1235         192 :         php_stream_write(newfile, buf, 1024);
    1236         192 :         efree(buf);
    1237             : 
    1238         192 :         if (closeoldfile) {
    1239           1 :                 php_stream_close(oldfile);
    1240             :         }
    1241             : 
    1242             :         /* on error in the hash iterator above, error is set */
    1243         192 :         if (error && *error) {
    1244           3 :                 php_stream_close(newfile);
    1245           3 :                 return EOF;
    1246             :         }
    1247             : 
    1248         189 :         if (phar->fp && pass.free_fp) {
    1249         155 :                 php_stream_close(phar->fp);
    1250             :         }
    1251             : 
    1252         189 :         if (phar->ufp) {
    1253           3 :                 if (pass.free_ufp) {
    1254           3 :                         php_stream_close(phar->ufp);
    1255             :                 }
    1256           3 :                 phar->ufp = NULL;
    1257             :         }
    1258             : 
    1259         189 :         phar->is_brandnew = 0;
    1260         189 :         php_stream_rewind(newfile);
    1261             : 
    1262         189 :         if (phar->donotflush) {
    1263             :                 /* deferred flush */
    1264           7 :                 phar->fp = newfile;
    1265             :         } else {
    1266         182 :                 phar->fp = php_stream_open_wrapper(phar->fname, "w+b", IGNORE_URL|STREAM_MUST_SEEK|REPORT_ERRORS, NULL);
    1267         182 :                 if (!phar->fp) {
    1268           0 :                         phar->fp = newfile;
    1269           0 :                         if (error) {
    1270           0 :                                 spprintf(error, 0, "unable to open new phar \"%s\" for writing", phar->fname);
    1271             :                         }
    1272           0 :                         return EOF;
    1273             :                 }
    1274             : 
    1275         182 :                 if (phar->flags & PHAR_FILE_COMPRESSED_GZ) {
    1276             :                         php_stream_filter *filter;
    1277             :                         /* to properly compress, we have to tell zlib to add a zlib header */
    1278             :                         zval filterparams;
    1279             : 
    1280           8 :                         array_init(&filterparams);
    1281             : /* this is defined in zlib's zconf.h */
    1282             : #ifndef MAX_WBITS
    1283             : #define MAX_WBITS 15
    1284             : #endif
    1285           8 :                         add_assoc_long(&filterparams, "window", MAX_WBITS + 16);
    1286           8 :                         filter = php_stream_filter_create("zlib.deflate", &filterparams, php_stream_is_persistent(phar->fp) TSRMLS_CC);
    1287             :                         zval_dtor(&filterparams);
    1288             : 
    1289           8 :                         if (!filter) {
    1290             :                                 /* copy contents uncompressed rather than lose them */
    1291           0 :                                 phar_stream_copy_to_stream(newfile, phar->fp, PHP_STREAM_COPY_ALL, NULL);
    1292           0 :                                 php_stream_close(newfile);
    1293           0 :                                 if (error) {
    1294           0 :                                         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);
    1295             :                                 }
    1296           0 :                                 return EOF;
    1297             :                         }
    1298             : 
    1299           8 :                         php_stream_filter_append(&phar->fp->writefilters, filter);
    1300           8 :                         phar_stream_copy_to_stream(newfile, phar->fp, PHP_STREAM_COPY_ALL, NULL);
    1301           8 :                         php_stream_filter_flush(filter, 1);
    1302           8 :                         php_stream_filter_remove(filter, 1 TSRMLS_CC);
    1303           8 :                         php_stream_close(phar->fp);
    1304             :                         /* use the temp stream as our base */
    1305           8 :                         phar->fp = newfile;
    1306         174 :                 } else if (phar->flags & PHAR_FILE_COMPRESSED_BZ2) {
    1307             :                         php_stream_filter *filter;
    1308             : 
    1309           4 :                         filter = php_stream_filter_create("bzip2.compress", NULL, php_stream_is_persistent(phar->fp) TSRMLS_CC);
    1310           4 :                         php_stream_filter_append(&phar->fp->writefilters, filter);
    1311           4 :                         phar_stream_copy_to_stream(newfile, phar->fp, PHP_STREAM_COPY_ALL, NULL);
    1312           4 :                         php_stream_filter_flush(filter, 1);
    1313           4 :                         php_stream_filter_remove(filter, 1 TSRMLS_CC);
    1314           4 :                         php_stream_close(phar->fp);
    1315             :                         /* use the temp stream as our base */
    1316           4 :                         phar->fp = newfile;
    1317             :                 } else {
    1318         170 :                         phar_stream_copy_to_stream(newfile, phar->fp, PHP_STREAM_COPY_ALL, NULL);
    1319             :                         /* we could also reopen the file in "rb" mode but there is no need for that */
    1320         170 :                         php_stream_close(newfile);
    1321             :                 }
    1322             :         }
    1323         189 :         return EOF;
    1324             : }
    1325             : /* }}} */
    1326             : 
    1327             : /*
    1328             :  * Local variables:
    1329             :  * tab-width: 4
    1330             :  * c-basic-offset: 4
    1331             :  * End:
    1332             :  * vim600: noet sw=4 ts=4 fdm=marker
    1333             :  * vim<600: noet sw=4 ts=4
    1334             :  */

Generated by: LCOV version 1.10

Generated at Sun, 20 Apr 2014 03:52:14 +0000 (4 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.