Annotation of embedaddon/php/ext/phar/zip.c, revision 1.1.1.3
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | ZIP archive support for Phar |
4: +----------------------------------------------------------------------+
1.1.1.3 ! misho 5: | Copyright (c) 2007-2014 The PHP Group |
1.1 misho 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: Gregory Beaver <cellog@php.net> |
16: +----------------------------------------------------------------------+
17: */
18:
19: #include "phar_internal.h"
20:
21: #define PHAR_GET_16(var) ((php_uint16)((((php_uint16)var[0]) & 0xff) | \
22: (((php_uint16)var[1]) & 0xff) << 8))
23: #define PHAR_GET_32(var) ((php_uint32)((((php_uint32)var[0]) & 0xff) | \
24: (((php_uint32)var[1]) & 0xff) << 8 | \
25: (((php_uint32)var[2]) & 0xff) << 16 | \
26: (((php_uint32)var[3]) & 0xff) << 24))
27: static inline void phar_write_32(char buffer[4], php_uint32 value)
28: {
29: buffer[3] = (unsigned char) ((value & 0xff000000) >> 24);
30: buffer[2] = (unsigned char) ((value & 0xff0000) >> 16);
31: buffer[1] = (unsigned char) ((value & 0xff00) >> 8);
32: buffer[0] = (unsigned char) (value & 0xff);
33: }
34: static inline void phar_write_16(char buffer[2], php_uint32 value)
35: {
36: buffer[1] = (unsigned char) ((value & 0xff00) >> 8);
37: buffer[0] = (unsigned char) (value & 0xff);
38: }
39: # define PHAR_SET_32(var, value) phar_write_32(var, (php_uint32) (value));
40: # define PHAR_SET_16(var, value) phar_write_16(var, (php_uint16) (value));
41:
42: static int phar_zip_process_extra(php_stream *fp, phar_entry_info *entry, php_uint16 len TSRMLS_DC) /* {{{ */
43: {
44: union {
45: phar_zip_extra_field_header header;
46: phar_zip_unix3 unix3;
47: } h;
48: int read;
49:
50: do {
51: if (sizeof(h.header) != php_stream_read(fp, (char *) &h.header, sizeof(h.header))) {
52: return FAILURE;
53: }
54:
55: if (h.header.tag[0] != 'n' || h.header.tag[1] != 'u') {
56: /* skip to next header */
57: php_stream_seek(fp, PHAR_GET_16(h.header.size), SEEK_CUR);
58: len -= PHAR_GET_16(h.header.size) + 4;
59: continue;
60: }
61:
62: /* unix3 header found */
63: read = php_stream_read(fp, (char *) &(h.unix3.crc32), sizeof(h.unix3) - sizeof(h.header));
64: len -= read + 4;
65:
66: if (sizeof(h.unix3) - sizeof(h.header) != read) {
67: return FAILURE;
68: }
69:
70: if (PHAR_GET_16(h.unix3.size) > sizeof(h.unix3) - 4) {
71: /* skip symlink filename - we may add this support in later */
72: php_stream_seek(fp, PHAR_GET_16(h.unix3.size) - sizeof(h.unix3.size), SEEK_CUR);
73: }
74:
75: /* set permissions */
76: entry->flags &= PHAR_ENT_COMPRESSION_MASK;
77:
78: if (entry->is_dir) {
79: entry->flags |= PHAR_GET_16(h.unix3.perms) & PHAR_ENT_PERM_MASK;
80: } else {
81: entry->flags |= PHAR_GET_16(h.unix3.perms) & PHAR_ENT_PERM_MASK;
82: }
83:
84: } while (len);
85:
86: return SUCCESS;
87: }
88: /* }}} */
89:
90: /*
91: extracted from libzip
92: zip_dirent.c -- read directory entry (local or central), clean dirent
93: Copyright (C) 1999, 2003, 2004, 2005 Dieter Baron and Thomas Klausner
94:
95: This function is part of libzip, a library to manipulate ZIP archives.
96: The authors can be contacted at <nih@giga.or.at>
97:
98: Redistribution and use in source and binary forms, with or without
99: modification, are permitted provided that the following conditions
100: are met:
101: 1. Redistributions of source code must retain the above copyright
102: notice, this list of conditions and the following disclaimer.
103: 2. Redistributions in binary form must reproduce the above copyright
104: notice, this list of conditions and the following disclaimer in
105: the documentation and/or other materials provided with the
106: distribution.
107: 3. The names of the authors may not be used to endorse or promote
108: products derived from this software without specific prior
109: written permission.
110:
111: THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
112: OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
113: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
114: ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
115: DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
116: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
117: GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
118: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
119: IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
120: OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
121: IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
122: */
123: static time_t phar_zip_d2u_time(char *cdtime, char *cddate) /* {{{ */
124: {
125: int dtime = PHAR_GET_16(cdtime), ddate = PHAR_GET_16(cddate);
126: struct tm *tm, tmbuf;
127: time_t now;
128:
129: now = time(NULL);
130: tm = php_localtime_r(&now, &tmbuf);
131:
132: tm->tm_year = ((ddate>>9)&127) + 1980 - 1900;
133: tm->tm_mon = ((ddate>>5)&15) - 1;
134: tm->tm_mday = ddate&31;
135:
136: tm->tm_hour = (dtime>>11)&31;
137: tm->tm_min = (dtime>>5)&63;
138: tm->tm_sec = (dtime<<1)&62;
139:
140: return mktime(tm);
141: }
142: /* }}} */
143:
144: static void phar_zip_u2d_time(time_t time, char *dtime, char *ddate) /* {{{ */
145: {
146: php_uint16 ctime, cdate;
147: struct tm *tm, tmbuf;
148:
149: tm = php_localtime_r(&time, &tmbuf);
150: cdate = ((tm->tm_year+1900-1980)<<9) + ((tm->tm_mon+1)<<5) + tm->tm_mday;
151: ctime = ((tm->tm_hour)<<11) + ((tm->tm_min)<<5) + ((tm->tm_sec)>>1);
152: PHAR_SET_16(dtime, ctime);
153: PHAR_SET_16(ddate, cdate);
154: }
155: /* }}} */
156:
157: /**
158: * Does not check for a previously opened phar in the cache.
159: *
160: * Parse a new one and add it to the cache, returning either SUCCESS or
161: * FAILURE, and setting pphar to the pointer to the manifest entry
162: *
163: * This is used by phar_open_from_fp to process a zip-based phar, but can be called
164: * directly.
165: */
166: int phar_parse_zipfile(php_stream *fp, char *fname, int fname_len, char *alias, int alias_len, phar_archive_data** pphar, char **error TSRMLS_DC) /* {{{ */
167: {
168: phar_zip_dir_end locator;
169: char buf[sizeof(locator) + 65536];
170: long size;
171: php_uint16 i;
172: phar_archive_data *mydata = NULL;
173: phar_entry_info entry = {0};
174: char *p = buf, *ext, *actual_alias = NULL;
175: char *metadata = NULL;
176:
177: size = php_stream_tell(fp);
178:
179: if (size > sizeof(locator) + 65536) {
180: /* seek to max comment length + end of central directory record */
181: size = sizeof(locator) + 65536;
182: if (FAILURE == php_stream_seek(fp, -size, SEEK_END)) {
183: php_stream_close(fp);
184: if (error) {
185: spprintf(error, 4096, "phar error: unable to search for end of central directory in zip-based phar \"%s\"", fname);
186: }
187: return FAILURE;
188: }
189: } else {
190: php_stream_seek(fp, 0, SEEK_SET);
191: }
192:
193: if (!php_stream_read(fp, buf, size)) {
194: php_stream_close(fp);
195: if (error) {
196: spprintf(error, 4096, "phar error: unable to read in data to search for end of central directory in zip-based phar \"%s\"", fname);
197: }
198: return FAILURE;
199: }
200:
201: while ((p=(char *) memchr(p + 1, 'P', (size_t) (size - (p + 1 - buf)))) != NULL) {
202: if (!memcmp(p + 1, "K\5\6", 3)) {
203: memcpy((void *)&locator, (void *) p, sizeof(locator));
204: if (PHAR_GET_16(locator.centraldisk) != 0 || PHAR_GET_16(locator.disknumber) != 0) {
205: /* split archives not handled */
206: php_stream_close(fp);
207: if (error) {
208: spprintf(error, 4096, "phar error: split archives spanning multiple zips cannot be processed in zip-based phar \"%s\"", fname);
209: }
210: return FAILURE;
211: }
212:
213: if (PHAR_GET_16(locator.counthere) != PHAR_GET_16(locator.count)) {
214: if (error) {
215: spprintf(error, 4096, "phar error: corrupt zip archive, conflicting file count in end of central directory record in zip-based phar \"%s\"", fname);
216: }
217: php_stream_close(fp);
218: return FAILURE;
219: }
220:
221: mydata = pecalloc(1, sizeof(phar_archive_data), PHAR_G(persist));
222: mydata->is_persistent = PHAR_G(persist);
223:
224: /* read in archive comment, if any */
225: if (PHAR_GET_16(locator.comment_len)) {
226:
227: metadata = p + sizeof(locator);
228:
229: if (PHAR_GET_16(locator.comment_len) != size - (metadata - buf)) {
230: if (error) {
231: spprintf(error, 4096, "phar error: corrupt zip archive, zip file comment truncated in zip-based phar \"%s\"", fname);
232: }
233: php_stream_close(fp);
234: pefree(mydata, mydata->is_persistent);
235: return FAILURE;
236: }
237:
238: mydata->metadata_len = PHAR_GET_16(locator.comment_len);
239:
240: if (phar_parse_metadata(&metadata, &mydata->metadata, PHAR_GET_16(locator.comment_len) TSRMLS_CC) == FAILURE) {
241: mydata->metadata_len = 0;
242: /* if not valid serialized data, it is a regular string */
243:
244: if (entry.is_persistent) {
245: ALLOC_PERMANENT_ZVAL(mydata->metadata);
246: } else {
247: ALLOC_ZVAL(mydata->metadata);
248: }
249:
250: INIT_ZVAL(*mydata->metadata);
251: metadata = pestrndup(metadata, PHAR_GET_16(locator.comment_len), mydata->is_persistent);
252: ZVAL_STRINGL(mydata->metadata, metadata, PHAR_GET_16(locator.comment_len), 0);
253: }
254: } else {
255: mydata->metadata = NULL;
256: }
257:
258: goto foundit;
259: }
260: }
261:
262: php_stream_close(fp);
263:
264: if (error) {
265: spprintf(error, 4096, "phar error: end of central directory not found in zip-based phar \"%s\"", fname);
266: }
267:
268: return FAILURE;
269: foundit:
270: mydata->fname = pestrndup(fname, fname_len, mydata->is_persistent);
271: #ifdef PHP_WIN32
272: phar_unixify_path_separators(mydata->fname, fname_len);
273: #endif
274: mydata->is_zip = 1;
275: mydata->fname_len = fname_len;
276: ext = strrchr(mydata->fname, '/');
277:
278: if (ext) {
279: mydata->ext = memchr(ext, '.', (mydata->fname + fname_len) - ext);
280: if (mydata->ext == ext) {
281: mydata->ext = memchr(ext + 1, '.', (mydata->fname + fname_len) - ext - 1);
282: }
283: if (mydata->ext) {
284: mydata->ext_len = (mydata->fname + fname_len) - mydata->ext;
285: }
286: }
287:
288: /* clean up on big-endian systems */
289: /* seek to central directory */
290: php_stream_seek(fp, PHAR_GET_32(locator.cdir_offset), SEEK_SET);
291: /* read in central directory */
292: zend_hash_init(&mydata->manifest, PHAR_GET_16(locator.count),
293: zend_get_hash_value, destroy_phar_manifest_entry, (zend_bool)mydata->is_persistent);
294: zend_hash_init(&mydata->mounted_dirs, 5,
295: zend_get_hash_value, NULL, (zend_bool)mydata->is_persistent);
296: zend_hash_init(&mydata->virtual_dirs, PHAR_GET_16(locator.count) * 2,
297: zend_get_hash_value, NULL, (zend_bool)mydata->is_persistent);
298: entry.phar = mydata;
299: entry.is_zip = 1;
300: entry.fp_type = PHAR_FP;
301: entry.is_persistent = mydata->is_persistent;
302: #define PHAR_ZIP_FAIL_FREE(errmsg, save) \
303: zend_hash_destroy(&mydata->manifest); \
304: mydata->manifest.arBuckets = 0; \
305: zend_hash_destroy(&mydata->mounted_dirs); \
306: mydata->mounted_dirs.arBuckets = 0; \
307: zend_hash_destroy(&mydata->virtual_dirs); \
308: mydata->virtual_dirs.arBuckets = 0; \
309: php_stream_close(fp); \
310: if (mydata->metadata) { \
311: zval_dtor(mydata->metadata); \
312: } \
313: if (mydata->signature) { \
314: efree(mydata->signature); \
315: } \
316: if (error) { \
317: spprintf(error, 4096, "phar error: %s in zip-based phar \"%s\"", errmsg, mydata->fname); \
318: } \
319: pefree(mydata->fname, mydata->is_persistent); \
320: if (mydata->alias) { \
321: pefree(mydata->alias, mydata->is_persistent); \
322: } \
323: pefree(mydata, mydata->is_persistent); \
324: efree(save); \
325: return FAILURE;
326: #define PHAR_ZIP_FAIL(errmsg) \
327: zend_hash_destroy(&mydata->manifest); \
328: mydata->manifest.arBuckets = 0; \
329: zend_hash_destroy(&mydata->mounted_dirs); \
330: mydata->mounted_dirs.arBuckets = 0; \
331: zend_hash_destroy(&mydata->virtual_dirs); \
332: mydata->virtual_dirs.arBuckets = 0; \
333: php_stream_close(fp); \
334: if (mydata->metadata) { \
335: zval_dtor(mydata->metadata); \
336: } \
337: if (mydata->signature) { \
338: efree(mydata->signature); \
339: } \
340: if (error) { \
341: spprintf(error, 4096, "phar error: %s in zip-based phar \"%s\"", errmsg, mydata->fname); \
342: } \
343: pefree(mydata->fname, mydata->is_persistent); \
344: if (mydata->alias) { \
345: pefree(mydata->alias, mydata->is_persistent); \
346: } \
347: pefree(mydata, mydata->is_persistent); \
348: return FAILURE;
349:
350: /* add each central directory item to the manifest */
351: for (i = 0; i < PHAR_GET_16(locator.count); ++i) {
352: phar_zip_central_dir_file zipentry;
353: off_t beforeus = php_stream_tell(fp);
354:
355: if (sizeof(zipentry) != php_stream_read(fp, (char *) &zipentry, sizeof(zipentry))) {
356: PHAR_ZIP_FAIL("unable to read central directory entry, truncated");
357: }
358:
359: /* clean up for bigendian systems */
360: if (memcmp("PK\1\2", zipentry.signature, 4)) {
361: /* corrupted entry */
362: PHAR_ZIP_FAIL("corrupted central directory entry, no magic signature");
363: }
364:
365: if (entry.is_persistent) {
366: entry.manifest_pos = i;
367: }
368:
369: entry.compressed_filesize = PHAR_GET_32(zipentry.compsize);
370: entry.uncompressed_filesize = PHAR_GET_32(zipentry.uncompsize);
371: entry.crc32 = PHAR_GET_32(zipentry.crc32);
372: /* do not PHAR_GET_16 either on the next line */
373: entry.timestamp = phar_zip_d2u_time(zipentry.timestamp, zipentry.datestamp);
374: entry.flags = PHAR_ENT_PERM_DEF_FILE;
375: entry.header_offset = PHAR_GET_32(zipentry.offset);
376: entry.offset = entry.offset_abs = PHAR_GET_32(zipentry.offset) + sizeof(phar_zip_file_header) + PHAR_GET_16(zipentry.filename_len) +
377: PHAR_GET_16(zipentry.extra_len);
378:
379: if (PHAR_GET_16(zipentry.flags) & PHAR_ZIP_FLAG_ENCRYPTED) {
380: PHAR_ZIP_FAIL("Cannot process encrypted zip files");
381: }
382:
383: if (!PHAR_GET_16(zipentry.filename_len)) {
384: PHAR_ZIP_FAIL("Cannot process zips created from stdin (zero-length filename)");
385: }
386:
387: entry.filename_len = PHAR_GET_16(zipentry.filename_len);
388: entry.filename = (char *) pemalloc(entry.filename_len + 1, entry.is_persistent);
389:
390: if (entry.filename_len != php_stream_read(fp, entry.filename, entry.filename_len)) {
391: pefree(entry.filename, entry.is_persistent);
392: PHAR_ZIP_FAIL("unable to read in filename from central directory, truncated");
393: }
394:
395: entry.filename[entry.filename_len] = '\0';
396:
397: if (entry.filename[entry.filename_len - 1] == '/') {
398: entry.is_dir = 1;
399: entry.filename_len--;
400: entry.flags |= PHAR_ENT_PERM_DEF_DIR;
401: } else {
402: entry.is_dir = 0;
403: }
404:
405: if (entry.filename_len == sizeof(".phar/signature.bin")-1 && !strncmp(entry.filename, ".phar/signature.bin", sizeof(".phar/signature.bin")-1)) {
406: size_t read;
407: php_stream *sigfile;
408: off_t now;
409: char *sig;
410:
411: now = php_stream_tell(fp);
412: pefree(entry.filename, entry.is_persistent);
413: sigfile = php_stream_fopen_tmpfile();
414: if (!sigfile) {
415: PHAR_ZIP_FAIL("couldn't open temporary file");
416: }
417:
418: php_stream_seek(fp, 0, SEEK_SET);
419: /* copy file contents + local headers and zip comment, if any, to be hashed for signature */
420: phar_stream_copy_to_stream(fp, sigfile, entry.header_offset, NULL);
421: /* seek to central directory */
422: php_stream_seek(fp, PHAR_GET_32(locator.cdir_offset), SEEK_SET);
423: /* copy central directory header */
424: phar_stream_copy_to_stream(fp, sigfile, beforeus - PHAR_GET_32(locator.cdir_offset), NULL);
425: if (metadata) {
426: php_stream_write(sigfile, metadata, PHAR_GET_16(locator.comment_len));
427: }
428: php_stream_seek(fp, sizeof(phar_zip_file_header) + entry.header_offset + entry.filename_len + PHAR_GET_16(zipentry.extra_len), SEEK_SET);
429: sig = (char *) emalloc(entry.uncompressed_filesize);
430: read = php_stream_read(fp, sig, entry.uncompressed_filesize);
431: if (read != entry.uncompressed_filesize) {
432: php_stream_close(sigfile);
433: efree(sig);
434: PHAR_ZIP_FAIL("signature cannot be read");
435: }
436: mydata->sig_flags = PHAR_GET_32(sig);
437: if (FAILURE == phar_verify_signature(sigfile, php_stream_tell(sigfile), mydata->sig_flags, sig + 8, entry.uncompressed_filesize - 8, fname, &mydata->signature, &mydata->sig_len, error TSRMLS_CC)) {
438: efree(sig);
439: if (error) {
440: char *save;
441: php_stream_close(sigfile);
442: spprintf(&save, 4096, "signature cannot be verified: %s", *error);
443: efree(*error);
444: PHAR_ZIP_FAIL_FREE(save, save);
445: } else {
446: php_stream_close(sigfile);
447: PHAR_ZIP_FAIL("signature cannot be verified");
448: }
449: }
450: php_stream_close(sigfile);
451: efree(sig);
452: /* signature checked out, let's ensure this is the last file in the phar */
453: if (i != PHAR_GET_16(locator.count) - 1) {
454: PHAR_ZIP_FAIL("entries exist after signature, invalid phar");
455: }
456:
457: continue;
458: }
459:
460: phar_add_virtual_dirs(mydata, entry.filename, entry.filename_len TSRMLS_CC);
461:
462: if (PHAR_GET_16(zipentry.extra_len)) {
463: off_t loc = php_stream_tell(fp);
464: if (FAILURE == phar_zip_process_extra(fp, &entry, PHAR_GET_16(zipentry.extra_len) TSRMLS_CC)) {
465: pefree(entry.filename, entry.is_persistent);
466: PHAR_ZIP_FAIL("Unable to process extra field header for file in central directory");
467: }
468: php_stream_seek(fp, loc + PHAR_GET_16(zipentry.extra_len), SEEK_SET);
469: }
470:
471: switch (PHAR_GET_16(zipentry.compressed)) {
472: case PHAR_ZIP_COMP_NONE :
473: /* compression flag already set */
474: break;
475: case PHAR_ZIP_COMP_DEFLATE :
476: entry.flags |= PHAR_ENT_COMPRESSED_GZ;
477: if (!PHAR_G(has_zlib)) {
478: pefree(entry.filename, entry.is_persistent);
479: PHAR_ZIP_FAIL("zlib extension is required");
480: }
481: break;
482: case PHAR_ZIP_COMP_BZIP2 :
483: entry.flags |= PHAR_ENT_COMPRESSED_BZ2;
484: if (!PHAR_G(has_bz2)) {
485: pefree(entry.filename, entry.is_persistent);
486: PHAR_ZIP_FAIL("bzip2 extension is required");
487: }
488: break;
489: case 1 :
490: pefree(entry.filename, entry.is_persistent);
491: PHAR_ZIP_FAIL("unsupported compression method (Shrunk) used in this zip");
492: case 2 :
493: case 3 :
494: case 4 :
495: case 5 :
496: pefree(entry.filename, entry.is_persistent);
497: PHAR_ZIP_FAIL("unsupported compression method (Reduce) used in this zip");
498: case 6 :
499: pefree(entry.filename, entry.is_persistent);
500: PHAR_ZIP_FAIL("unsupported compression method (Implode) used in this zip");
501: case 7 :
502: pefree(entry.filename, entry.is_persistent);
503: PHAR_ZIP_FAIL("unsupported compression method (Tokenize) used in this zip");
504: case 9 :
505: pefree(entry.filename, entry.is_persistent);
506: PHAR_ZIP_FAIL("unsupported compression method (Deflate64) used in this zip");
507: case 10 :
508: pefree(entry.filename, entry.is_persistent);
509: PHAR_ZIP_FAIL("unsupported compression method (PKWare Implode/old IBM TERSE) used in this zip");
510: case 14 :
511: pefree(entry.filename, entry.is_persistent);
512: PHAR_ZIP_FAIL("unsupported compression method (LZMA) used in this zip");
513: case 18 :
514: pefree(entry.filename, entry.is_persistent);
515: PHAR_ZIP_FAIL("unsupported compression method (IBM TERSE) used in this zip");
516: case 19 :
517: pefree(entry.filename, entry.is_persistent);
518: PHAR_ZIP_FAIL("unsupported compression method (IBM LZ77) used in this zip");
519: case 97 :
520: pefree(entry.filename, entry.is_persistent);
521: PHAR_ZIP_FAIL("unsupported compression method (WavPack) used in this zip");
522: case 98 :
523: pefree(entry.filename, entry.is_persistent);
524: PHAR_ZIP_FAIL("unsupported compression method (PPMd) used in this zip");
525: default :
526: pefree(entry.filename, entry.is_persistent);
527: PHAR_ZIP_FAIL("unsupported compression method (unknown) used in this zip");
528: }
529:
530: /* get file metadata */
531: if (PHAR_GET_16(zipentry.comment_len)) {
532: if (PHAR_GET_16(zipentry.comment_len) != php_stream_read(fp, buf, PHAR_GET_16(zipentry.comment_len))) {
533: pefree(entry.filename, entry.is_persistent);
534: PHAR_ZIP_FAIL("unable to read in file comment, truncated");
535: }
536:
537: p = buf;
538: entry.metadata_len = PHAR_GET_16(zipentry.comment_len);
539:
540: if (phar_parse_metadata(&p, &(entry.metadata), PHAR_GET_16(zipentry.comment_len) TSRMLS_CC) == FAILURE) {
541: entry.metadata_len = 0;
542: /* if not valid serialized data, it is a regular string */
543:
544: if (entry.is_persistent) {
545: ALLOC_PERMANENT_ZVAL(entry.metadata);
546: } else {
547: ALLOC_ZVAL(entry.metadata);
548: }
549:
550: INIT_ZVAL(*entry.metadata);
551: ZVAL_STRINGL(entry.metadata, pestrndup(buf, PHAR_GET_16(zipentry.comment_len), entry.is_persistent), PHAR_GET_16(zipentry.comment_len), 0);
552: }
553: } else {
554: entry.metadata = NULL;
555: }
556:
557: if (!actual_alias && entry.filename_len == sizeof(".phar/alias.txt")-1 && !strncmp(entry.filename, ".phar/alias.txt", sizeof(".phar/alias.txt")-1)) {
558: php_stream_filter *filter;
559: off_t saveloc;
560: /* verify local file header */
561: phar_zip_file_header local;
562:
563: /* archive alias found */
564: saveloc = php_stream_tell(fp);
565: php_stream_seek(fp, PHAR_GET_32(zipentry.offset), SEEK_SET);
566:
567: if (sizeof(local) != php_stream_read(fp, (char *) &local, sizeof(local))) {
568: pefree(entry.filename, entry.is_persistent);
569: PHAR_ZIP_FAIL("phar error: internal corruption of zip-based phar (cannot read local file header for alias)");
570: }
571:
572: /* verify local header */
573: if (entry.filename_len != PHAR_GET_16(local.filename_len) || entry.crc32 != PHAR_GET_32(local.crc32) || entry.uncompressed_filesize != PHAR_GET_32(local.uncompsize) || entry.compressed_filesize != PHAR_GET_32(local.compsize)) {
574: pefree(entry.filename, entry.is_persistent);
575: PHAR_ZIP_FAIL("phar error: internal corruption of zip-based phar (local header of alias does not match central directory)");
576: }
577:
578: /* construct actual offset to file start - local extra_len can be different from central extra_len */
579: entry.offset = entry.offset_abs =
580: sizeof(local) + entry.header_offset + PHAR_GET_16(local.filename_len) + PHAR_GET_16(local.extra_len);
581: #if PHP_VERSION_ID < 50207
582: /* work around Bug #46147 */
583: fp->writepos = fp->readpos = 0;
584: #endif
585: php_stream_seek(fp, entry.offset, SEEK_SET);
586: /* these next lines should be for php < 5.2.6 after 5.3 filters are fixed */
587: fp->writepos = 0;
588: fp->readpos = 0;
589: php_stream_seek(fp, entry.offset, SEEK_SET);
590: fp->writepos = 0;
591: fp->readpos = 0;
592: /* the above lines should be for php < 5.2.6 after 5.3 filters are fixed */
593:
594: mydata->alias_len = entry.uncompressed_filesize;
595:
596: if (entry.flags & PHAR_ENT_COMPRESSED_GZ) {
597: filter = php_stream_filter_create("zlib.inflate", NULL, php_stream_is_persistent(fp) TSRMLS_CC);
598:
599: if (!filter) {
600: pefree(entry.filename, entry.is_persistent);
601: PHAR_ZIP_FAIL("unable to decompress alias, zlib filter creation failed");
602: }
603:
604: php_stream_filter_append(&fp->readfilters, filter);
605:
606: if (!(entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0)) || !actual_alias) {
607: pefree(entry.filename, entry.is_persistent);
608: #if PHP_VERSION_ID < 50207
609: PHAR_ZIP_FAIL("unable to read in alias, truncated (PHP 5.2.7 and newer has a potential fix for this problem)");
610: #endif
611: PHAR_ZIP_FAIL("unable to read in alias, truncated");
612: }
613:
614: php_stream_filter_flush(filter, 1);
615: php_stream_filter_remove(filter, 1 TSRMLS_CC);
616:
617: } else if (entry.flags & PHAR_ENT_COMPRESSED_BZ2) {
618: filter = php_stream_filter_create("bzip2.decompress", NULL, php_stream_is_persistent(fp) TSRMLS_CC);
619:
620: if (!filter) {
621: pefree(entry.filename, entry.is_persistent);
622: PHAR_ZIP_FAIL("unable to read in alias, bzip2 filter creation failed");
623: }
624:
625: php_stream_filter_append(&fp->readfilters, filter);
626:
627: if (!(entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0)) || !actual_alias) {
628: pefree(entry.filename, entry.is_persistent);
629: #if PHP_VERSION_ID < 50207
630: PHAR_ZIP_FAIL("unable to read in alias, truncated (PHP 5.2.7 and newer has a potential fix for this problem)");
631: #endif
632: PHAR_ZIP_FAIL("unable to read in alias, truncated");
633: }
634:
635: php_stream_filter_flush(filter, 1);
636: php_stream_filter_remove(filter, 1 TSRMLS_CC);
637: } else {
638: if (!(entry.uncompressed_filesize = php_stream_copy_to_mem(fp, &actual_alias, entry.uncompressed_filesize, 0)) || !actual_alias) {
639: pefree(entry.filename, entry.is_persistent);
640: PHAR_ZIP_FAIL("unable to read in alias, truncated");
641: }
642: }
643:
644: /* return to central directory parsing */
645: php_stream_seek(fp, saveloc, SEEK_SET);
646: }
647:
648: phar_set_inode(&entry TSRMLS_CC);
649: zend_hash_add(&mydata->manifest, entry.filename, entry.filename_len, (void *)&entry,sizeof(phar_entry_info), NULL);
650: }
651:
652: mydata->fp = fp;
653:
654: if (zend_hash_exists(&(mydata->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1)) {
655: mydata->is_data = 0;
656: } else {
657: mydata->is_data = 1;
658: }
659:
660: zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, (void*)&mydata, sizeof(phar_archive_data*), NULL);
661:
662: if (actual_alias) {
663: phar_archive_data **fd_ptr;
664:
665: if (!phar_validate_alias(actual_alias, mydata->alias_len)) {
666: if (error) {
667: spprintf(error, 4096, "phar error: invalid alias \"%s\" in zip-based phar \"%s\"", actual_alias, fname);
668: }
669: efree(actual_alias);
670: zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
671: return FAILURE;
672: }
673:
674: mydata->is_temporary_alias = 0;
675:
676: if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, (void **)&fd_ptr)) {
677: if (SUCCESS != phar_free_alias(*fd_ptr, actual_alias, mydata->alias_len TSRMLS_CC)) {
678: if (error) {
679: spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with implicit alias, alias is already in use", fname);
680: }
681: efree(actual_alias);
682: zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
683: return FAILURE;
684: }
685: }
686:
687: mydata->alias = entry.is_persistent ? pestrndup(actual_alias, mydata->alias_len, 1) : actual_alias;
688:
689: if (entry.is_persistent) {
690: efree(actual_alias);
691: }
692:
693: zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, (void*)&mydata, sizeof(phar_archive_data*), NULL);
694: } else {
695: phar_archive_data **fd_ptr;
696:
697: if (alias_len) {
698: if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void **)&fd_ptr)) {
699: if (SUCCESS != phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) {
700: if (error) {
701: spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with explicit alias, alias is already in use", fname);
702: }
703: zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
704: return FAILURE;
705: }
706: }
707:
708: zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, (void*)&mydata, sizeof(phar_archive_data*), NULL);
709: mydata->alias = pestrndup(alias, alias_len, mydata->is_persistent);
710: mydata->alias_len = alias_len;
711: } else {
712: mydata->alias = pestrndup(mydata->fname, fname_len, mydata->is_persistent);
713: mydata->alias_len = fname_len;
714: }
715:
716: mydata->is_temporary_alias = 1;
717: }
718:
719: if (pphar) {
720: *pphar = mydata;
721: }
722:
723: return SUCCESS;
724: }
725: /* }}} */
726:
727: /**
728: * Create or open a zip-based phar for writing
729: */
730: int phar_open_or_create_zip(char *fname, int fname_len, char *alias, int alias_len, int is_data, int options, phar_archive_data** pphar, char **error TSRMLS_DC) /* {{{ */
731: {
732: phar_archive_data *phar;
733: int ret = phar_create_or_parse_filename(fname, fname_len, alias, alias_len, is_data, options, &phar, error TSRMLS_CC);
734:
735: if (FAILURE == ret) {
736: return FAILURE;
737: }
738:
739: if (pphar) {
740: *pphar = phar;
741: }
742:
743: phar->is_data = is_data;
744:
745: if (phar->is_zip) {
746: return ret;
747: }
748:
749: if (phar->is_brandnew) {
750: phar->internal_file_start = 0;
751: phar->is_zip = 1;
752: phar->is_tar = 0;
753: return SUCCESS;
754: }
755:
756: /* we've reached here - the phar exists and is a regular phar */
757: if (error) {
758: spprintf(error, 4096, "phar zip error: phar \"%s\" already exists as a regular phar and must be deleted from disk prior to creating as a zip-based phar", fname);
759: }
760:
761: return FAILURE;
762: }
763: /* }}} */
764:
765: struct _phar_zip_pass {
766: php_stream *filefp;
767: php_stream *centralfp;
768: php_stream *old;
769: int free_fp;
770: int free_ufp;
771: char **error;
772: };
773: /* perform final modification of zip contents for each file in the manifest before saving */
774: static int phar_zip_changed_apply(void *data, void *arg TSRMLS_DC) /* {{{ */
775: {
776: phar_entry_info *entry;
777: phar_zip_file_header local;
778: phar_zip_unix3 perms;
779: phar_zip_central_dir_file central;
780: struct _phar_zip_pass *p;
781: php_uint32 newcrc32;
782: off_t offset;
783: int not_really_modified = 0;
784: entry = (phar_entry_info *)data;
785: p = (struct _phar_zip_pass*) arg;
786:
787: if (entry->is_mounted) {
788: return ZEND_HASH_APPLY_KEEP;
789: }
790:
791: if (entry->is_deleted) {
792: if (entry->fp_refcount <= 0) {
793: return ZEND_HASH_APPLY_REMOVE;
794: } else {
795: /* we can't delete this in-memory until it is closed */
796: return ZEND_HASH_APPLY_KEEP;
797: }
798: }
799:
800: phar_add_virtual_dirs(entry->phar, entry->filename, entry->filename_len TSRMLS_CC);
801: memset(&local, 0, sizeof(local));
802: memset(¢ral, 0, sizeof(central));
803: memset(&perms, 0, sizeof(perms));
804: strncpy(local.signature, "PK\3\4", 4);
805: strncpy(central.signature, "PK\1\2", 4);
806: PHAR_SET_16(central.extra_len, sizeof(perms));
807: PHAR_SET_16(local.extra_len, sizeof(perms));
808: perms.tag[0] = 'n';
809: perms.tag[1] = 'u';
810: PHAR_SET_16(perms.size, sizeof(perms) - 4);
811: PHAR_SET_16(perms.perms, entry->flags & PHAR_ENT_PERM_MASK);
812: {
813: php_uint32 crc = (php_uint32) ~0;
814: CRC32(crc, perms.perms[0]);
815: CRC32(crc, perms.perms[1]);
816: PHAR_SET_32(perms.crc32, ~crc);
817: }
818:
819: if (entry->flags & PHAR_ENT_COMPRESSED_GZ) {
820: PHAR_SET_16(central.compressed, PHAR_ZIP_COMP_DEFLATE);
821: PHAR_SET_16(local.compressed, PHAR_ZIP_COMP_DEFLATE);
822: }
823:
824: if (entry->flags & PHAR_ENT_COMPRESSED_BZ2) {
825: PHAR_SET_16(central.compressed, PHAR_ZIP_COMP_BZIP2);
826: PHAR_SET_16(local.compressed, PHAR_ZIP_COMP_BZIP2);
827: }
828:
829: /* do not use PHAR_GET_16 on either field of the next line */
830: phar_zip_u2d_time(entry->timestamp, local.timestamp, local.datestamp);
831: memcpy(central.timestamp, local.timestamp, sizeof(local.timestamp));
832: memcpy(central.datestamp, local.datestamp, sizeof(local.datestamp));
833: PHAR_SET_16(central.filename_len, entry->filename_len + (entry->is_dir ? 1 : 0));
834: PHAR_SET_16(local.filename_len, entry->filename_len + (entry->is_dir ? 1 : 0));
835: PHAR_SET_32(central.offset, php_stream_tell(p->filefp));
836:
837: /* do extra field for perms later */
838: if (entry->is_modified) {
839: php_uint32 loc;
840: php_stream_filter *filter;
841: php_stream *efp;
842:
843: if (entry->is_dir) {
844: entry->is_modified = 0;
845: if (entry->fp_type == PHAR_MOD && entry->fp != entry->phar->fp && entry->fp != entry->phar->ufp) {
846: php_stream_close(entry->fp);
847: entry->fp = NULL;
848: entry->fp_type = PHAR_FP;
849: }
850: goto continue_dir;
851: }
852:
853: if (FAILURE == phar_open_entry_fp(entry, p->error, 0 TSRMLS_CC)) {
854: spprintf(p->error, 0, "unable to open file contents of file \"%s\" in zip-based phar \"%s\"", entry->filename, entry->phar->fname);
855: return ZEND_HASH_APPLY_STOP;
856: }
857:
858: /* we can be modified and already be compressed, such as when chmod() is executed */
859: if (entry->flags & PHAR_ENT_COMPRESSION_MASK && (entry->old_flags == entry->flags || !entry->old_flags)) {
860: not_really_modified = 1;
861: goto is_compressed;
862: }
863:
864: if (-1 == phar_seek_efp(entry, 0, SEEK_SET, 0, 0 TSRMLS_CC)) {
865: spprintf(p->error, 0, "unable to seek to start of file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
866: return ZEND_HASH_APPLY_STOP;
867: }
868:
869: efp = phar_get_efp(entry, 0 TSRMLS_CC);
870: newcrc32 = ~0;
871:
872: for (loc = 0;loc < entry->uncompressed_filesize; ++loc) {
873: CRC32(newcrc32, php_stream_getc(efp));
874: }
875:
876: entry->crc32 = ~newcrc32;
877: PHAR_SET_32(central.uncompsize, entry->uncompressed_filesize);
878: PHAR_SET_32(local.uncompsize, entry->uncompressed_filesize);
879:
880: if (!(entry->flags & PHAR_ENT_COMPRESSION_MASK)) {
881: /* not compressed */
882: entry->compressed_filesize = entry->uncompressed_filesize;
883: PHAR_SET_32(central.compsize, entry->uncompressed_filesize);
884: PHAR_SET_32(local.compsize, entry->uncompressed_filesize);
885: goto not_compressed;
886: }
887:
888: filter = php_stream_filter_create(phar_compress_filter(entry, 0), NULL, 0 TSRMLS_CC);
889:
890: if (!filter) {
891: if (entry->flags & PHAR_ENT_COMPRESSED_GZ) {
892: spprintf(p->error, 0, "unable to gzip compress file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
893: } else {
894: spprintf(p->error, 0, "unable to bzip2 compress file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
895: }
896: return ZEND_HASH_APPLY_STOP;
897: }
898:
899: /* create new file that holds the compressed version */
900: /* work around inability to specify freedom in write and strictness
901: in read count */
902: entry->cfp = php_stream_fopen_tmpfile();
903:
904: if (!entry->cfp) {
905: spprintf(p->error, 0, "unable to create temporary file for file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
906: return ZEND_HASH_APPLY_STOP;
907: }
908:
909: php_stream_flush(efp);
910:
911: if (-1 == phar_seek_efp(entry, 0, SEEK_SET, 0, 0 TSRMLS_CC)) {
912: spprintf(p->error, 0, "unable to seek to start of file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
913: return ZEND_HASH_APPLY_STOP;
914: }
915:
916: php_stream_filter_append((&entry->cfp->writefilters), filter);
917:
918: if (SUCCESS != phar_stream_copy_to_stream(efp, entry->cfp, entry->uncompressed_filesize, NULL)) {
919: spprintf(p->error, 0, "unable to copy compressed file contents of file \"%s\" while creating new phar \"%s\"", entry->filename, entry->phar->fname);
920: return ZEND_HASH_APPLY_STOP;
921: }
922:
923: php_stream_filter_flush(filter, 1);
924: php_stream_flush(entry->cfp);
925: php_stream_filter_remove(filter, 1 TSRMLS_CC);
926: php_stream_seek(entry->cfp, 0, SEEK_END);
927: entry->compressed_filesize = (php_uint32) php_stream_tell(entry->cfp);
928: PHAR_SET_32(central.compsize, entry->compressed_filesize);
929: PHAR_SET_32(local.compsize, entry->compressed_filesize);
930: /* generate crc on compressed file */
931: php_stream_rewind(entry->cfp);
932: entry->old_flags = entry->flags;
933: entry->is_modified = 1;
934: } else {
935: is_compressed:
936: PHAR_SET_32(central.uncompsize, entry->uncompressed_filesize);
937: PHAR_SET_32(local.uncompsize, entry->uncompressed_filesize);
938: PHAR_SET_32(central.compsize, entry->compressed_filesize);
939: PHAR_SET_32(local.compsize, entry->compressed_filesize);
1.1.1.2 misho 940: if (p->old) {
941: if (-1 == php_stream_seek(p->old, entry->offset_abs, SEEK_SET)) {
942: spprintf(p->error, 0, "unable to seek to start of file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
943: return ZEND_HASH_APPLY_STOP;
944: }
1.1 misho 945: }
946: }
947: not_compressed:
948: PHAR_SET_32(central.crc32, entry->crc32);
949: PHAR_SET_32(local.crc32, entry->crc32);
950: continue_dir:
951: /* set file metadata */
952: if (entry->metadata) {
953: php_serialize_data_t metadata_hash;
954:
955: if (entry->metadata_str.c) {
956: smart_str_free(&entry->metadata_str);
957: }
958: entry->metadata_str.c = 0;
959: entry->metadata_str.len = 0;
960: PHP_VAR_SERIALIZE_INIT(metadata_hash);
961: php_var_serialize(&entry->metadata_str, &entry->metadata, &metadata_hash TSRMLS_CC);
962: PHP_VAR_SERIALIZE_DESTROY(metadata_hash);
963: PHAR_SET_16(central.comment_len, entry->metadata_str.len);
964: }
965:
966: entry->header_offset = php_stream_tell(p->filefp);
967: offset = entry->header_offset + sizeof(local) + entry->filename_len + (entry->is_dir ? 1 : 0) + sizeof(perms);
968:
969: if (sizeof(local) != php_stream_write(p->filefp, (char *)&local, sizeof(local))) {
970: spprintf(p->error, 0, "unable to write local file header of file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
971: return ZEND_HASH_APPLY_STOP;
972: }
973:
974: if (sizeof(central) != php_stream_write(p->centralfp, (char *)¢ral, sizeof(central))) {
975: spprintf(p->error, 0, "unable to write central directory entry for file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
976: return ZEND_HASH_APPLY_STOP;
977: }
978:
979: if (entry->is_dir) {
980: if (entry->filename_len != php_stream_write(p->filefp, entry->filename, entry->filename_len)) {
981: spprintf(p->error, 0, "unable to write filename to local directory entry for directory \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
982: return ZEND_HASH_APPLY_STOP;
983: }
984:
985: if (1 != php_stream_write(p->filefp, "/", 1)) {
986: spprintf(p->error, 0, "unable to write filename to local directory entry for directory \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
987: return ZEND_HASH_APPLY_STOP;
988: }
989:
990: if (entry->filename_len != php_stream_write(p->centralfp, entry->filename, entry->filename_len)) {
991: spprintf(p->error, 0, "unable to write filename to central directory entry for directory \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
992: return ZEND_HASH_APPLY_STOP;
993: }
994:
995: if (1 != php_stream_write(p->centralfp, "/", 1)) {
996: spprintf(p->error, 0, "unable to write filename to central directory entry for directory \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
997: return ZEND_HASH_APPLY_STOP;
998: }
999: } else {
1000: if (entry->filename_len != php_stream_write(p->filefp, entry->filename, entry->filename_len)) {
1001: spprintf(p->error, 0, "unable to write filename to local directory entry for file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1002: return ZEND_HASH_APPLY_STOP;
1003: }
1004:
1005: if (entry->filename_len != php_stream_write(p->centralfp, entry->filename, entry->filename_len)) {
1006: spprintf(p->error, 0, "unable to write filename to central directory entry for file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1007: return ZEND_HASH_APPLY_STOP;
1008: }
1009: }
1010:
1011: if (sizeof(perms) != php_stream_write(p->filefp, (char *)&perms, sizeof(perms))) {
1012: spprintf(p->error, 0, "unable to write local extra permissions file header of file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1013: return ZEND_HASH_APPLY_STOP;
1014: }
1015:
1016: if (sizeof(perms) != php_stream_write(p->centralfp, (char *)&perms, sizeof(perms))) {
1017: spprintf(p->error, 0, "unable to write central extra permissions file header of file \"%s\" to zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1018: return ZEND_HASH_APPLY_STOP;
1019: }
1020:
1021: if (!not_really_modified && entry->is_modified) {
1022: if (entry->cfp) {
1023: if (SUCCESS != phar_stream_copy_to_stream(entry->cfp, p->filefp, entry->compressed_filesize, NULL)) {
1024: spprintf(p->error, 0, "unable to write compressed contents of file \"%s\" in zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1025: return ZEND_HASH_APPLY_STOP;
1026: }
1027:
1028: php_stream_close(entry->cfp);
1029: entry->cfp = NULL;
1030: } else {
1031: if (FAILURE == phar_open_entry_fp(entry, p->error, 0 TSRMLS_CC)) {
1032: return ZEND_HASH_APPLY_STOP;
1033: }
1034:
1035: phar_seek_efp(entry, 0, SEEK_SET, 0, 0 TSRMLS_CC);
1036:
1037: if (SUCCESS != phar_stream_copy_to_stream(phar_get_efp(entry, 0 TSRMLS_CC), p->filefp, entry->uncompressed_filesize, NULL)) {
1038: spprintf(p->error, 0, "unable to write contents of file \"%s\" in zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1039: return ZEND_HASH_APPLY_STOP;
1040: }
1041: }
1042:
1043: if (entry->fp_type == PHAR_MOD && entry->fp != entry->phar->fp && entry->fp != entry->phar->ufp && entry->fp_refcount == 0) {
1044: php_stream_close(entry->fp);
1045: }
1046:
1047: entry->is_modified = 0;
1048: } else {
1049: entry->is_modified = 0;
1050: if (entry->fp_refcount) {
1051: /* open file pointers refer to this fp, do not free the stream */
1052: switch (entry->fp_type) {
1053: case PHAR_FP:
1054: p->free_fp = 0;
1055: break;
1056: case PHAR_UFP:
1057: p->free_ufp = 0;
1058: default:
1059: break;
1060: }
1061: }
1062:
1063: if (!entry->is_dir && entry->compressed_filesize && SUCCESS != phar_stream_copy_to_stream(p->old, p->filefp, entry->compressed_filesize, NULL)) {
1064: spprintf(p->error, 0, "unable to copy contents of file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1065: return ZEND_HASH_APPLY_STOP;
1066: }
1067: }
1068:
1069: entry->fp = NULL;
1070: entry->offset = entry->offset_abs = offset;
1071: entry->fp_type = PHAR_FP;
1072:
1073: if (entry->metadata_str.c) {
1074: if (entry->metadata_str.len != php_stream_write(p->centralfp, entry->metadata_str.c, entry->metadata_str.len)) {
1075: spprintf(p->error, 0, "unable to write metadata as file comment for file \"%s\" while creating zip-based phar \"%s\"", entry->filename, entry->phar->fname);
1076: smart_str_free(&entry->metadata_str);
1077: return ZEND_HASH_APPLY_STOP;
1078: }
1079:
1080: smart_str_free(&entry->metadata_str);
1081: }
1082:
1083: return ZEND_HASH_APPLY_KEEP;
1084: }
1085: /* }}} */
1086:
1087: static int phar_zip_applysignature(phar_archive_data *phar, struct _phar_zip_pass *pass,
1088: smart_str *metadata TSRMLS_DC) /* {{{ */
1089: {
1090: /* add signature for executable tars or tars explicitly set with setSignatureAlgorithm */
1091: if (!phar->is_data || phar->sig_flags) {
1092: int signature_length;
1093: char *signature, sigbuf[8];
1094: phar_entry_info entry = {0};
1095: php_stream *newfile;
1096: off_t tell, st;
1097:
1098: newfile = php_stream_fopen_tmpfile();
1.1.1.2 misho 1099: if (newfile == NULL) {
1100: spprintf(pass->error, 0, "phar error: unable to create temporary file for the signature file");
1101: return FAILURE;
1102: }
1.1 misho 1103: st = tell = php_stream_tell(pass->filefp);
1104: /* copy the local files, central directory, and the zip comment to generate the hash */
1105: php_stream_seek(pass->filefp, 0, SEEK_SET);
1106: phar_stream_copy_to_stream(pass->filefp, newfile, tell, NULL);
1107: tell = php_stream_tell(pass->centralfp);
1108: php_stream_seek(pass->centralfp, 0, SEEK_SET);
1109: phar_stream_copy_to_stream(pass->centralfp, newfile, tell, NULL);
1110: if (metadata->c) {
1111: php_stream_write(newfile, metadata->c, metadata->len);
1112: }
1113:
1114: if (FAILURE == phar_create_signature(phar, newfile, &signature, &signature_length, pass->error TSRMLS_CC)) {
1115: if (pass->error) {
1116: char *save = *(pass->error);
1117: spprintf(pass->error, 0, "phar error: unable to write signature to zip-based phar: %s", save);
1118: efree(save);
1119: }
1120:
1121: php_stream_close(newfile);
1122: return FAILURE;
1123: }
1124:
1125: entry.filename = ".phar/signature.bin";
1126: entry.filename_len = sizeof(".phar/signature.bin")-1;
1127: entry.fp = php_stream_fopen_tmpfile();
1128: entry.fp_type = PHAR_MOD;
1129: entry.is_modified = 1;
1.1.1.2 misho 1130: if (entry.fp == NULL) {
1131: spprintf(pass->error, 0, "phar error: unable to create temporary file for signature");
1132: return FAILURE;
1133: }
1.1 misho 1134:
1135: PHAR_SET_32(sigbuf, phar->sig_flags);
1136: PHAR_SET_32(sigbuf + 4, signature_length);
1137:
1138: if (8 != (int)php_stream_write(entry.fp, sigbuf, 8) || signature_length != (int)php_stream_write(entry.fp, signature, signature_length)) {
1139: efree(signature);
1140: if (pass->error) {
1141: spprintf(pass->error, 0, "phar error: unable to write signature to zip-based phar %s", phar->fname);
1142: }
1143:
1144: php_stream_close(newfile);
1145: return FAILURE;
1146: }
1147:
1148: efree(signature);
1149: entry.uncompressed_filesize = entry.compressed_filesize = signature_length + 8;
1150: entry.phar = phar;
1151: /* throw out return value and write the signature */
1152: phar_zip_changed_apply((void *)&entry, (void *)pass TSRMLS_CC);
1153: php_stream_close(newfile);
1154:
1155: if (pass->error && *(pass->error)) {
1156: /* error is set by writeheaders */
1157: php_stream_close(newfile);
1158: return FAILURE;
1159: }
1160: } /* signature */
1161: return SUCCESS;
1162: }
1163: /* }}} */
1164:
1165: int phar_zip_flush(phar_archive_data *phar, char *user_stub, long len, int defaultstub, char **error TSRMLS_DC) /* {{{ */
1166: {
1167: char *pos;
1168: smart_str main_metadata_str = {0};
1169: static const char newstub[] = "<?php // zip-based phar archive stub file\n__HALT_COMPILER();";
1170: char halt_stub[] = "__HALT_COMPILER();";
1171: char *tmp;
1172:
1173: php_stream *stubfile, *oldfile;
1174: php_serialize_data_t metadata_hash;
1175: int free_user_stub, closeoldfile = 0;
1176: phar_entry_info entry = {0};
1177: char *temperr = NULL;
1178: struct _phar_zip_pass pass;
1179: phar_zip_dir_end eocd;
1180: php_uint32 cdir_size, cdir_offset;
1181:
1182: pass.error = &temperr;
1183: entry.flags = PHAR_ENT_PERM_DEF_FILE;
1184: entry.timestamp = time(NULL);
1185: entry.is_modified = 1;
1186: entry.is_zip = 1;
1187: entry.phar = phar;
1188: entry.fp_type = PHAR_MOD;
1189:
1190: if (phar->is_persistent) {
1191: if (error) {
1192: spprintf(error, 0, "internal error: attempt to flush cached zip-based phar \"%s\"", phar->fname);
1193: }
1194: return EOF;
1195: }
1196:
1197: if (phar->is_data) {
1198: goto nostub;
1199: }
1200:
1201: /* set alias */
1202: if (!phar->is_temporary_alias && phar->alias_len) {
1203: entry.fp = php_stream_fopen_tmpfile();
1.1.1.2 misho 1204: if (entry.fp == NULL) {
1205: spprintf(error, 0, "phar error: unable to create temporary file");
1206: return EOF;
1207: }
1.1 misho 1208: if (phar->alias_len != (int)php_stream_write(entry.fp, phar->alias, phar->alias_len)) {
1209: if (error) {
1210: spprintf(error, 0, "unable to set alias in zip-based phar \"%s\"", phar->fname);
1211: }
1212: return EOF;
1213: }
1214:
1215: entry.uncompressed_filesize = entry.compressed_filesize = phar->alias_len;
1216: entry.filename = estrndup(".phar/alias.txt", sizeof(".phar/alias.txt")-1);
1217: entry.filename_len = sizeof(".phar/alias.txt")-1;
1218:
1219: if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
1220: if (error) {
1221: spprintf(error, 0, "unable to set alias in zip-based phar \"%s\"", phar->fname);
1222: }
1223: return EOF;
1224: }
1225: } else {
1226: zend_hash_del(&phar->manifest, ".phar/alias.txt", sizeof(".phar/alias.txt")-1);
1227: }
1228:
1229: /* register alias */
1230: if (phar->alias_len) {
1231: if (FAILURE == phar_get_archive(&phar, phar->fname, phar->fname_len, phar->alias, phar->alias_len, error TSRMLS_CC)) {
1232: return EOF;
1233: }
1234: }
1235:
1236: /* set stub */
1237: if (user_stub && !defaultstub) {
1238: if (len < 0) {
1239: /* resource passed in */
1240: if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) {
1241: if (error) {
1242: spprintf(error, 0, "unable to access resource to copy stub to new zip-based phar \"%s\"", phar->fname);
1243: }
1244: return EOF;
1245: }
1246:
1247: if (len == -1) {
1248: len = PHP_STREAM_COPY_ALL;
1249: } else {
1250: len = -len;
1251: }
1252:
1253: user_stub = 0;
1254:
1255: if (!(len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0)) || !user_stub) {
1256: if (error) {
1257: spprintf(error, 0, "unable to read resource to copy stub to new zip-based phar \"%s\"", phar->fname);
1258: }
1259: return EOF;
1260: }
1261: free_user_stub = 1;
1262: } else {
1263: free_user_stub = 0;
1264: }
1265:
1266: tmp = estrndup(user_stub, len);
1267: if ((pos = php_stristr(tmp, halt_stub, len, sizeof(halt_stub) - 1)) == NULL) {
1268: efree(tmp);
1269: if (error) {
1270: spprintf(error, 0, "illegal stub for zip-based phar \"%s\"", phar->fname);
1271: }
1272: if (free_user_stub) {
1273: efree(user_stub);
1274: }
1275: return EOF;
1276: }
1277: pos = user_stub + (pos - tmp);
1278: efree(tmp);
1279:
1280: len = pos - user_stub + 18;
1281: entry.fp = php_stream_fopen_tmpfile();
1.1.1.2 misho 1282: if (entry.fp == NULL) {
1283: spprintf(error, 0, "phar error: unable to create temporary file");
1284: return EOF;
1285: }
1.1 misho 1286: entry.uncompressed_filesize = len + 5;
1287:
1288: if ((size_t)len != php_stream_write(entry.fp, user_stub, len)
1289: || 5 != php_stream_write(entry.fp, " ?>\r\n", 5)) {
1290: if (error) {
1291: spprintf(error, 0, "unable to create stub from string in new zip-based phar \"%s\"", phar->fname);
1292: }
1293: if (free_user_stub) {
1294: efree(user_stub);
1295: }
1296: php_stream_close(entry.fp);
1297: return EOF;
1298: }
1299:
1300: entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1);
1301: entry.filename_len = sizeof(".phar/stub.php")-1;
1302:
1303: if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
1304: if (free_user_stub) {
1305: efree(user_stub);
1306: }
1307: if (error) {
1308: spprintf(error, 0, "unable to set stub in zip-based phar \"%s\"", phar->fname);
1309: }
1310: return EOF;
1311: }
1312:
1313: if (free_user_stub) {
1314: efree(user_stub);
1315: }
1316: } else {
1317: /* Either this is a brand new phar (add the stub), or the default stub is required (overwrite the stub) */
1318: entry.fp = php_stream_fopen_tmpfile();
1.1.1.2 misho 1319: if (entry.fp == NULL) {
1320: spprintf(error, 0, "phar error: unable to create temporary file");
1321: return EOF;
1322: }
1.1 misho 1323: if (sizeof(newstub)-1 != php_stream_write(entry.fp, newstub, sizeof(newstub)-1)) {
1324: php_stream_close(entry.fp);
1325: if (error) {
1326: spprintf(error, 0, "unable to %s stub in%szip-based phar \"%s\", failed", user_stub ? "overwrite" : "create", user_stub ? " " : " new ", phar->fname);
1327: }
1328: return EOF;
1329: }
1330:
1331: entry.uncompressed_filesize = entry.compressed_filesize = sizeof(newstub) - 1;
1332: entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1);
1333: entry.filename_len = sizeof(".phar/stub.php")-1;
1334:
1335: if (!defaultstub) {
1336: if (!zend_hash_exists(&phar->manifest, ".phar/stub.php", sizeof(".phar/stub.php")-1)) {
1337: if (SUCCESS != zend_hash_add(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
1338: php_stream_close(entry.fp);
1339: efree(entry.filename);
1340: if (error) {
1341: spprintf(error, 0, "unable to create stub in zip-based phar \"%s\"", phar->fname);
1342: }
1343: return EOF;
1344: }
1345: } else {
1346: php_stream_close(entry.fp);
1347: efree(entry.filename);
1348: }
1349: } else {
1350: if (SUCCESS != zend_hash_update(&phar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
1351: php_stream_close(entry.fp);
1352: efree(entry.filename);
1353: if (error) {
1354: spprintf(error, 0, "unable to overwrite stub in zip-based phar \"%s\"", phar->fname);
1355: }
1356: return EOF;
1357: }
1358: }
1359: }
1360: nostub:
1361: if (phar->fp && !phar->is_brandnew) {
1362: oldfile = phar->fp;
1363: closeoldfile = 0;
1364: php_stream_rewind(oldfile);
1365: } else {
1366: oldfile = php_stream_open_wrapper(phar->fname, "rb", 0, NULL);
1367: closeoldfile = oldfile != NULL;
1368: }
1369:
1370: /* save modified files to the zip */
1371: pass.old = oldfile;
1372: pass.filefp = php_stream_fopen_tmpfile();
1373:
1374: if (!pass.filefp) {
1375: fperror:
1376: if (closeoldfile) {
1377: php_stream_close(oldfile);
1378: }
1379: if (error) {
1380: spprintf(error, 4096, "phar zip flush of \"%s\" failed: unable to open temporary file", phar->fname);
1381: }
1382: return EOF;
1383: }
1384:
1385: pass.centralfp = php_stream_fopen_tmpfile();
1386:
1387: if (!pass.centralfp) {
1388: goto fperror;
1389: }
1390:
1391: pass.free_fp = pass.free_ufp = 1;
1392: memset(&eocd, 0, sizeof(eocd));
1393:
1394: strncpy(eocd.signature, "PK\5\6", 4);
1395: if (!phar->is_data && !phar->sig_flags) {
1396: phar->sig_flags = PHAR_SIG_SHA1;
1397: }
1398: if (phar->sig_flags) {
1399: PHAR_SET_16(eocd.counthere, zend_hash_num_elements(&phar->manifest) + 1);
1400: PHAR_SET_16(eocd.count, zend_hash_num_elements(&phar->manifest) + 1);
1401: } else {
1402: PHAR_SET_16(eocd.counthere, zend_hash_num_elements(&phar->manifest));
1403: PHAR_SET_16(eocd.count, zend_hash_num_elements(&phar->manifest));
1404: }
1405: zend_hash_apply_with_argument(&phar->manifest, phar_zip_changed_apply, (void *) &pass TSRMLS_CC);
1406:
1407: if (phar->metadata) {
1408: /* set phar metadata */
1409: PHP_VAR_SERIALIZE_INIT(metadata_hash);
1410: php_var_serialize(&main_metadata_str, &phar->metadata, &metadata_hash TSRMLS_CC);
1411: PHP_VAR_SERIALIZE_DESTROY(metadata_hash);
1412: }
1413: if (temperr) {
1414: if (error) {
1415: spprintf(error, 4096, "phar zip flush of \"%s\" failed: %s", phar->fname, temperr);
1416: }
1417: efree(temperr);
1418: temperror:
1419: php_stream_close(pass.centralfp);
1420: nocentralerror:
1421: if (phar->metadata) {
1422: smart_str_free(&main_metadata_str);
1423: }
1424: php_stream_close(pass.filefp);
1425: if (closeoldfile) {
1426: php_stream_close(oldfile);
1427: }
1428: return EOF;
1429: }
1430:
1431: if (FAILURE == phar_zip_applysignature(phar, &pass, &main_metadata_str TSRMLS_CC)) {
1432: goto temperror;
1433: }
1434:
1435: /* save zip */
1436: cdir_size = php_stream_tell(pass.centralfp);
1437: cdir_offset = php_stream_tell(pass.filefp);
1438: PHAR_SET_32(eocd.cdir_size, cdir_size);
1439: PHAR_SET_32(eocd.cdir_offset, cdir_offset);
1440: php_stream_seek(pass.centralfp, 0, SEEK_SET);
1441:
1442: {
1443: size_t clen;
1444: int ret = phar_stream_copy_to_stream(pass.centralfp, pass.filefp, PHP_STREAM_COPY_ALL, &clen);
1445: if (SUCCESS != ret || clen != cdir_size) {
1446: if (error) {
1447: spprintf(error, 4096, "phar zip flush of \"%s\" failed: unable to write central-directory", phar->fname);
1448: }
1449: goto temperror;
1450: }
1451: }
1452:
1453: php_stream_close(pass.centralfp);
1454:
1455: if (phar->metadata) {
1456: /* set phar metadata */
1457: PHAR_SET_16(eocd.comment_len, main_metadata_str.len);
1458:
1459: if (sizeof(eocd) != php_stream_write(pass.filefp, (char *)&eocd, sizeof(eocd))) {
1460: if (error) {
1461: spprintf(error, 4096, "phar zip flush of \"%s\" failed: unable to write end of central-directory", phar->fname);
1462: }
1463: goto nocentralerror;
1464: }
1465:
1466: if (main_metadata_str.len != php_stream_write(pass.filefp, main_metadata_str.c, main_metadata_str.len)) {
1467: if (error) {
1468: spprintf(error, 4096, "phar zip flush of \"%s\" failed: unable to write metadata to zip comment", phar->fname);
1469: }
1470: goto nocentralerror;
1471: }
1472:
1473: smart_str_free(&main_metadata_str);
1474:
1475: } else {
1476: if (sizeof(eocd) != php_stream_write(pass.filefp, (char *)&eocd, sizeof(eocd))) {
1477: if (error) {
1478: spprintf(error, 4096, "phar zip flush of \"%s\" failed: unable to write end of central-directory", phar->fname);
1479: }
1480: goto nocentralerror;
1481: }
1482: }
1483:
1484: if (phar->fp && pass.free_fp) {
1485: php_stream_close(phar->fp);
1486: }
1487:
1488: if (phar->ufp) {
1489: if (pass.free_ufp) {
1490: php_stream_close(phar->ufp);
1491: }
1492: phar->ufp = NULL;
1493: }
1494:
1495: /* re-open */
1496: phar->is_brandnew = 0;
1497:
1498: if (phar->donotflush) {
1499: /* deferred flush */
1500: phar->fp = pass.filefp;
1501: } else {
1502: phar->fp = php_stream_open_wrapper(phar->fname, "w+b", IGNORE_URL|STREAM_MUST_SEEK|REPORT_ERRORS, NULL);
1503: if (!phar->fp) {
1504: if (closeoldfile) {
1505: php_stream_close(oldfile);
1506: }
1507: phar->fp = pass.filefp;
1508: if (error) {
1509: spprintf(error, 4096, "unable to open new phar \"%s\" for writing", phar->fname);
1510: }
1511: return EOF;
1512: }
1513: php_stream_rewind(pass.filefp);
1514: phar_stream_copy_to_stream(pass.filefp, phar->fp, PHP_STREAM_COPY_ALL, NULL);
1515: /* we could also reopen the file in "rb" mode but there is no need for that */
1516: php_stream_close(pass.filefp);
1517: }
1518:
1519: if (closeoldfile) {
1520: php_stream_close(oldfile);
1521: }
1522: return EOF;
1523: }
1524: /* }}} */
1525:
1526: /*
1527: * Local variables:
1528: * tab-width: 4
1529: * c-basic-offset: 4
1530: * End:
1531: * vim600: noet sw=4 ts=4 fdm=marker
1532: * vim<600: noet sw=4 ts=4
1533: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zip.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