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