![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.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|
Return to util.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / phar |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | phar php single-file executable PHP extension |
4: | utility functions |
5: +----------------------------------------------------------------------+
1.1.1.4 ! misho 6: | Copyright (c) 2005-2014 The PHP Group |
1.1 misho 7: +----------------------------------------------------------------------+
8: | This source file is subject to version 3.01 of the PHP license, |
9: | that is bundled with this package in the file LICENSE, and is |
10: | available through the world-wide-web at the following url: |
11: | http://www.php.net/license/3_01.txt. |
12: | If you did not receive a copy of the PHP license and are unable to |
13: | obtain it through the world-wide-web, please send a note to |
14: | license@php.net so we can mail you a copy immediately. |
15: +----------------------------------------------------------------------+
16: | Authors: Gregory Beaver <cellog@php.net> |
17: | Marcus Boerger <helly@php.net> |
18: +----------------------------------------------------------------------+
19: */
20:
1.1.1.2 misho 21: /* $Id$ */
1.1 misho 22:
23: #include "phar_internal.h"
24: #ifdef PHAR_HASH_OK
25: #include "ext/hash/php_hash_sha.h"
26: #endif
27:
28: #ifdef PHAR_HAVE_OPENSSL
29: /* OpenSSL includes */
30: #include <openssl/evp.h>
31: #include <openssl/x509.h>
32: #include <openssl/x509v3.h>
33: #include <openssl/crypto.h>
34: #include <openssl/pem.h>
35: #include <openssl/err.h>
36: #include <openssl/conf.h>
37: #include <openssl/rand.h>
38: #include <openssl/ssl.h>
39: #include <openssl/pkcs12.h>
40: #else
41: static int phar_call_openssl_signverify(int is_sign, php_stream *fp, off_t end, char *key, int key_len, char **signature, int *signature_len TSRMLS_DC);
42: #endif
43:
44: #if !defined(PHP_VERSION_ID) || PHP_VERSION_ID < 50300
45: extern php_stream_wrapper php_stream_phar_wrapper;
46: #endif
47:
48: /* for links to relative location, prepend cwd of the entry */
49: static char *phar_get_link_location(phar_entry_info *entry TSRMLS_DC) /* {{{ */
50: {
51: char *p, *ret = NULL;
52: if (!entry->link) {
53: return NULL;
54: }
55: if (entry->link[0] == '/') {
56: return estrdup(entry->link + 1);
57: }
58: p = strrchr(entry->filename, '/');
59: if (p) {
60: *p = '\0';
61: spprintf(&ret, 0, "%s/%s", entry->filename, entry->link);
62: return ret;
63: }
64: return entry->link;
65: }
66: /* }}} */
67:
68: phar_entry_info *phar_get_link_source(phar_entry_info *entry TSRMLS_DC) /* {{{ */
69: {
70: phar_entry_info *link_entry;
71: char *link;
72:
73: if (!entry->link) {
74: return entry;
75: }
76:
77: link = phar_get_link_location(entry TSRMLS_CC);
78: if (SUCCESS == zend_hash_find(&(entry->phar->manifest), entry->link, strlen(entry->link), (void **)&link_entry) ||
79: SUCCESS == zend_hash_find(&(entry->phar->manifest), link, strlen(link), (void **)&link_entry)) {
80: if (link != entry->link) {
81: efree(link);
82: }
83: return phar_get_link_source(link_entry TSRMLS_CC);
84: } else {
85: if (link != entry->link) {
86: efree(link);
87: }
88: return NULL;
89: }
90: }
91: /* }}} */
92:
93: /* retrieve a phar_entry_info's current file pointer for reading contents */
94: php_stream *phar_get_efp(phar_entry_info *entry, int follow_links TSRMLS_DC) /* {{{ */
95: {
96: if (follow_links && entry->link) {
97: phar_entry_info *link_entry = phar_get_link_source(entry TSRMLS_CC);
98:
99: if (link_entry && link_entry != entry) {
100: return phar_get_efp(link_entry, 1 TSRMLS_CC);
101: }
102: }
103:
104: if (phar_get_fp_type(entry TSRMLS_CC) == PHAR_FP) {
105: if (!phar_get_entrypfp(entry TSRMLS_CC)) {
106: /* re-open just in time for cases where our refcount reached 0 on the phar archive */
107: phar_open_archive_fp(entry->phar TSRMLS_CC);
108: }
109: return phar_get_entrypfp(entry TSRMLS_CC);
110: } else if (phar_get_fp_type(entry TSRMLS_CC) == PHAR_UFP) {
111: return phar_get_entrypufp(entry TSRMLS_CC);
112: } else if (entry->fp_type == PHAR_MOD) {
113: return entry->fp;
114: } else {
115: /* temporary manifest entry */
116: if (!entry->fp) {
117: entry->fp = php_stream_open_wrapper(entry->tmp, "rb", STREAM_MUST_SEEK|0, NULL);
118: }
119: return entry->fp;
120: }
121: }
122: /* }}} */
123:
124: int phar_seek_efp(phar_entry_info *entry, off_t offset, int whence, off_t position, int follow_links TSRMLS_DC) /* {{{ */
125: {
126: php_stream *fp = phar_get_efp(entry, follow_links TSRMLS_CC);
127: off_t temp, eoffset;
128:
129: if (!fp) {
130: return -1;
131: }
132:
133: if (follow_links) {
134: phar_entry_info *t;
135: t = phar_get_link_source(entry TSRMLS_CC);
136: if (t) {
137: entry = t;
138: }
139: }
140:
141: if (entry->is_dir) {
142: return 0;
143: }
144:
145: eoffset = phar_get_fp_offset(entry TSRMLS_CC);
146:
147: switch (whence) {
148: case SEEK_END:
149: temp = eoffset + entry->uncompressed_filesize + offset;
150: break;
151: case SEEK_CUR:
152: temp = eoffset + position + offset;
153: break;
154: case SEEK_SET:
155: temp = eoffset + offset;
156: break;
157: default:
158: temp = 0;
159: }
160:
161: if (temp > eoffset + (off_t) entry->uncompressed_filesize) {
162: return -1;
163: }
164:
165: if (temp < eoffset) {
166: return -1;
167: }
168:
169: return php_stream_seek(fp, temp, SEEK_SET);
170: }
171: /* }}} */
172:
173: /* mount an absolute path or uri to a path internal to the phar archive */
174: int phar_mount_entry(phar_archive_data *phar, char *filename, int filename_len, char *path, int path_len TSRMLS_DC) /* {{{ */
175: {
176: phar_entry_info entry = {0};
177: php_stream_statbuf ssb;
178: int is_phar;
179: const char *err;
180:
181: if (phar_path_check(&path, &path_len, &err) > pcr_is_ok) {
182: return FAILURE;
183: }
184:
185: if (path_len >= sizeof(".phar")-1 && !memcmp(path, ".phar", sizeof(".phar")-1)) {
186: /* no creating magic phar files by mounting them */
187: return FAILURE;
188: }
189:
190: is_phar = (filename_len > 7 && !memcmp(filename, "phar://", 7));
191:
192: entry.phar = phar;
193: entry.filename = estrndup(path, path_len);
194: #ifdef PHP_WIN32
195: phar_unixify_path_separators(entry.filename, path_len);
196: #endif
197: entry.filename_len = path_len;
198: if (is_phar) {
199: entry.tmp = estrndup(filename, filename_len);
200: } else {
201: entry.tmp = expand_filepath(filename, NULL TSRMLS_CC);
202: if (!entry.tmp) {
203: entry.tmp = estrndup(filename, filename_len);
204: }
205: }
206: #if PHP_API_VERSION < 20100412
207: if (PG(safe_mode) && !is_phar && (!php_checkuid(entry.tmp, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
208: efree(entry.tmp);
209: efree(entry.filename);
210: return FAILURE;
211: }
212: #endif
213: filename = entry.tmp;
214:
215: /* only check openbasedir for files, not for phar streams */
216: if (!is_phar && php_check_open_basedir(filename TSRMLS_CC)) {
217: efree(entry.tmp);
218: efree(entry.filename);
219: return FAILURE;
220: }
221:
222: entry.is_mounted = 1;
223: entry.is_crc_checked = 1;
224: entry.fp_type = PHAR_TMP;
225:
226: if (SUCCESS != php_stream_stat_path(filename, &ssb)) {
227: efree(entry.tmp);
228: efree(entry.filename);
229: return FAILURE;
230: }
231:
232: if (ssb.sb.st_mode & S_IFDIR) {
233: entry.is_dir = 1;
234: if (SUCCESS != zend_hash_add(&phar->mounted_dirs, entry.filename, path_len, (void *)&(entry.filename), sizeof(char *), NULL)) {
235: /* directory already mounted */
236: efree(entry.tmp);
237: efree(entry.filename);
238: return FAILURE;
239: }
240: } else {
241: entry.is_dir = 0;
242: entry.uncompressed_filesize = entry.compressed_filesize = ssb.sb.st_size;
243: }
244:
245: entry.flags = ssb.sb.st_mode;
246:
247: if (SUCCESS == zend_hash_add(&phar->manifest, entry.filename, path_len, (void*)&entry, sizeof(phar_entry_info), NULL)) {
248: return SUCCESS;
249: }
250:
251: efree(entry.tmp);
252: efree(entry.filename);
253: return FAILURE;
254: }
255: /* }}} */
256:
257: char *phar_find_in_include_path(char *filename, int filename_len, phar_archive_data **pphar TSRMLS_DC) /* {{{ */
258: {
259: #if PHP_VERSION_ID >= 50300
260: char *path, *fname, *arch, *entry, *ret, *test;
261: int arch_len, entry_len, fname_len, ret_len;
262: phar_archive_data *phar;
263:
264: if (pphar) {
265: *pphar = NULL;
266: } else {
267: pphar = &phar;
268: }
269:
270: if (!zend_is_executing(TSRMLS_C) || !PHAR_G(cwd)) {
271: return phar_save_resolve_path(filename, filename_len TSRMLS_CC);
272: }
273:
1.1.1.2 misho 274: fname = (char*)zend_get_executed_filename(TSRMLS_C);
1.1 misho 275: fname_len = strlen(fname);
276:
277: if (PHAR_G(last_phar) && !memcmp(fname, "phar://", 7) && fname_len - 7 >= PHAR_G(last_phar_name_len) && !memcmp(fname + 7, PHAR_G(last_phar_name), PHAR_G(last_phar_name_len))) {
278: arch = estrndup(PHAR_G(last_phar_name), PHAR_G(last_phar_name_len));
279: arch_len = PHAR_G(last_phar_name_len);
280: phar = PHAR_G(last_phar);
281: goto splitted;
282: }
283:
284: if (fname_len < 7 || memcmp(fname, "phar://", 7) || SUCCESS != phar_split_fname(fname, strlen(fname), &arch, &arch_len, &entry, &entry_len, 1, 0 TSRMLS_CC)) {
285: return phar_save_resolve_path(filename, filename_len TSRMLS_CC);
286: }
287:
288: efree(entry);
289:
290: if (*filename == '.') {
291: int try_len;
292:
293: if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
294: efree(arch);
295: return phar_save_resolve_path(filename, filename_len TSRMLS_CC);
296: }
297: splitted:
298: if (pphar) {
299: *pphar = phar;
300: }
301:
302: try_len = filename_len;
303: test = phar_fix_filepath(estrndup(filename, filename_len), &try_len, 1 TSRMLS_CC);
304:
305: if (*test == '/') {
306: if (zend_hash_exists(&(phar->manifest), test + 1, try_len - 1)) {
307: spprintf(&ret, 0, "phar://%s%s", arch, test);
308: efree(arch);
309: efree(test);
310: return ret;
311: }
312: } else {
313: if (zend_hash_exists(&(phar->manifest), test, try_len)) {
314: spprintf(&ret, 0, "phar://%s/%s", arch, test);
315: efree(arch);
316: efree(test);
317: return ret;
318: }
319: }
320: efree(test);
321: }
322:
323: spprintf(&path, MAXPATHLEN, "phar://%s/%s%c%s", arch, PHAR_G(cwd), DEFAULT_DIR_SEPARATOR, PG(include_path));
324: efree(arch);
325: ret = php_resolve_path(filename, filename_len, path TSRMLS_CC);
326: efree(path);
327:
328: if (ret && strlen(ret) > 8 && !strncmp(ret, "phar://", 7)) {
329: ret_len = strlen(ret);
330: /* found phar:// */
331:
332: if (SUCCESS != phar_split_fname(ret, ret_len, &arch, &arch_len, &entry, &entry_len, 1, 0 TSRMLS_CC)) {
333: return ret;
334: }
335:
336: zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **) &pphar);
337:
338: if (!pphar && PHAR_G(manifest_cached)) {
339: zend_hash_find(&cached_phars, arch, arch_len, (void **) &pphar);
340: }
341:
342: efree(arch);
343: efree(entry);
344: }
345:
346: return ret;
347: #else /* PHP 5.2 */
348: char resolved_path[MAXPATHLEN];
349: char trypath[MAXPATHLEN];
350: char *ptr, *end, *path = PG(include_path);
351: php_stream_wrapper *wrapper;
352: const char *p;
353: int n = 0;
354: char *fname, *arch, *entry, *ret, *test;
355: int arch_len, entry_len;
356: phar_archive_data *phar = NULL;
357:
358: if (!filename) {
359: return NULL;
360: }
361:
362: if (!zend_is_executing(TSRMLS_C) || !PHAR_G(cwd)) {
363: goto doit;
364: }
365:
1.1.1.2 misho 366: fname = (char*)zend_get_executed_filename(TSRMLS_C);
1.1 misho 367:
368: if (SUCCESS != phar_split_fname(fname, strlen(fname), &arch, &arch_len, &entry, &entry_len, 1, 0 TSRMLS_CC)) {
369: goto doit;
370: }
371:
372: efree(entry);
373:
374: if (*filename == '.') {
375: int try_len;
376:
377: if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
378: efree(arch);
379: goto doit;
380: }
381:
382: try_len = filename_len;
383: test = phar_fix_filepath(estrndup(filename, filename_len), &try_len, 1 TSRMLS_CC);
384:
385: if (*test == '/') {
386: if (zend_hash_exists(&(phar->manifest), test + 1, try_len - 1)) {
387: spprintf(&ret, 0, "phar://%s%s", arch, test);
388: efree(arch);
389: efree(test);
390: return ret;
391: }
392: } else {
393: if (zend_hash_exists(&(phar->manifest), test, try_len)) {
394: spprintf(&ret, 0, "phar://%s/%s", arch, test);
395: efree(arch);
396: efree(test);
397: return ret;
398: }
399: }
400:
401: efree(test);
402: }
403:
404: efree(arch);
405: doit:
406: if (*filename == '.' || IS_ABSOLUTE_PATH(filename, filename_len) || !path || !*path) {
407: if (tsrm_realpath(filename, resolved_path TSRMLS_CC)) {
408: return estrdup(resolved_path);
409: } else {
410: return NULL;
411: }
412: }
413:
414: /* test for stream wrappers and return */
415: for (p = filename; p - filename < filename_len && (isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'); ++p, ++n);
416:
417: if (n < filename_len - 3 && (*p == ':') && (!strncmp("//", p+1, 2) || ( filename_len > 4 && !memcmp("data", filename, 4)))) {
418: /* found stream wrapper, this is an absolute path until stream wrappers implement realpath */
419: return estrndup(filename, filename_len);
420: }
421:
422: ptr = (char *) path;
423: while (ptr && *ptr) {
424: int len, is_stream_wrapper = 0, maybe_stream = 1;
425:
426: end = strchr(ptr, DEFAULT_DIR_SEPARATOR);
427: #ifndef PHP_WIN32
428: /* search for stream wrapper */
429: if (end - ptr <= 1) {
430: maybe_stream = 0;
431: goto not_stream;
432: }
433:
434: for (p = ptr, n = 0; p < end && (isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'); ++p, ++n);
435:
436: if (n == end - ptr && *p && !strncmp("//", p+1, 2)) {
437: is_stream_wrapper = 1;
438: /* seek to real end of include_path portion */
439: end = strchr(end + 1, DEFAULT_DIR_SEPARATOR);
440: } else {
441: maybe_stream = 0;
442: }
443: not_stream:
444: #endif
445: if (end) {
446: if ((end-ptr) + 1 + filename_len + 1 >= MAXPATHLEN) {
447: ptr = end + 1;
448: continue;
449: }
450:
451: memcpy(trypath, ptr, end-ptr);
452: len = end-ptr;
453: trypath[end-ptr] = '/';
454: memcpy(trypath+(end-ptr)+1, filename, filename_len+1);
455: ptr = end+1;
456: } else {
457: len = strlen(ptr);
458:
459: if (len + 1 + filename_len + 1 >= MAXPATHLEN) {
460: break;
461: }
462:
463: memcpy(trypath, ptr, len);
464: trypath[len] = '/';
465: memcpy(trypath+len+1, filename, filename_len+1);
466: ptr = NULL;
467: }
468:
469: if (!is_stream_wrapper && maybe_stream) {
470: /* search for stream wrapper */
471: for (p = trypath, n = 0; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; ++p, ++n);
472: }
473:
474: if (is_stream_wrapper || (n < len - 3 && (*p == ':') && (n > 1) && (!strncmp("//", p+1, 2) || !memcmp("data", trypath, 4)))) {
475: char *actual;
476:
477: wrapper = php_stream_locate_url_wrapper(trypath, &actual, STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);
478: if (wrapper == &php_plain_files_wrapper) {
479: strlcpy(trypath, actual, sizeof(trypath));
480: } else if (!wrapper) {
481: /* if wrapper is NULL, there was a mal-formed include_path stream wrapper, so skip this ptr */
482: continue;
483: } else {
484: if (wrapper->wops->url_stat) {
485: php_stream_statbuf ssb;
486:
487: if (SUCCESS == wrapper->wops->url_stat(wrapper, trypath, 0, &ssb, NULL TSRMLS_CC)) {
488: if (wrapper == &php_stream_phar_wrapper) {
489: char *arch, *entry;
490: int arch_len, entry_len, ret_len;
491:
492: ret_len = strlen(trypath);
493: /* found phar:// */
494:
495: if (SUCCESS != phar_split_fname(trypath, ret_len, &arch, &arch_len, &entry, &entry_len, 1, 0 TSRMLS_CC)) {
496: return estrndup(trypath, ret_len);
497: }
498:
499: zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **) &pphar);
500:
501: if (!pphar && PHAR_G(manifest_cached)) {
502: zend_hash_find(&cached_phars, arch, arch_len, (void **) &pphar);
503: }
504:
505: efree(arch);
506: efree(entry);
507:
508: return estrndup(trypath, ret_len);
509: }
510: return estrdup(trypath);
511: }
512: }
513: continue;
514: }
515: }
516:
517: if (tsrm_realpath(trypath, resolved_path TSRMLS_CC)) {
518: return estrdup(resolved_path);
519: }
520: } /* end provided path */
521:
522: /* check in calling scripts' current working directory as a fall back case */
523: if (zend_is_executing(TSRMLS_C)) {
1.1.1.2 misho 524: char *exec_fname = (char*)zend_get_executed_filename(TSRMLS_C);
1.1 misho 525: int exec_fname_length = strlen(exec_fname);
526: const char *p;
527: int n = 0;
528:
529: while ((--exec_fname_length >= 0) && !IS_SLASH(exec_fname[exec_fname_length]));
530: if (exec_fname && exec_fname[0] != '[' &&
531: exec_fname_length > 0 &&
532: exec_fname_length + 1 + filename_len + 1 < MAXPATHLEN) {
533: memcpy(trypath, exec_fname, exec_fname_length + 1);
534: memcpy(trypath+exec_fname_length + 1, filename, filename_len+1);
535:
536: /* search for stream wrapper */
537: for (p = trypath; isalnum((int)*p) || *p == '+' || *p == '-' || *p == '.'; ++p, ++n);
538:
539: if (n < exec_fname_length - 3 && (*p == ':') && (n > 1) && (!strncmp("//", p+1, 2) || !memcmp("data", trypath, 4))) {
540: char *actual;
541:
542: wrapper = php_stream_locate_url_wrapper(trypath, &actual, STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);
543:
544: if (wrapper == &php_plain_files_wrapper) {
545: /* this should never technically happen, but we'll leave it here for completeness */
546: strlcpy(trypath, actual, sizeof(trypath));
547: } else if (!wrapper) {
548: /* if wrapper is NULL, there was a malformed include_path stream wrapper
549: this also should be impossible */
550: return NULL;
551: } else {
552: return estrdup(trypath);
553: }
554: }
555:
556: if (tsrm_realpath(trypath, resolved_path TSRMLS_CC)) {
557: return estrdup(resolved_path);
558: }
559: }
560: }
561:
562: return NULL;
563: #endif /* PHP 5.2 */
564: }
565: /* }}} */
566:
567: /**
568: * Retrieve a copy of the file information on a single file within a phar, or null.
569: * This also transfers the open file pointer, if any, to the entry.
570: *
571: * If the file does not already exist, this will fail. Pre-existing files can be
572: * appended, truncated, or read. For read, if the entry is marked unmodified, it is
573: * assumed that the file pointer, if present, is opened for reading
574: */
575: int phar_get_entry_data(phar_entry_data **ret, char *fname, int fname_len, char *path, int path_len, char *mode, char allow_dir, char **error, int security TSRMLS_DC) /* {{{ */
576: {
577: phar_archive_data *phar;
578: phar_entry_info *entry;
579: int for_write = mode[0] != 'r' || mode[1] == '+';
580: int for_append = mode[0] == 'a';
581: int for_create = mode[0] != 'r';
582: int for_trunc = mode[0] == 'w';
583:
584: if (!ret) {
585: return FAILURE;
586: }
587:
588: *ret = NULL;
589:
590: if (error) {
591: *error = NULL;
592: }
593:
594: if (FAILURE == phar_get_archive(&phar, fname, fname_len, NULL, 0, error TSRMLS_CC)) {
595: return FAILURE;
596: }
597:
598: if (for_write && PHAR_G(readonly) && !phar->is_data) {
599: if (error) {
600: spprintf(error, 4096, "phar error: file \"%s\" in phar \"%s\" cannot be opened for writing, disabled by ini setting", path, fname);
601: }
602: return FAILURE;
603: }
604:
605: if (!path_len) {
606: if (error) {
607: spprintf(error, 4096, "phar error: file \"\" in phar \"%s\" cannot be empty", fname);
608: }
609: return FAILURE;
610: }
611: really_get_entry:
612: if (allow_dir) {
613: if ((entry = phar_get_entry_info_dir(phar, path, path_len, allow_dir, for_create && !PHAR_G(readonly) && !phar->is_data ? NULL : error, security TSRMLS_CC)) == NULL) {
614: if (for_create && (!PHAR_G(readonly) || phar->is_data)) {
615: return SUCCESS;
616: }
617: return FAILURE;
618: }
619: } else {
620: if ((entry = phar_get_entry_info(phar, path, path_len, for_create && !PHAR_G(readonly) && !phar->is_data ? NULL : error, security TSRMLS_CC)) == NULL) {
621: if (for_create && (!PHAR_G(readonly) || phar->is_data)) {
622: return SUCCESS;
623: }
624: return FAILURE;
625: }
626: }
627:
628: if (for_write && phar->is_persistent) {
629: if (FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
630: if (error) {
631: spprintf(error, 4096, "phar error: file \"%s\" in phar \"%s\" cannot be opened for writing, could not make cached phar writeable", path, fname);
632: }
633: return FAILURE;
634: } else {
635: goto really_get_entry;
636: }
637: }
638:
639: if (entry->is_modified && !for_write) {
640: if (error) {
641: spprintf(error, 4096, "phar error: file \"%s\" in phar \"%s\" cannot be opened for reading, writable file pointers are open", path, fname);
642: }
643: return FAILURE;
644: }
645:
646: if (entry->fp_refcount && for_write) {
647: if (error) {
648: spprintf(error, 4096, "phar error: file \"%s\" in phar \"%s\" cannot be opened for writing, readable file pointers are open", path, fname);
649: }
650: return FAILURE;
651: }
652:
653: if (entry->is_deleted) {
654: if (!for_create) {
655: return FAILURE;
656: }
657: entry->is_deleted = 0;
658: }
659:
660: if (entry->is_dir) {
661: *ret = (phar_entry_data *) emalloc(sizeof(phar_entry_data));
662: (*ret)->position = 0;
663: (*ret)->fp = NULL;
664: (*ret)->phar = phar;
665: (*ret)->for_write = for_write;
666: (*ret)->internal_file = entry;
667: (*ret)->is_zip = entry->is_zip;
668: (*ret)->is_tar = entry->is_tar;
669:
670: if (!phar->is_persistent) {
671: ++(entry->phar->refcount);
672: ++(entry->fp_refcount);
673: }
674:
675: return SUCCESS;
676: }
677:
678: if (entry->fp_type == PHAR_MOD) {
679: if (for_trunc) {
680: if (FAILURE == phar_create_writeable_entry(phar, entry, error TSRMLS_CC)) {
681: return FAILURE;
682: }
683: } else if (for_append) {
684: phar_seek_efp(entry, 0, SEEK_END, 0, 0 TSRMLS_CC);
685: }
686: } else {
687: if (for_write) {
688: if (entry->link) {
689: efree(entry->link);
690: entry->link = NULL;
691: entry->tar_type = (entry->is_tar ? TAR_FILE : '\0');
692: }
693:
694: if (for_trunc) {
695: if (FAILURE == phar_create_writeable_entry(phar, entry, error TSRMLS_CC)) {
696: return FAILURE;
697: }
698: } else {
699: if (FAILURE == phar_separate_entry_fp(entry, error TSRMLS_CC)) {
700: return FAILURE;
701: }
702: }
703: } else {
704: if (FAILURE == phar_open_entry_fp(entry, error, 1 TSRMLS_CC)) {
705: return FAILURE;
706: }
707: }
708: }
709:
710: *ret = (phar_entry_data *) emalloc(sizeof(phar_entry_data));
711: (*ret)->position = 0;
712: (*ret)->phar = phar;
713: (*ret)->for_write = for_write;
714: (*ret)->internal_file = entry;
715: (*ret)->is_zip = entry->is_zip;
716: (*ret)->is_tar = entry->is_tar;
717: (*ret)->fp = phar_get_efp(entry, 1 TSRMLS_CC);
718: if (entry->link) {
719: (*ret)->zero = phar_get_fp_offset(phar_get_link_source(entry TSRMLS_CC) TSRMLS_CC);
720: } else {
721: (*ret)->zero = phar_get_fp_offset(entry TSRMLS_CC);
722: }
723:
724: if (!phar->is_persistent) {
725: ++(entry->fp_refcount);
726: ++(entry->phar->refcount);
727: }
728:
729: return SUCCESS;
730: }
731: /* }}} */
732:
733: /**
734: * Create a new dummy file slot within a writeable phar for a newly created file
735: */
736: phar_entry_data *phar_get_or_create_entry_data(char *fname, int fname_len, char *path, int path_len, char *mode, char allow_dir, char **error, int security TSRMLS_DC) /* {{{ */
737: {
738: phar_archive_data *phar;
739: phar_entry_info *entry, etemp;
740: phar_entry_data *ret;
741: const char *pcr_error;
742: char is_dir;
743:
744: #ifdef PHP_WIN32
745: phar_unixify_path_separators(path, path_len);
746: #endif
747:
748: is_dir = (path_len && path[path_len - 1] == '/') ? 1 : 0;
749:
750: if (FAILURE == phar_get_archive(&phar, fname, fname_len, NULL, 0, error TSRMLS_CC)) {
751: return NULL;
752: }
753:
754: if (FAILURE == phar_get_entry_data(&ret, fname, fname_len, path, path_len, mode, allow_dir, error, security TSRMLS_CC)) {
755: return NULL;
756: } else if (ret) {
757: return ret;
758: }
759:
760: if (phar_path_check(&path, &path_len, &pcr_error) > pcr_is_ok) {
761: if (error) {
762: spprintf(error, 0, "phar error: invalid path \"%s\" contains %s", path, pcr_error);
763: }
764: return NULL;
765: }
766:
767: if (phar->is_persistent && FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
768: if (error) {
769: spprintf(error, 4096, "phar error: file \"%s\" in phar \"%s\" cannot be created, could not make cached phar writeable", path, fname);
770: }
771: return NULL;
772: }
773:
774: /* create a new phar data holder */
775: ret = (phar_entry_data *) emalloc(sizeof(phar_entry_data));
776:
777: /* create an entry, this is a new file */
778: memset(&etemp, 0, sizeof(phar_entry_info));
779: etemp.filename_len = path_len;
780: etemp.fp_type = PHAR_MOD;
781: etemp.fp = php_stream_fopen_tmpfile();
782:
783: if (!etemp.fp) {
784: if (error) {
785: spprintf(error, 0, "phar error: unable to create temporary file");
786: }
787: efree(ret);
788: return NULL;
789: }
790:
791: etemp.fp_refcount = 1;
792:
793: if (allow_dir == 2) {
794: etemp.is_dir = 1;
795: etemp.flags = etemp.old_flags = PHAR_ENT_PERM_DEF_DIR;
796: } else {
797: etemp.flags = etemp.old_flags = PHAR_ENT_PERM_DEF_FILE;
798: }
799: if (is_dir) {
800: etemp.filename_len--; /* strip trailing / */
801: path_len--;
802: }
803:
804: phar_add_virtual_dirs(phar, path, path_len TSRMLS_CC);
805: etemp.is_modified = 1;
806: etemp.timestamp = time(0);
807: etemp.is_crc_checked = 1;
808: etemp.phar = phar;
809: etemp.filename = estrndup(path, path_len);
810: etemp.is_zip = phar->is_zip;
811:
812: if (phar->is_tar) {
813: etemp.is_tar = phar->is_tar;
814: etemp.tar_type = etemp.is_dir ? TAR_DIR : TAR_FILE;
815: }
816:
817: if (FAILURE == zend_hash_add(&phar->manifest, etemp.filename, path_len, (void*)&etemp, sizeof(phar_entry_info), (void **) &entry)) {
818: php_stream_close(etemp.fp);
819: if (error) {
820: spprintf(error, 0, "phar error: unable to add new entry \"%s\" to phar \"%s\"", etemp.filename, phar->fname);
821: }
822: efree(ret);
823: efree(etemp.filename);
824: return NULL;
825: }
826:
827: if (!entry) {
828: php_stream_close(etemp.fp);
829: efree(etemp.filename);
830: efree(ret);
831: return NULL;
832: }
833:
834: ++(phar->refcount);
835: ret->phar = phar;
836: ret->fp = entry->fp;
837: ret->position = ret->zero = 0;
838: ret->for_write = 1;
839: ret->is_zip = entry->is_zip;
840: ret->is_tar = entry->is_tar;
841: ret->internal_file = entry;
842:
843: return ret;
844: }
845: /* }}} */
846:
847: /* initialize a phar_archive_data's read-only fp for existing phar data */
848: int phar_open_archive_fp(phar_archive_data *phar TSRMLS_DC) /* {{{ */
849: {
850: if (phar_get_pharfp(phar TSRMLS_CC)) {
851: return SUCCESS;
852: }
853: #if PHP_API_VERSION < 20100412
854: if (PG(safe_mode) && (!php_checkuid(phar->fname, NULL, CHECKUID_ALLOW_ONLY_FILE))) {
855: return FAILURE;
856: }
857: #endif
858:
859: if (php_check_open_basedir(phar->fname TSRMLS_CC)) {
860: return FAILURE;
861: }
862:
863: phar_set_pharfp(phar, php_stream_open_wrapper(phar->fname, "rb", IGNORE_URL|STREAM_MUST_SEEK|0, NULL) TSRMLS_CC);
864:
865: if (!phar_get_pharfp(phar TSRMLS_CC)) {
866: return FAILURE;
867: }
868:
869: return SUCCESS;
870: }
871: /* }}} */
872:
873: /* copy file data from an existing to a new phar_entry_info that is not in the manifest */
874: int phar_copy_entry_fp(phar_entry_info *source, phar_entry_info *dest, char **error TSRMLS_DC) /* {{{ */
875: {
876: phar_entry_info *link;
877:
878: if (FAILURE == phar_open_entry_fp(source, error, 1 TSRMLS_CC)) {
879: return FAILURE;
880: }
881:
882: if (dest->link) {
883: efree(dest->link);
884: dest->link = NULL;
885: dest->tar_type = (dest->is_tar ? TAR_FILE : '\0');
886: }
887:
888: dest->fp_type = PHAR_MOD;
889: dest->offset = 0;
890: dest->is_modified = 1;
891: dest->fp = php_stream_fopen_tmpfile();
1.1.1.3 misho 892: if (dest->fp == NULL) {
893: spprintf(error, 0, "phar error: unable to create temporary file");
894: return EOF;
895: }
1.1 misho 896: phar_seek_efp(source, 0, SEEK_SET, 0, 1 TSRMLS_CC);
897: link = phar_get_link_source(source TSRMLS_CC);
898:
899: if (!link) {
900: link = source;
901: }
902:
903: if (SUCCESS != phar_stream_copy_to_stream(phar_get_efp(link, 0 TSRMLS_CC), dest->fp, link->uncompressed_filesize, NULL)) {
904: php_stream_close(dest->fp);
905: dest->fp_type = PHAR_FP;
906: if (error) {
907: spprintf(error, 4096, "phar error: unable to copy contents of file \"%s\" to \"%s\" in phar archive \"%s\"", source->filename, dest->filename, source->phar->fname);
908: }
909: return FAILURE;
910: }
911:
912: return SUCCESS;
913: }
914: /* }}} */
915:
916: /* open and decompress a compressed phar entry
917: */
918: int phar_open_entry_fp(phar_entry_info *entry, char **error, int follow_links TSRMLS_DC) /* {{{ */
919: {
920: php_stream_filter *filter;
921: phar_archive_data *phar = entry->phar;
922: char *filtername;
923: off_t loc;
924: php_stream *ufp;
925: phar_entry_data dummy;
926:
927: if (follow_links && entry->link) {
928: phar_entry_info *link_entry = phar_get_link_source(entry TSRMLS_CC);
929: if (link_entry && link_entry != entry) {
930: return phar_open_entry_fp(link_entry, error, 1 TSRMLS_CC);
931: }
932: }
933:
934: if (entry->is_modified) {
935: return SUCCESS;
936: }
937:
938: if (entry->fp_type == PHAR_TMP) {
939: if (!entry->fp) {
940: entry->fp = php_stream_open_wrapper(entry->tmp, "rb", STREAM_MUST_SEEK|0, NULL);
941: }
942: return SUCCESS;
943: }
944:
945: if (entry->fp_type != PHAR_FP) {
946: /* either newly created or already modified */
947: return SUCCESS;
948: }
949:
950: if (!phar_get_pharfp(phar TSRMLS_CC)) {
951: if (FAILURE == phar_open_archive_fp(phar TSRMLS_CC)) {
952: spprintf(error, 4096, "phar error: Cannot open phar archive \"%s\" for reading", phar->fname);
953: return FAILURE;
954: }
955: }
956:
957: if ((entry->old_flags && !(entry->old_flags & PHAR_ENT_COMPRESSION_MASK)) || !(entry->flags & PHAR_ENT_COMPRESSION_MASK)) {
958: dummy.internal_file = entry;
959: dummy.phar = phar;
960: dummy.zero = entry->offset;
961: dummy.fp = phar_get_pharfp(phar TSRMLS_CC);
962: if (FAILURE == phar_postprocess_file(&dummy, entry->crc32, error, 1 TSRMLS_CC)) {
963: return FAILURE;
964: }
965: return SUCCESS;
966: }
967:
968: if (!phar_get_entrypufp(entry TSRMLS_CC)) {
969: phar_set_entrypufp(entry, php_stream_fopen_tmpfile() TSRMLS_CC);
970: if (!phar_get_entrypufp(entry TSRMLS_CC)) {
971: spprintf(error, 4096, "phar error: Cannot open temporary file for decompressing phar archive \"%s\" file \"%s\"", phar->fname, entry->filename);
972: return FAILURE;
973: }
974: }
975:
976: dummy.internal_file = entry;
977: dummy.phar = phar;
978: dummy.zero = entry->offset;
979: dummy.fp = phar_get_pharfp(phar TSRMLS_CC);
980: if (FAILURE == phar_postprocess_file(&dummy, entry->crc32, error, 1 TSRMLS_CC)) {
981: return FAILURE;
982: }
983:
984: ufp = phar_get_entrypufp(entry TSRMLS_CC);
985:
986: if ((filtername = phar_decompress_filter(entry, 0)) != NULL) {
987: filter = php_stream_filter_create(filtername, NULL, 0 TSRMLS_CC);
988: } else {
989: filter = NULL;
990: }
991:
992: if (!filter) {
993: spprintf(error, 4096, "phar error: unable to read phar \"%s\" (cannot create %s filter while decompressing file \"%s\")", phar->fname, phar_decompress_filter(entry, 1), entry->filename);
994: return FAILURE;
995: }
996:
997: /* now we can safely use proper decompression */
998: /* save the new offset location within ufp */
999: php_stream_seek(ufp, 0, SEEK_END);
1000: loc = php_stream_tell(ufp);
1001: php_stream_filter_append(&ufp->writefilters, filter);
1002: php_stream_seek(phar_get_entrypfp(entry TSRMLS_CC), phar_get_fp_offset(entry TSRMLS_CC), SEEK_SET);
1003:
1004: if (entry->uncompressed_filesize) {
1005: if (SUCCESS != phar_stream_copy_to_stream(phar_get_entrypfp(entry TSRMLS_CC), ufp, entry->compressed_filesize, NULL)) {
1006: spprintf(error, 4096, "phar error: internal corruption of phar \"%s\" (actual filesize mismatch on file \"%s\")", phar->fname, entry->filename);
1007: php_stream_filter_remove(filter, 1 TSRMLS_CC);
1008: return FAILURE;
1009: }
1010: }
1011:
1012: php_stream_filter_flush(filter, 1);
1013: php_stream_flush(ufp);
1014: php_stream_filter_remove(filter, 1 TSRMLS_CC);
1015:
1016: if (php_stream_tell(ufp) - loc != (off_t) entry->uncompressed_filesize) {
1017: spprintf(error, 4096, "phar error: internal corruption of phar \"%s\" (actual filesize mismatch on file \"%s\")", phar->fname, entry->filename);
1018: return FAILURE;
1019: }
1020:
1021: entry->old_flags = entry->flags;
1022:
1023: /* this is now the new location of the file contents within this fp */
1024: phar_set_fp_type(entry, PHAR_UFP, loc TSRMLS_CC);
1025: dummy.zero = entry->offset;
1026: dummy.fp = ufp;
1027: if (FAILURE == phar_postprocess_file(&dummy, entry->crc32, error, 0 TSRMLS_CC)) {
1028: return FAILURE;
1029: }
1030: return SUCCESS;
1031: }
1032: /* }}} */
1033:
1034: #if defined(PHP_VERSION_ID) && PHP_VERSION_ID < 50202
1035: typedef struct {
1036: char *data;
1037: size_t fpos;
1038: size_t fsize;
1039: size_t smax;
1040: int mode;
1041: php_stream **owner_ptr;
1042: } php_stream_memory_data;
1043: #endif
1044:
1045: int phar_create_writeable_entry(phar_archive_data *phar, phar_entry_info *entry, char **error TSRMLS_DC) /* {{{ */
1046: {
1047: if (entry->fp_type == PHAR_MOD) {
1048: /* already newly created, truncate */
1049: #if PHP_VERSION_ID >= 50202
1050: php_stream_truncate_set_size(entry->fp, 0);
1051: #else
1052: if (php_stream_is(entry->fp, PHP_STREAM_IS_TEMP)) {
1053: if (php_stream_is(*(php_stream**)entry->fp->abstract, PHP_STREAM_IS_MEMORY)) {
1054: php_stream *inner = *(php_stream**)entry->fp->abstract;
1055: php_stream_memory_data *memfp = (php_stream_memory_data*)inner->abstract;
1056: memfp->fpos = 0;
1057: memfp->fsize = 0;
1058: } else if (php_stream_is(*(php_stream**)entry->fp->abstract, PHP_STREAM_IS_STDIO)) {
1059: php_stream_truncate_set_size(*(php_stream**)entry->fp->abstract, 0);
1060: } else {
1061: if (error) {
1062: spprintf(error, 0, "phar error: file \"%s\" cannot be opened for writing, no truncate support", phar->fname);
1063: }
1064: return FAILURE;
1065: }
1066: } else if (php_stream_is(entry->fp, PHP_STREAM_IS_STDIO)) {
1067: php_stream_truncate_set_size(entry->fp, 0);
1068: } else {
1069: if (error) {
1070: spprintf(error, 0, "phar error: file \"%s\" cannot be opened for writing, no truncate support", phar->fname);
1071: }
1072: return FAILURE;
1073: }
1074: #endif
1075: entry->old_flags = entry->flags;
1076: entry->is_modified = 1;
1077: phar->is_modified = 1;
1078: /* reset file size */
1079: entry->uncompressed_filesize = 0;
1080: entry->compressed_filesize = 0;
1081: entry->crc32 = 0;
1082: entry->flags = PHAR_ENT_PERM_DEF_FILE;
1083: entry->fp_type = PHAR_MOD;
1084: entry->offset = 0;
1085: return SUCCESS;
1086: }
1087:
1088: if (error) {
1089: *error = NULL;
1090: }
1091:
1092: /* open a new temp file for writing */
1093: if (entry->link) {
1094: efree(entry->link);
1095: entry->link = NULL;
1096: entry->tar_type = (entry->is_tar ? TAR_FILE : '\0');
1097: }
1098:
1099: entry->fp = php_stream_fopen_tmpfile();
1100:
1101: if (!entry->fp) {
1102: if (error) {
1103: spprintf(error, 0, "phar error: unable to create temporary file");
1104: }
1105: return FAILURE;
1106: }
1107:
1108: entry->old_flags = entry->flags;
1109: entry->is_modified = 1;
1110: phar->is_modified = 1;
1111: /* reset file size */
1112: entry->uncompressed_filesize = 0;
1113: entry->compressed_filesize = 0;
1114: entry->crc32 = 0;
1115: entry->flags = PHAR_ENT_PERM_DEF_FILE;
1116: entry->fp_type = PHAR_MOD;
1117: entry->offset = 0;
1118: return SUCCESS;
1119: }
1120: /* }}} */
1121:
1122: int phar_separate_entry_fp(phar_entry_info *entry, char **error TSRMLS_DC) /* {{{ */
1123: {
1124: php_stream *fp;
1125: phar_entry_info *link;
1126:
1127: if (FAILURE == phar_open_entry_fp(entry, error, 1 TSRMLS_CC)) {
1128: return FAILURE;
1129: }
1130:
1131: if (entry->fp_type == PHAR_MOD) {
1132: return SUCCESS;
1133: }
1134:
1135: fp = php_stream_fopen_tmpfile();
1.1.1.3 misho 1136: if (fp == NULL) {
1137: spprintf(error, 0, "phar error: unable to create temporary file");
1138: return FAILURE;
1139: }
1.1 misho 1140: phar_seek_efp(entry, 0, SEEK_SET, 0, 1 TSRMLS_CC);
1141: link = phar_get_link_source(entry TSRMLS_CC);
1142:
1143: if (!link) {
1144: link = entry;
1145: }
1146:
1147: if (SUCCESS != phar_stream_copy_to_stream(phar_get_efp(link, 0 TSRMLS_CC), fp, link->uncompressed_filesize, NULL)) {
1148: if (error) {
1149: spprintf(error, 4096, "phar error: cannot separate entry file \"%s\" contents in phar archive \"%s\" for write access", entry->filename, entry->phar->fname);
1150: }
1151: return FAILURE;
1152: }
1153:
1154: if (entry->link) {
1155: efree(entry->link);
1156: entry->link = NULL;
1157: entry->tar_type = (entry->is_tar ? TAR_FILE : '\0');
1158: }
1159:
1160: entry->offset = 0;
1161: entry->fp = fp;
1162: entry->fp_type = PHAR_MOD;
1163: entry->is_modified = 1;
1164: return SUCCESS;
1165: }
1166: /* }}} */
1167:
1168: /**
1169: * helper function to open an internal file's fp just-in-time
1170: */
1171: phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry, char **error TSRMLS_DC) /* {{{ */
1172: {
1173: if (error) {
1174: *error = NULL;
1175: }
1176: /* seek to start of internal file and read it */
1177: if (FAILURE == phar_open_entry_fp(entry, error, 1 TSRMLS_CC)) {
1178: return NULL;
1179: }
1180: if (-1 == phar_seek_efp(entry, 0, SEEK_SET, 0, 1 TSRMLS_CC)) {
1181: spprintf(error, 4096, "phar error: cannot seek to start of file \"%s\" in phar \"%s\"", entry->filename, phar->fname);
1182: return NULL;
1183: }
1184: return entry;
1185: }
1186: /* }}} */
1187:
1188: int phar_free_alias(phar_archive_data *phar, char *alias, int alias_len TSRMLS_DC) /* {{{ */
1189: {
1190: if (phar->refcount || phar->is_persistent) {
1191: return FAILURE;
1192: }
1193:
1194: /* this archive has no open references, so emit an E_STRICT and remove it */
1195: if (zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
1196: return FAILURE;
1197: }
1198:
1199: /* invalidate phar cache */
1200: PHAR_G(last_phar) = NULL;
1201: PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
1202:
1203: return SUCCESS;
1204: }
1205: /* }}} */
1206:
1207: /**
1208: * Looks up a phar archive in the filename map, connecting it to the alias
1209: * (if any) or returns null
1210: */
1211: int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, char *alias, int alias_len, char **error TSRMLS_DC) /* {{{ */
1212: {
1213: phar_archive_data *fd, **fd_ptr;
1214: char *my_realpath, *save;
1215: int save_len;
1216: ulong fhash, ahash = 0;
1217:
1218: phar_request_initialize(TSRMLS_C);
1219:
1220: if (error) {
1221: *error = NULL;
1222: }
1223:
1224: *archive = NULL;
1225:
1226: if (PHAR_G(last_phar) && fname_len == PHAR_G(last_phar_name_len) && !memcmp(fname, PHAR_G(last_phar_name), fname_len)) {
1227: *archive = PHAR_G(last_phar);
1228: if (alias && alias_len) {
1229:
1230: if (!PHAR_G(last_phar)->is_temporary_alias && (alias_len != PHAR_G(last_phar)->alias_len || memcmp(PHAR_G(last_phar)->alias, alias, alias_len))) {
1231: if (error) {
1232: spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, PHAR_G(last_phar)->fname, fname);
1233: }
1234: *archive = NULL;
1235: return FAILURE;
1236: }
1237:
1238: if (PHAR_G(last_phar)->alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len, (void**)&fd_ptr)) {
1239: zend_hash_del(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len);
1240: }
1241:
1242: zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&(*archive), sizeof(phar_archive_data*), NULL);
1243: PHAR_G(last_alias) = alias;
1244: PHAR_G(last_alias_len) = alias_len;
1245: }
1246:
1247: return SUCCESS;
1248: }
1249:
1250: if (alias && alias_len && PHAR_G(last_phar) && alias_len == PHAR_G(last_alias_len) && !memcmp(alias, PHAR_G(last_alias), alias_len)) {
1251: fd = PHAR_G(last_phar);
1252: fd_ptr = &fd;
1253: goto alias_success;
1254: }
1255:
1256: if (alias && alias_len) {
1257: ahash = zend_inline_hash_func(alias, alias_len);
1258: if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, ahash, (void**)&fd_ptr)) {
1259: alias_success:
1260: if (fname && (fname_len != (*fd_ptr)->fname_len || strncmp(fname, (*fd_ptr)->fname, fname_len))) {
1261: if (error) {
1262: spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, (*fd_ptr)->fname, fname);
1263: }
1264: if (SUCCESS == phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) {
1.1.1.4 ! misho 1265: if (error) {
! 1266: efree(*error);
! 1267: *error = NULL;
! 1268: }
1.1 misho 1269: }
1270: return FAILURE;
1271: }
1272:
1273: *archive = *fd_ptr;
1274: fd = *fd_ptr;
1275: PHAR_G(last_phar) = fd;
1276: PHAR_G(last_phar_name) = fd->fname;
1277: PHAR_G(last_phar_name_len) = fd->fname_len;
1278: PHAR_G(last_alias) = alias;
1279: PHAR_G(last_alias_len) = alias_len;
1280:
1281: return SUCCESS;
1282: }
1283:
1284: if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_alias, alias, alias_len, ahash, (void **)&fd_ptr)) {
1285: goto alias_success;
1286: }
1287: }
1288:
1289: fhash = zend_inline_hash_func(fname, fname_len);
1290: my_realpath = NULL;
1291: save = fname;
1292: save_len = fname_len;
1293:
1294: if (fname && fname_len) {
1295: if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, fhash, (void**)&fd_ptr)) {
1296: *archive = *fd_ptr;
1297: fd = *fd_ptr;
1298:
1299: if (alias && alias_len) {
1300: if (!fd->is_temporary_alias && (alias_len != fd->alias_len || memcmp(fd->alias, alias, alias_len))) {
1301: if (error) {
1302: spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, (*fd_ptr)->fname, fname);
1303: }
1304: return FAILURE;
1305: }
1306:
1307: if (fd->alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len, (void**)&fd_ptr)) {
1308: zend_hash_del(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len);
1309: }
1310:
1311: zend_hash_quick_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, ahash, (void*)&fd, sizeof(phar_archive_data*), NULL);
1312: }
1313:
1314: PHAR_G(last_phar) = fd;
1315: PHAR_G(last_phar_name) = fd->fname;
1316: PHAR_G(last_phar_name_len) = fd->fname_len;
1317: PHAR_G(last_alias) = fd->alias;
1318: PHAR_G(last_alias_len) = fd->alias_len;
1319:
1320: return SUCCESS;
1321: }
1322:
1323: if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_phars, fname, fname_len, fhash, (void**)&fd_ptr)) {
1324: *archive = *fd_ptr;
1325: fd = *fd_ptr;
1326:
1327: /* this could be problematic - alias should never be different from manifest alias
1328: for cached phars */
1329: if (!fd->is_temporary_alias && alias && alias_len) {
1330: if (alias_len != fd->alias_len || memcmp(fd->alias, alias, alias_len)) {
1331: if (error) {
1332: spprintf(error, 0, "alias \"%s\" is already used for archive \"%s\" cannot be overloaded with \"%s\"", alias, (*fd_ptr)->fname, fname);
1333: }
1334: return FAILURE;
1335: }
1336: }
1337:
1338: PHAR_G(last_phar) = fd;
1339: PHAR_G(last_phar_name) = fd->fname;
1340: PHAR_G(last_phar_name_len) = fd->fname_len;
1341: PHAR_G(last_alias) = fd->alias;
1342: PHAR_G(last_alias_len) = fd->alias_len;
1343:
1344: return SUCCESS;
1345: }
1346:
1347: if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_alias_map), save, save_len, fhash, (void**)&fd_ptr)) {
1348: fd = *archive = *fd_ptr;
1349:
1350: PHAR_G(last_phar) = fd;
1351: PHAR_G(last_phar_name) = fd->fname;
1352: PHAR_G(last_phar_name_len) = fd->fname_len;
1353: PHAR_G(last_alias) = fd->alias;
1354: PHAR_G(last_alias_len) = fd->alias_len;
1355:
1356: return SUCCESS;
1357: }
1358:
1359: if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_alias, save, save_len, fhash, (void**)&fd_ptr)) {
1360: fd = *archive = *fd_ptr;
1361:
1362: PHAR_G(last_phar) = fd;
1363: PHAR_G(last_phar_name) = fd->fname;
1364: PHAR_G(last_phar_name_len) = fd->fname_len;
1365: PHAR_G(last_alias) = fd->alias;
1366: PHAR_G(last_alias_len) = fd->alias_len;
1367:
1368: return SUCCESS;
1369: }
1370:
1371: /* not found, try converting \ to / */
1372: my_realpath = expand_filepath(fname, my_realpath TSRMLS_CC);
1373:
1374: if (my_realpath) {
1375: fname_len = strlen(my_realpath);
1376: fname = my_realpath;
1377: } else {
1378: return FAILURE;
1379: }
1380: #ifdef PHP_WIN32
1381: phar_unixify_path_separators(fname, fname_len);
1382: #endif
1383: fhash = zend_inline_hash_func(fname, fname_len);
1384:
1385: if (SUCCESS == zend_hash_quick_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, fhash, (void**)&fd_ptr)) {
1386: realpath_success:
1387: *archive = *fd_ptr;
1388: fd = *fd_ptr;
1389:
1390: if (alias && alias_len) {
1391: zend_hash_quick_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, ahash, (void*)&fd, sizeof(phar_archive_data*), NULL);
1392: }
1393:
1394: efree(my_realpath);
1395:
1396: PHAR_G(last_phar) = fd;
1397: PHAR_G(last_phar_name) = fd->fname;
1398: PHAR_G(last_phar_name_len) = fd->fname_len;
1399: PHAR_G(last_alias) = fd->alias;
1400: PHAR_G(last_alias_len) = fd->alias_len;
1401:
1402: return SUCCESS;
1403: }
1404:
1405: if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_quick_find(&cached_phars, fname, fname_len, fhash, (void**)&fd_ptr)) {
1406: goto realpath_success;
1407: }
1408:
1409: efree(my_realpath);
1410: }
1411:
1412: return FAILURE;
1413: }
1414: /* }}} */
1415:
1416: /**
1417: * Determine which stream compression filter (if any) we need to read this file
1418: */
1419: char * phar_compress_filter(phar_entry_info * entry, int return_unknown) /* {{{ */
1420: {
1421: switch (entry->flags & PHAR_ENT_COMPRESSION_MASK) {
1422: case PHAR_ENT_COMPRESSED_GZ:
1423: return "zlib.deflate";
1424: case PHAR_ENT_COMPRESSED_BZ2:
1425: return "bzip2.compress";
1426: default:
1427: return return_unknown ? "unknown" : NULL;
1428: }
1429: }
1430: /* }}} */
1431:
1432: /**
1433: * Determine which stream decompression filter (if any) we need to read this file
1434: */
1435: char * phar_decompress_filter(phar_entry_info * entry, int return_unknown) /* {{{ */
1436: {
1437: php_uint32 flags;
1438:
1439: if (entry->is_modified) {
1440: flags = entry->old_flags;
1441: } else {
1442: flags = entry->flags;
1443: }
1444:
1445: switch (flags & PHAR_ENT_COMPRESSION_MASK) {
1446: case PHAR_ENT_COMPRESSED_GZ:
1447: return "zlib.inflate";
1448: case PHAR_ENT_COMPRESSED_BZ2:
1449: return "bzip2.decompress";
1450: default:
1451: return return_unknown ? "unknown" : NULL;
1452: }
1453: }
1454: /* }}} */
1455:
1456: /**
1457: * retrieve information on a file contained within a phar, or null if it ain't there
1458: */
1459: phar_entry_info *phar_get_entry_info(phar_archive_data *phar, char *path, int path_len, char **error, int security TSRMLS_DC) /* {{{ */
1460: {
1461: return phar_get_entry_info_dir(phar, path, path_len, 0, error, security TSRMLS_CC);
1462: }
1463: /* }}} */
1464: /**
1465: * retrieve information on a file or directory contained within a phar, or null if none found
1466: * allow_dir is 0 for none, 1 for both empty directories in the phar and temp directories, and 2 for only
1467: * valid pre-existing empty directory entries
1468: */
1469: phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, int path_len, char dir, char **error, int security TSRMLS_DC) /* {{{ */
1470: {
1471: const char *pcr_error;
1472: phar_entry_info *entry;
1473: int is_dir;
1474:
1475: #ifdef PHP_WIN32
1476: phar_unixify_path_separators(path, path_len);
1477: #endif
1478:
1479: is_dir = (path_len && (path[path_len - 1] == '/')) ? 1 : 0;
1480:
1481: if (error) {
1482: *error = NULL;
1483: }
1484:
1485: if (security && path_len >= sizeof(".phar")-1 && !memcmp(path, ".phar", sizeof(".phar")-1)) {
1486: if (error) {
1487: spprintf(error, 4096, "phar error: cannot directly access magic \".phar\" directory or files within it");
1488: }
1489: return NULL;
1490: }
1491:
1492: if (!path_len && !dir) {
1493: if (error) {
1494: spprintf(error, 4096, "phar error: invalid path \"%s\" must not be empty", path);
1495: }
1496: return NULL;
1497: }
1498:
1499: if (phar_path_check(&path, &path_len, &pcr_error) > pcr_is_ok) {
1500: if (error) {
1501: spprintf(error, 4096, "phar error: invalid path \"%s\" contains %s", path, pcr_error);
1502: }
1503: return NULL;
1504: }
1505:
1506: if (!phar->manifest.arBuckets) {
1507: return NULL;
1508: }
1509:
1510: if (is_dir) {
1511: if (!path_len || path_len == 1) {
1512: return NULL;
1513: }
1514: path_len--;
1515: }
1516:
1517: if (SUCCESS == zend_hash_find(&phar->manifest, path, path_len, (void**)&entry)) {
1518: if (entry->is_deleted) {
1519: /* entry is deleted, but has not been flushed to disk yet */
1520: return NULL;
1521: }
1522: if (entry->is_dir && !dir) {
1523: if (error) {
1524: spprintf(error, 4096, "phar error: path \"%s\" is a directory", path);
1525: }
1526: return NULL;
1527: }
1528: if (!entry->is_dir && dir == 2) {
1529: /* user requested a directory, we must return one */
1530: if (error) {
1531: spprintf(error, 4096, "phar error: path \"%s\" exists and is a not a directory", path);
1532: }
1533: return NULL;
1534: }
1535: return entry;
1536: }
1537:
1538: if (dir) {
1539: if (zend_hash_exists(&phar->virtual_dirs, path, path_len)) {
1540: /* a file or directory exists in a sub-directory of this path */
1541: entry = (phar_entry_info *) ecalloc(1, sizeof(phar_entry_info));
1542: /* this next line tells PharFileInfo->__destruct() to efree the filename */
1543: entry->is_temp_dir = entry->is_dir = 1;
1544: entry->filename = (char *) estrndup(path, path_len + 1);
1545: entry->filename_len = path_len;
1546: entry->phar = phar;
1547: return entry;
1548: }
1549: }
1550:
1551: if (phar->mounted_dirs.arBuckets && zend_hash_num_elements(&phar->mounted_dirs)) {
1552: phar_zstr key;
1553: char *str_key;
1554: ulong unused;
1555: uint keylen;
1556:
1557: zend_hash_internal_pointer_reset(&phar->mounted_dirs);
1558: while (FAILURE != zend_hash_has_more_elements(&phar->mounted_dirs)) {
1559: if (HASH_KEY_NON_EXISTANT == zend_hash_get_current_key_ex(&phar->mounted_dirs, &key, &keylen, &unused, 0, NULL)) {
1560: break;
1561: }
1562:
1563: PHAR_STR(key, str_key);
1564:
1565: if ((int)keylen >= path_len || strncmp(str_key, path, keylen)) {
1566: PHAR_STR_FREE(str_key);
1567: continue;
1568: } else {
1569: char *test;
1570: int test_len;
1571: php_stream_statbuf ssb;
1572:
1573: if (SUCCESS != zend_hash_find(&phar->manifest, str_key, keylen, (void **) &entry)) {
1574: if (error) {
1575: spprintf(error, 4096, "phar internal error: mounted path \"%s\" could not be retrieved from manifest", str_key);
1576: }
1577: PHAR_STR_FREE(str_key);
1578: return NULL;
1579: }
1580:
1581: if (!entry->tmp || !entry->is_mounted) {
1582: if (error) {
1583: spprintf(error, 4096, "phar internal error: mounted path \"%s\" is not properly initialized as a mounted path", str_key);
1584: }
1585: PHAR_STR_FREE(str_key);
1586: return NULL;
1587: }
1588: PHAR_STR_FREE(str_key);
1589:
1590: test_len = spprintf(&test, MAXPATHLEN, "%s%s", entry->tmp, path + keylen);
1591:
1592: if (SUCCESS != php_stream_stat_path(test, &ssb)) {
1593: efree(test);
1594: return NULL;
1595: }
1596:
1597: if (ssb.sb.st_mode & S_IFDIR && !dir) {
1598: efree(test);
1599: if (error) {
1600: spprintf(error, 4096, "phar error: path \"%s\" is a directory", path);
1601: }
1602: return NULL;
1603: }
1604:
1605: if ((ssb.sb.st_mode & S_IFDIR) == 0 && dir) {
1606: efree(test);
1607: /* user requested a directory, we must return one */
1608: if (error) {
1609: spprintf(error, 4096, "phar error: path \"%s\" exists and is a not a directory", path);
1610: }
1611: return NULL;
1612: }
1613:
1614: /* mount the file just in time */
1615: if (SUCCESS != phar_mount_entry(phar, test, test_len, path, path_len TSRMLS_CC)) {
1616: efree(test);
1617: if (error) {
1618: spprintf(error, 4096, "phar error: path \"%s\" exists as file \"%s\" and could not be mounted", path, test);
1619: }
1620: return NULL;
1621: }
1622:
1623: efree(test);
1624:
1625: if (SUCCESS != zend_hash_find(&phar->manifest, path, path_len, (void**)&entry)) {
1626: if (error) {
1627: spprintf(error, 4096, "phar error: path \"%s\" exists as file \"%s\" and could not be retrieved after being mounted", path, test);
1628: }
1629: return NULL;
1630: }
1631: return entry;
1632: }
1633: }
1634: }
1635:
1636: return NULL;
1637: }
1638: /* }}} */
1639:
1640: static const char hexChars[] = "0123456789ABCDEF";
1641:
1642: static int phar_hex_str(const char *digest, size_t digest_len, char **signature TSRMLS_DC) /* {{{ */
1643: {
1644: int pos = -1;
1645: size_t len = 0;
1646:
1647: *signature = (char*)safe_pemalloc(digest_len, 2, 1, PHAR_G(persist));
1648:
1649: for (; len < digest_len; ++len) {
1650: (*signature)[++pos] = hexChars[((const unsigned char *)digest)[len] >> 4];
1651: (*signature)[++pos] = hexChars[((const unsigned char *)digest)[len] & 0x0F];
1652: }
1653: (*signature)[++pos] = '\0';
1654: return pos;
1655: }
1656: /* }}} */
1657:
1658: #ifndef PHAR_HAVE_OPENSSL
1659: static int phar_call_openssl_signverify(int is_sign, php_stream *fp, off_t end, char *key, int key_len, char **signature, int *signature_len TSRMLS_DC) /* {{{ */
1660: {
1661: zend_fcall_info fci;
1662: zend_fcall_info_cache fcc;
1663: zval *zdata, *zsig, *zkey, *retval_ptr, **zp[3], *openssl;
1664:
1665: MAKE_STD_ZVAL(zdata);
1666: MAKE_STD_ZVAL(openssl);
1667: ZVAL_STRINGL(openssl, is_sign ? "openssl_sign" : "openssl_verify", is_sign ? sizeof("openssl_sign")-1 : sizeof("openssl_verify")-1, 1);
1668: MAKE_STD_ZVAL(zsig);
1669: ZVAL_STRINGL(zsig, *signature, *signature_len, 1);
1670: MAKE_STD_ZVAL(zkey);
1671: ZVAL_STRINGL(zkey, key, key_len, 1);
1672: zp[0] = &zdata;
1673: zp[1] = &zsig;
1674: zp[2] = &zkey;
1675:
1676: php_stream_rewind(fp);
1677: Z_TYPE_P(zdata) = IS_STRING;
1678: Z_STRLEN_P(zdata) = end;
1679:
1680: #if PHP_MAJOR_VERSION > 5
1681: if (end != (off_t) php_stream_copy_to_mem(fp, (void **) &(Z_STRVAL_P(zdata)), (size_t) end, 0)) {
1682: #else
1683: if (end != (off_t) php_stream_copy_to_mem(fp, &(Z_STRVAL_P(zdata)), (size_t) end, 0)) {
1684: #endif
1685: zval_dtor(zdata);
1686: zval_dtor(zsig);
1687: zval_dtor(zkey);
1688: zval_dtor(openssl);
1689: efree(openssl);
1690: efree(zdata);
1691: efree(zkey);
1692: efree(zsig);
1693: return FAILURE;
1694: }
1695:
1696: #if PHP_VERSION_ID < 50300
1697: if (FAILURE == zend_fcall_info_init(openssl, &fci, &fcc TSRMLS_CC)) {
1698: #else
1699: if (FAILURE == zend_fcall_info_init(openssl, 0, &fci, &fcc, NULL, NULL TSRMLS_CC)) {
1700: #endif
1701: zval_dtor(zdata);
1702: zval_dtor(zsig);
1703: zval_dtor(zkey);
1704: zval_dtor(openssl);
1705: efree(openssl);
1706: efree(zdata);
1707: efree(zkey);
1708: efree(zsig);
1709: return FAILURE;
1710: }
1711:
1712: fci.param_count = 3;
1713: fci.params = zp;
1714: #if PHP_VERSION_ID < 50300
1715: ++(zdata->refcount);
1716: if (!is_sign) {
1717: ++(zsig->refcount);
1718: }
1719: ++(zkey->refcount);
1720: #else
1721: Z_ADDREF_P(zdata);
1722: if (is_sign) {
1723: Z_SET_ISREF_P(zsig);
1724: } else {
1725: Z_ADDREF_P(zsig);
1726: }
1727: Z_ADDREF_P(zkey);
1728: #endif
1729: fci.retval_ptr_ptr = &retval_ptr;
1730:
1731: if (FAILURE == zend_call_function(&fci, &fcc TSRMLS_CC)) {
1732: zval_dtor(zdata);
1733: zval_dtor(zsig);
1734: zval_dtor(zkey);
1735: zval_dtor(openssl);
1736: efree(openssl);
1737: efree(zdata);
1738: efree(zkey);
1739: efree(zsig);
1740: return FAILURE;
1741: }
1742:
1743: zval_dtor(openssl);
1744: efree(openssl);
1745: #if PHP_VERSION_ID < 50300
1746: --(zdata->refcount);
1747: if (!is_sign) {
1748: --(zsig->refcount);
1749: }
1750: --(zkey->refcount);
1751: #else
1752: Z_DELREF_P(zdata);
1753: if (is_sign) {
1754: Z_UNSET_ISREF_P(zsig);
1755: } else {
1756: Z_DELREF_P(zsig);
1757: }
1758: Z_DELREF_P(zkey);
1759: #endif
1760: zval_dtor(zdata);
1761: efree(zdata);
1762: zval_dtor(zkey);
1763: efree(zkey);
1764:
1765: switch (Z_TYPE_P(retval_ptr)) {
1766: default:
1767: case IS_LONG:
1768: zval_dtor(zsig);
1769: efree(zsig);
1770: if (1 == Z_LVAL_P(retval_ptr)) {
1771: efree(retval_ptr);
1772: return SUCCESS;
1773: }
1774: efree(retval_ptr);
1775: return FAILURE;
1776: case IS_BOOL:
1777: efree(retval_ptr);
1778: if (Z_BVAL_P(retval_ptr)) {
1779: *signature = estrndup(Z_STRVAL_P(zsig), Z_STRLEN_P(zsig));
1780: *signature_len = Z_STRLEN_P(zsig);
1781: zval_dtor(zsig);
1782: efree(zsig);
1783: return SUCCESS;
1784: }
1785: zval_dtor(zsig);
1786: efree(zsig);
1787: return FAILURE;
1788: }
1789: }
1790: /* }}} */
1791: #endif /* #ifndef PHAR_HAVE_OPENSSL */
1792:
1793: int phar_verify_signature(php_stream *fp, size_t end_of_phar, php_uint32 sig_type, char *sig, int sig_len, char *fname, char **signature, int *signature_len, char **error TSRMLS_DC) /* {{{ */
1794: {
1795: int read_size, len;
1796: off_t read_len;
1797: unsigned char buf[1024];
1798:
1799: php_stream_rewind(fp);
1800:
1801: switch (sig_type) {
1802: case PHAR_SIG_OPENSSL: {
1803: #ifdef PHAR_HAVE_OPENSSL
1804: BIO *in;
1805: EVP_PKEY *key;
1806: EVP_MD *mdtype = (EVP_MD *) EVP_sha1();
1807: EVP_MD_CTX md_ctx;
1808: #else
1809: int tempsig;
1810: #endif
1811: php_uint32 pubkey_len;
1812: char *pubkey = NULL, *pfile;
1813: php_stream *pfp;
1814: #ifndef PHAR_HAVE_OPENSSL
1815: if (!zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) {
1816: if (error) {
1817: spprintf(error, 0, "openssl not loaded");
1818: }
1819: return FAILURE;
1820: }
1821: #endif
1822: /* use __FILE__ . '.pubkey' for public key file */
1823: spprintf(&pfile, 0, "%s.pubkey", fname);
1824: pfp = php_stream_open_wrapper(pfile, "rb", 0, NULL);
1825: efree(pfile);
1826:
1827: #if PHP_MAJOR_VERSION > 5
1828: if (!pfp || !(pubkey_len = php_stream_copy_to_mem(pfp, (void **) &pubkey, PHP_STREAM_COPY_ALL, 0)) || !pubkey) {
1829: #else
1830: if (!pfp || !(pubkey_len = php_stream_copy_to_mem(pfp, &pubkey, PHP_STREAM_COPY_ALL, 0)) || !pubkey) {
1831: #endif
1832: if (pfp) {
1833: php_stream_close(pfp);
1834: }
1835: if (error) {
1836: spprintf(error, 0, "openssl public key could not be read");
1837: }
1838: return FAILURE;
1839: }
1840:
1841: php_stream_close(pfp);
1842: #ifndef PHAR_HAVE_OPENSSL
1843: tempsig = sig_len;
1844:
1845: if (FAILURE == phar_call_openssl_signverify(0, fp, end_of_phar, pubkey, pubkey_len, &sig, &tempsig TSRMLS_CC)) {
1846: if (pubkey) {
1847: efree(pubkey);
1848: }
1849:
1850: if (error) {
1851: spprintf(error, 0, "openssl signature could not be verified");
1852: }
1853:
1854: return FAILURE;
1855: }
1856:
1857: if (pubkey) {
1858: efree(pubkey);
1859: }
1860:
1861: sig_len = tempsig;
1862: #else
1863: in = BIO_new_mem_buf(pubkey, pubkey_len);
1864:
1865: if (NULL == in) {
1866: efree(pubkey);
1867: if (error) {
1868: spprintf(error, 0, "openssl signature could not be processed");
1869: }
1870: return FAILURE;
1871: }
1872:
1873: key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
1874: BIO_free(in);
1875: efree(pubkey);
1876:
1877: if (NULL == key) {
1878: if (error) {
1879: spprintf(error, 0, "openssl signature could not be processed");
1880: }
1881: return FAILURE;
1882: }
1883:
1884: EVP_VerifyInit(&md_ctx, mdtype);
1885: read_len = end_of_phar;
1886:
1887: if (read_len > sizeof(buf)) {
1888: read_size = sizeof(buf);
1889: } else {
1890: read_size = (int)read_len;
1891: }
1892:
1893: php_stream_seek(fp, 0, SEEK_SET);
1894:
1895: while (read_size && (len = php_stream_read(fp, (char*)buf, read_size)) > 0) {
1896: EVP_VerifyUpdate (&md_ctx, buf, len);
1897: read_len -= (off_t)len;
1898:
1899: if (read_len < read_size) {
1900: read_size = (int)read_len;
1901: }
1902: }
1903:
1904: if (EVP_VerifyFinal(&md_ctx, (unsigned char *)sig, sig_len, key) != 1) {
1905: /* 1: signature verified, 0: signature does not match, -1: failed signature operation */
1906: EVP_MD_CTX_cleanup(&md_ctx);
1907:
1908: if (error) {
1909: spprintf(error, 0, "broken openssl signature");
1910: }
1911:
1912: return FAILURE;
1913: }
1914:
1915: EVP_MD_CTX_cleanup(&md_ctx);
1916: #endif
1917:
1918: *signature_len = phar_hex_str((const char*)sig, sig_len, signature TSRMLS_CC);
1919: }
1920: break;
1921: #ifdef PHAR_HASH_OK
1922: case PHAR_SIG_SHA512: {
1923: unsigned char digest[64];
1924: PHP_SHA512_CTX context;
1925:
1926: PHP_SHA512Init(&context);
1927: read_len = end_of_phar;
1928:
1929: if (read_len > sizeof(buf)) {
1930: read_size = sizeof(buf);
1931: } else {
1932: read_size = (int)read_len;
1933: }
1934:
1935: while ((len = php_stream_read(fp, (char*)buf, read_size)) > 0) {
1936: PHP_SHA512Update(&context, buf, len);
1937: read_len -= (off_t)len;
1938: if (read_len < read_size) {
1939: read_size = (int)read_len;
1940: }
1941: }
1942:
1943: PHP_SHA512Final(digest, &context);
1944:
1945: if (memcmp(digest, sig, sizeof(digest))) {
1946: if (error) {
1947: spprintf(error, 0, "broken signature");
1948: }
1949: return FAILURE;
1950: }
1951:
1952: *signature_len = phar_hex_str((const char*)digest, sizeof(digest), signature TSRMLS_CC);
1953: break;
1954: }
1955: case PHAR_SIG_SHA256: {
1956: unsigned char digest[32];
1957: PHP_SHA256_CTX context;
1958:
1959: PHP_SHA256Init(&context);
1960: read_len = end_of_phar;
1961:
1962: if (read_len > sizeof(buf)) {
1963: read_size = sizeof(buf);
1964: } else {
1965: read_size = (int)read_len;
1966: }
1967:
1968: while ((len = php_stream_read(fp, (char*)buf, read_size)) > 0) {
1969: PHP_SHA256Update(&context, buf, len);
1970: read_len -= (off_t)len;
1971: if (read_len < read_size) {
1972: read_size = (int)read_len;
1973: }
1974: }
1975:
1976: PHP_SHA256Final(digest, &context);
1977:
1978: if (memcmp(digest, sig, sizeof(digest))) {
1979: if (error) {
1980: spprintf(error, 0, "broken signature");
1981: }
1982: return FAILURE;
1983: }
1984:
1985: *signature_len = phar_hex_str((const char*)digest, sizeof(digest), signature TSRMLS_CC);
1986: break;
1987: }
1988: #else
1989: case PHAR_SIG_SHA512:
1990: case PHAR_SIG_SHA256:
1991: if (error) {
1992: spprintf(error, 0, "unsupported signature");
1993: }
1994: return FAILURE;
1995: #endif
1996: case PHAR_SIG_SHA1: {
1997: unsigned char digest[20];
1998: PHP_SHA1_CTX context;
1999:
2000: PHP_SHA1Init(&context);
2001: read_len = end_of_phar;
2002:
2003: if (read_len > sizeof(buf)) {
2004: read_size = sizeof(buf);
2005: } else {
2006: read_size = (int)read_len;
2007: }
2008:
2009: while ((len = php_stream_read(fp, (char*)buf, read_size)) > 0) {
2010: PHP_SHA1Update(&context, buf, len);
2011: read_len -= (off_t)len;
2012: if (read_len < read_size) {
2013: read_size = (int)read_len;
2014: }
2015: }
2016:
2017: PHP_SHA1Final(digest, &context);
2018:
2019: if (memcmp(digest, sig, sizeof(digest))) {
2020: if (error) {
2021: spprintf(error, 0, "broken signature");
2022: }
2023: return FAILURE;
2024: }
2025:
2026: *signature_len = phar_hex_str((const char*)digest, sizeof(digest), signature TSRMLS_CC);
2027: break;
2028: }
2029: case PHAR_SIG_MD5: {
2030: unsigned char digest[16];
2031: PHP_MD5_CTX context;
2032:
2033: PHP_MD5Init(&context);
2034: read_len = end_of_phar;
2035:
2036: if (read_len > sizeof(buf)) {
2037: read_size = sizeof(buf);
2038: } else {
2039: read_size = (int)read_len;
2040: }
2041:
2042: while ((len = php_stream_read(fp, (char*)buf, read_size)) > 0) {
2043: PHP_MD5Update(&context, buf, len);
2044: read_len -= (off_t)len;
2045: if (read_len < read_size) {
2046: read_size = (int)read_len;
2047: }
2048: }
2049:
2050: PHP_MD5Final(digest, &context);
2051:
2052: if (memcmp(digest, sig, sizeof(digest))) {
2053: if (error) {
2054: spprintf(error, 0, "broken signature");
2055: }
2056: return FAILURE;
2057: }
2058:
2059: *signature_len = phar_hex_str((const char*)digest, sizeof(digest), signature TSRMLS_CC);
2060: break;
2061: }
2062: default:
2063: if (error) {
2064: spprintf(error, 0, "broken or unsupported signature");
2065: }
2066: return FAILURE;
2067: }
2068: return SUCCESS;
2069: }
2070: /* }}} */
2071:
2072: int phar_create_signature(phar_archive_data *phar, php_stream *fp, char **signature, int *signature_length, char **error TSRMLS_DC) /* {{{ */
2073: {
2074: unsigned char buf[1024];
2075: int sig_len;
2076:
2077: php_stream_rewind(fp);
2078:
2079: if (phar->signature) {
2080: efree(phar->signature);
2081: phar->signature = NULL;
2082: }
2083:
2084: switch(phar->sig_flags) {
2085: #ifdef PHAR_HASH_OK
2086: case PHAR_SIG_SHA512: {
2087: unsigned char digest[64];
2088: PHP_SHA512_CTX context;
2089:
2090: PHP_SHA512Init(&context);
2091:
2092: while ((sig_len = php_stream_read(fp, (char*)buf, sizeof(buf))) > 0) {
2093: PHP_SHA512Update(&context, buf, sig_len);
2094: }
2095:
2096: PHP_SHA512Final(digest, &context);
2097: *signature = estrndup((char *) digest, 64);
2098: *signature_length = 64;
2099: break;
2100: }
2101: case PHAR_SIG_SHA256: {
2102: unsigned char digest[32];
2103: PHP_SHA256_CTX context;
2104:
2105: PHP_SHA256Init(&context);
2106:
2107: while ((sig_len = php_stream_read(fp, (char*)buf, sizeof(buf))) > 0) {
2108: PHP_SHA256Update(&context, buf, sig_len);
2109: }
2110:
2111: PHP_SHA256Final(digest, &context);
2112: *signature = estrndup((char *) digest, 32);
2113: *signature_length = 32;
2114: break;
2115: }
2116: #else
2117: case PHAR_SIG_SHA512:
2118: case PHAR_SIG_SHA256:
2119: if (error) {
2120: spprintf(error, 0, "unable to write to phar \"%s\" with requested hash type", phar->fname);
2121: }
2122:
2123: return FAILURE;
2124: #endif
2125: case PHAR_SIG_OPENSSL: {
2126: int siglen;
2127: unsigned char *sigbuf;
2128: #ifdef PHAR_HAVE_OPENSSL
2129: BIO *in;
2130: EVP_PKEY *key;
1.1.1.3 misho 2131: EVP_MD_CTX *md_ctx;
1.1 misho 2132:
2133: in = BIO_new_mem_buf(PHAR_G(openssl_privatekey), PHAR_G(openssl_privatekey_len));
2134:
2135: if (in == NULL) {
2136: if (error) {
2137: spprintf(error, 0, "unable to write to phar \"%s\" with requested openssl signature", phar->fname);
2138: }
2139: return FAILURE;
2140: }
2141:
2142: key = PEM_read_bio_PrivateKey(in, NULL,NULL, "");
2143: BIO_free(in);
2144:
2145: if (!key) {
2146: if (error) {
2147: spprintf(error, 0, "unable to process private key");
2148: }
2149: return FAILURE;
2150: }
2151:
1.1.1.3 misho 2152: md_ctx = EVP_MD_CTX_create();
2153:
1.1 misho 2154: siglen = EVP_PKEY_size(key);
2155: sigbuf = emalloc(siglen + 1);
1.1.1.3 misho 2156:
2157: if (!EVP_SignInit(md_ctx, EVP_sha1())) {
2158: efree(sigbuf);
2159: if (error) {
2160: spprintf(error, 0, "unable to initialize openssl signature for phar \"%s\"", phar->fname);
2161: }
2162: return FAILURE;
2163: }
1.1 misho 2164:
2165: while ((sig_len = php_stream_read(fp, (char*)buf, sizeof(buf))) > 0) {
1.1.1.3 misho 2166: if (!EVP_SignUpdate(md_ctx, buf, sig_len)) {
2167: efree(sigbuf);
2168: if (error) {
2169: spprintf(error, 0, "unable to update the openssl signature for phar \"%s\"", phar->fname);
2170: }
2171: return FAILURE;
2172: }
1.1 misho 2173: }
2174:
1.1.1.3 misho 2175: if (!EVP_SignFinal (md_ctx, sigbuf,(unsigned int *)&siglen, key)) {
1.1 misho 2176: efree(sigbuf);
2177: if (error) {
2178: spprintf(error, 0, "unable to write phar \"%s\" with requested openssl signature", phar->fname);
2179: }
2180: return FAILURE;
2181: }
2182:
2183: sigbuf[siglen] = '\0';
1.1.1.3 misho 2184: EVP_MD_CTX_destroy(md_ctx);
1.1 misho 2185: #else
2186: sigbuf = NULL;
2187: siglen = 0;
2188: php_stream_seek(fp, 0, SEEK_END);
2189:
2190: if (FAILURE == phar_call_openssl_signverify(1, fp, php_stream_tell(fp), PHAR_G(openssl_privatekey), PHAR_G(openssl_privatekey_len), (char **)&sigbuf, &siglen TSRMLS_CC)) {
2191: if (error) {
2192: spprintf(error, 0, "unable to write phar \"%s\" with requested openssl signature", phar->fname);
2193: }
2194: return FAILURE;
2195: }
2196: #endif
2197: *signature = (char *) sigbuf;
2198: *signature_length = siglen;
2199: }
2200: break;
2201: default:
2202: phar->sig_flags = PHAR_SIG_SHA1;
2203: case PHAR_SIG_SHA1: {
2204: unsigned char digest[20];
2205: PHP_SHA1_CTX context;
2206:
2207: PHP_SHA1Init(&context);
2208:
2209: while ((sig_len = php_stream_read(fp, (char*)buf, sizeof(buf))) > 0) {
2210: PHP_SHA1Update(&context, buf, sig_len);
2211: }
2212:
2213: PHP_SHA1Final(digest, &context);
2214: *signature = estrndup((char *) digest, 20);
2215: *signature_length = 20;
2216: break;
2217: }
2218: case PHAR_SIG_MD5: {
2219: unsigned char digest[16];
2220: PHP_MD5_CTX context;
2221:
2222: PHP_MD5Init(&context);
2223:
2224: while ((sig_len = php_stream_read(fp, (char*)buf, sizeof(buf))) > 0) {
2225: PHP_MD5Update(&context, buf, sig_len);
2226: }
2227:
2228: PHP_MD5Final(digest, &context);
2229: *signature = estrndup((char *) digest, 16);
2230: *signature_length = 16;
2231: break;
2232: }
2233: }
2234:
2235: phar->sig_len = phar_hex_str((const char *)*signature, *signature_length, &phar->signature TSRMLS_CC);
2236: return SUCCESS;
2237: }
2238: /* }}} */
2239:
2240: void phar_add_virtual_dirs(phar_archive_data *phar, char *filename, int filename_len TSRMLS_DC) /* {{{ */
2241: {
1.1.1.2 misho 2242: const char *s;
1.1 misho 2243:
2244: while ((s = zend_memrchr(filename, '/', filename_len))) {
2245: filename_len = s - filename;
2246: if (FAILURE == zend_hash_add_empty_element(&phar->virtual_dirs, filename, filename_len)) {
2247: break;
2248: }
2249: }
2250: }
2251: /* }}} */
2252:
2253: static int phar_update_cached_entry(void *data, void *argument) /* {{{ */
2254: {
2255: phar_entry_info *entry = (phar_entry_info *)data;
2256: TSRMLS_FETCH();
2257:
2258: entry->phar = (phar_archive_data *)argument;
2259:
2260: if (entry->link) {
2261: entry->link = estrdup(entry->link);
2262: }
2263:
2264: if (entry->tmp) {
2265: entry->tmp = estrdup(entry->tmp);
2266: }
2267:
2268: entry->metadata_str.c = 0;
2269: entry->filename = estrndup(entry->filename, entry->filename_len);
2270: entry->is_persistent = 0;
2271:
2272: if (entry->metadata) {
2273: if (entry->metadata_len) {
2274: char *buf = estrndup((char *) entry->metadata, entry->metadata_len);
2275: /* assume success, we would have failed before */
2276: phar_parse_metadata((char **) &buf, &entry->metadata, entry->metadata_len TSRMLS_CC);
2277: efree(buf);
2278: } else {
2279: zval *t;
2280:
2281: t = entry->metadata;
2282: ALLOC_ZVAL(entry->metadata);
2283: *entry->metadata = *t;
2284: zval_copy_ctor(entry->metadata);
2285: #if PHP_VERSION_ID < 50300
2286: entry->metadata->refcount = 1;
2287: #else
2288: Z_SET_REFCOUNT_P(entry->metadata, 1);
2289: #endif
2290: entry->metadata_str.c = NULL;
2291: entry->metadata_str.len = 0;
2292: }
2293: }
2294: return ZEND_HASH_APPLY_KEEP;
2295: }
2296: /* }}} */
2297:
2298: static void phar_copy_cached_phar(phar_archive_data **pphar TSRMLS_DC) /* {{{ */
2299: {
2300: phar_archive_data *phar;
2301: HashTable newmanifest;
2302: char *fname;
2303: phar_archive_object **objphar;
2304:
2305: phar = (phar_archive_data *) emalloc(sizeof(phar_archive_data));
2306: *phar = **pphar;
2307: phar->is_persistent = 0;
2308: fname = phar->fname;
2309: phar->fname = estrndup(phar->fname, phar->fname_len);
2310: phar->ext = phar->fname + (phar->ext - fname);
2311:
2312: if (phar->alias) {
2313: phar->alias = estrndup(phar->alias, phar->alias_len);
2314: }
2315:
2316: if (phar->signature) {
2317: phar->signature = estrdup(phar->signature);
2318: }
2319:
2320: if (phar->metadata) {
2321: /* assume success, we would have failed before */
2322: if (phar->metadata_len) {
2323: char *buf = estrndup((char *) phar->metadata, phar->metadata_len);
2324: phar_parse_metadata(&buf, &phar->metadata, phar->metadata_len TSRMLS_CC);
2325: efree(buf);
2326: } else {
2327: zval *t;
2328:
2329: t = phar->metadata;
2330: ALLOC_ZVAL(phar->metadata);
2331: *phar->metadata = *t;
2332: zval_copy_ctor(phar->metadata);
2333: #if PHP_VERSION_ID < 50300
2334: phar->metadata->refcount = 1;
2335: #else
2336: Z_SET_REFCOUNT_P(phar->metadata, 1);
2337: #endif
2338: }
2339: }
2340:
2341: zend_hash_init(&newmanifest, sizeof(phar_entry_info),
2342: zend_get_hash_value, destroy_phar_manifest_entry, 0);
2343: zend_hash_copy(&newmanifest, &(*pphar)->manifest, NULL, NULL, sizeof(phar_entry_info));
2344: zend_hash_apply_with_argument(&newmanifest, (apply_func_arg_t) phar_update_cached_entry, (void *)phar TSRMLS_CC);
2345: phar->manifest = newmanifest;
2346: zend_hash_init(&phar->mounted_dirs, sizeof(char *),
2347: zend_get_hash_value, NULL, 0);
2348: zend_hash_init(&phar->virtual_dirs, sizeof(char *),
2349: zend_get_hash_value, NULL, 0);
2350: zend_hash_copy(&phar->virtual_dirs, &(*pphar)->virtual_dirs, NULL, NULL, sizeof(void *));
2351: *pphar = phar;
2352:
2353: /* now, scan the list of persistent Phar objects referencing this phar and update the pointers */
2354: for (zend_hash_internal_pointer_reset(&PHAR_GLOBALS->phar_persist_map);
2355: SUCCESS == zend_hash_get_current_data(&PHAR_GLOBALS->phar_persist_map, (void **) &objphar);
2356: zend_hash_move_forward(&PHAR_GLOBALS->phar_persist_map)) {
2357: if (objphar[0]->arc.archive->fname_len == phar->fname_len && !memcmp(objphar[0]->arc.archive->fname, phar->fname, phar->fname_len)) {
2358: objphar[0]->arc.archive = phar;
2359: }
2360: }
2361: }
2362: /* }}} */
2363:
2364: int phar_copy_on_write(phar_archive_data **pphar TSRMLS_DC) /* {{{ */
2365: {
2366: phar_archive_data **newpphar, *newphar = NULL;
2367:
2368: if (SUCCESS != zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len, (void *)&newphar, sizeof(phar_archive_data *), (void **)&newpphar)) {
2369: return FAILURE;
2370: }
2371:
2372: *newpphar = *pphar;
2373: phar_copy_cached_phar(newpphar TSRMLS_CC);
2374: /* invalidate phar cache */
2375: PHAR_G(last_phar) = NULL;
2376: PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
2377:
2378: if (newpphar[0]->alias_len && FAILURE == zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), newpphar[0]->alias, newpphar[0]->alias_len, (void*)newpphar, sizeof(phar_archive_data*), NULL)) {
2379: zend_hash_del(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len);
2380: return FAILURE;
2381: }
2382:
2383: *pphar = *newpphar;
2384: return SUCCESS;
2385: }
2386: /* }}} */
2387:
2388: /*
2389: * Local variables:
2390: * tab-width: 4
2391: * c-basic-offset: 4
2392: * End:
2393: * vim600: noet sw=4 ts=4 fdm=marker
2394: * vim<600: noet sw=4 ts=4
2395: */