Annotation of embedaddon/php/ext/phar/phar_object.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | phar php single-file executable PHP extension |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 2005-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt. |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Gregory Beaver <cellog@php.net> |
! 16: | Marcus Boerger <helly@php.net> |
! 17: +----------------------------------------------------------------------+
! 18: */
! 19:
! 20: /* $Id: phar_object.c 321634 2012-01-01 13:15:04Z felipe $ */
! 21:
! 22: #include "phar_internal.h"
! 23: #include "func_interceptors.h"
! 24:
! 25: static zend_class_entry *phar_ce_archive;
! 26: static zend_class_entry *phar_ce_data;
! 27: static zend_class_entry *phar_ce_PharException;
! 28:
! 29: #if HAVE_SPL
! 30: static zend_class_entry *phar_ce_entry;
! 31: #endif
! 32:
! 33: #if PHP_MAJOR_VERSION > 5 || ((PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION >= 3))
! 34: # define PHAR_ARG_INFO
! 35: #else
! 36: # define PHAR_ARG_INFO static
! 37: #endif
! 38:
! 39: static int phar_file_type(HashTable *mimes, char *file, char **mime_type TSRMLS_DC) /* {{{ */
! 40: {
! 41: char *ext;
! 42: phar_mime_type *mime;
! 43: ext = strrchr(file, '.');
! 44: if (!ext) {
! 45: *mime_type = "text/plain";
! 46: /* no file extension = assume text/plain */
! 47: return PHAR_MIME_OTHER;
! 48: }
! 49: ++ext;
! 50: if (SUCCESS != zend_hash_find(mimes, ext, strlen(ext), (void **) &mime)) {
! 51: *mime_type = "application/octet-stream";
! 52: return PHAR_MIME_OTHER;
! 53: }
! 54: *mime_type = mime->mime;
! 55: return mime->type;
! 56: }
! 57: /* }}} */
! 58:
! 59: static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char *basename, int request_uri_len TSRMLS_DC) /* {{{ */
! 60: {
! 61: #if PHP_MAJOR_VERSION >= 6
! 62: int is_unicode = 0;
! 63: #endif
! 64: HashTable *_SERVER;
! 65: zval **stuff;
! 66: char *path_info;
! 67: int basename_len = strlen(basename);
! 68: int code;
! 69: zval *temp;
! 70:
! 71: /* "tweak" $_SERVER variables requested in earlier call to Phar::mungServer() */
! 72: if (!PG(http_globals)[TRACK_VARS_SERVER]) {
! 73: return;
! 74: }
! 75:
! 76: _SERVER = Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]);
! 77:
! 78: /* PATH_INFO and PATH_TRANSLATED should always be munged */
! 79: #if PHP_MAJOR_VERSION >= 6
! 80: if (phar_find_key(_SERVER, "PATH_INFO", sizeof("PATH_INFO"), (void **) &stuff TSRMLS_CC)) {
! 81: if (Z_TYPE_PP(stuff) == IS_UNICODE) {
! 82: is_unicode = 1;
! 83: zval_unicode_to_string(*stuff TSRMLS_CC);
! 84: } else {
! 85: is_unicode = 0;
! 86: }
! 87: #else
! 88: if (SUCCESS == zend_hash_find(_SERVER, "PATH_INFO", sizeof("PATH_INFO"), (void **) &stuff)) {
! 89: #endif
! 90:
! 91: path_info = Z_STRVAL_PP(stuff);
! 92: code = Z_STRLEN_PP(stuff);
! 93:
! 94: if (Z_STRLEN_PP(stuff) > entry_len && !memcmp(Z_STRVAL_PP(stuff), entry, entry_len)) {
! 95: ZVAL_STRINGL(*stuff, Z_STRVAL_PP(stuff) + entry_len, request_uri_len, 1);
! 96:
! 97: MAKE_STD_ZVAL(temp);
! 98: ZVAL_STRINGL(temp, path_info, code, 0);
! 99: #if PHP_MAJOR_VERSION >= 6
! 100: if (is_unicode) {
! 101: zval_string_to_unicode(*stuff TSRMLS_CC);
! 102: }
! 103: #endif
! 104: zend_hash_update(_SERVER, "PHAR_PATH_INFO", sizeof("PHAR_PATH_INFO"), &temp, sizeof(zval **), NULL);
! 105: }
! 106: }
! 107:
! 108: #if PHP_MAJOR_VERSION >= 6
! 109: if (phar_find_key(_SERVER, "PATH_TRANSLATED", sizeof("PATH_TRANSLATED"), (void **) &stuff TSRMLS_CC)) {
! 110: if (Z_TYPE_PP(stuff) == IS_UNICODE) {
! 111: is_unicode = 1;
! 112: zval_unicode_to_string(*stuff TSRMLS_CC);
! 113: } else {
! 114: is_unicode = 0;
! 115: }
! 116: #else
! 117: if (SUCCESS == zend_hash_find(_SERVER, "PATH_TRANSLATED", sizeof("PATH_TRANSLATED"), (void **) &stuff)) {
! 118: #endif
! 119:
! 120: path_info = Z_STRVAL_PP(stuff);
! 121: code = Z_STRLEN_PP(stuff);
! 122: Z_STRLEN_PP(stuff) = spprintf(&(Z_STRVAL_PP(stuff)), 4096, "phar://%s%s", fname, entry);
! 123:
! 124: MAKE_STD_ZVAL(temp);
! 125: ZVAL_STRINGL(temp, path_info, code, 0);
! 126: #if PHP_MAJOR_VERSION >= 6
! 127: if (is_unicode) {
! 128: zval_string_to_unicode(*stuff TSRMLS_CC);
! 129: }
! 130: #endif
! 131: zend_hash_update(_SERVER, "PHAR_PATH_TRANSLATED", sizeof("PHAR_PATH_TRANSLATED"), (void *) &temp, sizeof(zval **), NULL);
! 132: }
! 133:
! 134: if (!PHAR_GLOBALS->phar_SERVER_mung_list) {
! 135: return;
! 136: }
! 137:
! 138: if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_REQUEST_URI) {
! 139: #if PHP_MAJOR_VERSION >= 6
! 140: if (phar_find_key(_SERVER, "REQUEST_URI", sizeof("REQUEST_URI"), (void **) &stuff TSRMLS_CC)) {
! 141: if (Z_TYPE_PP(stuff) == IS_UNICODE) {
! 142: is_unicode = 1;
! 143: zval_unicode_to_string(*stuff TSRMLS_CC);
! 144: } else {
! 145: is_unicode = 0;
! 146: }
! 147: #else
! 148: if (SUCCESS == zend_hash_find(_SERVER, "REQUEST_URI", sizeof("REQUEST_URI"), (void **) &stuff)) {
! 149: #endif
! 150:
! 151: path_info = Z_STRVAL_PP(stuff);
! 152: code = Z_STRLEN_PP(stuff);
! 153:
! 154: if (Z_STRLEN_PP(stuff) > basename_len && !memcmp(Z_STRVAL_PP(stuff), basename, basename_len)) {
! 155: ZVAL_STRINGL(*stuff, Z_STRVAL_PP(stuff) + basename_len, Z_STRLEN_PP(stuff) - basename_len, 1);
! 156:
! 157: MAKE_STD_ZVAL(temp);
! 158: ZVAL_STRINGL(temp, path_info, code, 0);
! 159: #if PHP_MAJOR_VERSION >= 6
! 160: if (is_unicode) {
! 161: zval_string_to_unicode(*stuff TSRMLS_CC);
! 162: }
! 163: #endif
! 164: zend_hash_update(_SERVER, "PHAR_REQUEST_URI", sizeof("PHAR_REQUEST_URI"), (void *) &temp, sizeof(zval **), NULL);
! 165: }
! 166: }
! 167: }
! 168:
! 169: if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_PHP_SELF) {
! 170: #if PHP_MAJOR_VERSION >= 6
! 171: if (phar_find_key(_SERVER, "PHP_SELF", sizeof("PHP_SELF"), (void **) &stuff TSRMLS_CC)) {
! 172: if (Z_TYPE_PP(stuff) == IS_UNICODE) {
! 173: is_unicode = 1;
! 174: zval_unicode_to_string(*stuff TSRMLS_CC);
! 175: } else {
! 176: is_unicode = 0;
! 177: }
! 178: #else
! 179: if (SUCCESS == zend_hash_find(_SERVER, "PHP_SELF", sizeof("PHP_SELF"), (void **) &stuff)) {
! 180: #endif
! 181:
! 182: path_info = Z_STRVAL_PP(stuff);
! 183: code = Z_STRLEN_PP(stuff);
! 184:
! 185: if (Z_STRLEN_PP(stuff) > basename_len && !memcmp(Z_STRVAL_PP(stuff), basename, basename_len)) {
! 186: ZVAL_STRINGL(*stuff, Z_STRVAL_PP(stuff) + basename_len, Z_STRLEN_PP(stuff) - basename_len, 1);
! 187:
! 188: MAKE_STD_ZVAL(temp);
! 189: ZVAL_STRINGL(temp, path_info, code, 0);
! 190: #if PHP_MAJOR_VERSION >= 6
! 191: if (is_unicode) {
! 192: zval_string_to_unicode(*stuff TSRMLS_CC);
! 193: }
! 194: #endif
! 195: zend_hash_update(_SERVER, "PHAR_PHP_SELF", sizeof("PHAR_PHP_SELF"), (void *) &temp, sizeof(zval **), NULL);
! 196: }
! 197: }
! 198: }
! 199:
! 200: if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_NAME) {
! 201: #if PHP_MAJOR_VERSION >= 6
! 202: if (phar_find_key(_SERVER, "SCRIPT_NAME", sizeof("SCRIPT_NAME"), (void **) &stuff TSRMLS_CC)) {
! 203: if (Z_TYPE_PP(stuff) == IS_UNICODE) {
! 204: is_unicode = 1;
! 205: zval_unicode_to_string(*stuff TSRMLS_CC);
! 206: } else {
! 207: is_unicode = 0;
! 208: }
! 209: #else
! 210: if (SUCCESS == zend_hash_find(_SERVER, "SCRIPT_NAME", sizeof("SCRIPT_NAME"), (void **) &stuff)) {
! 211: #endif
! 212:
! 213: path_info = Z_STRVAL_PP(stuff);
! 214: code = Z_STRLEN_PP(stuff);
! 215: ZVAL_STRINGL(*stuff, entry, entry_len, 1);
! 216:
! 217: MAKE_STD_ZVAL(temp);
! 218: ZVAL_STRINGL(temp, path_info, code, 0);
! 219: #if PHP_MAJOR_VERSION >= 6
! 220: if (is_unicode) {
! 221: zval_string_to_unicode(*stuff TSRMLS_CC);
! 222: }
! 223: #endif
! 224: zend_hash_update(_SERVER, "PHAR_SCRIPT_NAME", sizeof("PHAR_SCRIPT_NAME"), (void *) &temp, sizeof(zval **), NULL);
! 225: }
! 226: }
! 227:
! 228: if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_FILENAME) {
! 229: #if PHP_MAJOR_VERSION >= 6
! 230: if (phar_find_key(_SERVER, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME"), (void **) &stuff TSRMLS_CC)) {
! 231: if (Z_TYPE_PP(stuff) == IS_UNICODE) {
! 232: is_unicode = 1;
! 233: zval_unicode_to_string(*stuff TSRMLS_CC);
! 234: } else {
! 235: is_unicode = 0;
! 236: }
! 237: #else
! 238: if (SUCCESS == zend_hash_find(_SERVER, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME"), (void **) &stuff)) {
! 239: #endif
! 240:
! 241: path_info = Z_STRVAL_PP(stuff);
! 242: code = Z_STRLEN_PP(stuff);
! 243: Z_STRLEN_PP(stuff) = spprintf(&(Z_STRVAL_PP(stuff)), 4096, "phar://%s%s", fname, entry);
! 244:
! 245: MAKE_STD_ZVAL(temp);
! 246: ZVAL_STRINGL(temp, path_info, code, 0);
! 247: #if PHP_MAJOR_VERSION >= 6
! 248: if (is_unicode) {
! 249: zval_string_to_unicode(*stuff TSRMLS_CC);
! 250: }
! 251: #endif
! 252: zend_hash_update(_SERVER, "PHAR_SCRIPT_FILENAME", sizeof("PHAR_SCRIPT_FILENAME"), (void *) &temp, sizeof(zval **), NULL);
! 253: }
! 254: }
! 255: }
! 256: /* }}} */
! 257:
! 258: static int phar_file_action(phar_archive_data *phar, phar_entry_info *info, char *mime_type, int code, char *entry, int entry_len, char *arch, char *basename, char *ru, int ru_len TSRMLS_DC) /* {{{ */
! 259: {
! 260: char *name = NULL, buf[8192], *cwd;
! 261: zend_syntax_highlighter_ini syntax_highlighter_ini;
! 262: sapi_header_line ctr = {0};
! 263: size_t got;
! 264: int dummy = 1, name_len;
! 265: zend_file_handle file_handle;
! 266: zend_op_array *new_op_array;
! 267: zval *result = NULL;
! 268: php_stream *fp;
! 269: off_t position;
! 270:
! 271: switch (code) {
! 272: case PHAR_MIME_PHPS:
! 273: efree(basename);
! 274: /* highlight source */
! 275: if (entry[0] == '/') {
! 276: name_len = spprintf(&name, 4096, "phar://%s%s", arch, entry);
! 277: } else {
! 278: name_len = spprintf(&name, 4096, "phar://%s/%s", arch, entry);
! 279: }
! 280: php_get_highlight_struct(&syntax_highlighter_ini);
! 281:
! 282: highlight_file(name, &syntax_highlighter_ini TSRMLS_CC);
! 283:
! 284: efree(name);
! 285: #ifdef PHP_WIN32
! 286: efree(arch);
! 287: #endif
! 288: zend_bailout();
! 289: case PHAR_MIME_OTHER:
! 290: /* send headers, output file contents */
! 291: efree(basename);
! 292: ctr.line_len = spprintf(&(ctr.line), 0, "Content-type: %s", mime_type);
! 293: sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
! 294: efree(ctr.line);
! 295: ctr.line_len = spprintf(&(ctr.line), 0, "Content-length: %u", info->uncompressed_filesize);
! 296: sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
! 297: efree(ctr.line);
! 298:
! 299: if (FAILURE == sapi_send_headers(TSRMLS_C)) {
! 300: zend_bailout();
! 301: }
! 302:
! 303: /* prepare to output */
! 304: fp = phar_get_efp(info, 1 TSRMLS_CC);
! 305:
! 306: if (!fp) {
! 307: char *error;
! 308: if (!phar_open_jit(phar, info, &error TSRMLS_CC)) {
! 309: if (error) {
! 310: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 311: efree(error);
! 312: }
! 313: return -1;
! 314: }
! 315: fp = phar_get_efp(info, 1 TSRMLS_CC);
! 316: }
! 317: position = 0;
! 318: phar_seek_efp(info, 0, SEEK_SET, 0, 1 TSRMLS_CC);
! 319:
! 320: do {
! 321: got = php_stream_read(fp, buf, MIN(8192, info->uncompressed_filesize - position));
! 322: if (got > 0) {
! 323: PHPWRITE(buf, got);
! 324: position += got;
! 325: if (position == (off_t) info->uncompressed_filesize) {
! 326: break;
! 327: }
! 328: }
! 329: } while (1);
! 330:
! 331: zend_bailout();
! 332: case PHAR_MIME_PHP:
! 333: if (basename) {
! 334: phar_mung_server_vars(arch, entry, entry_len, basename, ru_len TSRMLS_CC);
! 335: efree(basename);
! 336: }
! 337:
! 338: if (entry[0] == '/') {
! 339: name_len = spprintf(&name, 4096, "phar://%s%s", arch, entry);
! 340: } else {
! 341: name_len = spprintf(&name, 4096, "phar://%s/%s", arch, entry);
! 342: }
! 343:
! 344: file_handle.type = ZEND_HANDLE_FILENAME;
! 345: file_handle.handle.fd = 0;
! 346: file_handle.filename = name;
! 347: file_handle.opened_path = NULL;
! 348: file_handle.free_filename = 0;
! 349:
! 350: PHAR_G(cwd) = NULL;
! 351: PHAR_G(cwd_len) = 0;
! 352:
! 353: if (zend_hash_add(&EG(included_files), name, name_len+1, (void *)&dummy, sizeof(int), NULL) == SUCCESS) {
! 354: if ((cwd = zend_memrchr(entry, '/', entry_len))) {
! 355: PHAR_G(cwd_init) = 1;
! 356: if (entry == cwd) {
! 357: /* root directory */
! 358: PHAR_G(cwd_len) = 0;
! 359: PHAR_G(cwd) = NULL;
! 360: } else if (entry[0] == '/') {
! 361: PHAR_G(cwd_len) = cwd - (entry + 1);
! 362: PHAR_G(cwd) = estrndup(entry + 1, PHAR_G(cwd_len));
! 363: } else {
! 364: PHAR_G(cwd_len) = cwd - entry;
! 365: PHAR_G(cwd) = estrndup(entry, PHAR_G(cwd_len));
! 366: }
! 367: }
! 368:
! 369: new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE TSRMLS_CC);
! 370:
! 371: if (!new_op_array) {
! 372: zend_hash_del(&EG(included_files), name, name_len+1);
! 373: }
! 374:
! 375: zend_destroy_file_handle(&file_handle TSRMLS_CC);
! 376:
! 377: } else {
! 378: efree(name);
! 379: new_op_array = NULL;
! 380: }
! 381: #ifdef PHP_WIN32
! 382: efree(arch);
! 383: #endif
! 384: if (new_op_array) {
! 385: EG(return_value_ptr_ptr) = &result;
! 386: EG(active_op_array) = new_op_array;
! 387:
! 388: zend_try {
! 389: zend_execute(new_op_array TSRMLS_CC);
! 390: if (PHAR_G(cwd)) {
! 391: efree(PHAR_G(cwd));
! 392: PHAR_G(cwd) = NULL;
! 393: PHAR_G(cwd_len) = 0;
! 394: }
! 395:
! 396: PHAR_G(cwd_init) = 0;
! 397: efree(name);
! 398: destroy_op_array(new_op_array TSRMLS_CC);
! 399: efree(new_op_array);
! 400:
! 401:
! 402: if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
! 403: zval_ptr_dtor(EG(return_value_ptr_ptr));
! 404: }
! 405: } zend_catch {
! 406: if (PHAR_G(cwd)) {
! 407: efree(PHAR_G(cwd));
! 408: PHAR_G(cwd) = NULL;
! 409: PHAR_G(cwd_len) = 0;
! 410: }
! 411:
! 412: PHAR_G(cwd_init) = 0;
! 413: efree(name);
! 414: } zend_end_try();
! 415:
! 416: zend_bailout();
! 417: }
! 418:
! 419: return PHAR_MIME_PHP;
! 420: }
! 421: return -1;
! 422: }
! 423: /* }}} */
! 424:
! 425: static void phar_do_403(char *entry, int entry_len TSRMLS_DC) /* {{{ */
! 426: {
! 427: sapi_header_line ctr = {0};
! 428:
! 429: ctr.response_code = 403;
! 430: ctr.line_len = sizeof("HTTP/1.0 403 Access Denied");
! 431: ctr.line = "HTTP/1.0 403 Access Denied";
! 432: sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
! 433: sapi_send_headers(TSRMLS_C);
! 434: PHPWRITE("<html>\n <head>\n <title>Access Denied</title>\n </head>\n <body>\n <h1>403 - File ", sizeof("<html>\n <head>\n <title>Access Denied</title>\n </head>\n <body>\n <h1>403 - File ") - 1);
! 435: PHPWRITE(entry, entry_len);
! 436: PHPWRITE(" Access Denied</h1>\n </body>\n</html>", sizeof(" Access Denied</h1>\n </body>\n</html>") - 1);
! 437: }
! 438: /* }}} */
! 439:
! 440: static void phar_do_404(phar_archive_data *phar, char *fname, int fname_len, char *f404, int f404_len, char *entry, int entry_len TSRMLS_DC) /* {{{ */
! 441: {
! 442: sapi_header_line ctr = {0};
! 443: phar_entry_info *info;
! 444:
! 445: if (phar && f404_len) {
! 446: info = phar_get_entry_info(phar, f404, f404_len, NULL, 1 TSRMLS_CC);
! 447:
! 448: if (info) {
! 449: phar_file_action(phar, info, "text/html", PHAR_MIME_PHP, f404, f404_len, fname, NULL, NULL, 0 TSRMLS_CC);
! 450: return;
! 451: }
! 452: }
! 453:
! 454: ctr.response_code = 404;
! 455: ctr.line_len = sizeof("HTTP/1.0 404 Not Found")+1;
! 456: ctr.line = "HTTP/1.0 404 Not Found";
! 457: sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
! 458: sapi_send_headers(TSRMLS_C);
! 459: PHPWRITE("<html>\n <head>\n <title>File Not Found</title>\n </head>\n <body>\n <h1>404 - File ", sizeof("<html>\n <head>\n <title>File Not Found</title>\n </head>\n <body>\n <h1>404 - File ") - 1);
! 460: PHPWRITE(entry, entry_len);
! 461: PHPWRITE(" Not Found</h1>\n </body>\n</html>", sizeof(" Not Found</h1>\n </body>\n</html>") - 1);
! 462: }
! 463: /* }}} */
! 464:
! 465: /* post-process REQUEST_URI and retrieve the actual request URI. This is for
! 466: cases like http://localhost/blah.phar/path/to/file.php/extra/stuff
! 467: which calls "blah.phar" file "path/to/file.php" with PATH_INFO "/extra/stuff" */
! 468: static void phar_postprocess_ru_web(char *fname, int fname_len, char **entry, int *entry_len, char **ru, int *ru_len TSRMLS_DC) /* {{{ */
! 469: {
! 470: char *e = *entry + 1, *u = NULL, *u1 = NULL, *saveu = NULL;
! 471: int e_len = *entry_len - 1, u_len = 0;
! 472: phar_archive_data **pphar = NULL;
! 473:
! 474: /* we already know we can retrieve the phar if we reach here */
! 475: zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, (void **) &pphar);
! 476:
! 477: if (!pphar && PHAR_G(manifest_cached)) {
! 478: zend_hash_find(&cached_phars, fname, fname_len, (void **) &pphar);
! 479: }
! 480:
! 481: do {
! 482: if (zend_hash_exists(&((*pphar)->manifest), e, e_len)) {
! 483: if (u) {
! 484: u[0] = '/';
! 485: *ru = estrndup(u, u_len+1);
! 486: ++u_len;
! 487: u[0] = '\0';
! 488: } else {
! 489: *ru = NULL;
! 490: }
! 491: *ru_len = u_len;
! 492: *entry_len = e_len + 1;
! 493: return;
! 494: }
! 495:
! 496: if (u) {
! 497: u1 = strrchr(e, '/');
! 498: u[0] = '/';
! 499: saveu = u;
! 500: e_len += u_len + 1;
! 501: u = u1;
! 502: if (!u) {
! 503: return;
! 504: }
! 505: } else {
! 506: u = strrchr(e, '/');
! 507: if (!u) {
! 508: if (saveu) {
! 509: saveu[0] = '/';
! 510: }
! 511: return;
! 512: }
! 513: }
! 514:
! 515: u[0] = '\0';
! 516: u_len = strlen(u + 1);
! 517: e_len -= u_len + 1;
! 518:
! 519: if (e_len < 0) {
! 520: if (saveu) {
! 521: saveu[0] = '/';
! 522: }
! 523: return;
! 524: }
! 525: } while (1);
! 526: }
! 527: /* }}} */
! 528:
! 529: /* {{{ proto void Phar::running([bool retphar = true])
! 530: * return the name of the currently running phar archive. If the optional parameter
! 531: * is set to true, return the phar:// URL to the currently running phar
! 532: */
! 533: PHP_METHOD(Phar, running)
! 534: {
! 535: char *fname, *arch, *entry;
! 536: int fname_len, arch_len, entry_len;
! 537: zend_bool retphar = 1;
! 538:
! 539: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &retphar) == FAILURE) {
! 540: return;
! 541: }
! 542:
! 543: fname = zend_get_executed_filename(TSRMLS_C);
! 544: fname_len = strlen(fname);
! 545:
! 546: if (fname_len > 7 && !memcmp(fname, "phar://", 7) && SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
! 547: efree(entry);
! 548: if (retphar) {
! 549: RETVAL_STRINGL(fname, arch_len + 7, 1);
! 550: efree(arch);
! 551: return;
! 552: } else {
! 553: RETURN_STRINGL(arch, arch_len, 0);
! 554: }
! 555: }
! 556:
! 557: RETURN_STRINGL("", 0, 1);
! 558: }
! 559: /* }}} */
! 560:
! 561: /* {{{ proto void Phar::mount(string pharpath, string externalfile)
! 562: * mount an external file or path to a location within the phar. This maps
! 563: * an external file or directory to a location within the phar archive, allowing
! 564: * reference to an external location as if it were within the phar archive. This
! 565: * is useful for writable temp files like databases
! 566: */
! 567: PHP_METHOD(Phar, mount)
! 568: {
! 569: char *fname, *arch = NULL, *entry = NULL, *path, *actual;
! 570: int fname_len, arch_len, entry_len, path_len, actual_len;
! 571: phar_archive_data **pphar;
! 572:
! 573: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &path, &path_len, &actual, &actual_len) == FAILURE) {
! 574: return;
! 575: }
! 576:
! 577: fname = zend_get_executed_filename(TSRMLS_C);
! 578: fname_len = strlen(fname);
! 579:
! 580: #ifdef PHP_WIN32
! 581: phar_unixify_path_separators(fname, fname_len);
! 582: #endif
! 583:
! 584: if (fname_len > 7 && !memcmp(fname, "phar://", 7) && SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
! 585: efree(entry);
! 586: entry = NULL;
! 587:
! 588: if (path_len > 7 && !memcmp(path, "phar://", 7)) {
! 589: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Can only mount internal paths within a phar archive, use a relative path instead of \"%s\"", path);
! 590: efree(arch);
! 591: return;
! 592: }
! 593: carry_on2:
! 594: if (SUCCESS != zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **)&pphar)) {
! 595: if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, arch, arch_len, (void **)&pphar)) {
! 596: if (SUCCESS == phar_copy_on_write(pphar TSRMLS_CC)) {
! 597: goto carry_on;
! 598: }
! 599: }
! 600:
! 601: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s is not a phar archive, cannot mount", arch);
! 602:
! 603: if (arch) {
! 604: efree(arch);
! 605: }
! 606: return;
! 607: }
! 608: carry_on:
! 609: if (SUCCESS != phar_mount_entry(*pphar, actual, actual_len, path, path_len TSRMLS_CC)) {
! 610: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Mounting of %s to %s within phar %s failed", path, actual, arch);
! 611: if (path && path == entry) {
! 612: efree(entry);
! 613: }
! 614:
! 615: if (arch) {
! 616: efree(arch);
! 617: }
! 618:
! 619: return;
! 620: }
! 621:
! 622: if (entry && path && path == entry) {
! 623: efree(entry);
! 624: }
! 625:
! 626: if (arch) {
! 627: efree(arch);
! 628: }
! 629:
! 630: return;
! 631: } else if (PHAR_GLOBALS->phar_fname_map.arBuckets && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, (void **)&pphar)) {
! 632: goto carry_on;
! 633: } else if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, fname, fname_len, (void **)&pphar)) {
! 634: if (SUCCESS == phar_copy_on_write(pphar TSRMLS_CC)) {
! 635: goto carry_on;
! 636: }
! 637:
! 638: goto carry_on;
! 639: } else if (SUCCESS == phar_split_fname(path, path_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
! 640: path = entry;
! 641: path_len = entry_len;
! 642: goto carry_on2;
! 643: }
! 644:
! 645: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Mounting of %s to %s failed", path, actual);
! 646: }
! 647: /* }}} */
! 648:
! 649: /* {{{ proto void Phar::webPhar([string alias, [string index, [string f404, [array mimetypes, [callback rewrites]]]]])
! 650: * mapPhar for web-based phars. Reads the currently executed file (a phar)
! 651: * and registers its manifest. When executed in the CLI or CGI command-line sapi,
! 652: * this works exactly like mapPhar(). When executed by a web-based sapi, this
! 653: * reads $_SERVER['REQUEST_URI'] (the actual original value) and parses out the
! 654: * intended internal file.
! 655: */
! 656: PHP_METHOD(Phar, webPhar)
! 657: {
! 658: zval *mimeoverride = NULL, *rewrite = NULL;
! 659: char *alias = NULL, *error, *index_php = NULL, *f404 = NULL, *ru = NULL;
! 660: int alias_len = 0, ret, f404_len = 0, free_pathinfo = 0, ru_len = 0;
! 661: char *fname, *basename, *path_info, *mime_type = NULL, *entry, *pt;
! 662: int fname_len, entry_len, code, index_php_len = 0, not_cgi;
! 663: phar_archive_data *phar = NULL;
! 664: phar_entry_info *info = NULL;
! 665:
! 666: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!saz", &alias, &alias_len, &index_php, &index_php_len, &f404, &f404_len, &mimeoverride, &rewrite) == FAILURE) {
! 667: return;
! 668: }
! 669:
! 670: phar_request_initialize(TSRMLS_C);
! 671: fname = zend_get_executed_filename(TSRMLS_C);
! 672: fname_len = strlen(fname);
! 673:
! 674: if (phar_open_executed_filename(alias, alias_len, &error TSRMLS_CC) != SUCCESS) {
! 675: if (error) {
! 676: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 677: efree(error);
! 678: }
! 679: return;
! 680: }
! 681:
! 682: /* retrieve requested file within phar */
! 683: if (!(SG(request_info).request_method && SG(request_info).request_uri && (!strcmp(SG(request_info).request_method, "GET") || !strcmp(SG(request_info).request_method, "POST")))) {
! 684: return;
! 685: }
! 686:
! 687: #ifdef PHP_WIN32
! 688: fname = estrndup(fname, fname_len);
! 689: phar_unixify_path_separators(fname, fname_len);
! 690: #endif
! 691: basename = zend_memrchr(fname, '/', fname_len);
! 692:
! 693: if (!basename) {
! 694: basename = fname;
! 695: } else {
! 696: ++basename;
! 697: }
! 698:
! 699: if ((strlen(sapi_module.name) == sizeof("cgi-fcgi")-1 && !strncmp(sapi_module.name, "cgi-fcgi", sizeof("cgi-fcgi")-1))
! 700: || (strlen(sapi_module.name) == sizeof("cgi")-1 && !strncmp(sapi_module.name, "cgi", sizeof("cgi")-1))) {
! 701:
! 702: if (PG(http_globals)[TRACK_VARS_SERVER]) {
! 703: HashTable *_server = Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]);
! 704: zval **z_script_name, **z_path_info;
! 705:
! 706: if (SUCCESS != zend_hash_find(_server, "SCRIPT_NAME", sizeof("SCRIPT_NAME"), (void**)&z_script_name) ||
! 707: IS_STRING != Z_TYPE_PP(z_script_name) ||
! 708: !strstr(Z_STRVAL_PP(z_script_name), basename)) {
! 709: return;
! 710: }
! 711:
! 712: if (SUCCESS == zend_hash_find(_server, "PATH_INFO", sizeof("PATH_INFO"), (void**)&z_path_info) &&
! 713: IS_STRING == Z_TYPE_PP(z_path_info)) {
! 714: entry_len = Z_STRLEN_PP(z_path_info);
! 715: entry = estrndup(Z_STRVAL_PP(z_path_info), entry_len);
! 716: path_info = emalloc(Z_STRLEN_PP(z_script_name) + entry_len + 1);
! 717: memcpy(path_info, Z_STRVAL_PP(z_script_name), Z_STRLEN_PP(z_script_name));
! 718: memcpy(path_info + Z_STRLEN_PP(z_script_name), entry, entry_len + 1);
! 719: free_pathinfo = 1;
! 720: } else {
! 721: entry_len = 0;
! 722: entry = estrndup("", 0);
! 723: path_info = Z_STRVAL_PP(z_script_name);
! 724: }
! 725:
! 726: pt = estrndup(Z_STRVAL_PP(z_script_name), Z_STRLEN_PP(z_script_name));
! 727:
! 728: } else {
! 729: char *testit;
! 730:
! 731: testit = sapi_getenv("SCRIPT_NAME", sizeof("SCRIPT_NAME")-1 TSRMLS_CC);
! 732: if (!(pt = strstr(testit, basename))) {
! 733: efree(testit);
! 734: return;
! 735: }
! 736:
! 737: path_info = sapi_getenv("PATH_INFO", sizeof("PATH_INFO")-1 TSRMLS_CC);
! 738:
! 739: if (path_info) {
! 740: entry = path_info;
! 741: entry_len = strlen(entry);
! 742: spprintf(&path_info, 0, "%s%s", testit, path_info);
! 743: free_pathinfo = 1;
! 744: } else {
! 745: path_info = testit;
! 746: free_pathinfo = 1;
! 747: entry = estrndup("", 0);
! 748: entry_len = 0;
! 749: }
! 750:
! 751: pt = estrndup(testit, (pt - testit) + (fname_len - (basename - fname)));
! 752: }
! 753: not_cgi = 0;
! 754: } else {
! 755: path_info = SG(request_info).request_uri;
! 756:
! 757: if (!(pt = strstr(path_info, basename))) {
! 758: /* this can happen with rewrite rules - and we have no idea what to do then, so return */
! 759: return;
! 760: }
! 761:
! 762: entry_len = strlen(path_info);
! 763: entry_len -= (pt - path_info) + (fname_len - (basename - fname));
! 764: entry = estrndup(pt + (fname_len - (basename - fname)), entry_len);
! 765:
! 766: pt = estrndup(path_info, (pt - path_info) + (fname_len - (basename - fname)));
! 767: not_cgi = 1;
! 768: }
! 769:
! 770: if (rewrite) {
! 771: zend_fcall_info fci;
! 772: zend_fcall_info_cache fcc;
! 773: zval *params, *retval_ptr, **zp[1];
! 774:
! 775: MAKE_STD_ZVAL(params);
! 776: ZVAL_STRINGL(params, entry, entry_len, 1);
! 777: zp[0] = ¶ms;
! 778:
! 779: #if PHP_VERSION_ID < 50300
! 780: if (FAILURE == zend_fcall_info_init(rewrite, &fci, &fcc TSRMLS_CC)) {
! 781: #else
! 782: if (FAILURE == zend_fcall_info_init(rewrite, 0, &fci, &fcc, NULL, NULL TSRMLS_CC)) {
! 783: #endif
! 784: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar error: invalid rewrite callback");
! 785:
! 786: if (free_pathinfo) {
! 787: efree(path_info);
! 788: }
! 789:
! 790: return;
! 791: }
! 792:
! 793: fci.param_count = 1;
! 794: fci.params = zp;
! 795: #if PHP_VERSION_ID < 50300
! 796: ++(params->refcount);
! 797: #else
! 798: Z_ADDREF_P(params);
! 799: #endif
! 800: fci.retval_ptr_ptr = &retval_ptr;
! 801:
! 802: if (FAILURE == zend_call_function(&fci, &fcc TSRMLS_CC)) {
! 803: if (!EG(exception)) {
! 804: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar error: failed to call rewrite callback");
! 805: }
! 806:
! 807: if (free_pathinfo) {
! 808: efree(path_info);
! 809: }
! 810:
! 811: return;
! 812: }
! 813:
! 814: if (!fci.retval_ptr_ptr || !retval_ptr) {
! 815: if (free_pathinfo) {
! 816: efree(path_info);
! 817: }
! 818: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar error: rewrite callback must return a string or false");
! 819: return;
! 820: }
! 821:
! 822: switch (Z_TYPE_P(retval_ptr)) {
! 823: #if PHP_VERSION_ID >= 60000
! 824: case IS_UNICODE:
! 825: zval_unicode_to_string(retval_ptr TSRMLS_CC);
! 826: /* break intentionally omitted */
! 827: #endif
! 828: case IS_STRING:
! 829: efree(entry);
! 830:
! 831: if (fci.retval_ptr_ptr != &retval_ptr) {
! 832: entry = estrndup(Z_STRVAL_PP(fci.retval_ptr_ptr), Z_STRLEN_PP(fci.retval_ptr_ptr));
! 833: entry_len = Z_STRLEN_PP(fci.retval_ptr_ptr);
! 834: } else {
! 835: entry = Z_STRVAL_P(retval_ptr);
! 836: entry_len = Z_STRLEN_P(retval_ptr);
! 837: }
! 838:
! 839: break;
! 840: case IS_BOOL:
! 841: phar_do_403(entry, entry_len TSRMLS_CC);
! 842:
! 843: if (free_pathinfo) {
! 844: efree(path_info);
! 845: }
! 846:
! 847: zend_bailout();
! 848: return;
! 849: default:
! 850: efree(retval_ptr);
! 851:
! 852: if (free_pathinfo) {
! 853: efree(path_info);
! 854: }
! 855:
! 856: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar error: rewrite callback must return a string or false");
! 857: return;
! 858: }
! 859: }
! 860:
! 861: if (entry_len) {
! 862: phar_postprocess_ru_web(fname, fname_len, &entry, &entry_len, &ru, &ru_len TSRMLS_CC);
! 863: }
! 864:
! 865: if (!entry_len || (entry_len == 1 && entry[0] == '/')) {
! 866: efree(entry);
! 867: /* direct request */
! 868: if (index_php_len) {
! 869: entry = index_php;
! 870: entry_len = index_php_len;
! 871: if (entry[0] != '/') {
! 872: spprintf(&entry, 0, "/%s", index_php);
! 873: ++entry_len;
! 874: }
! 875: } else {
! 876: /* assume "index.php" is starting point */
! 877: entry = estrndup("/index.php", sizeof("/index.php"));
! 878: entry_len = sizeof("/index.php")-1;
! 879: }
! 880:
! 881: if (FAILURE == phar_get_archive(&phar, fname, fname_len, NULL, 0, NULL TSRMLS_CC) ||
! 882: (info = phar_get_entry_info(phar, entry, entry_len, NULL, 0 TSRMLS_CC)) == NULL) {
! 883: phar_do_404(phar, fname, fname_len, f404, f404_len, entry, entry_len TSRMLS_CC);
! 884:
! 885: if (free_pathinfo) {
! 886: efree(path_info);
! 887: }
! 888:
! 889: zend_bailout();
! 890: } else {
! 891: char *tmp = NULL, sa = '\0';
! 892: sapi_header_line ctr = {0};
! 893: ctr.response_code = 301;
! 894: ctr.line_len = sizeof("HTTP/1.1 301 Moved Permanently")+1;
! 895: ctr.line = "HTTP/1.1 301 Moved Permanently";
! 896: sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
! 897:
! 898: if (not_cgi) {
! 899: tmp = strstr(path_info, basename) + fname_len;
! 900: sa = *tmp;
! 901: *tmp = '\0';
! 902: }
! 903:
! 904: ctr.response_code = 0;
! 905:
! 906: if (path_info[strlen(path_info)-1] == '/') {
! 907: ctr.line_len = spprintf(&(ctr.line), 4096, "Location: %s%s", path_info, entry + 1);
! 908: } else {
! 909: ctr.line_len = spprintf(&(ctr.line), 4096, "Location: %s%s", path_info, entry);
! 910: }
! 911:
! 912: if (not_cgi) {
! 913: *tmp = sa;
! 914: }
! 915:
! 916: if (free_pathinfo) {
! 917: efree(path_info);
! 918: }
! 919:
! 920: sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
! 921: sapi_send_headers(TSRMLS_C);
! 922: efree(ctr.line);
! 923: zend_bailout();
! 924: }
! 925: }
! 926:
! 927: if (FAILURE == phar_get_archive(&phar, fname, fname_len, NULL, 0, NULL TSRMLS_CC) ||
! 928: (info = phar_get_entry_info(phar, entry, entry_len, NULL, 0 TSRMLS_CC)) == NULL) {
! 929: phar_do_404(phar, fname, fname_len, f404, f404_len, entry, entry_len TSRMLS_CC);
! 930: #ifdef PHP_WIN32
! 931: efree(fname);
! 932: #endif
! 933: zend_bailout();
! 934: }
! 935:
! 936: if (mimeoverride && zend_hash_num_elements(Z_ARRVAL_P(mimeoverride))) {
! 937: char *ext = zend_memrchr(entry, '.', entry_len);
! 938: zval **val;
! 939:
! 940: if (ext) {
! 941: ++ext;
! 942:
! 943: #if PHP_MAJOR_VERSION >= 6
! 944: if (phar_find_key(Z_ARRVAL_P(mimeoverride), ext, strlen(ext)+1, (void **) &val TSRMLS_CC)) {
! 945: #else
! 946: if (SUCCESS == zend_hash_find(Z_ARRVAL_P(mimeoverride), ext, strlen(ext)+1, (void **) &val)) {
! 947: #endif
! 948: switch (Z_TYPE_PP(val)) {
! 949: case IS_LONG:
! 950: if (Z_LVAL_PP(val) == PHAR_MIME_PHP || Z_LVAL_PP(val) == PHAR_MIME_PHPS) {
! 951: mime_type = "";
! 952: code = Z_LVAL_PP(val);
! 953: } else {
! 954: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown mime type specifier used, only Phar::PHP, Phar::PHPS and a mime type string are allowed");
! 955: #ifdef PHP_WIN32
! 956: efree(fname);
! 957: #endif
! 958: RETURN_FALSE;
! 959: }
! 960: break;
! 961: #if PHP_MAJOR_VERSION >= 6
! 962: case IS_UNICODE:
! 963: zval_unicode_to_string(*(val) TSRMLS_CC);
! 964: /* break intentionally omitted */
! 965: #endif
! 966: case IS_STRING:
! 967: mime_type = Z_STRVAL_PP(val);
! 968: code = PHAR_MIME_OTHER;
! 969: break;
! 970: default:
! 971: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown mime type specifier used (not a string or int), only Phar::PHP, Phar::PHPS and a mime type string are allowed");
! 972: #ifdef PHP_WIN32
! 973: efree(fname);
! 974: #endif
! 975: RETURN_FALSE;
! 976: }
! 977: }
! 978: }
! 979: }
! 980:
! 981: if (!mime_type) {
! 982: code = phar_file_type(&PHAR_G(mime_types), entry, &mime_type TSRMLS_CC);
! 983: }
! 984: ret = phar_file_action(phar, info, mime_type, code, entry, entry_len, fname, pt, ru, ru_len TSRMLS_CC);
! 985: }
! 986: /* }}} */
! 987:
! 988: /* {{{ proto void Phar::mungServer(array munglist)
! 989: * Defines a list of up to 4 $_SERVER variables that should be modified for execution
! 990: * to mask the presence of the phar archive. This should be used in conjunction with
! 991: * Phar::webPhar(), and has no effect otherwise
! 992: * SCRIPT_NAME, PHP_SELF, REQUEST_URI and SCRIPT_FILENAME
! 993: */
! 994: PHP_METHOD(Phar, mungServer)
! 995: {
! 996: zval *mungvalues;
! 997:
! 998: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &mungvalues) == FAILURE) {
! 999: return;
! 1000: }
! 1001:
! 1002: if (!zend_hash_num_elements(Z_ARRVAL_P(mungvalues))) {
! 1003: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "No values passed to Phar::mungServer(), expecting an array of any of these strings: PHP_SELF, REQUEST_URI, SCRIPT_FILENAME, SCRIPT_NAME");
! 1004: return;
! 1005: }
! 1006:
! 1007: if (zend_hash_num_elements(Z_ARRVAL_P(mungvalues)) > 4) {
! 1008: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Too many values passed to Phar::mungServer(), expecting an array of any of these strings: PHP_SELF, REQUEST_URI, SCRIPT_FILENAME, SCRIPT_NAME");
! 1009: return;
! 1010: }
! 1011:
! 1012: phar_request_initialize(TSRMLS_C);
! 1013:
! 1014: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(mungvalues)); SUCCESS == zend_hash_has_more_elements(Z_ARRVAL_P(mungvalues)); zend_hash_move_forward(Z_ARRVAL_P(mungvalues))) {
! 1015: zval **data = NULL;
! 1016: #if PHP_MAJOR_VERSION >= 6
! 1017: zval *unicopy = NULL;
! 1018: #endif
! 1019:
! 1020: if (SUCCESS != zend_hash_get_current_data(Z_ARRVAL_P(mungvalues), (void **) &data)) {
! 1021: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "unable to retrieve array value in Phar::mungServer()");
! 1022: return;
! 1023: }
! 1024:
! 1025: #if PHP_MAJOR_VERSION >= 6
! 1026: if (Z_TYPE_PP(data) == IS_UNICODE) {
! 1027: MAKE_STD_ZVAL(unicopy);
! 1028: *unicopy = **data;
! 1029: zval_copy_ctor(unicopy);
! 1030: INIT_PZVAL(unicopy);
! 1031: zval_unicode_to_string(unicopy TSRMLS_CC);
! 1032: data = &unicopy;
! 1033: }
! 1034: #endif
! 1035:
! 1036: if (Z_TYPE_PP(data) != IS_STRING) {
! 1037: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Non-string value passed to Phar::mungServer(), expecting an array of any of these strings: PHP_SELF, REQUEST_URI, SCRIPT_FILENAME, SCRIPT_NAME");
! 1038: return;
! 1039: }
! 1040:
! 1041: if (Z_STRLEN_PP(data) == sizeof("PHP_SELF")-1 && !strncmp(Z_STRVAL_PP(data), "PHP_SELF", sizeof("PHP_SELF")-1)) {
! 1042: PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_PHP_SELF;
! 1043: }
! 1044:
! 1045: if (Z_STRLEN_PP(data) == sizeof("REQUEST_URI")-1) {
! 1046: if (!strncmp(Z_STRVAL_PP(data), "REQUEST_URI", sizeof("REQUEST_URI")-1)) {
! 1047: PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_REQUEST_URI;
! 1048: }
! 1049: if (!strncmp(Z_STRVAL_PP(data), "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1)) {
! 1050: PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_NAME;
! 1051: }
! 1052: }
! 1053:
! 1054: if (Z_STRLEN_PP(data) == sizeof("SCRIPT_FILENAME")-1 && !strncmp(Z_STRVAL_PP(data), "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1)) {
! 1055: PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_FILENAME;
! 1056: }
! 1057: #if PHP_MAJOR_VERSION >= 6
! 1058: if (unicopy) {
! 1059: zval_ptr_dtor(&unicopy);
! 1060: }
! 1061: #endif
! 1062: }
! 1063: }
! 1064: /* }}} */
! 1065:
! 1066: /* {{{ proto void Phar::interceptFileFuncs()
! 1067: * instructs phar to intercept fopen, file_get_contents, opendir, and all of the stat-related functions
! 1068: * and return stat on files within the phar for relative paths
! 1069: *
! 1070: * Once called, this cannot be reversed, and continue until the end of the request.
! 1071: *
! 1072: * This allows legacy scripts to be pharred unmodified
! 1073: */
! 1074: PHP_METHOD(Phar, interceptFileFuncs)
! 1075: {
! 1076: if (zend_parse_parameters_none() == FAILURE) {
! 1077: return;
! 1078: }
! 1079: phar_intercept_functions(TSRMLS_C);
! 1080: }
! 1081: /* }}} */
! 1082:
! 1083: /* {{{ proto array Phar::createDefaultStub([string indexfile[, string webindexfile]])
! 1084: * Return a stub that can be used to run a phar-based archive without the phar extension
! 1085: * indexfile is the CLI startup filename, which defaults to "index.php", webindexfile
! 1086: * is the web startup filename, and also defaults to "index.php"
! 1087: */
! 1088: PHP_METHOD(Phar, createDefaultStub)
! 1089: {
! 1090: char *index = NULL, *webindex = NULL, *stub, *error;
! 1091: int index_len = 0, webindex_len = 0;
! 1092: size_t stub_len;
! 1093:
! 1094: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ss", &index, &index_len, &webindex, &webindex_len) == FAILURE) {
! 1095: return;
! 1096: }
! 1097:
! 1098: stub = phar_create_default_stub(index, webindex, &stub_len, &error TSRMLS_CC);
! 1099:
! 1100: if (error) {
! 1101: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 1102: efree(error);
! 1103: return;
! 1104: }
! 1105: RETURN_STRINGL(stub, stub_len, 0);
! 1106: }
! 1107: /* }}} */
! 1108:
! 1109: /* {{{ proto mixed Phar::mapPhar([string alias, [int dataoffset]])
! 1110: * Reads the currently executed file (a phar) and registers its manifest */
! 1111: PHP_METHOD(Phar, mapPhar)
! 1112: {
! 1113: char *alias = NULL, *error;
! 1114: int alias_len = 0;
! 1115: long dataoffset = 0;
! 1116:
! 1117: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!l", &alias, &alias_len, &dataoffset) == FAILURE) {
! 1118: return;
! 1119: }
! 1120:
! 1121: phar_request_initialize(TSRMLS_C);
! 1122:
! 1123: RETVAL_BOOL(phar_open_executed_filename(alias, alias_len, &error TSRMLS_CC) == SUCCESS);
! 1124:
! 1125: if (error) {
! 1126: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 1127: efree(error);
! 1128: }
! 1129: } /* }}} */
! 1130:
! 1131: /* {{{ proto mixed Phar::loadPhar(string filename [, string alias])
! 1132: * Loads any phar archive with an alias */
! 1133: PHP_METHOD(Phar, loadPhar)
! 1134: {
! 1135: char *fname, *alias = NULL, *error;
! 1136: int fname_len, alias_len = 0;
! 1137:
! 1138: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!", &fname, &fname_len, &alias, &alias_len) == FAILURE) {
! 1139: return;
! 1140: }
! 1141:
! 1142: phar_request_initialize(TSRMLS_C);
! 1143:
! 1144: RETVAL_BOOL(phar_open_from_filename(fname, fname_len, alias, alias_len, REPORT_ERRORS, NULL, &error TSRMLS_CC) == SUCCESS);
! 1145:
! 1146: if (error) {
! 1147: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 1148: efree(error);
! 1149: }
! 1150: } /* }}} */
! 1151:
! 1152: /* {{{ proto string Phar::apiVersion()
! 1153: * Returns the api version */
! 1154: PHP_METHOD(Phar, apiVersion)
! 1155: {
! 1156: if (zend_parse_parameters_none() == FAILURE) {
! 1157: return;
! 1158: }
! 1159: RETURN_STRINGL(PHP_PHAR_API_VERSION, sizeof(PHP_PHAR_API_VERSION)-1, 1);
! 1160: }
! 1161: /* }}}*/
! 1162:
! 1163: /* {{{ proto bool Phar::canCompress([int method])
! 1164: * Returns whether phar extension supports compression using zlib/bzip2 */
! 1165: PHP_METHOD(Phar, canCompress)
! 1166: {
! 1167: long method = 0;
! 1168:
! 1169: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &method) == FAILURE) {
! 1170: return;
! 1171: }
! 1172:
! 1173: phar_request_initialize(TSRMLS_C);
! 1174: switch (method) {
! 1175: case PHAR_ENT_COMPRESSED_GZ:
! 1176: if (PHAR_G(has_zlib)) {
! 1177: RETURN_TRUE;
! 1178: } else {
! 1179: RETURN_FALSE;
! 1180: }
! 1181: case PHAR_ENT_COMPRESSED_BZ2:
! 1182: if (PHAR_G(has_bz2)) {
! 1183: RETURN_TRUE;
! 1184: } else {
! 1185: RETURN_FALSE;
! 1186: }
! 1187: default:
! 1188: if (PHAR_G(has_zlib) || PHAR_G(has_bz2)) {
! 1189: RETURN_TRUE;
! 1190: } else {
! 1191: RETURN_FALSE;
! 1192: }
! 1193: }
! 1194: }
! 1195: /* }}} */
! 1196:
! 1197: /* {{{ proto bool Phar::canWrite()
! 1198: * Returns whether phar extension supports writing and creating phars */
! 1199: PHP_METHOD(Phar, canWrite)
! 1200: {
! 1201: if (zend_parse_parameters_none() == FAILURE) {
! 1202: return;
! 1203: }
! 1204: RETURN_BOOL(!PHAR_G(readonly));
! 1205: }
! 1206: /* }}} */
! 1207:
! 1208: /* {{{ proto bool Phar::isValidPharFilename(string filename[, bool executable = true])
! 1209: * Returns whether the given filename is a valid phar filename */
! 1210: PHP_METHOD(Phar, isValidPharFilename)
! 1211: {
! 1212: char *fname;
! 1213: const char *ext_str;
! 1214: int fname_len, ext_len, is_executable;
! 1215: zend_bool executable = 1;
! 1216:
! 1217: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &fname, &fname_len, &executable) == FAILURE) {
! 1218: return;
! 1219: }
! 1220:
! 1221: is_executable = executable;
! 1222: RETVAL_BOOL(phar_detect_phar_fname_ext(fname, fname_len, &ext_str, &ext_len, is_executable, 2, 1 TSRMLS_CC) == SUCCESS);
! 1223: }
! 1224: /* }}} */
! 1225:
! 1226: #if HAVE_SPL
! 1227: /**
! 1228: * from spl_directory
! 1229: */
! 1230: static void phar_spl_foreign_dtor(spl_filesystem_object *object TSRMLS_DC) /* {{{ */
! 1231: {
! 1232: phar_archive_data *phar = (phar_archive_data *) object->oth;
! 1233:
! 1234: if (!phar->is_persistent) {
! 1235: phar_archive_delref(phar TSRMLS_CC);
! 1236: }
! 1237:
! 1238: object->oth = NULL;
! 1239: }
! 1240: /* }}} */
! 1241:
! 1242: /**
! 1243: * from spl_directory
! 1244: */
! 1245: static void phar_spl_foreign_clone(spl_filesystem_object *src, spl_filesystem_object *dst TSRMLS_DC) /* {{{ */
! 1246: {
! 1247: phar_archive_data *phar_data = (phar_archive_data *) dst->oth;
! 1248:
! 1249: if (!phar_data->is_persistent) {
! 1250: ++(phar_data->refcount);
! 1251: }
! 1252: }
! 1253: /* }}} */
! 1254:
! 1255: static spl_other_handler phar_spl_foreign_handler = {
! 1256: phar_spl_foreign_dtor,
! 1257: phar_spl_foreign_clone
! 1258: };
! 1259: #endif /* HAVE_SPL */
! 1260:
! 1261: /* {{{ proto void Phar::__construct(string fname [, int flags [, string alias]])
! 1262: * Construct a Phar archive object
! 1263: *
! 1264: * proto void PharData::__construct(string fname [[, int flags [, string alias]], int file format = Phar::TAR])
! 1265: * Construct a PharData archive object
! 1266: *
! 1267: * This function is used as the constructor for both the Phar and PharData
! 1268: * classes, hence the two prototypes above.
! 1269: */
! 1270: PHP_METHOD(Phar, __construct)
! 1271: {
! 1272: #if !HAVE_SPL
! 1273: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Cannot instantiate Phar object without SPL extension");
! 1274: #else
! 1275: char *fname, *alias = NULL, *error, *arch = NULL, *entry = NULL, *save_fname;
! 1276: int fname_len, alias_len = 0, arch_len, entry_len, is_data;
! 1277: #if PHP_VERSION_ID < 50300
! 1278: long flags = 0;
! 1279: #else
! 1280: long flags = SPL_FILE_DIR_SKIPDOTS|SPL_FILE_DIR_UNIXPATHS;
! 1281: #endif
! 1282: long format = 0;
! 1283: phar_archive_object *phar_obj;
! 1284: phar_archive_data *phar_data;
! 1285: zval *zobj = getThis(), arg1, arg2;
! 1286:
! 1287: phar_obj = (phar_archive_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1288:
! 1289: is_data = instanceof_function(Z_OBJCE_P(zobj), phar_ce_data TSRMLS_CC);
! 1290:
! 1291: if (is_data) {
! 1292: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls!l", &fname, &fname_len, &flags, &alias, &alias_len, &format) == FAILURE) {
! 1293: return;
! 1294: }
! 1295: } else {
! 1296: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls!", &fname, &fname_len, &flags, &alias, &alias_len) == FAILURE) {
! 1297: return;
! 1298: }
! 1299: }
! 1300:
! 1301: if (phar_obj->arc.archive) {
! 1302: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot call constructor twice");
! 1303: return;
! 1304: }
! 1305:
! 1306: save_fname = fname;
! 1307: if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, !is_data, 2 TSRMLS_CC)) {
! 1308: /* use arch (the basename for the archive) for fname instead of fname */
! 1309: /* this allows support for RecursiveDirectoryIterator of subdirectories */
! 1310: #ifdef PHP_WIN32
! 1311: phar_unixify_path_separators(arch, arch_len);
! 1312: #endif
! 1313: fname = arch;
! 1314: fname_len = arch_len;
! 1315: #ifdef PHP_WIN32
! 1316: } else {
! 1317: arch = estrndup(fname, fname_len);
! 1318: arch_len = fname_len;
! 1319: fname = arch;
! 1320: phar_unixify_path_separators(arch, arch_len);
! 1321: #endif
! 1322: }
! 1323:
! 1324: if (phar_open_or_create_filename(fname, fname_len, alias, alias_len, is_data, REPORT_ERRORS, &phar_data, &error TSRMLS_CC) == FAILURE) {
! 1325:
! 1326: if (fname == arch && fname != save_fname) {
! 1327: efree(arch);
! 1328: fname = save_fname;
! 1329: }
! 1330:
! 1331: if (entry) {
! 1332: efree(entry);
! 1333: }
! 1334:
! 1335: if (error) {
! 1336: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 1337: "%s", error);
! 1338: efree(error);
! 1339: } else {
! 1340: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 1341: "Phar creation or opening failed");
! 1342: }
! 1343:
! 1344: return;
! 1345: }
! 1346:
! 1347: if (is_data && phar_data->is_tar && phar_data->is_brandnew && format == PHAR_FORMAT_ZIP) {
! 1348: phar_data->is_zip = 1;
! 1349: phar_data->is_tar = 0;
! 1350: }
! 1351:
! 1352: if (fname == arch) {
! 1353: efree(arch);
! 1354: fname = save_fname;
! 1355: }
! 1356:
! 1357: if ((is_data && !phar_data->is_data) || (!is_data && phar_data->is_data)) {
! 1358: if (is_data) {
! 1359: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 1360: "PharData class can only be used for non-executable tar and zip archives");
! 1361: } else {
! 1362: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 1363: "Phar class can only be used for executable tar and zip archives");
! 1364: }
! 1365: efree(entry);
! 1366: return;
! 1367: }
! 1368:
! 1369: is_data = phar_data->is_data;
! 1370:
! 1371: if (!phar_data->is_persistent) {
! 1372: ++(phar_data->refcount);
! 1373: }
! 1374:
! 1375: phar_obj->arc.archive = phar_data;
! 1376: phar_obj->spl.oth_handler = &phar_spl_foreign_handler;
! 1377:
! 1378: if (entry) {
! 1379: fname_len = spprintf(&fname, 0, "phar://%s%s", phar_data->fname, entry);
! 1380: efree(entry);
! 1381: } else {
! 1382: fname_len = spprintf(&fname, 0, "phar://%s", phar_data->fname);
! 1383: }
! 1384:
! 1385: INIT_PZVAL(&arg1);
! 1386: ZVAL_STRINGL(&arg1, fname, fname_len, 0);
! 1387: INIT_PZVAL(&arg2);
! 1388: ZVAL_LONG(&arg2, flags);
! 1389:
! 1390: zend_call_method_with_2_params(&zobj, Z_OBJCE_P(zobj),
! 1391: &spl_ce_RecursiveDirectoryIterator->constructor, "__construct", NULL, &arg1, &arg2);
! 1392:
! 1393: if (!phar_data->is_persistent) {
! 1394: phar_obj->arc.archive->is_data = is_data;
! 1395: } else if (!EG(exception)) {
! 1396: /* register this guy so we can modify if necessary */
! 1397: zend_hash_add(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->arc.archive, sizeof(phar_obj->arc.archive), (void *) &phar_obj, sizeof(phar_archive_object **), NULL);
! 1398: }
! 1399:
! 1400: phar_obj->spl.info_class = phar_ce_entry;
! 1401: efree(fname);
! 1402: #endif /* HAVE_SPL */
! 1403: }
! 1404: /* }}} */
! 1405:
! 1406: /* {{{ proto array Phar::getSupportedSignatures()
! 1407: * Return array of supported signature types
! 1408: */
! 1409: PHP_METHOD(Phar, getSupportedSignatures)
! 1410: {
! 1411: if (zend_parse_parameters_none() == FAILURE) {
! 1412: return;
! 1413: }
! 1414:
! 1415: array_init(return_value);
! 1416:
! 1417: add_next_index_stringl(return_value, "MD5", 3, 1);
! 1418: add_next_index_stringl(return_value, "SHA-1", 5, 1);
! 1419: #ifdef PHAR_HASH_OK
! 1420: add_next_index_stringl(return_value, "SHA-256", 7, 1);
! 1421: add_next_index_stringl(return_value, "SHA-512", 7, 1);
! 1422: #endif
! 1423: #if PHAR_HAVE_OPENSSL
! 1424: add_next_index_stringl(return_value, "OpenSSL", 7, 1);
! 1425: #else
! 1426: if (zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) {
! 1427: add_next_index_stringl(return_value, "OpenSSL", 7, 1);
! 1428: }
! 1429: #endif
! 1430: }
! 1431: /* }}} */
! 1432:
! 1433: /* {{{ proto array Phar::getSupportedCompression()
! 1434: * Return array of supported comparession algorithms
! 1435: */
! 1436: PHP_METHOD(Phar, getSupportedCompression)
! 1437: {
! 1438: if (zend_parse_parameters_none() == FAILURE) {
! 1439: return;
! 1440: }
! 1441:
! 1442: array_init(return_value);
! 1443: phar_request_initialize(TSRMLS_C);
! 1444:
! 1445: if (PHAR_G(has_zlib)) {
! 1446: add_next_index_stringl(return_value, "GZ", 2, 1);
! 1447: }
! 1448:
! 1449: if (PHAR_G(has_bz2)) {
! 1450: add_next_index_stringl(return_value, "BZIP2", 5, 1);
! 1451: }
! 1452: }
! 1453: /* }}} */
! 1454:
! 1455: /* {{{ proto array Phar::unlinkArchive(string archive)
! 1456: * Completely remove a phar archive from memory and disk
! 1457: */
! 1458: PHP_METHOD(Phar, unlinkArchive)
! 1459: {
! 1460: char *fname, *error, *zname, *arch, *entry;
! 1461: int fname_len, zname_len, arch_len, entry_len;
! 1462: phar_archive_data *phar;
! 1463:
! 1464: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &fname, &fname_len) == FAILURE) {
! 1465: RETURN_FALSE;
! 1466: }
! 1467:
! 1468: if (!fname_len) {
! 1469: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown phar archive \"\"");
! 1470: return;
! 1471: }
! 1472:
! 1473: if (FAILURE == phar_open_from_filename(fname, fname_len, NULL, 0, REPORT_ERRORS, &phar, &error TSRMLS_CC)) {
! 1474: if (error) {
! 1475: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown phar archive \"%s\": %s", fname, error);
! 1476: efree(error);
! 1477: } else {
! 1478: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown phar archive \"%s\"", fname);
! 1479: }
! 1480: return;
! 1481: }
! 1482:
! 1483: zname = zend_get_executed_filename(TSRMLS_C);
! 1484: zname_len = strlen(zname);
! 1485:
! 1486: if (zname_len > 7 && !memcmp(zname, "phar://", 7) && SUCCESS == phar_split_fname(zname, zname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
! 1487: if (arch_len == fname_len && !memcmp(arch, fname, arch_len)) {
! 1488: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar archive \"%s\" cannot be unlinked from within itself", fname);
! 1489: efree(arch);
! 1490: efree(entry);
! 1491: return;
! 1492: }
! 1493: efree(arch);
! 1494: efree(entry);
! 1495: }
! 1496:
! 1497: if (phar->is_persistent) {
! 1498: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar archive \"%s\" is in phar.cache_list, cannot unlinkArchive()", fname);
! 1499: return;
! 1500: }
! 1501:
! 1502: if (phar->refcount) {
! 1503: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar archive \"%s\" has open file handles or objects. fclose() all file handles, and unset() all objects prior to calling unlinkArchive()", fname);
! 1504: return;
! 1505: }
! 1506:
! 1507: fname = estrndup(phar->fname, phar->fname_len);
! 1508:
! 1509: /* invalidate phar cache */
! 1510: PHAR_G(last_phar) = NULL;
! 1511: PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
! 1512:
! 1513: phar_archive_delref(phar TSRMLS_CC);
! 1514: unlink(fname);
! 1515: efree(fname);
! 1516: RETURN_TRUE;
! 1517: }
! 1518: /* }}} */
! 1519:
! 1520: #if HAVE_SPL
! 1521:
! 1522: #define PHAR_ARCHIVE_OBJECT() \
! 1523: phar_archive_object *phar_obj = (phar_archive_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
! 1524: if (!phar_obj->arc.archive) { \
! 1525: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 1526: "Cannot call method on an uninitialized Phar object"); \
! 1527: return; \
! 1528: }
! 1529:
! 1530: /* {{{ proto void Phar::__destruct()
! 1531: * if persistent, remove from the cache
! 1532: */
! 1533: PHP_METHOD(Phar, __destruct)
! 1534: {
! 1535: phar_archive_object *phar_obj = (phar_archive_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1536:
! 1537: if (phar_obj->arc.archive && phar_obj->arc.archive->is_persistent) {
! 1538: zend_hash_del(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->arc.archive, sizeof(phar_obj->arc.archive));
! 1539: }
! 1540: }
! 1541: /* }}} */
! 1542:
! 1543: struct _phar_t {
! 1544: phar_archive_object *p;
! 1545: zend_class_entry *c;
! 1546: char *b;
! 1547: uint l;
! 1548: zval *ret;
! 1549: int count;
! 1550: php_stream *fp;
! 1551: };
! 1552:
! 1553: static int phar_build(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
! 1554: {
! 1555: zval **value;
! 1556: zend_uchar key_type;
! 1557: zend_bool close_fp = 1;
! 1558: ulong int_key;
! 1559: struct _phar_t *p_obj = (struct _phar_t*) puser;
! 1560: uint str_key_len, base_len = p_obj->l, fname_len;
! 1561: phar_entry_data *data;
! 1562: php_stream *fp;
! 1563: size_t contents_len;
! 1564: char *fname, *error = NULL, *base = p_obj->b, *opened, *save = NULL, *temp = NULL;
! 1565: phar_zstr key;
! 1566: char *str_key;
! 1567: zend_class_entry *ce = p_obj->c;
! 1568: phar_archive_object *phar_obj = p_obj->p;
! 1569: char *str = "[stream]";
! 1570:
! 1571: iter->funcs->get_current_data(iter, &value TSRMLS_CC);
! 1572:
! 1573: if (EG(exception)) {
! 1574: return ZEND_HASH_APPLY_STOP;
! 1575: }
! 1576:
! 1577: if (!value) {
! 1578: /* failure in get_current_data */
! 1579: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned no value", ce->name);
! 1580: return ZEND_HASH_APPLY_STOP;
! 1581: }
! 1582:
! 1583: switch (Z_TYPE_PP(value)) {
! 1584: #if PHP_VERSION_ID >= 60000
! 1585: case IS_UNICODE:
! 1586: zval_unicode_to_string(*(value) TSRMLS_CC);
! 1587: /* break intentionally omitted */
! 1588: #endif
! 1589: case IS_STRING:
! 1590: break;
! 1591: case IS_RESOURCE:
! 1592: php_stream_from_zval_no_verify(fp, value);
! 1593:
! 1594: if (!fp) {
! 1595: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Iterator %v returned an invalid stream handle", ce->name);
! 1596: return ZEND_HASH_APPLY_STOP;
! 1597: }
! 1598:
! 1599: if (iter->funcs->get_current_key) {
! 1600: key_type = iter->funcs->get_current_key(iter, &key, &str_key_len, &int_key TSRMLS_CC);
! 1601:
! 1602: if (EG(exception)) {
! 1603: return ZEND_HASH_APPLY_STOP;
! 1604: }
! 1605:
! 1606: if (key_type == HASH_KEY_IS_LONG) {
! 1607: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned an invalid key (must return a string)", ce->name);
! 1608: return ZEND_HASH_APPLY_STOP;
! 1609: }
! 1610:
! 1611: if (key_type > 9) { /* IS_UNICODE == 10 */
! 1612: #if PHP_VERSION_ID < 60000
! 1613: /* this can never happen, but fixes a compile warning */
! 1614: spprintf(&str_key, 0, "%s", key);
! 1615: #else
! 1616: spprintf(&str_key, 0, "%v", key);
! 1617: ezfree(key);
! 1618: #endif
! 1619: } else {
! 1620: PHAR_STR(key, str_key);
! 1621: }
! 1622:
! 1623: save = str_key;
! 1624:
! 1625: if (str_key[str_key_len - 1] == '\0') {
! 1626: str_key_len--;
! 1627: }
! 1628:
! 1629: } else {
! 1630: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned an invalid key (must return a string)", ce->name);
! 1631: return ZEND_HASH_APPLY_STOP;
! 1632: }
! 1633:
! 1634: close_fp = 0;
! 1635: opened = (char *) estrndup(str, sizeof("[stream]") + 1);
! 1636: goto after_open_fp;
! 1637: case IS_OBJECT:
! 1638: if (instanceof_function(Z_OBJCE_PP(value), spl_ce_SplFileInfo TSRMLS_CC)) {
! 1639: char *test = NULL;
! 1640: zval dummy;
! 1641: spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(*value TSRMLS_CC);
! 1642:
! 1643: if (!base_len) {
! 1644: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Iterator %v returns an SplFileInfo object, so base directory must be specified", ce->name);
! 1645: return ZEND_HASH_APPLY_STOP;
! 1646: }
! 1647:
! 1648: switch (intern->type) {
! 1649: case SPL_FS_DIR:
! 1650: #if PHP_VERSION_ID >= 60000
! 1651: test = spl_filesystem_object_get_path(intern, NULL, NULL TSRMLS_CC).s;
! 1652: #elif PHP_VERSION_ID >= 50300
! 1653: test = spl_filesystem_object_get_path(intern, NULL TSRMLS_CC);
! 1654: #else
! 1655: test = intern->path;
! 1656: #endif
! 1657: fname_len = spprintf(&fname, 0, "%s%c%s", test, DEFAULT_SLASH, intern->u.dir.entry.d_name);
! 1658: php_stat(fname, fname_len, FS_IS_DIR, &dummy TSRMLS_CC);
! 1659:
! 1660: if (Z_BVAL(dummy)) {
! 1661: /* ignore directories */
! 1662: efree(fname);
! 1663: return ZEND_HASH_APPLY_KEEP;
! 1664: }
! 1665:
! 1666: test = expand_filepath(fname, NULL TSRMLS_CC);
! 1667: efree(fname);
! 1668:
! 1669: if (test) {
! 1670: fname = test;
! 1671: fname_len = strlen(fname);
! 1672: } else {
! 1673: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Could not resolve file path");
! 1674: return ZEND_HASH_APPLY_STOP;
! 1675: }
! 1676:
! 1677: save = fname;
! 1678: goto phar_spl_fileinfo;
! 1679: case SPL_FS_INFO:
! 1680: case SPL_FS_FILE:
! 1681: #if PHP_VERSION_ID >= 60000
! 1682: if (intern->file_name_type == IS_UNICODE) {
! 1683: zval zv;
! 1684:
! 1685: INIT_ZVAL(zv);
! 1686: Z_UNIVAL(zv) = intern->file_name;
! 1687: Z_UNILEN(zv) = intern->file_name_len;
! 1688: Z_TYPE(zv) = IS_UNICODE;
! 1689:
! 1690: zval_copy_ctor(&zv);
! 1691: zval_unicode_to_string(&zv TSRMLS_CC);
! 1692: fname = expand_filepath(Z_STRVAL(zv), NULL TSRMLS_CC);
! 1693: ezfree(Z_UNIVAL(zv));
! 1694: } else {
! 1695: fname = expand_filepath(intern->file_name.s, NULL TSRMLS_CC);
! 1696: }
! 1697: #else
! 1698: fname = expand_filepath(intern->file_name, NULL TSRMLS_CC);
! 1699: #endif
! 1700: if (!fname) {
! 1701: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Could not resolve file path");
! 1702: return ZEND_HASH_APPLY_STOP;
! 1703: }
! 1704:
! 1705: fname_len = strlen(fname);
! 1706: save = fname;
! 1707: goto phar_spl_fileinfo;
! 1708: }
! 1709: }
! 1710: /* fall-through */
! 1711: default:
! 1712: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned an invalid value (must return a string)", ce->name);
! 1713: return ZEND_HASH_APPLY_STOP;
! 1714: }
! 1715:
! 1716: fname = Z_STRVAL_PP(value);
! 1717: fname_len = Z_STRLEN_PP(value);
! 1718:
! 1719: phar_spl_fileinfo:
! 1720: if (base_len) {
! 1721: temp = expand_filepath(base, NULL TSRMLS_CC);
! 1722: if (!temp) {
! 1723: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Could not resolve file path");
! 1724: if (save) {
! 1725: efree(save);
! 1726: }
! 1727: return ZEND_HASH_APPLY_STOP;
! 1728: }
! 1729:
! 1730: base = temp;
! 1731: base_len = strlen(base);
! 1732:
! 1733: if (strstr(fname, base)) {
! 1734: str_key_len = fname_len - base_len;
! 1735:
! 1736: if (str_key_len <= 0) {
! 1737: if (save) {
! 1738: efree(save);
! 1739: efree(temp);
! 1740: }
! 1741: return ZEND_HASH_APPLY_KEEP;
! 1742: }
! 1743:
! 1744: str_key = fname + base_len;
! 1745:
! 1746: if (*str_key == '/' || *str_key == '\\') {
! 1747: str_key++;
! 1748: str_key_len--;
! 1749: }
! 1750:
! 1751: } else {
! 1752: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned a path \"%s\" that is not in the base directory \"%s\"", ce->name, fname, base);
! 1753:
! 1754: if (save) {
! 1755: efree(save);
! 1756: efree(temp);
! 1757: }
! 1758:
! 1759: return ZEND_HASH_APPLY_STOP;
! 1760: }
! 1761: } else {
! 1762: if (iter->funcs->get_current_key) {
! 1763: key_type = iter->funcs->get_current_key(iter, &key, &str_key_len, &int_key TSRMLS_CC);
! 1764:
! 1765: if (EG(exception)) {
! 1766: return ZEND_HASH_APPLY_STOP;
! 1767: }
! 1768:
! 1769: if (key_type == HASH_KEY_IS_LONG) {
! 1770: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned an invalid key (must return a string)", ce->name);
! 1771: return ZEND_HASH_APPLY_STOP;
! 1772: }
! 1773:
! 1774: if (key_type > 9) { /* IS_UNICODE == 10 */
! 1775: #if PHP_VERSION_ID < 60000
! 1776: /* this can never happen, but fixes a compile warning */
! 1777: spprintf(&str_key, 0, "%s", key);
! 1778: #else
! 1779: spprintf(&str_key, 0, "%v", key);
! 1780: ezfree(key);
! 1781: #endif
! 1782: } else {
! 1783: PHAR_STR(key, str_key);
! 1784: }
! 1785:
! 1786: save = str_key;
! 1787:
! 1788: if (str_key[str_key_len - 1] == '\0') str_key_len--;
! 1789: } else {
! 1790: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned an invalid key (must return a string)", ce->name);
! 1791: return ZEND_HASH_APPLY_STOP;
! 1792: }
! 1793: }
! 1794: #if PHP_API_VERSION < 20100412
! 1795: if (PG(safe_mode) && (!php_checkuid(fname, NULL, CHECKUID_ALLOW_ONLY_FILE))) {
! 1796: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned a path \"%s\" that safe mode prevents opening", ce->name, fname);
! 1797:
! 1798: if (save) {
! 1799: efree(save);
! 1800: }
! 1801:
! 1802: if (temp) {
! 1803: efree(temp);
! 1804: }
! 1805:
! 1806: return ZEND_HASH_APPLY_STOP;
! 1807: }
! 1808: #endif
! 1809:
! 1810: if (php_check_open_basedir(fname TSRMLS_CC)) {
! 1811: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned a path \"%s\" that open_basedir prevents opening", ce->name, fname);
! 1812:
! 1813: if (save) {
! 1814: efree(save);
! 1815: }
! 1816:
! 1817: if (temp) {
! 1818: efree(temp);
! 1819: }
! 1820:
! 1821: return ZEND_HASH_APPLY_STOP;
! 1822: }
! 1823:
! 1824: /* try to open source file, then create internal phar file and copy contents */
! 1825: fp = php_stream_open_wrapper(fname, "rb", STREAM_MUST_SEEK|0, &opened);
! 1826:
! 1827: if (!fp) {
! 1828: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Iterator %v returned a file that could not be opened \"%s\"", ce->name, fname);
! 1829:
! 1830: if (save) {
! 1831: efree(save);
! 1832: }
! 1833:
! 1834: if (temp) {
! 1835: efree(temp);
! 1836: }
! 1837:
! 1838: return ZEND_HASH_APPLY_STOP;
! 1839: }
! 1840: after_open_fp:
! 1841: if (str_key_len >= sizeof(".phar")-1 && !memcmp(str_key, ".phar", sizeof(".phar")-1)) {
! 1842: /* silently skip any files that would be added to the magic .phar directory */
! 1843: if (save) {
! 1844: efree(save);
! 1845: }
! 1846:
! 1847: if (temp) {
! 1848: efree(temp);
! 1849: }
! 1850:
! 1851: if (opened) {
! 1852: efree(opened);
! 1853: }
! 1854:
! 1855: if (close_fp) {
! 1856: php_stream_close(fp);
! 1857: }
! 1858:
! 1859: return ZEND_HASH_APPLY_KEEP;
! 1860: }
! 1861:
! 1862: if (!(data = phar_get_or_create_entry_data(phar_obj->arc.archive->fname, phar_obj->arc.archive->fname_len, str_key, str_key_len, "w+b", 0, &error, 1 TSRMLS_CC))) {
! 1863: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s cannot be created: %s", str_key, error);
! 1864: efree(error);
! 1865:
! 1866: if (save) {
! 1867: efree(save);
! 1868: }
! 1869:
! 1870: if (opened) {
! 1871: efree(opened);
! 1872: }
! 1873:
! 1874: if (temp) {
! 1875: efree(temp);
! 1876: }
! 1877:
! 1878: if (close_fp) {
! 1879: php_stream_close(fp);
! 1880: }
! 1881:
! 1882: return ZEND_HASH_APPLY_STOP;
! 1883:
! 1884: } else {
! 1885: if (error) {
! 1886: efree(error);
! 1887: }
! 1888: /* convert to PHAR_UFP */
! 1889: if (data->internal_file->fp_type == PHAR_MOD) {
! 1890: php_stream_close(data->internal_file->fp);
! 1891: }
! 1892:
! 1893: data->internal_file->fp = NULL;
! 1894: data->internal_file->fp_type = PHAR_UFP;
! 1895: data->internal_file->offset_abs = data->internal_file->offset = php_stream_tell(p_obj->fp);
! 1896: data->fp = NULL;
! 1897: phar_stream_copy_to_stream(fp, p_obj->fp, PHP_STREAM_COPY_ALL, &contents_len);
! 1898: data->internal_file->uncompressed_filesize = data->internal_file->compressed_filesize =
! 1899: php_stream_tell(p_obj->fp) - data->internal_file->offset;
! 1900: }
! 1901:
! 1902: if (close_fp) {
! 1903: php_stream_close(fp);
! 1904: }
! 1905:
! 1906: add_assoc_string(p_obj->ret, str_key, opened, 0);
! 1907:
! 1908: if (save) {
! 1909: efree(save);
! 1910: }
! 1911:
! 1912: if (temp) {
! 1913: efree(temp);
! 1914: }
! 1915:
! 1916: data->internal_file->compressed_filesize = data->internal_file->uncompressed_filesize = contents_len;
! 1917: phar_entry_delref(data TSRMLS_CC);
! 1918:
! 1919: return ZEND_HASH_APPLY_KEEP;
! 1920: }
! 1921: /* }}} */
! 1922:
! 1923: /* {{{ proto array Phar::buildFromDirectory(string base_dir[, string regex])
! 1924: * Construct a phar archive from an existing directory, recursively.
! 1925: * Optional second parameter is a regular expression for filtering directory contents.
! 1926: *
! 1927: * Return value is an array mapping phar index to actual files added.
! 1928: */
! 1929: PHP_METHOD(Phar, buildFromDirectory)
! 1930: {
! 1931: char *dir, *error, *regex = NULL;
! 1932: int dir_len, regex_len = 0;
! 1933: zend_bool apply_reg = 0;
! 1934: zval arg, arg2, *iter, *iteriter, *regexiter = NULL;
! 1935: struct _phar_t pass;
! 1936:
! 1937: PHAR_ARCHIVE_OBJECT();
! 1938:
! 1939: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 1940: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 1941: "Cannot write to archive - write operations restricted by INI setting");
! 1942: return;
! 1943: }
! 1944:
! 1945: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &dir, &dir_len, ®ex, ®ex_len) == FAILURE) {
! 1946: RETURN_FALSE;
! 1947: }
! 1948:
! 1949: MAKE_STD_ZVAL(iter);
! 1950:
! 1951: if (SUCCESS != object_init_ex(iter, spl_ce_RecursiveDirectoryIterator)) {
! 1952: zval_ptr_dtor(&iter);
! 1953: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate directory iterator for %s", phar_obj->arc.archive->fname);
! 1954: RETURN_FALSE;
! 1955: }
! 1956:
! 1957: INIT_PZVAL(&arg);
! 1958: ZVAL_STRINGL(&arg, dir, dir_len, 0);
! 1959: INIT_PZVAL(&arg2);
! 1960: #if PHP_VERSION_ID < 50300
! 1961: ZVAL_LONG(&arg2, 0);
! 1962: #else
! 1963: ZVAL_LONG(&arg2, SPL_FILE_DIR_SKIPDOTS|SPL_FILE_DIR_UNIXPATHS);
! 1964: #endif
! 1965:
! 1966: zend_call_method_with_2_params(&iter, spl_ce_RecursiveDirectoryIterator,
! 1967: &spl_ce_RecursiveDirectoryIterator->constructor, "__construct", NULL, &arg, &arg2);
! 1968:
! 1969: if (EG(exception)) {
! 1970: zval_ptr_dtor(&iter);
! 1971: RETURN_FALSE;
! 1972: }
! 1973:
! 1974: MAKE_STD_ZVAL(iteriter);
! 1975:
! 1976: if (SUCCESS != object_init_ex(iteriter, spl_ce_RecursiveIteratorIterator)) {
! 1977: zval_ptr_dtor(&iter);
! 1978: zval_ptr_dtor(&iteriter);
! 1979: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate directory iterator for %s", phar_obj->arc.archive->fname);
! 1980: RETURN_FALSE;
! 1981: }
! 1982:
! 1983: zend_call_method_with_1_params(&iteriter, spl_ce_RecursiveIteratorIterator,
! 1984: &spl_ce_RecursiveIteratorIterator->constructor, "__construct", NULL, iter);
! 1985:
! 1986: if (EG(exception)) {
! 1987: zval_ptr_dtor(&iter);
! 1988: zval_ptr_dtor(&iteriter);
! 1989: RETURN_FALSE;
! 1990: }
! 1991:
! 1992: zval_ptr_dtor(&iter);
! 1993:
! 1994: if (regex_len > 0) {
! 1995: apply_reg = 1;
! 1996: MAKE_STD_ZVAL(regexiter);
! 1997:
! 1998: if (SUCCESS != object_init_ex(regexiter, spl_ce_RegexIterator)) {
! 1999: zval_ptr_dtor(&iteriter);
! 2000: zval_dtor(regexiter);
! 2001: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate regex iterator for %s", phar_obj->arc.archive->fname);
! 2002: RETURN_FALSE;
! 2003: }
! 2004:
! 2005: INIT_PZVAL(&arg2);
! 2006: ZVAL_STRINGL(&arg2, regex, regex_len, 0);
! 2007:
! 2008: zend_call_method_with_2_params(®exiter, spl_ce_RegexIterator,
! 2009: &spl_ce_RegexIterator->constructor, "__construct", NULL, iteriter, &arg2);
! 2010: }
! 2011:
! 2012: array_init(return_value);
! 2013:
! 2014: pass.c = apply_reg ? Z_OBJCE_P(regexiter) : Z_OBJCE_P(iteriter);
! 2015: pass.p = phar_obj;
! 2016: pass.b = dir;
! 2017: pass.l = dir_len;
! 2018: pass.count = 0;
! 2019: pass.ret = return_value;
! 2020: pass.fp = php_stream_fopen_tmpfile();
! 2021:
! 2022: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 2023: zval_ptr_dtor(&iteriter);
! 2024: if (apply_reg) {
! 2025: zval_ptr_dtor(®exiter);
! 2026: }
! 2027: php_stream_close(pass.fp);
! 2028: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 2029: return;
! 2030: }
! 2031:
! 2032: if (SUCCESS == spl_iterator_apply((apply_reg ? regexiter : iteriter), (spl_iterator_apply_func_t) phar_build, (void *) &pass TSRMLS_CC)) {
! 2033: zval_ptr_dtor(&iteriter);
! 2034:
! 2035: if (apply_reg) {
! 2036: zval_ptr_dtor(®exiter);
! 2037: }
! 2038:
! 2039: phar_obj->arc.archive->ufp = pass.fp;
! 2040: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 2041:
! 2042: if (error) {
! 2043: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 2044: efree(error);
! 2045: }
! 2046:
! 2047: } else {
! 2048: zval_ptr_dtor(&iteriter);
! 2049: if (apply_reg) {
! 2050: zval_ptr_dtor(®exiter);
! 2051: }
! 2052: php_stream_close(pass.fp);
! 2053: }
! 2054: }
! 2055: /* }}} */
! 2056:
! 2057: /* {{{ proto array Phar::buildFromIterator(Iterator iter[, string base_directory])
! 2058: * Construct a phar archive from an iterator. The iterator must return a series of strings
! 2059: * that are full paths to files that should be added to the phar. The iterator key should
! 2060: * be the path that the file will have within the phar archive.
! 2061: *
! 2062: * If base directory is specified, then the key will be ignored, and instead the portion of
! 2063: * the current value minus the base directory will be used
! 2064: *
! 2065: * Returned is an array mapping phar index to actual file added
! 2066: */
! 2067: PHP_METHOD(Phar, buildFromIterator)
! 2068: {
! 2069: zval *obj;
! 2070: char *error;
! 2071: uint base_len = 0;
! 2072: char *base = NULL;
! 2073: struct _phar_t pass;
! 2074:
! 2075: PHAR_ARCHIVE_OBJECT();
! 2076:
! 2077: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 2078: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2079: "Cannot write out phar archive, phar is read-only");
! 2080: return;
! 2081: }
! 2082:
! 2083: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|s", &obj, zend_ce_traversable, &base, &base_len) == FAILURE) {
! 2084: RETURN_FALSE;
! 2085: }
! 2086:
! 2087: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 2088: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 2089: return;
! 2090: }
! 2091:
! 2092: array_init(return_value);
! 2093:
! 2094: pass.c = Z_OBJCE_P(obj);
! 2095: pass.p = phar_obj;
! 2096: pass.b = base;
! 2097: pass.l = base_len;
! 2098: pass.ret = return_value;
! 2099: pass.count = 0;
! 2100: pass.fp = php_stream_fopen_tmpfile();
! 2101:
! 2102: if (SUCCESS == spl_iterator_apply(obj, (spl_iterator_apply_func_t) phar_build, (void *) &pass TSRMLS_CC)) {
! 2103: phar_obj->arc.archive->ufp = pass.fp;
! 2104: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 2105: if (error) {
! 2106: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 2107: efree(error);
! 2108: }
! 2109: } else {
! 2110: php_stream_close(pass.fp);
! 2111: }
! 2112: }
! 2113: /* }}} */
! 2114:
! 2115: /* {{{ proto int Phar::count()
! 2116: * Returns the number of entries in the Phar archive
! 2117: */
! 2118: PHP_METHOD(Phar, count)
! 2119: {
! 2120: PHAR_ARCHIVE_OBJECT();
! 2121:
! 2122: if (zend_parse_parameters_none() == FAILURE) {
! 2123: return;
! 2124: }
! 2125:
! 2126: RETURN_LONG(zend_hash_num_elements(&phar_obj->arc.archive->manifest));
! 2127: }
! 2128: /* }}} */
! 2129:
! 2130: /* {{{ proto bool Phar::isFileFormat(int format)
! 2131: * Returns true if the phar archive is based on the tar/zip/phar file format depending
! 2132: * on whether Phar::TAR, Phar::ZIP or Phar::PHAR was passed in
! 2133: */
! 2134: PHP_METHOD(Phar, isFileFormat)
! 2135: {
! 2136: long type;
! 2137: PHAR_ARCHIVE_OBJECT();
! 2138:
! 2139: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type) == FAILURE) {
! 2140: RETURN_FALSE;
! 2141: }
! 2142:
! 2143: switch (type) {
! 2144: case PHAR_FORMAT_TAR:
! 2145: RETURN_BOOL(phar_obj->arc.archive->is_tar);
! 2146: case PHAR_FORMAT_ZIP:
! 2147: RETURN_BOOL(phar_obj->arc.archive->is_zip);
! 2148: case PHAR_FORMAT_PHAR:
! 2149: RETURN_BOOL(!phar_obj->arc.archive->is_tar && !phar_obj->arc.archive->is_zip);
! 2150: default:
! 2151: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Unknown file format specified");
! 2152: }
! 2153: }
! 2154: /* }}} */
! 2155:
! 2156: static int phar_copy_file_contents(phar_entry_info *entry, php_stream *fp TSRMLS_DC) /* {{{ */
! 2157: {
! 2158: char *error;
! 2159: off_t offset;
! 2160: phar_entry_info *link;
! 2161:
! 2162: if (FAILURE == phar_open_entry_fp(entry, &error, 1 TSRMLS_CC)) {
! 2163: if (error) {
! 2164: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2165: "Cannot convert phar archive \"%s\", unable to open entry \"%s\" contents: %s", entry->phar->fname, entry->filename, error);
! 2166: efree(error);
! 2167: } else {
! 2168: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2169: "Cannot convert phar archive \"%s\", unable to open entry \"%s\" contents", entry->phar->fname, entry->filename);
! 2170: }
! 2171: return FAILURE;
! 2172: }
! 2173:
! 2174: /* copy old contents in entirety */
! 2175: phar_seek_efp(entry, 0, SEEK_SET, 0, 1 TSRMLS_CC);
! 2176: offset = php_stream_tell(fp);
! 2177: link = phar_get_link_source(entry TSRMLS_CC);
! 2178:
! 2179: if (!link) {
! 2180: link = entry;
! 2181: }
! 2182:
! 2183: if (SUCCESS != phar_stream_copy_to_stream(phar_get_efp(link, 0 TSRMLS_CC), fp, link->uncompressed_filesize, NULL)) {
! 2184: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2185: "Cannot convert phar archive \"%s\", unable to copy entry \"%s\" contents", entry->phar->fname, entry->filename);
! 2186: return FAILURE;
! 2187: }
! 2188:
! 2189: if (entry->fp_type == PHAR_MOD) {
! 2190: /* save for potential restore on error */
! 2191: entry->cfp = entry->fp;
! 2192: entry->fp = NULL;
! 2193: }
! 2194:
! 2195: /* set new location of file contents */
! 2196: entry->fp_type = PHAR_FP;
! 2197: entry->offset = offset;
! 2198: return SUCCESS;
! 2199: }
! 2200: /* }}} */
! 2201:
! 2202: static zval *phar_rename_archive(phar_archive_data *phar, char *ext, zend_bool compress TSRMLS_DC) /* {{{ */
! 2203: {
! 2204: char *oldname = NULL, *oldpath = NULL;
! 2205: char *basename = NULL, *basepath = NULL;
! 2206: char *newname = NULL, *newpath = NULL;
! 2207: zval *ret, arg1;
! 2208: zend_class_entry *ce;
! 2209: char *error;
! 2210: const char *pcr_error;
! 2211: int ext_len = ext ? strlen(ext) : 0;
! 2212: int oldname_len;
! 2213: phar_archive_data **pphar = NULL;
! 2214: php_stream_statbuf ssb;
! 2215:
! 2216: if (!ext) {
! 2217: if (phar->is_zip) {
! 2218:
! 2219: if (phar->is_data) {
! 2220: ext = "zip";
! 2221: } else {
! 2222: ext = "phar.zip";
! 2223: }
! 2224:
! 2225: } else if (phar->is_tar) {
! 2226:
! 2227: switch (phar->flags) {
! 2228: case PHAR_FILE_COMPRESSED_GZ:
! 2229: if (phar->is_data) {
! 2230: ext = "tar.gz";
! 2231: } else {
! 2232: ext = "phar.tar.gz";
! 2233: }
! 2234: break;
! 2235: case PHAR_FILE_COMPRESSED_BZ2:
! 2236: if (phar->is_data) {
! 2237: ext = "tar.bz2";
! 2238: } else {
! 2239: ext = "phar.tar.bz2";
! 2240: }
! 2241: break;
! 2242: default:
! 2243: if (phar->is_data) {
! 2244: ext = "tar";
! 2245: } else {
! 2246: ext = "phar.tar";
! 2247: }
! 2248: }
! 2249: } else {
! 2250:
! 2251: switch (phar->flags) {
! 2252: case PHAR_FILE_COMPRESSED_GZ:
! 2253: ext = "phar.gz";
! 2254: break;
! 2255: case PHAR_FILE_COMPRESSED_BZ2:
! 2256: ext = "phar.bz2";
! 2257: break;
! 2258: default:
! 2259: ext = "phar";
! 2260: }
! 2261: }
! 2262: } else if (phar_path_check(&ext, &ext_len, &pcr_error) > pcr_is_ok) {
! 2263:
! 2264: if (phar->is_data) {
! 2265: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "data phar converted from \"%s\" has invalid extension %s", phar->fname, ext);
! 2266: } else {
! 2267: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "phar converted from \"%s\" has invalid extension %s", phar->fname, ext);
! 2268: }
! 2269: return NULL;
! 2270: }
! 2271:
! 2272: if (ext[0] == '.') {
! 2273: ++ext;
! 2274: }
! 2275:
! 2276: oldpath = estrndup(phar->fname, phar->fname_len);
! 2277: oldname = zend_memrchr(phar->fname, '/', phar->fname_len);
! 2278: ++oldname;
! 2279: oldname_len = strlen(oldname);
! 2280:
! 2281: basename = estrndup(oldname, oldname_len);
! 2282: spprintf(&newname, 0, "%s.%s", strtok(basename, "."), ext);
! 2283: efree(basename);
! 2284:
! 2285:
! 2286:
! 2287: basepath = estrndup(oldpath, (strlen(oldpath) - oldname_len));
! 2288: phar->fname_len = spprintf(&newpath, 0, "%s%s", basepath, newname);
! 2289: phar->fname = newpath;
! 2290: phar->ext = newpath + phar->fname_len - strlen(ext) - 1;
! 2291: efree(basepath);
! 2292: efree(newname);
! 2293:
! 2294: if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, newpath, phar->fname_len, (void **) &pphar)) {
! 2295: efree(oldpath);
! 2296: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to add newly converted phar \"%s\" to the list of phars, new phar name is in phar.cache_list", phar->fname);
! 2297: return NULL;
! 2298: }
! 2299:
! 2300: if (SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, (void **) &pphar)) {
! 2301: if ((*pphar)->fname_len == phar->fname_len && !memcmp((*pphar)->fname, phar->fname, phar->fname_len)) {
! 2302: if (!zend_hash_num_elements(&phar->manifest)) {
! 2303: (*pphar)->is_tar = phar->is_tar;
! 2304: (*pphar)->is_zip = phar->is_zip;
! 2305: (*pphar)->is_data = phar->is_data;
! 2306: (*pphar)->flags = phar->flags;
! 2307: (*pphar)->fp = phar->fp;
! 2308: phar->fp = NULL;
! 2309: phar_destroy_phar_data(phar TSRMLS_CC);
! 2310: phar = *pphar;
! 2311: phar->refcount++;
! 2312: newpath = oldpath;
! 2313: goto its_ok;
! 2314: }
! 2315: }
! 2316:
! 2317: efree(oldpath);
! 2318: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to add newly converted phar \"%s\" to the list of phars, a phar with that name already exists", phar->fname);
! 2319: return NULL;
! 2320: }
! 2321: its_ok:
! 2322: if (SUCCESS == php_stream_stat_path(newpath, &ssb)) {
! 2323: efree(oldpath);
! 2324: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "phar \"%s\" exists and must be unlinked prior to conversion", newpath);
! 2325: return NULL;
! 2326: }
! 2327: if (!phar->is_data) {
! 2328: if (SUCCESS != phar_detect_phar_fname_ext(newpath, phar->fname_len, (const char **) &(phar->ext), &(phar->ext_len), 1, 1, 1 TSRMLS_CC)) {
! 2329: efree(oldpath);
! 2330: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "phar \"%s\" has invalid extension %s", phar->fname, ext);
! 2331: return NULL;
! 2332: }
! 2333:
! 2334: if (phar->alias) {
! 2335: if (phar->is_temporary_alias) {
! 2336: phar->alias = NULL;
! 2337: phar->alias_len = 0;
! 2338: } else {
! 2339: phar->alias = estrndup(newpath, strlen(newpath));
! 2340: phar->alias_len = strlen(newpath);
! 2341: phar->is_temporary_alias = 1;
! 2342: zend_hash_update(&(PHAR_GLOBALS->phar_alias_map), newpath, phar->fname_len, (void*)&phar, sizeof(phar_archive_data*), NULL);
! 2343: }
! 2344: }
! 2345:
! 2346: } else {
! 2347:
! 2348: if (SUCCESS != phar_detect_phar_fname_ext(newpath, phar->fname_len, (const char **) &(phar->ext), &(phar->ext_len), 0, 1, 1 TSRMLS_CC)) {
! 2349: efree(oldpath);
! 2350: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "data phar \"%s\" has invalid extension %s", phar->fname, ext);
! 2351: return NULL;
! 2352: }
! 2353:
! 2354: phar->alias = NULL;
! 2355: phar->alias_len = 0;
! 2356: }
! 2357:
! 2358: if ((!pphar || phar == *pphar) && SUCCESS != zend_hash_update(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, (void*)&phar, sizeof(phar_archive_data*), NULL)) {
! 2359: efree(oldpath);
! 2360: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to add newly converted phar \"%s\" to the list of phars", phar->fname);
! 2361: return NULL;
! 2362: }
! 2363:
! 2364: phar_flush(phar, 0, 0, 1, &error TSRMLS_CC);
! 2365:
! 2366: if (error) {
! 2367: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s", error);
! 2368: efree(error);
! 2369: efree(oldpath);
! 2370: return NULL;
! 2371: }
! 2372:
! 2373: efree(oldpath);
! 2374:
! 2375: if (phar->is_data) {
! 2376: ce = phar_ce_data;
! 2377: } else {
! 2378: ce = phar_ce_archive;
! 2379: }
! 2380:
! 2381: MAKE_STD_ZVAL(ret);
! 2382:
! 2383: if (SUCCESS != object_init_ex(ret, ce)) {
! 2384: zval_dtor(ret);
! 2385: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Unable to instantiate phar object when converting archive \"%s\"", phar->fname);
! 2386: return NULL;
! 2387: }
! 2388:
! 2389: INIT_PZVAL(&arg1);
! 2390: ZVAL_STRINGL(&arg1, phar->fname, phar->fname_len, 0);
! 2391:
! 2392: zend_call_method_with_1_params(&ret, ce, &ce->constructor, "__construct", NULL, &arg1);
! 2393: return ret;
! 2394: }
! 2395: /* }}} */
! 2396:
! 2397: static zval *phar_convert_to_other(phar_archive_data *source, int convert, char *ext, php_uint32 flags TSRMLS_DC) /* {{{ */
! 2398: {
! 2399: phar_archive_data *phar;
! 2400: phar_entry_info *entry, newentry;
! 2401: zval *ret;
! 2402:
! 2403: /* invalidate phar cache */
! 2404: PHAR_G(last_phar) = NULL;
! 2405: PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
! 2406:
! 2407: phar = (phar_archive_data *) ecalloc(1, sizeof(phar_archive_data));
! 2408: /* set whole-archive compression and type from parameter */
! 2409: phar->flags = flags;
! 2410: phar->is_data = source->is_data;
! 2411:
! 2412: switch (convert) {
! 2413: case PHAR_FORMAT_TAR:
! 2414: phar->is_tar = 1;
! 2415: break;
! 2416: case PHAR_FORMAT_ZIP:
! 2417: phar->is_zip = 1;
! 2418: break;
! 2419: default:
! 2420: phar->is_data = 0;
! 2421: break;
! 2422: }
! 2423:
! 2424: zend_hash_init(&(phar->manifest), sizeof(phar_entry_info),
! 2425: zend_get_hash_value, destroy_phar_manifest_entry, 0);
! 2426: zend_hash_init(&phar->mounted_dirs, sizeof(char *),
! 2427: zend_get_hash_value, NULL, 0);
! 2428: zend_hash_init(&phar->virtual_dirs, sizeof(char *),
! 2429: zend_get_hash_value, NULL, 0);
! 2430:
! 2431: phar->fp = php_stream_fopen_tmpfile();
! 2432: phar->fname = source->fname;
! 2433: phar->fname_len = source->fname_len;
! 2434: phar->is_temporary_alias = source->is_temporary_alias;
! 2435: phar->alias = source->alias;
! 2436:
! 2437: if (source->metadata) {
! 2438: zval *t;
! 2439:
! 2440: t = source->metadata;
! 2441: ALLOC_ZVAL(phar->metadata);
! 2442: *phar->metadata = *t;
! 2443: zval_copy_ctor(phar->metadata);
! 2444: #if PHP_VERSION_ID < 50300
! 2445: phar->metadata->refcount = 1;
! 2446: #else
! 2447: Z_SET_REFCOUNT_P(phar->metadata, 1);
! 2448: #endif
! 2449:
! 2450: phar->metadata_len = 0;
! 2451: }
! 2452:
! 2453: /* first copy each file's uncompressed contents to a temporary file and set per-file flags */
! 2454: for (zend_hash_internal_pointer_reset(&source->manifest); SUCCESS == zend_hash_has_more_elements(&source->manifest); zend_hash_move_forward(&source->manifest)) {
! 2455:
! 2456: if (FAILURE == zend_hash_get_current_data(&source->manifest, (void **) &entry)) {
! 2457: zend_hash_destroy(&(phar->manifest));
! 2458: php_stream_close(phar->fp);
! 2459: efree(phar);
! 2460: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2461: "Cannot convert phar archive \"%s\"", source->fname);
! 2462: return NULL;
! 2463: }
! 2464:
! 2465: newentry = *entry;
! 2466:
! 2467: if (newentry.link) {
! 2468: newentry.link = estrdup(newentry.link);
! 2469: goto no_copy;
! 2470: }
! 2471:
! 2472: if (newentry.tmp) {
! 2473: newentry.tmp = estrdup(newentry.tmp);
! 2474: goto no_copy;
! 2475: }
! 2476:
! 2477: newentry.metadata_str.c = 0;
! 2478:
! 2479: if (FAILURE == phar_copy_file_contents(&newentry, phar->fp TSRMLS_CC)) {
! 2480: zend_hash_destroy(&(phar->manifest));
! 2481: php_stream_close(phar->fp);
! 2482: efree(phar);
! 2483: /* exception already thrown */
! 2484: return NULL;
! 2485: }
! 2486: no_copy:
! 2487: newentry.filename = estrndup(newentry.filename, newentry.filename_len);
! 2488:
! 2489: if (newentry.metadata) {
! 2490: zval *t;
! 2491:
! 2492: t = newentry.metadata;
! 2493: ALLOC_ZVAL(newentry.metadata);
! 2494: *newentry.metadata = *t;
! 2495: zval_copy_ctor(newentry.metadata);
! 2496: #if PHP_VERSION_ID < 50300
! 2497: newentry.metadata->refcount = 1;
! 2498: #else
! 2499: Z_SET_REFCOUNT_P(newentry.metadata, 1);
! 2500: #endif
! 2501:
! 2502: newentry.metadata_str.c = NULL;
! 2503: newentry.metadata_str.len = 0;
! 2504: }
! 2505:
! 2506: newentry.is_zip = phar->is_zip;
! 2507: newentry.is_tar = phar->is_tar;
! 2508:
! 2509: if (newentry.is_tar) {
! 2510: newentry.tar_type = (entry->is_dir ? TAR_DIR : TAR_FILE);
! 2511: }
! 2512:
! 2513: newentry.is_modified = 1;
! 2514: newentry.phar = phar;
! 2515: newentry.old_flags = newentry.flags & ~PHAR_ENT_COMPRESSION_MASK; /* remove compression from old_flags */
! 2516: phar_set_inode(&newentry TSRMLS_CC);
! 2517: zend_hash_add(&(phar->manifest), newentry.filename, newentry.filename_len, (void*)&newentry, sizeof(phar_entry_info), NULL);
! 2518: phar_add_virtual_dirs(phar, newentry.filename, newentry.filename_len TSRMLS_CC);
! 2519: }
! 2520:
! 2521: if ((ret = phar_rename_archive(phar, ext, 0 TSRMLS_CC))) {
! 2522: return ret;
! 2523: } else {
! 2524: zend_hash_destroy(&(phar->manifest));
! 2525: zend_hash_destroy(&(phar->mounted_dirs));
! 2526: zend_hash_destroy(&(phar->virtual_dirs));
! 2527: php_stream_close(phar->fp);
! 2528: efree(phar->fname);
! 2529: efree(phar);
! 2530: return NULL;
! 2531: }
! 2532: }
! 2533: /* }}} */
! 2534:
! 2535: /* {{{ proto object Phar::convertToExecutable([int format[, int compression [, string file_ext]]])
! 2536: * Convert a phar.tar or phar.zip archive to the phar file format. The
! 2537: * optional parameter allows the user to determine the new
! 2538: * filename extension (default is phar).
! 2539: */
! 2540: PHP_METHOD(Phar, convertToExecutable)
! 2541: {
! 2542: char *ext = NULL;
! 2543: int is_data, ext_len = 0;
! 2544: php_uint32 flags;
! 2545: zval *ret;
! 2546: /* a number that is not 0, 1 or 2 (Which is also Greg's birthday, so there) */
! 2547: long format = 9021976, method = 9021976;
! 2548: PHAR_ARCHIVE_OBJECT();
! 2549:
! 2550: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lls", &format, &method, &ext, &ext_len) == FAILURE) {
! 2551: return;
! 2552: }
! 2553:
! 2554: if (PHAR_G(readonly)) {
! 2555: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2556: "Cannot write out executable phar archive, phar is read-only");
! 2557: return;
! 2558: }
! 2559:
! 2560: switch (format) {
! 2561: case 9021976:
! 2562: case PHAR_FORMAT_SAME: /* null is converted to 0 */
! 2563: /* by default, use the existing format */
! 2564: if (phar_obj->arc.archive->is_tar) {
! 2565: format = PHAR_FORMAT_TAR;
! 2566: } else if (phar_obj->arc.archive->is_zip) {
! 2567: format = PHAR_FORMAT_ZIP;
! 2568: } else {
! 2569: format = PHAR_FORMAT_PHAR;
! 2570: }
! 2571: break;
! 2572: case PHAR_FORMAT_PHAR:
! 2573: case PHAR_FORMAT_TAR:
! 2574: case PHAR_FORMAT_ZIP:
! 2575: break;
! 2576: default:
! 2577: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2578: "Unknown file format specified, please pass one of Phar::PHAR, Phar::TAR or Phar::ZIP");
! 2579: return;
! 2580: }
! 2581:
! 2582: switch (method) {
! 2583: case 9021976:
! 2584: flags = phar_obj->arc.archive->flags & PHAR_FILE_COMPRESSION_MASK;
! 2585: break;
! 2586: case 0:
! 2587: flags = PHAR_FILE_COMPRESSED_NONE;
! 2588: break;
! 2589: case PHAR_ENT_COMPRESSED_GZ:
! 2590: if (format == PHAR_FORMAT_ZIP) {
! 2591: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2592: "Cannot compress entire archive with gzip, zip archives do not support whole-archive compression");
! 2593: return;
! 2594: }
! 2595:
! 2596: if (!PHAR_G(has_zlib)) {
! 2597: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2598: "Cannot compress entire archive with gzip, enable ext/zlib in php.ini");
! 2599: return;
! 2600: }
! 2601:
! 2602: flags = PHAR_FILE_COMPRESSED_GZ;
! 2603: break;
! 2604: case PHAR_ENT_COMPRESSED_BZ2:
! 2605: if (format == PHAR_FORMAT_ZIP) {
! 2606: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2607: "Cannot compress entire archive with bz2, zip archives do not support whole-archive compression");
! 2608: return;
! 2609: }
! 2610:
! 2611: if (!PHAR_G(has_bz2)) {
! 2612: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2613: "Cannot compress entire archive with bz2, enable ext/bz2 in php.ini");
! 2614: return;
! 2615: }
! 2616:
! 2617: flags = PHAR_FILE_COMPRESSED_BZ2;
! 2618: break;
! 2619: default:
! 2620: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2621: "Unknown compression specified, please pass one of Phar::GZ or Phar::BZ2");
! 2622: return;
! 2623: }
! 2624:
! 2625: is_data = phar_obj->arc.archive->is_data;
! 2626: phar_obj->arc.archive->is_data = 0;
! 2627: ret = phar_convert_to_other(phar_obj->arc.archive, format, ext, flags TSRMLS_CC);
! 2628: phar_obj->arc.archive->is_data = is_data;
! 2629:
! 2630: if (ret) {
! 2631: RETURN_ZVAL(ret, 1, 1);
! 2632: } else {
! 2633: RETURN_NULL();
! 2634: }
! 2635: }
! 2636: /* }}} */
! 2637:
! 2638: /* {{{ proto object Phar::convertToData([int format[, int compression [, string file_ext]]])
! 2639: * Convert an archive to a non-executable .tar or .zip.
! 2640: * The optional parameter allows the user to determine the new
! 2641: * filename extension (default is .zip or .tar).
! 2642: */
! 2643: PHP_METHOD(Phar, convertToData)
! 2644: {
! 2645: char *ext = NULL;
! 2646: int is_data, ext_len = 0;
! 2647: php_uint32 flags;
! 2648: zval *ret;
! 2649: /* a number that is not 0, 1 or 2 (Which is also Greg's birthday so there) */
! 2650: long format = 9021976, method = 9021976;
! 2651: PHAR_ARCHIVE_OBJECT();
! 2652:
! 2653: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lls", &format, &method, &ext, &ext_len) == FAILURE) {
! 2654: return;
! 2655: }
! 2656:
! 2657: switch (format) {
! 2658: case 9021976:
! 2659: case PHAR_FORMAT_SAME: /* null is converted to 0 */
! 2660: /* by default, use the existing format */
! 2661: if (phar_obj->arc.archive->is_tar) {
! 2662: format = PHAR_FORMAT_TAR;
! 2663: } else if (phar_obj->arc.archive->is_zip) {
! 2664: format = PHAR_FORMAT_ZIP;
! 2665: } else {
! 2666: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2667: "Cannot write out data phar archive, use Phar::TAR or Phar::ZIP");
! 2668: return;
! 2669: }
! 2670: break;
! 2671: case PHAR_FORMAT_PHAR:
! 2672: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2673: "Cannot write out data phar archive, use Phar::TAR or Phar::ZIP");
! 2674: return;
! 2675: case PHAR_FORMAT_TAR:
! 2676: case PHAR_FORMAT_ZIP:
! 2677: break;
! 2678: default:
! 2679: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2680: "Unknown file format specified, please pass one of Phar::TAR or Phar::ZIP");
! 2681: return;
! 2682: }
! 2683:
! 2684: switch (method) {
! 2685: case 9021976:
! 2686: flags = phar_obj->arc.archive->flags & PHAR_FILE_COMPRESSION_MASK;
! 2687: break;
! 2688: case 0:
! 2689: flags = PHAR_FILE_COMPRESSED_NONE;
! 2690: break;
! 2691: case PHAR_ENT_COMPRESSED_GZ:
! 2692: if (format == PHAR_FORMAT_ZIP) {
! 2693: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2694: "Cannot compress entire archive with gzip, zip archives do not support whole-archive compression");
! 2695: return;
! 2696: }
! 2697:
! 2698: if (!PHAR_G(has_zlib)) {
! 2699: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2700: "Cannot compress entire archive with gzip, enable ext/zlib in php.ini");
! 2701: return;
! 2702: }
! 2703:
! 2704: flags = PHAR_FILE_COMPRESSED_GZ;
! 2705: break;
! 2706: case PHAR_ENT_COMPRESSED_BZ2:
! 2707: if (format == PHAR_FORMAT_ZIP) {
! 2708: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2709: "Cannot compress entire archive with bz2, zip archives do not support whole-archive compression");
! 2710: return;
! 2711: }
! 2712:
! 2713: if (!PHAR_G(has_bz2)) {
! 2714: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2715: "Cannot compress entire archive with bz2, enable ext/bz2 in php.ini");
! 2716: return;
! 2717: }
! 2718:
! 2719: flags = PHAR_FILE_COMPRESSED_BZ2;
! 2720: break;
! 2721: default:
! 2722: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 2723: "Unknown compression specified, please pass one of Phar::GZ or Phar::BZ2");
! 2724: return;
! 2725: }
! 2726:
! 2727: is_data = phar_obj->arc.archive->is_data;
! 2728: phar_obj->arc.archive->is_data = 1;
! 2729: ret = phar_convert_to_other(phar_obj->arc.archive, format, ext, flags TSRMLS_CC);
! 2730: phar_obj->arc.archive->is_data = is_data;
! 2731:
! 2732: if (ret) {
! 2733: RETURN_ZVAL(ret, 1, 1);
! 2734: } else {
! 2735: RETURN_NULL();
! 2736: }
! 2737: }
! 2738: /* }}} */
! 2739:
! 2740: /* {{{ proto int|false Phar::isCompressed()
! 2741: * Returns Phar::GZ or PHAR::BZ2 if the entire archive is compressed
! 2742: * (.tar.gz/tar.bz2 and so on), or FALSE otherwise.
! 2743: */
! 2744: PHP_METHOD(Phar, isCompressed)
! 2745: {
! 2746: PHAR_ARCHIVE_OBJECT();
! 2747:
! 2748: if (zend_parse_parameters_none() == FAILURE) {
! 2749: return;
! 2750: }
! 2751:
! 2752: if (phar_obj->arc.archive->flags & PHAR_FILE_COMPRESSED_GZ) {
! 2753: RETURN_LONG(PHAR_ENT_COMPRESSED_GZ);
! 2754: }
! 2755:
! 2756: if (phar_obj->arc.archive->flags & PHAR_FILE_COMPRESSED_BZ2) {
! 2757: RETURN_LONG(PHAR_ENT_COMPRESSED_BZ2);
! 2758: }
! 2759:
! 2760: RETURN_FALSE;
! 2761: }
! 2762: /* }}} */
! 2763:
! 2764: /* {{{ proto bool Phar::isWritable()
! 2765: * Returns true if phar.readonly=0 or phar is a PharData AND the actual file is writable.
! 2766: */
! 2767: PHP_METHOD(Phar, isWritable)
! 2768: {
! 2769: php_stream_statbuf ssb;
! 2770: PHAR_ARCHIVE_OBJECT();
! 2771:
! 2772: if (zend_parse_parameters_none() == FAILURE) {
! 2773: return;
! 2774: }
! 2775:
! 2776: if (!phar_obj->arc.archive->is_writeable) {
! 2777: RETURN_FALSE;
! 2778: }
! 2779:
! 2780: if (SUCCESS != php_stream_stat_path(phar_obj->arc.archive->fname, &ssb)) {
! 2781: if (phar_obj->arc.archive->is_brandnew) {
! 2782: /* assume it works if the file doesn't exist yet */
! 2783: RETURN_TRUE;
! 2784: }
! 2785: RETURN_FALSE;
! 2786: }
! 2787:
! 2788: RETURN_BOOL((ssb.sb.st_mode & (S_IWOTH | S_IWGRP | S_IWUSR)) != 0);
! 2789: }
! 2790: /* }}} */
! 2791:
! 2792: /* {{{ proto bool Phar::delete(string entry)
! 2793: * Deletes a named file within the archive.
! 2794: */
! 2795: PHP_METHOD(Phar, delete)
! 2796: {
! 2797: char *fname;
! 2798: int fname_len;
! 2799: char *error;
! 2800: phar_entry_info *entry;
! 2801: PHAR_ARCHIVE_OBJECT();
! 2802:
! 2803: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 2804: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2805: "Cannot write out phar archive, phar is read-only");
! 2806: return;
! 2807: }
! 2808:
! 2809: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &fname, &fname_len) == FAILURE) {
! 2810: RETURN_FALSE;
! 2811: }
! 2812:
! 2813: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 2814: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 2815: return;
! 2816: }
! 2817: if (zend_hash_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) {
! 2818: if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void**)&entry)) {
! 2819: if (entry->is_deleted) {
! 2820: /* entry is deleted, but has not been flushed to disk yet */
! 2821: RETURN_TRUE;
! 2822: } else {
! 2823: entry->is_deleted = 1;
! 2824: entry->is_modified = 1;
! 2825: phar_obj->arc.archive->is_modified = 1;
! 2826: }
! 2827: }
! 2828: } else {
! 2829: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s does not exist and cannot be deleted", fname);
! 2830: RETURN_FALSE;
! 2831: }
! 2832:
! 2833: phar_flush(phar_obj->arc.archive, NULL, 0, 0, &error TSRMLS_CC);
! 2834: if (error) {
! 2835: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 2836: efree(error);
! 2837: }
! 2838:
! 2839: RETURN_TRUE;
! 2840: }
! 2841: /* }}} */
! 2842:
! 2843: /* {{{ proto int Phar::getAlias()
! 2844: * Returns the alias for the Phar or NULL.
! 2845: */
! 2846: PHP_METHOD(Phar, getAlias)
! 2847: {
! 2848: PHAR_ARCHIVE_OBJECT();
! 2849:
! 2850: if (zend_parse_parameters_none() == FAILURE) {
! 2851: return;
! 2852: }
! 2853:
! 2854: if (phar_obj->arc.archive->alias && phar_obj->arc.archive->alias != phar_obj->arc.archive->fname) {
! 2855: RETURN_STRINGL(phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len, 1);
! 2856: }
! 2857: }
! 2858: /* }}} */
! 2859:
! 2860: /* {{{ proto int Phar::getPath()
! 2861: * Returns the real path to the phar archive on disk
! 2862: */
! 2863: PHP_METHOD(Phar, getPath)
! 2864: {
! 2865: PHAR_ARCHIVE_OBJECT();
! 2866:
! 2867: if (zend_parse_parameters_none() == FAILURE) {
! 2868: return;
! 2869: }
! 2870:
! 2871: RETURN_STRINGL(phar_obj->arc.archive->fname, phar_obj->arc.archive->fname_len, 1);
! 2872: }
! 2873: /* }}} */
! 2874:
! 2875: /* {{{ proto bool Phar::setAlias(string alias)
! 2876: * Sets the alias for a Phar archive. The default value is the full path
! 2877: * to the archive.
! 2878: */
! 2879: PHP_METHOD(Phar, setAlias)
! 2880: {
! 2881: char *alias, *error, *oldalias;
! 2882: phar_archive_data **fd_ptr;
! 2883: int alias_len, oldalias_len, old_temp, readd = 0;
! 2884:
! 2885: PHAR_ARCHIVE_OBJECT();
! 2886:
! 2887: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 2888: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2889: "Cannot write out phar archive, phar is read-only");
! 2890: RETURN_FALSE;
! 2891: }
! 2892:
! 2893: /* invalidate phar cache */
! 2894: PHAR_G(last_phar) = NULL;
! 2895: PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
! 2896:
! 2897: if (phar_obj->arc.archive->is_data) {
! 2898: if (phar_obj->arc.archive->is_tar) {
! 2899: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2900: "A Phar alias cannot be set in a plain tar archive");
! 2901: } else {
! 2902: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2903: "A Phar alias cannot be set in a plain zip archive");
! 2904: }
! 2905: RETURN_FALSE;
! 2906: }
! 2907:
! 2908: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &alias, &alias_len) == SUCCESS) {
! 2909: if (alias_len == phar_obj->arc.archive->alias_len && memcmp(phar_obj->arc.archive->alias, alias, alias_len) == 0) {
! 2910: RETURN_TRUE;
! 2911: }
! 2912: if (alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void**)&fd_ptr)) {
! 2913: spprintf(&error, 0, "alias \"%s\" is already used for archive \"%s\" and cannot be used for other archives", alias, (*fd_ptr)->fname);
! 2914: if (SUCCESS == phar_free_alias(*fd_ptr, alias, alias_len TSRMLS_CC)) {
! 2915: efree(error);
! 2916: goto valid_alias;
! 2917: }
! 2918: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 2919: efree(error);
! 2920: RETURN_FALSE;
! 2921: }
! 2922: if (!phar_validate_alias(alias, alias_len)) {
! 2923: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 2924: "Invalid alias \"%s\" specified for phar \"%s\"", alias, phar_obj->arc.archive->fname);
! 2925: RETURN_FALSE;
! 2926: }
! 2927: valid_alias:
! 2928: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 2929: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 2930: return;
! 2931: }
! 2932: if (phar_obj->arc.archive->alias_len && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len, (void**)&fd_ptr)) {
! 2933: zend_hash_del(&(PHAR_GLOBALS->phar_alias_map), phar_obj->arc.archive->alias, phar_obj->arc.archive->alias_len);
! 2934: readd = 1;
! 2935: }
! 2936:
! 2937: oldalias = phar_obj->arc.archive->alias;
! 2938: oldalias_len = phar_obj->arc.archive->alias_len;
! 2939: old_temp = phar_obj->arc.archive->is_temporary_alias;
! 2940:
! 2941: if (alias_len) {
! 2942: phar_obj->arc.archive->alias = estrndup(alias, alias_len);
! 2943: } else {
! 2944: phar_obj->arc.archive->alias = NULL;
! 2945: }
! 2946:
! 2947: phar_obj->arc.archive->alias_len = alias_len;
! 2948: phar_obj->arc.archive->is_temporary_alias = 0;
! 2949: phar_flush(phar_obj->arc.archive, NULL, 0, 0, &error TSRMLS_CC);
! 2950:
! 2951: if (error) {
! 2952: phar_obj->arc.archive->alias = oldalias;
! 2953: phar_obj->arc.archive->alias_len = oldalias_len;
! 2954: phar_obj->arc.archive->is_temporary_alias = old_temp;
! 2955: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 2956: if (readd) {
! 2957: zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), oldalias, oldalias_len, (void*)&(phar_obj->arc.archive), sizeof(phar_archive_data*), NULL);
! 2958: }
! 2959: efree(error);
! 2960: RETURN_FALSE;
! 2961: }
! 2962:
! 2963: zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void*)&(phar_obj->arc.archive), sizeof(phar_archive_data*), NULL);
! 2964:
! 2965: if (oldalias) {
! 2966: efree(oldalias);
! 2967: }
! 2968:
! 2969: RETURN_TRUE;
! 2970: }
! 2971:
! 2972: RETURN_FALSE;
! 2973: }
! 2974: /* }}} */
! 2975:
! 2976: /* {{{ proto string Phar::getVersion()
! 2977: * Return version info of Phar archive
! 2978: */
! 2979: PHP_METHOD(Phar, getVersion)
! 2980: {
! 2981: PHAR_ARCHIVE_OBJECT();
! 2982:
! 2983: if (zend_parse_parameters_none() == FAILURE) {
! 2984: return;
! 2985: }
! 2986:
! 2987: RETURN_STRING(phar_obj->arc.archive->version, 1);
! 2988: }
! 2989: /* }}} */
! 2990:
! 2991: /* {{{ proto void Phar::startBuffering()
! 2992: * Do not flush a writeable phar (save its contents) until explicitly requested
! 2993: */
! 2994: PHP_METHOD(Phar, startBuffering)
! 2995: {
! 2996: PHAR_ARCHIVE_OBJECT();
! 2997:
! 2998: if (zend_parse_parameters_none() == FAILURE) {
! 2999: return;
! 3000: }
! 3001:
! 3002: phar_obj->arc.archive->donotflush = 1;
! 3003: }
! 3004: /* }}} */
! 3005:
! 3006: /* {{{ proto bool Phar::isBuffering()
! 3007: * Returns whether write operations are flushing to disk immediately.
! 3008: */
! 3009: PHP_METHOD(Phar, isBuffering)
! 3010: {
! 3011: PHAR_ARCHIVE_OBJECT();
! 3012:
! 3013: if (zend_parse_parameters_none() == FAILURE) {
! 3014: return;
! 3015: }
! 3016:
! 3017: RETURN_BOOL(phar_obj->arc.archive->donotflush);
! 3018: }
! 3019: /* }}} */
! 3020:
! 3021: /* {{{ proto bool Phar::stopBuffering()
! 3022: * Saves the contents of a modified archive to disk.
! 3023: */
! 3024: PHP_METHOD(Phar, stopBuffering)
! 3025: {
! 3026: char *error;
! 3027:
! 3028: PHAR_ARCHIVE_OBJECT();
! 3029:
! 3030: if (zend_parse_parameters_none() == FAILURE) {
! 3031: return;
! 3032: }
! 3033:
! 3034: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3035: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3036: "Cannot write out phar archive, phar is read-only");
! 3037: return;
! 3038: }
! 3039:
! 3040: phar_obj->arc.archive->donotflush = 0;
! 3041: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 3042:
! 3043: if (error) {
! 3044: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3045: efree(error);
! 3046: }
! 3047: }
! 3048: /* }}} */
! 3049:
! 3050: /* {{{ proto bool Phar::setStub(string|stream stub [, int len])
! 3051: * Change the stub in a phar, phar.tar or phar.zip archive to something other
! 3052: * than the default. The stub *must* end with a call to __HALT_COMPILER().
! 3053: */
! 3054: PHP_METHOD(Phar, setStub)
! 3055: {
! 3056: zval *zstub;
! 3057: char *stub, *error;
! 3058: int stub_len;
! 3059: long len = -1;
! 3060: php_stream *stream;
! 3061: PHAR_ARCHIVE_OBJECT();
! 3062:
! 3063: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3064: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3065: "Cannot change stub, phar is read-only");
! 3066: return;
! 3067: }
! 3068:
! 3069: if (phar_obj->arc.archive->is_data) {
! 3070: if (phar_obj->arc.archive->is_tar) {
! 3071: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3072: "A Phar stub cannot be set in a plain tar archive");
! 3073: } else {
! 3074: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3075: "A Phar stub cannot be set in a plain zip archive");
! 3076: }
! 3077: return;
! 3078: }
! 3079:
! 3080: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zstub, &len) == SUCCESS) {
! 3081: if ((php_stream_from_zval_no_verify(stream, &zstub)) != NULL) {
! 3082: if (len > 0) {
! 3083: len = -len;
! 3084: } else {
! 3085: len = -1;
! 3086: }
! 3087: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3088: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3089: return;
! 3090: }
! 3091: phar_flush(phar_obj->arc.archive, (char *) &zstub, len, 0, &error TSRMLS_CC);
! 3092: if (error) {
! 3093: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3094: efree(error);
! 3095: }
! 3096: RETURN_TRUE;
! 3097: } else {
! 3098: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3099: "Cannot change stub, unable to read from input stream");
! 3100: }
! 3101: } else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &stub, &stub_len) == SUCCESS) {
! 3102: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3103: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3104: return;
! 3105: }
! 3106: phar_flush(phar_obj->arc.archive, stub, stub_len, 0, &error TSRMLS_CC);
! 3107:
! 3108: if (error) {
! 3109: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3110: efree(error);
! 3111: }
! 3112:
! 3113: RETURN_TRUE;
! 3114: }
! 3115:
! 3116: RETURN_FALSE;
! 3117: }
! 3118: /* }}} */
! 3119:
! 3120: /* {{{ proto bool Phar::setDefaultStub([string index[, string webindex]])
! 3121: * In a pure phar archive, sets a stub that can be used to run the archive
! 3122: * regardless of whether the phar extension is available. The first parameter
! 3123: * is the CLI startup filename, which defaults to "index.php". The second
! 3124: * parameter is the web startup filename and also defaults to "index.php"
! 3125: * (falling back to CLI behaviour).
! 3126: * Both parameters are optional.
! 3127: * In a phar.zip or phar.tar archive, the default stub is used only to
! 3128: * identify the archive to the extension as a Phar object. This allows the
! 3129: * extension to treat phar.zip and phar.tar types as honorary phars. Since
! 3130: * files cannot be loaded via this kind of stub, no parameters are accepted
! 3131: * when the Phar object is zip- or tar-based.
! 3132: */
! 3133: PHP_METHOD(Phar, setDefaultStub)
! 3134: {
! 3135: char *index = NULL, *webindex = NULL, *error = NULL, *stub = NULL;
! 3136: int index_len = 0, webindex_len = 0, created_stub = 0;
! 3137: size_t stub_len = 0;
! 3138: PHAR_ARCHIVE_OBJECT();
! 3139:
! 3140: if (phar_obj->arc.archive->is_data) {
! 3141: if (phar_obj->arc.archive->is_tar) {
! 3142: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3143: "A Phar stub cannot be set in a plain tar archive");
! 3144: } else {
! 3145: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3146: "A Phar stub cannot be set in a plain zip archive");
! 3147: }
! 3148: return;
! 3149: }
! 3150:
! 3151: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s", &index, &index_len, &webindex, &webindex_len) == FAILURE) {
! 3152: RETURN_FALSE;
! 3153: }
! 3154:
! 3155: if (ZEND_NUM_ARGS() > 0 && (phar_obj->arc.archive->is_tar || phar_obj->arc.archive->is_zip)) {
! 3156: php_error_docref(NULL TSRMLS_CC, E_WARNING, "method accepts no arguments for a tar- or zip-based phar stub, %d given", ZEND_NUM_ARGS());
! 3157: RETURN_FALSE;
! 3158: }
! 3159:
! 3160: if (PHAR_G(readonly)) {
! 3161: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3162: "Cannot change stub: phar.readonly=1");
! 3163: RETURN_FALSE;
! 3164: }
! 3165:
! 3166: if (!phar_obj->arc.archive->is_tar && !phar_obj->arc.archive->is_zip) {
! 3167: stub = phar_create_default_stub(index, webindex, &stub_len, &error TSRMLS_CC);
! 3168:
! 3169: if (error) {
! 3170: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "%s", error);
! 3171: efree(error);
! 3172: if (stub) {
! 3173: efree(stub);
! 3174: }
! 3175: RETURN_FALSE;
! 3176: }
! 3177:
! 3178: created_stub = 1;
! 3179: }
! 3180:
! 3181: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3182: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3183: return;
! 3184: }
! 3185: phar_flush(phar_obj->arc.archive, stub, stub_len, 1, &error TSRMLS_CC);
! 3186:
! 3187: if (created_stub) {
! 3188: efree(stub);
! 3189: }
! 3190:
! 3191: if (error) {
! 3192: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3193: efree(error);
! 3194: RETURN_FALSE;
! 3195: }
! 3196:
! 3197: RETURN_TRUE;
! 3198: }
! 3199: /* }}} */
! 3200:
! 3201: /* {{{ proto array Phar::setSignatureAlgorithm(int sigtype[, string privatekey])
! 3202: * Sets the signature algorithm for a phar and applies it. The signature
! 3203: * algorithm must be one of Phar::MD5, Phar::SHA1, Phar::SHA256,
! 3204: * Phar::SHA512, or Phar::OPENSSL. Note that zip- based phar archives
! 3205: * cannot support signatures.
! 3206: */
! 3207: PHP_METHOD(Phar, setSignatureAlgorithm)
! 3208: {
! 3209: long algo;
! 3210: char *error, *key = NULL;
! 3211: int key_len = 0;
! 3212:
! 3213: PHAR_ARCHIVE_OBJECT();
! 3214:
! 3215: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3216: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3217: "Cannot set signature algorithm, phar is read-only");
! 3218: return;
! 3219: }
! 3220:
! 3221: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "l|s", &algo, &key, &key_len) != SUCCESS) {
! 3222: return;
! 3223: }
! 3224:
! 3225: switch (algo) {
! 3226: case PHAR_SIG_SHA256:
! 3227: case PHAR_SIG_SHA512:
! 3228: #ifndef PHAR_HASH_OK
! 3229: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3230: "SHA-256 and SHA-512 signatures are only supported if the hash extension is enabled and built non-shared");
! 3231: return;
! 3232: #endif
! 3233: case PHAR_SIG_MD5:
! 3234: case PHAR_SIG_SHA1:
! 3235: case PHAR_SIG_OPENSSL:
! 3236: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3237: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3238: return;
! 3239: }
! 3240: phar_obj->arc.archive->sig_flags = algo;
! 3241: phar_obj->arc.archive->is_modified = 1;
! 3242: PHAR_G(openssl_privatekey) = key;
! 3243: PHAR_G(openssl_privatekey_len) = key_len;
! 3244:
! 3245: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 3246: if (error) {
! 3247: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3248: efree(error);
! 3249: }
! 3250: break;
! 3251: default:
! 3252: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3253: "Unknown signature algorithm specified");
! 3254: }
! 3255: }
! 3256: /* }}} */
! 3257:
! 3258: /* {{{ proto array|false Phar::getSignature()
! 3259: * Returns a hash signature, or FALSE if the archive is unsigned.
! 3260: */
! 3261: PHP_METHOD(Phar, getSignature)
! 3262: {
! 3263: PHAR_ARCHIVE_OBJECT();
! 3264:
! 3265: if (zend_parse_parameters_none() == FAILURE) {
! 3266: return;
! 3267: }
! 3268:
! 3269: if (phar_obj->arc.archive->signature) {
! 3270: char *unknown;
! 3271: int unknown_len;
! 3272:
! 3273: array_init(return_value);
! 3274: add_assoc_stringl(return_value, "hash", phar_obj->arc.archive->signature, phar_obj->arc.archive->sig_len, 1);
! 3275: switch(phar_obj->arc.archive->sig_flags) {
! 3276: case PHAR_SIG_MD5:
! 3277: add_assoc_stringl(return_value, "hash_type", "MD5", 3, 1);
! 3278: break;
! 3279: case PHAR_SIG_SHA1:
! 3280: add_assoc_stringl(return_value, "hash_type", "SHA-1", 5, 1);
! 3281: break;
! 3282: case PHAR_SIG_SHA256:
! 3283: add_assoc_stringl(return_value, "hash_type", "SHA-256", 7, 1);
! 3284: break;
! 3285: case PHAR_SIG_SHA512:
! 3286: add_assoc_stringl(return_value, "hash_type", "SHA-512", 7, 1);
! 3287: break;
! 3288: case PHAR_SIG_OPENSSL:
! 3289: add_assoc_stringl(return_value, "hash_type", "OpenSSL", 7, 1);
! 3290: break;
! 3291: default:
! 3292: unknown_len = spprintf(&unknown, 0, "Unknown (%u)", phar_obj->arc.archive->sig_flags);
! 3293: add_assoc_stringl(return_value, "hash_type", unknown, unknown_len, 0);
! 3294: break;
! 3295: }
! 3296: } else {
! 3297: RETURN_FALSE;
! 3298: }
! 3299: }
! 3300: /* }}} */
! 3301:
! 3302: /* {{{ proto bool Phar::getModified()
! 3303: * Return whether phar was modified
! 3304: */
! 3305: PHP_METHOD(Phar, getModified)
! 3306: {
! 3307: PHAR_ARCHIVE_OBJECT();
! 3308:
! 3309: if (zend_parse_parameters_none() == FAILURE) {
! 3310: return;
! 3311: }
! 3312:
! 3313: RETURN_BOOL(phar_obj->arc.archive->is_modified);
! 3314: }
! 3315: /* }}} */
! 3316:
! 3317: static int phar_set_compression(void *pDest, void *argument TSRMLS_DC) /* {{{ */
! 3318: {
! 3319: phar_entry_info *entry = (phar_entry_info *)pDest;
! 3320: php_uint32 compress = *(php_uint32 *)argument;
! 3321:
! 3322: if (entry->is_deleted) {
! 3323: return ZEND_HASH_APPLY_KEEP;
! 3324: }
! 3325:
! 3326: entry->old_flags = entry->flags;
! 3327: entry->flags &= ~PHAR_ENT_COMPRESSION_MASK;
! 3328: entry->flags |= compress;
! 3329: entry->is_modified = 1;
! 3330: return ZEND_HASH_APPLY_KEEP;
! 3331: }
! 3332: /* }}} */
! 3333:
! 3334: static int phar_test_compression(void *pDest, void *argument TSRMLS_DC) /* {{{ */
! 3335: {
! 3336: phar_entry_info *entry = (phar_entry_info *)pDest;
! 3337:
! 3338: if (entry->is_deleted) {
! 3339: return ZEND_HASH_APPLY_KEEP;
! 3340: }
! 3341:
! 3342: if (!PHAR_G(has_bz2)) {
! 3343: if (entry->flags & PHAR_ENT_COMPRESSED_BZ2) {
! 3344: *(int *) argument = 0;
! 3345: }
! 3346: }
! 3347:
! 3348: if (!PHAR_G(has_zlib)) {
! 3349: if (entry->flags & PHAR_ENT_COMPRESSED_GZ) {
! 3350: *(int *) argument = 0;
! 3351: }
! 3352: }
! 3353:
! 3354: return ZEND_HASH_APPLY_KEEP;
! 3355: }
! 3356: /* }}} */
! 3357:
! 3358: static void pharobj_set_compression(HashTable *manifest, php_uint32 compress TSRMLS_DC) /* {{{ */
! 3359: {
! 3360: zend_hash_apply_with_argument(manifest, phar_set_compression, &compress TSRMLS_CC);
! 3361: }
! 3362: /* }}} */
! 3363:
! 3364: static int pharobj_cancompress(HashTable *manifest TSRMLS_DC) /* {{{ */
! 3365: {
! 3366: int test;
! 3367:
! 3368: test = 1;
! 3369: zend_hash_apply_with_argument(manifest, phar_test_compression, &test TSRMLS_CC);
! 3370: return test;
! 3371: }
! 3372: /* }}} */
! 3373:
! 3374: /* {{{ proto object Phar::compress(int method[, string extension])
! 3375: * Compress a .tar, or .phar.tar with whole-file compression
! 3376: * The parameter can be one of Phar::GZ or Phar::BZ2 to specify
! 3377: * the kind of compression desired
! 3378: */
! 3379: PHP_METHOD(Phar, compress)
! 3380: {
! 3381: long method;
! 3382: char *ext = NULL;
! 3383: int ext_len = 0;
! 3384: php_uint32 flags;
! 3385: zval *ret;
! 3386: PHAR_ARCHIVE_OBJECT();
! 3387:
! 3388: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|s", &method, &ext, &ext_len) == FAILURE) {
! 3389: return;
! 3390: }
! 3391:
! 3392: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3393: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3394: "Cannot compress phar archive, phar is read-only");
! 3395: return;
! 3396: }
! 3397:
! 3398: if (phar_obj->arc.archive->is_zip) {
! 3399: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3400: "Cannot compress zip-based archives with whole-archive compression");
! 3401: return;
! 3402: }
! 3403:
! 3404: switch (method) {
! 3405: case 0:
! 3406: flags = PHAR_FILE_COMPRESSED_NONE;
! 3407: break;
! 3408: case PHAR_ENT_COMPRESSED_GZ:
! 3409: if (!PHAR_G(has_zlib)) {
! 3410: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3411: "Cannot compress entire archive with gzip, enable ext/zlib in php.ini");
! 3412: return;
! 3413: }
! 3414: flags = PHAR_FILE_COMPRESSED_GZ;
! 3415: break;
! 3416:
! 3417: case PHAR_ENT_COMPRESSED_BZ2:
! 3418: if (!PHAR_G(has_bz2)) {
! 3419: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3420: "Cannot compress entire archive with bz2, enable ext/bz2 in php.ini");
! 3421: return;
! 3422: }
! 3423: flags = PHAR_FILE_COMPRESSED_BZ2;
! 3424: break;
! 3425: default:
! 3426: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3427: "Unknown compression specified, please pass one of Phar::GZ or Phar::BZ2");
! 3428: return;
! 3429: }
! 3430:
! 3431: if (phar_obj->arc.archive->is_tar) {
! 3432: ret = phar_convert_to_other(phar_obj->arc.archive, PHAR_FORMAT_TAR, ext, flags TSRMLS_CC);
! 3433: } else {
! 3434: ret = phar_convert_to_other(phar_obj->arc.archive, PHAR_FORMAT_PHAR, ext, flags TSRMLS_CC);
! 3435: }
! 3436:
! 3437: if (ret) {
! 3438: RETURN_ZVAL(ret, 1, 1);
! 3439: } else {
! 3440: RETURN_NULL();
! 3441: }
! 3442: }
! 3443: /* }}} */
! 3444:
! 3445: /* {{{ proto object Phar::decompress([string extension])
! 3446: * Decompress a .tar, or .phar.tar with whole-file compression
! 3447: */
! 3448: PHP_METHOD(Phar, decompress)
! 3449: {
! 3450: char *ext = NULL;
! 3451: int ext_len = 0;
! 3452: zval *ret;
! 3453: PHAR_ARCHIVE_OBJECT();
! 3454:
! 3455: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &ext, &ext_len) == FAILURE) {
! 3456: return;
! 3457: }
! 3458:
! 3459: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3460: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3461: "Cannot decompress phar archive, phar is read-only");
! 3462: return;
! 3463: }
! 3464:
! 3465: if (phar_obj->arc.archive->is_zip) {
! 3466: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3467: "Cannot decompress zip-based archives with whole-archive compression");
! 3468: return;
! 3469: }
! 3470:
! 3471: if (phar_obj->arc.archive->is_tar) {
! 3472: ret = phar_convert_to_other(phar_obj->arc.archive, PHAR_FORMAT_TAR, ext, PHAR_FILE_COMPRESSED_NONE TSRMLS_CC);
! 3473: } else {
! 3474: ret = phar_convert_to_other(phar_obj->arc.archive, PHAR_FORMAT_PHAR, ext, PHAR_FILE_COMPRESSED_NONE TSRMLS_CC);
! 3475: }
! 3476:
! 3477: if (ret) {
! 3478: RETURN_ZVAL(ret, 1, 1);
! 3479: } else {
! 3480: RETURN_NULL();
! 3481: }
! 3482: }
! 3483: /* }}} */
! 3484:
! 3485: /* {{{ proto object Phar::compressFiles(int method)
! 3486: * Compress all files within a phar or zip archive using the specified compression
! 3487: * The parameter can be one of Phar::GZ or Phar::BZ2 to specify
! 3488: * the kind of compression desired
! 3489: */
! 3490: PHP_METHOD(Phar, compressFiles)
! 3491: {
! 3492: char *error;
! 3493: php_uint32 flags;
! 3494: long method;
! 3495: PHAR_ARCHIVE_OBJECT();
! 3496:
! 3497: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &method) == FAILURE) {
! 3498: return;
! 3499: }
! 3500:
! 3501: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3502: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3503: "Phar is readonly, cannot change compression");
! 3504: return;
! 3505: }
! 3506:
! 3507: switch (method) {
! 3508: case PHAR_ENT_COMPRESSED_GZ:
! 3509: if (!PHAR_G(has_zlib)) {
! 3510: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3511: "Cannot compress files within archive with gzip, enable ext/zlib in php.ini");
! 3512: return;
! 3513: }
! 3514: flags = PHAR_ENT_COMPRESSED_GZ;
! 3515: break;
! 3516:
! 3517: case PHAR_ENT_COMPRESSED_BZ2:
! 3518: if (!PHAR_G(has_bz2)) {
! 3519: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3520: "Cannot compress files within archive with bz2, enable ext/bz2 in php.ini");
! 3521: return;
! 3522: }
! 3523: flags = PHAR_ENT_COMPRESSED_BZ2;
! 3524: break;
! 3525: default:
! 3526: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3527: "Unknown compression specified, please pass one of Phar::GZ or Phar::BZ2");
! 3528: return;
! 3529: }
! 3530:
! 3531: if (phar_obj->arc.archive->is_tar) {
! 3532: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3533: "Cannot compress with Gzip compression, tar archives cannot compress individual files, use compress() to compress the whole archive");
! 3534: return;
! 3535: }
! 3536:
! 3537: if (!pharobj_cancompress(&phar_obj->arc.archive->manifest TSRMLS_CC)) {
! 3538: if (flags == PHAR_FILE_COMPRESSED_GZ) {
! 3539: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3540: "Cannot compress all files as Gzip, some are compressed as bzip2 and cannot be decompressed");
! 3541: } else {
! 3542: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3543: "Cannot compress all files as Bzip2, some are compressed as gzip and cannot be decompressed");
! 3544: }
! 3545: return;
! 3546: }
! 3547:
! 3548: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3549: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3550: return;
! 3551: }
! 3552: pharobj_set_compression(&phar_obj->arc.archive->manifest, flags TSRMLS_CC);
! 3553: phar_obj->arc.archive->is_modified = 1;
! 3554: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 3555:
! 3556: if (error) {
! 3557: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s", error);
! 3558: efree(error);
! 3559: }
! 3560: }
! 3561: /* }}} */
! 3562:
! 3563: /* {{{ proto bool Phar::decompressFiles()
! 3564: * decompress every file
! 3565: */
! 3566: PHP_METHOD(Phar, decompressFiles)
! 3567: {
! 3568: char *error;
! 3569: PHAR_ARCHIVE_OBJECT();
! 3570:
! 3571: if (zend_parse_parameters_none() == FAILURE) {
! 3572: return;
! 3573: }
! 3574:
! 3575: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3576: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3577: "Phar is readonly, cannot change compression");
! 3578: return;
! 3579: }
! 3580:
! 3581: if (!pharobj_cancompress(&phar_obj->arc.archive->manifest TSRMLS_CC)) {
! 3582: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 3583: "Cannot decompress all files, some are compressed as bzip2 or gzip and cannot be decompressed");
! 3584: return;
! 3585: }
! 3586:
! 3587: if (phar_obj->arc.archive->is_tar) {
! 3588: RETURN_TRUE;
! 3589: } else {
! 3590: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3591: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3592: return;
! 3593: }
! 3594: pharobj_set_compression(&phar_obj->arc.archive->manifest, PHAR_ENT_COMPRESSED_NONE TSRMLS_CC);
! 3595: }
! 3596:
! 3597: phar_obj->arc.archive->is_modified = 1;
! 3598: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 3599:
! 3600: if (error) {
! 3601: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s", error);
! 3602: efree(error);
! 3603: }
! 3604:
! 3605: RETURN_TRUE;
! 3606: }
! 3607: /* }}} */
! 3608:
! 3609: /* {{{ proto bool Phar::copy(string oldfile, string newfile)
! 3610: * copy a file internal to the phar archive to another new file within the phar
! 3611: */
! 3612: PHP_METHOD(Phar, copy)
! 3613: {
! 3614: char *oldfile, *newfile, *error;
! 3615: const char *pcr_error;
! 3616: int oldfile_len, newfile_len;
! 3617: phar_entry_info *oldentry, newentry = {0}, *temp;
! 3618:
! 3619: PHAR_ARCHIVE_OBJECT();
! 3620:
! 3621: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &oldfile, &oldfile_len, &newfile, &newfile_len) == FAILURE) {
! 3622: return;
! 3623: }
! 3624:
! 3625: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3626: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3627: "Cannot copy \"%s\" to \"%s\", phar is read-only", oldfile, newfile);
! 3628: RETURN_FALSE;
! 3629: }
! 3630:
! 3631: if (oldfile_len >= sizeof(".phar")-1 && !memcmp(oldfile, ".phar", sizeof(".phar")-1)) {
! 3632: /* can't copy a meta file */
! 3633: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3634: "file \"%s\" cannot be copied to file \"%s\", cannot copy Phar meta-file in %s", oldfile, newfile, phar_obj->arc.archive->fname);
! 3635: RETURN_FALSE;
! 3636: }
! 3637:
! 3638: if (newfile_len >= sizeof(".phar")-1 && !memcmp(newfile, ".phar", sizeof(".phar")-1)) {
! 3639: /* can't copy a meta file */
! 3640: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3641: "file \"%s\" cannot be copied to file \"%s\", cannot copy to Phar meta-file in %s", oldfile, newfile, phar_obj->arc.archive->fname);
! 3642: RETURN_FALSE;
! 3643: }
! 3644:
! 3645: if (!zend_hash_exists(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len) || SUCCESS != zend_hash_find(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len, (void**)&oldentry) || oldentry->is_deleted) {
! 3646: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3647: "file \"%s\" cannot be copied to file \"%s\", file does not exist in %s", oldfile, newfile, phar_obj->arc.archive->fname);
! 3648: RETURN_FALSE;
! 3649: }
! 3650:
! 3651: if (zend_hash_exists(&phar_obj->arc.archive->manifest, newfile, (uint) newfile_len)) {
! 3652: if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, newfile, (uint) newfile_len, (void**)&temp) || !temp->is_deleted) {
! 3653: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3654: "file \"%s\" cannot be copied to file \"%s\", file must not already exist in phar %s", oldfile, newfile, phar_obj->arc.archive->fname);
! 3655: RETURN_FALSE;
! 3656: }
! 3657: }
! 3658:
! 3659: if (phar_path_check(&newfile, &newfile_len, &pcr_error) > pcr_is_ok) {
! 3660: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
! 3661: "file \"%s\" contains invalid characters %s, cannot be copied from \"%s\" in phar %s", newfile, pcr_error, oldfile, phar_obj->arc.archive->fname);
! 3662: RETURN_FALSE;
! 3663: }
! 3664:
! 3665: if (phar_obj->arc.archive->is_persistent) {
! 3666: if (FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3667: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3668: return;
! 3669: }
! 3670: /* re-populate with copied-on-write entry */
! 3671: zend_hash_find(&phar_obj->arc.archive->manifest, oldfile, (uint) oldfile_len, (void**)&oldentry);
! 3672: }
! 3673:
! 3674: memcpy((void *) &newentry, oldentry, sizeof(phar_entry_info));
! 3675:
! 3676: if (newentry.metadata) {
! 3677: zval *t;
! 3678:
! 3679: t = newentry.metadata;
! 3680: ALLOC_ZVAL(newentry.metadata);
! 3681: *newentry.metadata = *t;
! 3682: zval_copy_ctor(newentry.metadata);
! 3683: #if PHP_VERSION_ID < 50300
! 3684: newentry.metadata->refcount = 1;
! 3685: #else
! 3686: Z_SET_REFCOUNT_P(newentry.metadata, 1);
! 3687: #endif
! 3688:
! 3689: newentry.metadata_str.c = NULL;
! 3690: newentry.metadata_str.len = 0;
! 3691: }
! 3692:
! 3693: newentry.filename = estrndup(newfile, newfile_len);
! 3694: newentry.filename_len = newfile_len;
! 3695: newentry.fp_refcount = 0;
! 3696:
! 3697: if (oldentry->fp_type != PHAR_FP) {
! 3698: if (FAILURE == phar_copy_entry_fp(oldentry, &newentry, &error TSRMLS_CC)) {
! 3699: efree(newentry.filename);
! 3700: php_stream_close(newentry.fp);
! 3701: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3702: efree(error);
! 3703: return;
! 3704: }
! 3705: }
! 3706:
! 3707: zend_hash_add(&oldentry->phar->manifest, newfile, newfile_len, (void*)&newentry, sizeof(phar_entry_info), NULL);
! 3708: phar_obj->arc.archive->is_modified = 1;
! 3709: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 3710:
! 3711: if (error) {
! 3712: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3713: efree(error);
! 3714: }
! 3715:
! 3716: RETURN_TRUE;
! 3717: }
! 3718: /* }}} */
! 3719:
! 3720: /* {{{ proto int Phar::offsetExists(string entry)
! 3721: * determines whether a file exists in the phar
! 3722: */
! 3723: PHP_METHOD(Phar, offsetExists)
! 3724: {
! 3725: char *fname;
! 3726: int fname_len;
! 3727: phar_entry_info *entry;
! 3728:
! 3729: PHAR_ARCHIVE_OBJECT();
! 3730:
! 3731: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &fname, &fname_len) == FAILURE) {
! 3732: return;
! 3733: }
! 3734:
! 3735: if (zend_hash_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) {
! 3736: if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void**)&entry)) {
! 3737: if (entry->is_deleted) {
! 3738: /* entry is deleted, but has not been flushed to disk yet */
! 3739: RETURN_FALSE;
! 3740: }
! 3741: }
! 3742:
! 3743: if (fname_len >= sizeof(".phar")-1 && !memcmp(fname, ".phar", sizeof(".phar")-1)) {
! 3744: /* none of these are real files, so they don't exist */
! 3745: RETURN_FALSE;
! 3746: }
! 3747: RETURN_TRUE;
! 3748: } else {
! 3749: if (zend_hash_exists(&phar_obj->arc.archive->virtual_dirs, fname, (uint) fname_len)) {
! 3750: RETURN_TRUE;
! 3751: }
! 3752: RETURN_FALSE;
! 3753: }
! 3754: }
! 3755: /* }}} */
! 3756:
! 3757: /* {{{ proto int Phar::offsetGet(string entry)
! 3758: * get a PharFileInfo object for a specific file
! 3759: */
! 3760: PHP_METHOD(Phar, offsetGet)
! 3761: {
! 3762: char *fname, *error;
! 3763: int fname_len;
! 3764: zval *zfname;
! 3765: phar_entry_info *entry;
! 3766: PHAR_ARCHIVE_OBJECT();
! 3767:
! 3768: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &fname, &fname_len) == FAILURE) {
! 3769: return;
! 3770: }
! 3771:
! 3772: /* security is 0 here so that we can get a better error message than "entry doesn't exist" */
! 3773: if (!(entry = phar_get_entry_info_dir(phar_obj->arc.archive, fname, fname_len, 1, &error, 0 TSRMLS_CC))) {
! 3774: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s does not exist%s%s", fname, error?", ":"", error?error:"");
! 3775: } else {
! 3776: if (fname_len == sizeof(".phar/stub.php")-1 && !memcmp(fname, ".phar/stub.php", sizeof(".phar/stub.php")-1)) {
! 3777: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot get stub \".phar/stub.php\" directly in phar \"%s\", use getStub", phar_obj->arc.archive->fname);
! 3778: return;
! 3779: }
! 3780:
! 3781: if (fname_len == sizeof(".phar/alias.txt")-1 && !memcmp(fname, ".phar/alias.txt", sizeof(".phar/alias.txt")-1)) {
! 3782: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot get alias \".phar/alias.txt\" directly in phar \"%s\", use getAlias", phar_obj->arc.archive->fname);
! 3783: return;
! 3784: }
! 3785:
! 3786: if (fname_len >= sizeof(".phar")-1 && !memcmp(fname, ".phar", sizeof(".phar")-1)) {
! 3787: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot directly get any files or directories in magic \".phar\" directory", phar_obj->arc.archive->fname);
! 3788: return;
! 3789: }
! 3790:
! 3791: if (entry->is_temp_dir) {
! 3792: efree(entry->filename);
! 3793: efree(entry);
! 3794: }
! 3795:
! 3796: fname_len = spprintf(&fname, 0, "phar://%s/%s", phar_obj->arc.archive->fname, fname);
! 3797: MAKE_STD_ZVAL(zfname);
! 3798: ZVAL_STRINGL(zfname, fname, fname_len, 0);
! 3799: spl_instantiate_arg_ex1(phar_obj->spl.info_class, &return_value, 0, zfname TSRMLS_CC);
! 3800: zval_ptr_dtor(&zfname);
! 3801: }
! 3802: }
! 3803: /* }}} */
! 3804:
! 3805: /* {{{ add a file within the phar archive from a string or resource
! 3806: */
! 3807: static void phar_add_file(phar_archive_data **pphar, char *filename, int filename_len, char *cont_str, int cont_len, zval *zresource TSRMLS_DC)
! 3808: {
! 3809: char *error;
! 3810: size_t contents_len;
! 3811: phar_entry_data *data;
! 3812: php_stream *contents_file;
! 3813:
! 3814: if (filename_len >= sizeof(".phar")-1 && !memcmp(filename, ".phar", sizeof(".phar")-1)) {
! 3815: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot create any files in magic \".phar\" directory", (*pphar)->fname);
! 3816: return;
! 3817: }
! 3818:
! 3819: if (!(data = phar_get_or_create_entry_data((*pphar)->fname, (*pphar)->fname_len, filename, filename_len, "w+b", 0, &error, 1 TSRMLS_CC))) {
! 3820: if (error) {
! 3821: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s does not exist and cannot be created: %s", filename, error);
! 3822: efree(error);
! 3823: } else {
! 3824: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s does not exist and cannot be created", filename);
! 3825: }
! 3826: return;
! 3827: } else {
! 3828: if (error) {
! 3829: efree(error);
! 3830: }
! 3831:
! 3832: if (!data->internal_file->is_dir) {
! 3833: if (cont_str) {
! 3834: contents_len = php_stream_write(data->fp, cont_str, cont_len);
! 3835: if (contents_len != cont_len) {
! 3836: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s could not be written to", filename);
! 3837: return;
! 3838: }
! 3839: } else {
! 3840: if (!(php_stream_from_zval_no_verify(contents_file, &zresource))) {
! 3841: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Entry %s could not be written to", filename);
! 3842: return;
! 3843: }
! 3844: phar_stream_copy_to_stream(contents_file, data->fp, PHP_STREAM_COPY_ALL, &contents_len);
! 3845: }
! 3846:
! 3847: data->internal_file->compressed_filesize = data->internal_file->uncompressed_filesize = contents_len;
! 3848: }
! 3849:
! 3850: /* check for copy-on-write */
! 3851: if (pphar[0] != data->phar) {
! 3852: *pphar = data->phar;
! 3853: }
! 3854: phar_entry_delref(data TSRMLS_CC);
! 3855: phar_flush(*pphar, 0, 0, 0, &error TSRMLS_CC);
! 3856:
! 3857: if (error) {
! 3858: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3859: efree(error);
! 3860: }
! 3861: }
! 3862: }
! 3863: /* }}} */
! 3864:
! 3865: /* {{{ create a directory within the phar archive
! 3866: */
! 3867: static void phar_mkdir(phar_archive_data **pphar, char *dirname, int dirname_len TSRMLS_DC)
! 3868: {
! 3869: char *error;
! 3870: phar_entry_data *data;
! 3871:
! 3872: if (!(data = phar_get_or_create_entry_data((*pphar)->fname, (*pphar)->fname_len, dirname, dirname_len, "w+b", 2, &error, 1 TSRMLS_CC))) {
! 3873: if (error) {
! 3874: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Directory %s does not exist and cannot be created: %s", dirname, error);
! 3875: efree(error);
! 3876: } else {
! 3877: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Directory %s does not exist and cannot be created", dirname);
! 3878: }
! 3879:
! 3880: return;
! 3881: } else {
! 3882: if (error) {
! 3883: efree(error);
! 3884: }
! 3885:
! 3886: /* check for copy on write */
! 3887: if (data->phar != *pphar) {
! 3888: *pphar = data->phar;
! 3889: }
! 3890: phar_entry_delref(data TSRMLS_CC);
! 3891: phar_flush(*pphar, 0, 0, 0, &error TSRMLS_CC);
! 3892:
! 3893: if (error) {
! 3894: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3895: efree(error);
! 3896: }
! 3897: }
! 3898: }
! 3899: /* }}} */
! 3900:
! 3901: /* {{{ proto int Phar::offsetSet(string entry, string value)
! 3902: * set the contents of an internal file to those of an external file
! 3903: */
! 3904: PHP_METHOD(Phar, offsetSet)
! 3905: {
! 3906: char *fname, *cont_str = NULL;
! 3907: int fname_len, cont_len;
! 3908: zval *zresource;
! 3909: PHAR_ARCHIVE_OBJECT();
! 3910:
! 3911: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3912: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Write operations disabled by the php.ini setting phar.readonly");
! 3913: return;
! 3914: }
! 3915:
! 3916: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "sr", &fname, &fname_len, &zresource) == FAILURE
! 3917: && zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &fname, &fname_len, &cont_str, &cont_len) == FAILURE) {
! 3918: return;
! 3919: }
! 3920:
! 3921: if (fname_len == sizeof(".phar/stub.php")-1 && !memcmp(fname, ".phar/stub.php", sizeof(".phar/stub.php")-1)) {
! 3922: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot set stub \".phar/stub.php\" directly in phar \"%s\", use setStub", phar_obj->arc.archive->fname);
! 3923: return;
! 3924: }
! 3925:
! 3926: if (fname_len == sizeof(".phar/alias.txt")-1 && !memcmp(fname, ".phar/alias.txt", sizeof(".phar/alias.txt")-1)) {
! 3927: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot set alias \".phar/alias.txt\" directly in phar \"%s\", use setAlias", phar_obj->arc.archive->fname);
! 3928: return;
! 3929: }
! 3930:
! 3931: if (fname_len >= sizeof(".phar")-1 && !memcmp(fname, ".phar", sizeof(".phar")-1)) {
! 3932: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot set any files or directories in magic \".phar\" directory", phar_obj->arc.archive->fname);
! 3933: return;
! 3934: }
! 3935:
! 3936: phar_add_file(&(phar_obj->arc.archive), fname, fname_len, cont_str, cont_len, zresource TSRMLS_CC);
! 3937: }
! 3938: /* }}} */
! 3939:
! 3940: /* {{{ proto int Phar::offsetUnset(string entry)
! 3941: * remove a file from a phar
! 3942: */
! 3943: PHP_METHOD(Phar, offsetUnset)
! 3944: {
! 3945: char *fname, *error;
! 3946: int fname_len;
! 3947: phar_entry_info *entry;
! 3948: PHAR_ARCHIVE_OBJECT();
! 3949:
! 3950: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 3951: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Write operations disabled by the php.ini setting phar.readonly");
! 3952: return;
! 3953: }
! 3954:
! 3955: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &fname, &fname_len) == FAILURE) {
! 3956: return;
! 3957: }
! 3958:
! 3959: if (zend_hash_exists(&phar_obj->arc.archive->manifest, fname, (uint) fname_len)) {
! 3960: if (SUCCESS == zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void**)&entry)) {
! 3961: if (entry->is_deleted) {
! 3962: /* entry is deleted, but has not been flushed to disk yet */
! 3963: return;
! 3964: }
! 3965:
! 3966: if (phar_obj->arc.archive->is_persistent) {
! 3967: if (FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 3968: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 3969: return;
! 3970: }
! 3971: /* re-populate entry after copy on write */
! 3972: zend_hash_find(&phar_obj->arc.archive->manifest, fname, (uint) fname_len, (void **)&entry);
! 3973: }
! 3974: entry->is_modified = 0;
! 3975: entry->is_deleted = 1;
! 3976: /* we need to "flush" the stream to save the newly deleted file on disk */
! 3977: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 3978:
! 3979: if (error) {
! 3980: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 3981: efree(error);
! 3982: }
! 3983:
! 3984: RETURN_TRUE;
! 3985: }
! 3986: } else {
! 3987: RETURN_FALSE;
! 3988: }
! 3989: }
! 3990: /* }}} */
! 3991:
! 3992: /* {{{ proto string Phar::addEmptyDir(string dirname)
! 3993: * Adds an empty directory to the phar archive
! 3994: */
! 3995: PHP_METHOD(Phar, addEmptyDir)
! 3996: {
! 3997: char *dirname;
! 3998: int dirname_len;
! 3999:
! 4000: PHAR_ARCHIVE_OBJECT();
! 4001:
! 4002: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &dirname, &dirname_len) == FAILURE) {
! 4003: return;
! 4004: }
! 4005:
! 4006: if (dirname_len >= sizeof(".phar")-1 && !memcmp(dirname, ".phar", sizeof(".phar")-1)) {
! 4007: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot create a directory in magic \".phar\" directory");
! 4008: return;
! 4009: }
! 4010:
! 4011: phar_mkdir(&phar_obj->arc.archive, dirname, dirname_len TSRMLS_CC);
! 4012: }
! 4013: /* }}} */
! 4014:
! 4015: /* {{{ proto string Phar::addFile(string filename[, string localname])
! 4016: * Adds a file to the archive using the filename, or the second parameter as the name within the archive
! 4017: */
! 4018: PHP_METHOD(Phar, addFile)
! 4019: {
! 4020: char *fname, *localname = NULL;
! 4021: int fname_len, localname_len = 0;
! 4022: php_stream *resource;
! 4023: zval *zresource;
! 4024:
! 4025: PHAR_ARCHIVE_OBJECT();
! 4026:
! 4027: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &fname, &fname_len, &localname, &localname_len) == FAILURE) {
! 4028: return;
! 4029: }
! 4030:
! 4031: #if PHP_API_VERSION < 20100412
! 4032: if (PG(safe_mode) && (!php_checkuid(fname, NULL, CHECKUID_ALLOW_ONLY_FILE))) {
! 4033: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "phar error: unable to open file \"%s\" to add to phar archive, safe_mode restrictions prevent this", fname);
! 4034: return;
! 4035: }
! 4036: #endif
! 4037:
! 4038: if (!strstr(fname, "://") && php_check_open_basedir(fname TSRMLS_CC)) {
! 4039: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "phar error: unable to open file \"%s\" to add to phar archive, open_basedir restrictions prevent this", fname);
! 4040: return;
! 4041: }
! 4042:
! 4043: if (!(resource = php_stream_open_wrapper(fname, "rb", 0, NULL))) {
! 4044: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "phar error: unable to open file \"%s\" to add to phar archive", fname);
! 4045: return;
! 4046: }
! 4047:
! 4048: if (localname) {
! 4049: fname = localname;
! 4050: fname_len = localname_len;
! 4051: }
! 4052:
! 4053: MAKE_STD_ZVAL(zresource);
! 4054: php_stream_to_zval(resource, zresource);
! 4055: phar_add_file(&(phar_obj->arc.archive), fname, fname_len, NULL, 0, zresource TSRMLS_CC);
! 4056: efree(zresource);
! 4057: php_stream_close(resource);
! 4058: }
! 4059: /* }}} */
! 4060:
! 4061: /* {{{ proto string Phar::addFromString(string localname, string contents)
! 4062: * Adds a file to the archive using its contents as a string
! 4063: */
! 4064: PHP_METHOD(Phar, addFromString)
! 4065: {
! 4066: char *localname, *cont_str;
! 4067: int localname_len, cont_len;
! 4068:
! 4069: PHAR_ARCHIVE_OBJECT();
! 4070:
! 4071: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &localname, &localname_len, &cont_str, &cont_len) == FAILURE) {
! 4072: return;
! 4073: }
! 4074:
! 4075: phar_add_file(&(phar_obj->arc.archive), localname, localname_len, cont_str, cont_len, NULL TSRMLS_CC);
! 4076: }
! 4077: /* }}} */
! 4078:
! 4079: /* {{{ proto string Phar::getStub()
! 4080: * Returns the stub at the head of a phar archive as a string.
! 4081: */
! 4082: PHP_METHOD(Phar, getStub)
! 4083: {
! 4084: size_t len;
! 4085: char *buf;
! 4086: php_stream *fp;
! 4087: php_stream_filter *filter = NULL;
! 4088: phar_entry_info *stub;
! 4089:
! 4090: PHAR_ARCHIVE_OBJECT();
! 4091:
! 4092: if (zend_parse_parameters_none() == FAILURE) {
! 4093: return;
! 4094: }
! 4095:
! 4096: if (phar_obj->arc.archive->is_tar || phar_obj->arc.archive->is_zip) {
! 4097:
! 4098: if (SUCCESS == zend_hash_find(&(phar_obj->arc.archive->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1, (void **)&stub)) {
! 4099: if (phar_obj->arc.archive->fp && !phar_obj->arc.archive->is_brandnew && !(stub->flags & PHAR_ENT_COMPRESSION_MASK)) {
! 4100: fp = phar_obj->arc.archive->fp;
! 4101: } else {
! 4102: if (!(fp = php_stream_open_wrapper(phar_obj->arc.archive->fname, "rb", 0, NULL))) {
! 4103: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "phar error: unable to open phar \"%s\"", phar_obj->arc.archive->fname);
! 4104: return;
! 4105: }
! 4106: if (stub->flags & PHAR_ENT_COMPRESSION_MASK) {
! 4107: char *filter_name;
! 4108:
! 4109: if ((filter_name = phar_decompress_filter(stub, 0)) != NULL) {
! 4110: filter = php_stream_filter_create(filter_name, NULL, php_stream_is_persistent(fp) TSRMLS_CC);
! 4111: } else {
! 4112: filter = NULL;
! 4113: }
! 4114: if (!filter) {
! 4115: zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "phar error: unable to read stub of phar \"%s\" (cannot create %s filter)", phar_obj->arc.archive->fname, phar_decompress_filter(stub, 1));
! 4116: return;
! 4117: }
! 4118: php_stream_filter_append(&fp->readfilters, filter);
! 4119: }
! 4120: }
! 4121:
! 4122: if (!fp) {
! 4123: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4124: "Unable to read stub");
! 4125: return;
! 4126: }
! 4127:
! 4128: php_stream_seek(fp, stub->offset_abs, SEEK_SET);
! 4129: len = stub->uncompressed_filesize;
! 4130: goto carry_on;
! 4131: } else {
! 4132: RETURN_STRINGL("", 0, 1);
! 4133: }
! 4134: }
! 4135: len = phar_obj->arc.archive->halt_offset;
! 4136:
! 4137: if (phar_obj->arc.archive->fp && !phar_obj->arc.archive->is_brandnew) {
! 4138: fp = phar_obj->arc.archive->fp;
! 4139: } else {
! 4140: fp = php_stream_open_wrapper(phar_obj->arc.archive->fname, "rb", 0, NULL);
! 4141: }
! 4142:
! 4143: if (!fp) {
! 4144: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4145: "Unable to read stub");
! 4146: return;
! 4147: }
! 4148:
! 4149: php_stream_rewind(fp);
! 4150: carry_on:
! 4151: buf = safe_emalloc(len, 1, 1);
! 4152:
! 4153: if (len != php_stream_read(fp, buf, len)) {
! 4154: if (fp != phar_obj->arc.archive->fp) {
! 4155: php_stream_close(fp);
! 4156: }
! 4157: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4158: "Unable to read stub");
! 4159: efree(buf);
! 4160: return;
! 4161: }
! 4162:
! 4163: if (filter) {
! 4164: php_stream_filter_flush(filter, 1);
! 4165: php_stream_filter_remove(filter, 1 TSRMLS_CC);
! 4166: }
! 4167:
! 4168: if (fp != phar_obj->arc.archive->fp) {
! 4169: php_stream_close(fp);
! 4170: }
! 4171:
! 4172: buf[len] = '\0';
! 4173: RETURN_STRINGL(buf, len, 0);
! 4174: }
! 4175: /* }}}*/
! 4176:
! 4177: /* {{{ proto int Phar::hasMetaData()
! 4178: * Returns TRUE if the phar has global metadata, FALSE otherwise.
! 4179: */
! 4180: PHP_METHOD(Phar, hasMetadata)
! 4181: {
! 4182: PHAR_ARCHIVE_OBJECT();
! 4183:
! 4184: RETURN_BOOL(phar_obj->arc.archive->metadata != NULL);
! 4185: }
! 4186: /* }}} */
! 4187:
! 4188: /* {{{ proto int Phar::getMetaData()
! 4189: * Returns the global metadata of the phar
! 4190: */
! 4191: PHP_METHOD(Phar, getMetadata)
! 4192: {
! 4193: PHAR_ARCHIVE_OBJECT();
! 4194:
! 4195: if (zend_parse_parameters_none() == FAILURE) {
! 4196: return;
! 4197: }
! 4198:
! 4199: if (phar_obj->arc.archive->metadata) {
! 4200: if (phar_obj->arc.archive->is_persistent) {
! 4201: zval *ret;
! 4202: char *buf = estrndup((char *) phar_obj->arc.archive->metadata, phar_obj->arc.archive->metadata_len);
! 4203: /* assume success, we would have failed before */
! 4204: phar_parse_metadata(&buf, &ret, phar_obj->arc.archive->metadata_len TSRMLS_CC);
! 4205: efree(buf);
! 4206: RETURN_ZVAL(ret, 0, 1);
! 4207: }
! 4208: RETURN_ZVAL(phar_obj->arc.archive->metadata, 1, 0);
! 4209: }
! 4210: }
! 4211: /* }}} */
! 4212:
! 4213: /* {{{ proto int Phar::setMetaData(mixed $metadata)
! 4214: * Sets the global metadata of the phar
! 4215: */
! 4216: PHP_METHOD(Phar, setMetadata)
! 4217: {
! 4218: char *error;
! 4219: zval *metadata;
! 4220:
! 4221: PHAR_ARCHIVE_OBJECT();
! 4222:
! 4223: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 4224: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Write operations disabled by the php.ini setting phar.readonly");
! 4225: return;
! 4226: }
! 4227:
! 4228: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &metadata) == FAILURE) {
! 4229: return;
! 4230: }
! 4231:
! 4232: if (phar_obj->arc.archive->is_persistent && FAILURE == phar_copy_on_write(&(phar_obj->arc.archive) TSRMLS_CC)) {
! 4233: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar_obj->arc.archive->fname);
! 4234: return;
! 4235: }
! 4236: if (phar_obj->arc.archive->metadata) {
! 4237: zval_ptr_dtor(&phar_obj->arc.archive->metadata);
! 4238: phar_obj->arc.archive->metadata = NULL;
! 4239: }
! 4240:
! 4241: MAKE_STD_ZVAL(phar_obj->arc.archive->metadata);
! 4242: ZVAL_ZVAL(phar_obj->arc.archive->metadata, metadata, 1, 0);
! 4243: phar_obj->arc.archive->is_modified = 1;
! 4244: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 4245:
! 4246: if (error) {
! 4247: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 4248: efree(error);
! 4249: }
! 4250: }
! 4251: /* }}} */
! 4252:
! 4253: /* {{{ proto int Phar::delMetadata()
! 4254: * Deletes the global metadata of the phar
! 4255: */
! 4256: PHP_METHOD(Phar, delMetadata)
! 4257: {
! 4258: char *error;
! 4259:
! 4260: PHAR_ARCHIVE_OBJECT();
! 4261:
! 4262: if (PHAR_G(readonly) && !phar_obj->arc.archive->is_data) {
! 4263: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Write operations disabled by the php.ini setting phar.readonly");
! 4264: return;
! 4265: }
! 4266:
! 4267: if (phar_obj->arc.archive->metadata) {
! 4268: zval_ptr_dtor(&phar_obj->arc.archive->metadata);
! 4269: phar_obj->arc.archive->metadata = NULL;
! 4270: phar_obj->arc.archive->is_modified = 1;
! 4271: phar_flush(phar_obj->arc.archive, 0, 0, 0, &error TSRMLS_CC);
! 4272:
! 4273: if (error) {
! 4274: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 4275: efree(error);
! 4276: RETURN_FALSE;
! 4277: } else {
! 4278: RETURN_TRUE;
! 4279: }
! 4280:
! 4281: } else {
! 4282: RETURN_TRUE;
! 4283: }
! 4284: }
! 4285: /* }}} */
! 4286: #if PHP_API_VERSION < 20100412
! 4287: #define PHAR_OPENBASEDIR_CHECKPATH(filename) \
! 4288: (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) || php_check_open_basedir(filename TSRMLS_CC)
! 4289: #else
! 4290: #define PHAR_OPENBASEDIR_CHECKPATH(filename) \
! 4291: php_check_open_basedir(filename TSRMLS_CC)
! 4292: #endif
! 4293:
! 4294: static int phar_extract_file(zend_bool overwrite, phar_entry_info *entry, char *dest, int dest_len, char **error TSRMLS_DC) /* {{{ */
! 4295: {
! 4296: php_stream_statbuf ssb;
! 4297: int len;
! 4298: php_stream *fp;
! 4299: char *fullpath, *slash;
! 4300: mode_t mode;
! 4301:
! 4302: if (entry->is_mounted) {
! 4303: /* silently ignore mounted entries */
! 4304: return SUCCESS;
! 4305: }
! 4306:
! 4307: if (entry->filename_len >= sizeof(".phar")-1 && !memcmp(entry->filename, ".phar", sizeof(".phar")-1)) {
! 4308: return SUCCESS;
! 4309: }
! 4310:
! 4311: len = spprintf(&fullpath, 0, "%s/%s", dest, entry->filename);
! 4312:
! 4313: if (len >= MAXPATHLEN) {
! 4314: char *tmp;
! 4315: /* truncate for error message */
! 4316: fullpath[50] = '\0';
! 4317: if (entry->filename_len > 50) {
! 4318: tmp = estrndup(entry->filename, 50);
! 4319: spprintf(error, 4096, "Cannot extract \"%s...\" to \"%s...\", extracted filename is too long for filesystem", tmp, fullpath);
! 4320: efree(tmp);
! 4321: } else {
! 4322: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s...\", extracted filename is too long for filesystem", entry->filename, fullpath);
! 4323: }
! 4324: efree(fullpath);
! 4325: return FAILURE;
! 4326: }
! 4327:
! 4328: if (!len) {
! 4329: spprintf(error, 4096, "Cannot extract \"%s\", internal error", entry->filename);
! 4330: efree(fullpath);
! 4331: return FAILURE;
! 4332: }
! 4333:
! 4334: if (PHAR_OPENBASEDIR_CHECKPATH(fullpath)) {
! 4335: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", openbasedir/safe mode restrictions in effect", entry->filename, fullpath);
! 4336: efree(fullpath);
! 4337: return FAILURE;
! 4338: }
! 4339:
! 4340: /* let see if the path already exists */
! 4341: if (!overwrite && SUCCESS == php_stream_stat_path(fullpath, &ssb)) {
! 4342: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", path already exists", entry->filename, fullpath);
! 4343: efree(fullpath);
! 4344: return FAILURE;
! 4345: }
! 4346:
! 4347: /* perform dirname */
! 4348: slash = zend_memrchr(entry->filename, '/', entry->filename_len);
! 4349:
! 4350: if (slash) {
! 4351: fullpath[dest_len + (slash - entry->filename) + 1] = '\0';
! 4352: } else {
! 4353: fullpath[dest_len] = '\0';
! 4354: }
! 4355:
! 4356: if (FAILURE == php_stream_stat_path(fullpath, &ssb)) {
! 4357: if (entry->is_dir) {
! 4358: if (!php_stream_mkdir(fullpath, entry->flags & PHAR_ENT_PERM_MASK, PHP_STREAM_MKDIR_RECURSIVE, NULL)) {
! 4359: spprintf(error, 4096, "Cannot extract \"%s\", could not create directory \"%s\"", entry->filename, fullpath);
! 4360: efree(fullpath);
! 4361: return FAILURE;
! 4362: }
! 4363: } else {
! 4364: if (!php_stream_mkdir(fullpath, 0777, PHP_STREAM_MKDIR_RECURSIVE, NULL)) {
! 4365: spprintf(error, 4096, "Cannot extract \"%s\", could not create directory \"%s\"", entry->filename, fullpath);
! 4366: efree(fullpath);
! 4367: return FAILURE;
! 4368: }
! 4369: }
! 4370: }
! 4371:
! 4372: if (slash) {
! 4373: fullpath[dest_len + (slash - entry->filename) + 1] = '/';
! 4374: } else {
! 4375: fullpath[dest_len] = '/';
! 4376: }
! 4377:
! 4378: /* it is a standalone directory, job done */
! 4379: if (entry->is_dir) {
! 4380: efree(fullpath);
! 4381: return SUCCESS;
! 4382: }
! 4383:
! 4384: #if PHP_API_VERSION < 20100412
! 4385: fp = php_stream_open_wrapper(fullpath, "w+b", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
! 4386: #else
! 4387: fp = php_stream_open_wrapper(fullpath, "w+b", REPORT_ERRORS, NULL);
! 4388: #endif
! 4389:
! 4390: if (!fp) {
! 4391: spprintf(error, 4096, "Cannot extract \"%s\", could not open for writing \"%s\"", entry->filename, fullpath);
! 4392: efree(fullpath);
! 4393: return FAILURE;
! 4394: }
! 4395:
! 4396: if (!phar_get_efp(entry, 0 TSRMLS_CC)) {
! 4397: if (FAILURE == phar_open_entry_fp(entry, error, 1 TSRMLS_CC)) {
! 4398: if (error) {
! 4399: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", unable to open internal file pointer: %s", entry->filename, fullpath, *error);
! 4400: } else {
! 4401: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", unable to open internal file pointer", entry->filename, fullpath);
! 4402: }
! 4403: efree(fullpath);
! 4404: php_stream_close(fp);
! 4405: return FAILURE;
! 4406: }
! 4407: }
! 4408:
! 4409: if (FAILURE == phar_seek_efp(entry, 0, SEEK_SET, 0, 0 TSRMLS_CC)) {
! 4410: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", unable to seek internal file pointer", entry->filename, fullpath);
! 4411: efree(fullpath);
! 4412: php_stream_close(fp);
! 4413: return FAILURE;
! 4414: }
! 4415:
! 4416: if (SUCCESS != phar_stream_copy_to_stream(phar_get_efp(entry, 0 TSRMLS_CC), fp, entry->uncompressed_filesize, NULL)) {
! 4417: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", copying contents failed", entry->filename, fullpath);
! 4418: efree(fullpath);
! 4419: php_stream_close(fp);
! 4420: return FAILURE;
! 4421: }
! 4422:
! 4423: php_stream_close(fp);
! 4424: mode = (mode_t) entry->flags & PHAR_ENT_PERM_MASK;
! 4425:
! 4426: if (FAILURE == VCWD_CHMOD(fullpath, mode)) {
! 4427: spprintf(error, 4096, "Cannot extract \"%s\" to \"%s\", setting file permissions failed", entry->filename, fullpath);
! 4428: efree(fullpath);
! 4429: return FAILURE;
! 4430: }
! 4431:
! 4432: efree(fullpath);
! 4433: return SUCCESS;
! 4434: }
! 4435: /* }}} */
! 4436:
! 4437: /* {{{ proto bool Phar::extractTo(string pathto[[, mixed files], bool overwrite])
! 4438: * Extract one or more file from a phar archive, optionally overwriting existing files
! 4439: */
! 4440: PHP_METHOD(Phar, extractTo)
! 4441: {
! 4442: char *error = NULL;
! 4443: php_stream *fp;
! 4444: php_stream_statbuf ssb;
! 4445: phar_entry_info *entry;
! 4446: char *pathto, *filename, *actual;
! 4447: int pathto_len, filename_len;
! 4448: int ret, i;
! 4449: int nelems;
! 4450: zval *zval_files = NULL;
! 4451: zend_bool overwrite = 0;
! 4452:
! 4453: PHAR_ARCHIVE_OBJECT();
! 4454:
! 4455: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z!b", &pathto, &pathto_len, &zval_files, &overwrite) == FAILURE) {
! 4456: return;
! 4457: }
! 4458:
! 4459: fp = php_stream_open_wrapper(phar_obj->arc.archive->fname, "rb", IGNORE_URL|STREAM_MUST_SEEK, &actual);
! 4460:
! 4461: if (!fp) {
! 4462: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC,
! 4463: "Invalid argument, %s cannot be found", phar_obj->arc.archive->fname);
! 4464: return;
! 4465: }
! 4466:
! 4467: efree(actual);
! 4468: php_stream_close(fp);
! 4469:
! 4470: if (pathto_len < 1) {
! 4471: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC,
! 4472: "Invalid argument, extraction path must be non-zero length");
! 4473: return;
! 4474: }
! 4475:
! 4476: if (pathto_len >= MAXPATHLEN) {
! 4477: char *tmp = estrndup(pathto, 50);
! 4478: /* truncate for error message */
! 4479: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Cannot extract to \"%s...\", destination directory is too long for filesystem", tmp);
! 4480: efree(tmp);
! 4481: return;
! 4482: }
! 4483:
! 4484: if (php_stream_stat_path(pathto, &ssb) < 0) {
! 4485: ret = php_stream_mkdir(pathto, 0777, PHP_STREAM_MKDIR_RECURSIVE, NULL);
! 4486: if (!ret) {
! 4487: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4488: "Unable to create path \"%s\" for extraction", pathto);
! 4489: return;
! 4490: }
! 4491: } else if (!(ssb.sb.st_mode & S_IFDIR)) {
! 4492: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4493: "Unable to use path \"%s\" for extraction, it is a file, must be a directory", pathto);
! 4494: return;
! 4495: }
! 4496:
! 4497: if (zval_files) {
! 4498: switch (Z_TYPE_P(zval_files)) {
! 4499: case IS_NULL:
! 4500: goto all_files;
! 4501: #if PHP_VERSION_ID >= 60000
! 4502: case IS_UNICODE:
! 4503: zval_unicode_to_string(zval_files TSRMLS_CC);
! 4504: /* break intentionally omitted */
! 4505: #endif
! 4506: case IS_STRING:
! 4507: filename = Z_STRVAL_P(zval_files);
! 4508: filename_len = Z_STRLEN_P(zval_files);
! 4509: break;
! 4510: case IS_ARRAY:
! 4511: nelems = zend_hash_num_elements(Z_ARRVAL_P(zval_files));
! 4512: if (nelems == 0 ) {
! 4513: RETURN_FALSE;
! 4514: }
! 4515: for (i = 0; i < nelems; i++) {
! 4516: zval **zval_file;
! 4517: if (zend_hash_index_find(Z_ARRVAL_P(zval_files), i, (void **) &zval_file) == SUCCESS) {
! 4518: switch (Z_TYPE_PP(zval_file)) {
! 4519: #if PHP_VERSION_ID >= 60000
! 4520: case IS_UNICODE:
! 4521: zval_unicode_to_string(*(zval_file) TSRMLS_CC);
! 4522: /* break intentionally omitted */
! 4523: #endif
! 4524: case IS_STRING:
! 4525: break;
! 4526: default:
! 4527: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC,
! 4528: "Invalid argument, array of filenames to extract contains non-string value");
! 4529: return;
! 4530: }
! 4531: if (FAILURE == zend_hash_find(&phar_obj->arc.archive->manifest, Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file), (void **)&entry)) {
! 4532: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC,
! 4533: "Phar Error: attempted to extract non-existent file \"%s\" from phar \"%s\"", Z_STRVAL_PP(zval_file), phar_obj->arc.archive->fname);
! 4534: }
! 4535: if (FAILURE == phar_extract_file(overwrite, entry, pathto, pathto_len, &error TSRMLS_CC)) {
! 4536: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC,
! 4537: "Extraction from phar \"%s\" failed: %s", phar_obj->arc.archive->fname, error);
! 4538: efree(error);
! 4539: return;
! 4540: }
! 4541: }
! 4542: }
! 4543: RETURN_TRUE;
! 4544: default:
! 4545: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC,
! 4546: "Invalid argument, expected a filename (string) or array of filenames");
! 4547: return;
! 4548: }
! 4549:
! 4550: if (FAILURE == zend_hash_find(&phar_obj->arc.archive->manifest, filename, filename_len, (void **)&entry)) {
! 4551: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC,
! 4552: "Phar Error: attempted to extract non-existent file \"%s\" from phar \"%s\"", filename, phar_obj->arc.archive->fname);
! 4553: return;
! 4554: }
! 4555:
! 4556: if (FAILURE == phar_extract_file(overwrite, entry, pathto, pathto_len, &error TSRMLS_CC)) {
! 4557: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC,
! 4558: "Extraction from phar \"%s\" failed: %s", phar_obj->arc.archive->fname, error);
! 4559: efree(error);
! 4560: return;
! 4561: }
! 4562: } else {
! 4563: phar_archive_data *phar;
! 4564: all_files:
! 4565: phar = phar_obj->arc.archive;
! 4566: /* Extract all files */
! 4567: if (!zend_hash_num_elements(&(phar->manifest))) {
! 4568: RETURN_TRUE;
! 4569: }
! 4570:
! 4571: for (zend_hash_internal_pointer_reset(&phar->manifest);
! 4572: zend_hash_has_more_elements(&phar->manifest) == SUCCESS;
! 4573: zend_hash_move_forward(&phar->manifest)) {
! 4574:
! 4575: if (zend_hash_get_current_data(&phar->manifest, (void **)&entry) == FAILURE) {
! 4576: continue;
! 4577: }
! 4578:
! 4579: if (FAILURE == phar_extract_file(overwrite, entry, pathto, pathto_len, &error TSRMLS_CC)) {
! 4580: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC,
! 4581: "Extraction from phar \"%s\" failed: %s", phar->fname, error);
! 4582: efree(error);
! 4583: return;
! 4584: }
! 4585: }
! 4586: }
! 4587: RETURN_TRUE;
! 4588: }
! 4589: /* }}} */
! 4590:
! 4591:
! 4592: /* {{{ proto void PharFileInfo::__construct(string entry)
! 4593: * Construct a Phar entry object
! 4594: */
! 4595: PHP_METHOD(PharFileInfo, __construct)
! 4596: {
! 4597: char *fname, *arch, *entry, *error;
! 4598: int fname_len, arch_len, entry_len;
! 4599: phar_entry_object *entry_obj;
! 4600: phar_entry_info *entry_info;
! 4601: phar_archive_data *phar_data;
! 4602: zval *zobj = getThis(), arg1;
! 4603:
! 4604: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &fname, &fname_len) == FAILURE) {
! 4605: return;
! 4606: }
! 4607:
! 4608: entry_obj = (phar_entry_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 4609:
! 4610: if (entry_obj->ent.entry) {
! 4611: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot call constructor twice");
! 4612: return;
! 4613: }
! 4614:
! 4615: if (fname_len < 7 || memcmp(fname, "phar://", 7) || phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC) == FAILURE) {
! 4616: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4617: "'%s' is not a valid phar archive URL (must have at least phar://filename.phar)", fname);
! 4618: return;
! 4619: }
! 4620:
! 4621: if (phar_open_from_filename(arch, arch_len, NULL, 0, REPORT_ERRORS, &phar_data, &error TSRMLS_CC) == FAILURE) {
! 4622: efree(arch);
! 4623: efree(entry);
! 4624: if (error) {
! 4625: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4626: "Cannot open phar file '%s': %s", fname, error);
! 4627: efree(error);
! 4628: } else {
! 4629: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4630: "Cannot open phar file '%s'", fname);
! 4631: }
! 4632: return;
! 4633: }
! 4634:
! 4635: if ((entry_info = phar_get_entry_info_dir(phar_data, entry, entry_len, 1, &error, 1 TSRMLS_CC)) == NULL) {
! 4636: zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC,
! 4637: "Cannot access phar file entry '%s' in archive '%s'%s%s", entry, arch, error ? ", " : "", error ? error : "");
! 4638: efree(arch);
! 4639: efree(entry);
! 4640: return;
! 4641: }
! 4642:
! 4643: efree(arch);
! 4644: efree(entry);
! 4645:
! 4646: entry_obj->ent.entry = entry_info;
! 4647:
! 4648: INIT_PZVAL(&arg1);
! 4649: ZVAL_STRINGL(&arg1, fname, fname_len, 0);
! 4650:
! 4651: zend_call_method_with_1_params(&zobj, Z_OBJCE_P(zobj),
! 4652: &spl_ce_SplFileInfo->constructor, "__construct", NULL, &arg1);
! 4653: }
! 4654: /* }}} */
! 4655:
! 4656: #define PHAR_ENTRY_OBJECT() \
! 4657: phar_entry_object *entry_obj = (phar_entry_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
! 4658: if (!entry_obj->ent.entry) { \
! 4659: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4660: "Cannot call method on an uninitialized PharFileInfo object"); \
! 4661: return; \
! 4662: }
! 4663:
! 4664: /* {{{ proto void PharFileInfo::__destruct()
! 4665: * clean up directory-based entry objects
! 4666: */
! 4667: PHP_METHOD(PharFileInfo, __destruct)
! 4668: {
! 4669: phar_entry_object *entry_obj = (phar_entry_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
! 4670:
! 4671: if (entry_obj->ent.entry && entry_obj->ent.entry->is_temp_dir) {
! 4672: if (entry_obj->ent.entry->filename) {
! 4673: efree(entry_obj->ent.entry->filename);
! 4674: entry_obj->ent.entry->filename = NULL;
! 4675: }
! 4676:
! 4677: efree(entry_obj->ent.entry);
! 4678: entry_obj->ent.entry = NULL;
! 4679: }
! 4680: }
! 4681: /* }}} */
! 4682:
! 4683: /* {{{ proto int PharFileInfo::getCompressedSize()
! 4684: * Returns the compressed size
! 4685: */
! 4686: PHP_METHOD(PharFileInfo, getCompressedSize)
! 4687: {
! 4688: PHAR_ENTRY_OBJECT();
! 4689:
! 4690: if (zend_parse_parameters_none() == FAILURE) {
! 4691: return;
! 4692: }
! 4693:
! 4694: RETURN_LONG(entry_obj->ent.entry->compressed_filesize);
! 4695: }
! 4696: /* }}} */
! 4697:
! 4698: /* {{{ proto bool PharFileInfo::isCompressed([int compression_type])
! 4699: * Returns whether the entry is compressed, and whether it is compressed with Phar::GZ or Phar::BZ2 if specified
! 4700: */
! 4701: PHP_METHOD(PharFileInfo, isCompressed)
! 4702: {
! 4703: /* a number that is not Phar::GZ or Phar::BZ2 */
! 4704: long method = 9021976;
! 4705: PHAR_ENTRY_OBJECT();
! 4706:
! 4707: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &method) == FAILURE) {
! 4708: return;
! 4709: }
! 4710:
! 4711: switch (method) {
! 4712: case 9021976:
! 4713: RETURN_BOOL(entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSION_MASK);
! 4714: case PHAR_ENT_COMPRESSED_GZ:
! 4715: RETURN_BOOL(entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_GZ);
! 4716: case PHAR_ENT_COMPRESSED_BZ2:
! 4717: RETURN_BOOL(entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_BZ2);
! 4718: default:
! 4719: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4720: "Unknown compression type specified"); \
! 4721: }
! 4722: }
! 4723: /* }}} */
! 4724:
! 4725: /* {{{ proto int PharFileInfo::getCRC32()
! 4726: * Returns CRC32 code or throws an exception if not CRC checked
! 4727: */
! 4728: PHP_METHOD(PharFileInfo, getCRC32)
! 4729: {
! 4730: PHAR_ENTRY_OBJECT();
! 4731:
! 4732: if (zend_parse_parameters_none() == FAILURE) {
! 4733: return;
! 4734: }
! 4735:
! 4736: if (entry_obj->ent.entry->is_dir) {
! 4737: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4738: "Phar entry is a directory, does not have a CRC"); \
! 4739: return;
! 4740: }
! 4741:
! 4742: if (entry_obj->ent.entry->is_crc_checked) {
! 4743: RETURN_LONG(entry_obj->ent.entry->crc32);
! 4744: } else {
! 4745: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4746: "Phar entry was not CRC checked"); \
! 4747: }
! 4748: }
! 4749: /* }}} */
! 4750:
! 4751: /* {{{ proto int PharFileInfo::isCRCChecked()
! 4752: * Returns whether file entry is CRC checked
! 4753: */
! 4754: PHP_METHOD(PharFileInfo, isCRCChecked)
! 4755: {
! 4756: PHAR_ENTRY_OBJECT();
! 4757:
! 4758: if (zend_parse_parameters_none() == FAILURE) {
! 4759: return;
! 4760: }
! 4761:
! 4762: RETURN_BOOL(entry_obj->ent.entry->is_crc_checked);
! 4763: }
! 4764: /* }}} */
! 4765:
! 4766: /* {{{ proto int PharFileInfo::getPharFlags()
! 4767: * Returns the Phar file entry flags
! 4768: */
! 4769: PHP_METHOD(PharFileInfo, getPharFlags)
! 4770: {
! 4771: PHAR_ENTRY_OBJECT();
! 4772:
! 4773: if (zend_parse_parameters_none() == FAILURE) {
! 4774: return;
! 4775: }
! 4776:
! 4777: RETURN_LONG(entry_obj->ent.entry->flags & ~(PHAR_ENT_PERM_MASK|PHAR_ENT_COMPRESSION_MASK));
! 4778: }
! 4779: /* }}} */
! 4780:
! 4781: /* {{{ proto int PharFileInfo::chmod()
! 4782: * set the file permissions for the Phar. This only allows setting execution bit, read/write
! 4783: */
! 4784: PHP_METHOD(PharFileInfo, chmod)
! 4785: {
! 4786: char *error;
! 4787: long perms;
! 4788: PHAR_ENTRY_OBJECT();
! 4789:
! 4790: if (entry_obj->ent.entry->is_temp_dir) {
! 4791: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4792: "Phar entry \"%s\" is a temporary directory (not an actual entry in the archive), cannot chmod", entry_obj->ent.entry->filename); \
! 4793: return;
! 4794: }
! 4795:
! 4796: if (PHAR_G(readonly) && !entry_obj->ent.entry->phar->is_data) {
! 4797: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "Cannot modify permissions for file \"%s\" in phar \"%s\", write operations are prohibited", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname);
! 4798: return;
! 4799: }
! 4800:
! 4801: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &perms) == FAILURE) {
! 4802: return;
! 4803: }
! 4804:
! 4805: if (entry_obj->ent.entry->is_persistent) {
! 4806: phar_archive_data *phar = entry_obj->ent.entry->phar;
! 4807:
! 4808: if (FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
! 4809: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar->fname);
! 4810: return;
! 4811: }
! 4812: /* re-populate after copy-on-write */
! 4813: zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry);
! 4814: }
! 4815: /* clear permissions */
! 4816: entry_obj->ent.entry->flags &= ~PHAR_ENT_PERM_MASK;
! 4817: perms &= 0777;
! 4818: entry_obj->ent.entry->flags |= perms;
! 4819: entry_obj->ent.entry->old_flags = entry_obj->ent.entry->flags;
! 4820: entry_obj->ent.entry->phar->is_modified = 1;
! 4821: entry_obj->ent.entry->is_modified = 1;
! 4822:
! 4823: /* hackish cache in php_stat needs to be cleared */
! 4824: /* if this code fails to work, check main/streams/streams.c, _php_stream_stat_path */
! 4825: if (BG(CurrentLStatFile)) {
! 4826: efree(BG(CurrentLStatFile));
! 4827: }
! 4828:
! 4829: if (BG(CurrentStatFile)) {
! 4830: efree(BG(CurrentStatFile));
! 4831: }
! 4832:
! 4833: BG(CurrentLStatFile) = NULL;
! 4834: BG(CurrentStatFile) = NULL;
! 4835: phar_flush(entry_obj->ent.entry->phar, 0, 0, 0, &error TSRMLS_CC);
! 4836:
! 4837: if (error) {
! 4838: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 4839: efree(error);
! 4840: }
! 4841: }
! 4842: /* }}} */
! 4843:
! 4844: /* {{{ proto int PharFileInfo::hasMetaData()
! 4845: * Returns the metadata of the entry
! 4846: */
! 4847: PHP_METHOD(PharFileInfo, hasMetadata)
! 4848: {
! 4849: PHAR_ENTRY_OBJECT();
! 4850:
! 4851: if (zend_parse_parameters_none() == FAILURE) {
! 4852: return;
! 4853: }
! 4854:
! 4855: RETURN_BOOL(entry_obj->ent.entry->metadata != NULL);
! 4856: }
! 4857: /* }}} */
! 4858:
! 4859: /* {{{ proto int PharFileInfo::getMetaData()
! 4860: * Returns the metadata of the entry
! 4861: */
! 4862: PHP_METHOD(PharFileInfo, getMetadata)
! 4863: {
! 4864: PHAR_ENTRY_OBJECT();
! 4865:
! 4866: if (zend_parse_parameters_none() == FAILURE) {
! 4867: return;
! 4868: }
! 4869:
! 4870: if (entry_obj->ent.entry->metadata) {
! 4871: if (entry_obj->ent.entry->is_persistent) {
! 4872: zval *ret;
! 4873: char *buf = estrndup((char *) entry_obj->ent.entry->metadata, entry_obj->ent.entry->metadata_len);
! 4874: /* assume success, we would have failed before */
! 4875: phar_parse_metadata(&buf, &ret, entry_obj->ent.entry->metadata_len TSRMLS_CC);
! 4876: efree(buf);
! 4877: RETURN_ZVAL(ret, 0, 1);
! 4878: }
! 4879: RETURN_ZVAL(entry_obj->ent.entry->metadata, 1, 0);
! 4880: }
! 4881: }
! 4882: /* }}} */
! 4883:
! 4884: /* {{{ proto int PharFileInfo::setMetaData(mixed $metadata)
! 4885: * Sets the metadata of the entry
! 4886: */
! 4887: PHP_METHOD(PharFileInfo, setMetadata)
! 4888: {
! 4889: char *error;
! 4890: zval *metadata;
! 4891:
! 4892: PHAR_ENTRY_OBJECT();
! 4893:
! 4894: if (PHAR_G(readonly) && !entry_obj->ent.entry->phar->is_data) {
! 4895: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Write operations disabled by the php.ini setting phar.readonly");
! 4896: return;
! 4897: }
! 4898:
! 4899: if (entry_obj->ent.entry->is_temp_dir) {
! 4900: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4901: "Phar entry is a temporary directory (not an actual entry in the archive), cannot set metadata"); \
! 4902: return;
! 4903: }
! 4904:
! 4905: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &metadata) == FAILURE) {
! 4906: return;
! 4907: }
! 4908:
! 4909: if (entry_obj->ent.entry->is_persistent) {
! 4910: phar_archive_data *phar = entry_obj->ent.entry->phar;
! 4911:
! 4912: if (FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
! 4913: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar->fname);
! 4914: return;
! 4915: }
! 4916: /* re-populate after copy-on-write */
! 4917: zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry);
! 4918: }
! 4919: if (entry_obj->ent.entry->metadata) {
! 4920: zval_ptr_dtor(&entry_obj->ent.entry->metadata);
! 4921: entry_obj->ent.entry->metadata = NULL;
! 4922: }
! 4923:
! 4924: MAKE_STD_ZVAL(entry_obj->ent.entry->metadata);
! 4925: ZVAL_ZVAL(entry_obj->ent.entry->metadata, metadata, 1, 0);
! 4926:
! 4927: entry_obj->ent.entry->is_modified = 1;
! 4928: entry_obj->ent.entry->phar->is_modified = 1;
! 4929: phar_flush(entry_obj->ent.entry->phar, 0, 0, 0, &error TSRMLS_CC);
! 4930:
! 4931: if (error) {
! 4932: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 4933: efree(error);
! 4934: }
! 4935: }
! 4936: /* }}} */
! 4937:
! 4938: /* {{{ proto bool PharFileInfo::delMetaData()
! 4939: * Deletes the metadata of the entry
! 4940: */
! 4941: PHP_METHOD(PharFileInfo, delMetadata)
! 4942: {
! 4943: char *error;
! 4944:
! 4945: PHAR_ENTRY_OBJECT();
! 4946:
! 4947: if (zend_parse_parameters_none() == FAILURE) {
! 4948: return;
! 4949: }
! 4950:
! 4951: if (PHAR_G(readonly) && !entry_obj->ent.entry->phar->is_data) {
! 4952: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Write operations disabled by the php.ini setting phar.readonly");
! 4953: return;
! 4954: }
! 4955:
! 4956: if (entry_obj->ent.entry->is_temp_dir) {
! 4957: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 4958: "Phar entry is a temporary directory (not an actual entry in the archive), cannot delete metadata"); \
! 4959: return;
! 4960: }
! 4961:
! 4962: if (entry_obj->ent.entry->metadata) {
! 4963: if (entry_obj->ent.entry->is_persistent) {
! 4964: phar_archive_data *phar = entry_obj->ent.entry->phar;
! 4965:
! 4966: if (FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
! 4967: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar->fname);
! 4968: return;
! 4969: }
! 4970: /* re-populate after copy-on-write */
! 4971: zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry);
! 4972: }
! 4973: zval_ptr_dtor(&entry_obj->ent.entry->metadata);
! 4974: entry_obj->ent.entry->metadata = NULL;
! 4975: entry_obj->ent.entry->is_modified = 1;
! 4976: entry_obj->ent.entry->phar->is_modified = 1;
! 4977:
! 4978: phar_flush(entry_obj->ent.entry->phar, 0, 0, 0, &error TSRMLS_CC);
! 4979:
! 4980: if (error) {
! 4981: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 4982: efree(error);
! 4983: RETURN_FALSE;
! 4984: } else {
! 4985: RETURN_TRUE;
! 4986: }
! 4987:
! 4988: } else {
! 4989: RETURN_TRUE;
! 4990: }
! 4991: }
! 4992: /* }}} */
! 4993:
! 4994: /* {{{ proto string PharFileInfo::getContent()
! 4995: * return the complete file contents of the entry (like file_get_contents)
! 4996: */
! 4997: PHP_METHOD(PharFileInfo, getContent)
! 4998: {
! 4999: char *error;
! 5000: php_stream *fp;
! 5001: phar_entry_info *link;
! 5002:
! 5003: PHAR_ENTRY_OBJECT();
! 5004:
! 5005: if (zend_parse_parameters_none() == FAILURE) {
! 5006: return;
! 5007: }
! 5008:
! 5009: if (entry_obj->ent.entry->is_dir) {
! 5010: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5011: "Phar error: Cannot retrieve contents, \"%s\" in phar \"%s\" is a directory", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname);
! 5012: return;
! 5013: }
! 5014:
! 5015: link = phar_get_link_source(entry_obj->ent.entry TSRMLS_CC);
! 5016:
! 5017: if (!link) {
! 5018: link = entry_obj->ent.entry;
! 5019: }
! 5020:
! 5021: if (SUCCESS != phar_open_entry_fp(link, &error, 0 TSRMLS_CC)) {
! 5022: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5023: "Phar error: Cannot retrieve contents, \"%s\" in phar \"%s\": %s", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname, error);
! 5024: efree(error);
! 5025: return;
! 5026: }
! 5027:
! 5028: if (!(fp = phar_get_efp(link, 0 TSRMLS_CC))) {
! 5029: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5030: "Phar error: Cannot retrieve contents of \"%s\" in phar \"%s\"", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname);
! 5031: return;
! 5032: }
! 5033:
! 5034: phar_seek_efp(link, 0, SEEK_SET, 0, 0 TSRMLS_CC);
! 5035: Z_TYPE_P(return_value) = IS_STRING;
! 5036: #if PHP_MAJOR_VERSION >= 6
! 5037: Z_STRLEN_P(return_value) = php_stream_copy_to_mem(fp, (void **) &(Z_STRVAL_P(return_value)), link->uncompressed_filesize, 0);
! 5038: #else
! 5039: Z_STRLEN_P(return_value) = php_stream_copy_to_mem(fp, &(Z_STRVAL_P(return_value)), link->uncompressed_filesize, 0);
! 5040: #endif
! 5041:
! 5042: if (!Z_STRVAL_P(return_value)) {
! 5043: Z_STRVAL_P(return_value) = estrndup("", 0);
! 5044: }
! 5045: }
! 5046: /* }}} */
! 5047:
! 5048: /* {{{ proto int PharFileInfo::compress(int compression_type)
! 5049: * Instructs the Phar class to compress the current file using zlib or bzip2 compression
! 5050: */
! 5051: PHP_METHOD(PharFileInfo, compress)
! 5052: {
! 5053: long method;
! 5054: char *error;
! 5055: PHAR_ENTRY_OBJECT();
! 5056:
! 5057: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &method) == FAILURE) {
! 5058: return;
! 5059: }
! 5060:
! 5061: if (entry_obj->ent.entry->is_tar) {
! 5062: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5063: "Cannot compress with Gzip compression, not possible with tar-based phar archives");
! 5064: return;
! 5065: }
! 5066:
! 5067: if (entry_obj->ent.entry->is_dir) {
! 5068: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 5069: "Phar entry is a directory, cannot set compression"); \
! 5070: return;
! 5071: }
! 5072:
! 5073: if (PHAR_G(readonly) && !entry_obj->ent.entry->phar->is_data) {
! 5074: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5075: "Phar is readonly, cannot change compression");
! 5076: return;
! 5077: }
! 5078:
! 5079: if (entry_obj->ent.entry->is_deleted) {
! 5080: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5081: "Cannot compress deleted file");
! 5082: return;
! 5083: }
! 5084:
! 5085: if (entry_obj->ent.entry->is_persistent) {
! 5086: phar_archive_data *phar = entry_obj->ent.entry->phar;
! 5087:
! 5088: if (FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
! 5089: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar->fname);
! 5090: return;
! 5091: }
! 5092: /* re-populate after copy-on-write */
! 5093: zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry);
! 5094: }
! 5095: switch (method) {
! 5096: case PHAR_ENT_COMPRESSED_GZ:
! 5097: if (entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_GZ) {
! 5098: RETURN_TRUE;
! 5099: }
! 5100:
! 5101: if ((entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_BZ2) != 0) {
! 5102: if (!PHAR_G(has_bz2)) {
! 5103: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5104: "Cannot compress with gzip compression, file is already compressed with bzip2 compression and bz2 extension is not enabled, cannot decompress");
! 5105: return;
! 5106: }
! 5107:
! 5108: /* decompress this file indirectly */
! 5109: if (SUCCESS != phar_open_entry_fp(entry_obj->ent.entry, &error, 1 TSRMLS_CC)) {
! 5110: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5111: "Phar error: Cannot decompress bzip2-compressed file \"%s\" in phar \"%s\" in order to compress with gzip: %s", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname, error);
! 5112: efree(error);
! 5113: return;
! 5114: }
! 5115: }
! 5116:
! 5117: if (!PHAR_G(has_zlib)) {
! 5118: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5119: "Cannot compress with gzip compression, zlib extension is not enabled");
! 5120: return;
! 5121: }
! 5122:
! 5123: entry_obj->ent.entry->old_flags = entry_obj->ent.entry->flags;
! 5124: entry_obj->ent.entry->flags &= ~PHAR_ENT_COMPRESSION_MASK;
! 5125: entry_obj->ent.entry->flags |= PHAR_ENT_COMPRESSED_GZ;
! 5126: break;
! 5127: case PHAR_ENT_COMPRESSED_BZ2:
! 5128: if (entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_BZ2) {
! 5129: RETURN_TRUE;
! 5130: }
! 5131:
! 5132: if ((entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_GZ) != 0) {
! 5133: if (!PHAR_G(has_zlib)) {
! 5134: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5135: "Cannot compress with bzip2 compression, file is already compressed with gzip compression and zlib extension is not enabled, cannot decompress");
! 5136: return;
! 5137: }
! 5138:
! 5139: /* decompress this file indirectly */
! 5140: if (SUCCESS != phar_open_entry_fp(entry_obj->ent.entry, &error, 1 TSRMLS_CC)) {
! 5141: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5142: "Phar error: Cannot decompress gzip-compressed file \"%s\" in phar \"%s\" in order to compress with bzip2: %s", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname, error);
! 5143: efree(error);
! 5144: return;
! 5145: }
! 5146: }
! 5147:
! 5148: if (!PHAR_G(has_bz2)) {
! 5149: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5150: "Cannot compress with bzip2 compression, bz2 extension is not enabled");
! 5151: return;
! 5152: }
! 5153: entry_obj->ent.entry->old_flags = entry_obj->ent.entry->flags;
! 5154: entry_obj->ent.entry->flags &= ~PHAR_ENT_COMPRESSION_MASK;
! 5155: entry_obj->ent.entry->flags |= PHAR_ENT_COMPRESSED_BZ2;
! 5156: break;
! 5157: default:
! 5158: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 5159: "Unknown compression type specified"); \
! 5160: }
! 5161:
! 5162: entry_obj->ent.entry->phar->is_modified = 1;
! 5163: entry_obj->ent.entry->is_modified = 1;
! 5164: phar_flush(entry_obj->ent.entry->phar, 0, 0, 0, &error TSRMLS_CC);
! 5165:
! 5166: if (error) {
! 5167: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 5168: efree(error);
! 5169: }
! 5170:
! 5171: RETURN_TRUE;
! 5172: }
! 5173: /* }}} */
! 5174:
! 5175: /* {{{ proto int PharFileInfo::decompress()
! 5176: * Instructs the Phar class to decompress the current file
! 5177: */
! 5178: PHP_METHOD(PharFileInfo, decompress)
! 5179: {
! 5180: char *error;
! 5181: PHAR_ENTRY_OBJECT();
! 5182:
! 5183: if (zend_parse_parameters_none() == FAILURE) {
! 5184: return;
! 5185: }
! 5186:
! 5187: if (entry_obj->ent.entry->is_dir) {
! 5188: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, \
! 5189: "Phar entry is a directory, cannot set compression"); \
! 5190: return;
! 5191: }
! 5192:
! 5193: if ((entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSION_MASK) == 0) {
! 5194: RETURN_TRUE;
! 5195: }
! 5196:
! 5197: if (PHAR_G(readonly) && !entry_obj->ent.entry->phar->is_data) {
! 5198: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5199: "Phar is readonly, cannot decompress");
! 5200: return;
! 5201: }
! 5202:
! 5203: if (entry_obj->ent.entry->is_deleted) {
! 5204: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5205: "Cannot compress deleted file");
! 5206: return;
! 5207: }
! 5208:
! 5209: if ((entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_GZ) != 0 && !PHAR_G(has_zlib)) {
! 5210: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5211: "Cannot decompress Gzip-compressed file, zlib extension is not enabled");
! 5212: return;
! 5213: }
! 5214:
! 5215: if ((entry_obj->ent.entry->flags & PHAR_ENT_COMPRESSED_BZ2) != 0 && !PHAR_G(has_bz2)) {
! 5216: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
! 5217: "Cannot decompress Bzip2-compressed file, bz2 extension is not enabled");
! 5218: return;
! 5219: }
! 5220:
! 5221: if (entry_obj->ent.entry->is_persistent) {
! 5222: phar_archive_data *phar = entry_obj->ent.entry->phar;
! 5223:
! 5224: if (FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) {
! 5225: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "phar \"%s\" is persistent, unable to copy on write", phar->fname);
! 5226: return;
! 5227: }
! 5228: /* re-populate after copy-on-write */
! 5229: zend_hash_find(&phar->manifest, entry_obj->ent.entry->filename, entry_obj->ent.entry->filename_len, (void **)&entry_obj->ent.entry);
! 5230: }
! 5231: if (!entry_obj->ent.entry->fp) {
! 5232: if (FAILURE == phar_open_archive_fp(entry_obj->ent.entry->phar TSRMLS_CC)) {
! 5233: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Cannot decompress entry \"%s\", phar error: Cannot open phar archive \"%s\" for reading", entry_obj->ent.entry->filename, entry_obj->ent.entry->phar->fname);
! 5234: return;
! 5235: }
! 5236: entry_obj->ent.entry->fp_type = PHAR_FP;
! 5237: }
! 5238:
! 5239: entry_obj->ent.entry->old_flags = entry_obj->ent.entry->flags;
! 5240: entry_obj->ent.entry->flags &= ~PHAR_ENT_COMPRESSION_MASK;
! 5241: entry_obj->ent.entry->phar->is_modified = 1;
! 5242: entry_obj->ent.entry->is_modified = 1;
! 5243: phar_flush(entry_obj->ent.entry->phar, 0, 0, 0, &error TSRMLS_CC);
! 5244:
! 5245: if (error) {
! 5246: zend_throw_exception_ex(phar_ce_PharException, 0 TSRMLS_CC, "%s", error);
! 5247: efree(error);
! 5248: }
! 5249: RETURN_TRUE;
! 5250: }
! 5251: /* }}} */
! 5252:
! 5253: #endif /* HAVE_SPL */
! 5254:
! 5255: /* {{{ phar methods */
! 5256: PHAR_ARG_INFO
! 5257: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar___construct, 0, 0, 1)
! 5258: ZEND_ARG_INFO(0, filename)
! 5259: ZEND_ARG_INFO(0, flags)
! 5260: ZEND_ARG_INFO(0, alias)
! 5261: ZEND_ARG_INFO(0, fileformat)
! 5262: ZEND_END_ARG_INFO()
! 5263:
! 5264: PHAR_ARG_INFO
! 5265: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_createDS, 0, 0, 0)
! 5266: ZEND_ARG_INFO(0, index)
! 5267: ZEND_ARG_INFO(0, webindex)
! 5268: ZEND_END_ARG_INFO()
! 5269:
! 5270: PHAR_ARG_INFO
! 5271: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_cancompress, 0, 0, 0)
! 5272: ZEND_ARG_INFO(0, method)
! 5273: ZEND_END_ARG_INFO()
! 5274:
! 5275: PHAR_ARG_INFO
! 5276: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_isvalidpharfilename, 0, 0, 1)
! 5277: ZEND_ARG_INFO(0, filename)
! 5278: ZEND_ARG_INFO(0, executable)
! 5279: ZEND_END_ARG_INFO()
! 5280:
! 5281: PHAR_ARG_INFO
! 5282: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_loadPhar, 0, 0, 1)
! 5283: ZEND_ARG_INFO(0, filename)
! 5284: ZEND_ARG_INFO(0, alias)
! 5285: ZEND_END_ARG_INFO()
! 5286:
! 5287: PHAR_ARG_INFO
! 5288: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_mapPhar, 0, 0, 0)
! 5289: ZEND_ARG_INFO(0, alias)
! 5290: ZEND_ARG_INFO(0, offset)
! 5291: ZEND_END_ARG_INFO()
! 5292:
! 5293: PHAR_ARG_INFO
! 5294: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_mount, 0, 0, 2)
! 5295: ZEND_ARG_INFO(0, inphar)
! 5296: ZEND_ARG_INFO(0, externalfile)
! 5297: ZEND_END_ARG_INFO()
! 5298:
! 5299: PHAR_ARG_INFO
! 5300: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_mungServer, 0, 0, 1)
! 5301: ZEND_ARG_INFO(0, munglist)
! 5302: ZEND_END_ARG_INFO()
! 5303:
! 5304: PHAR_ARG_INFO
! 5305: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_webPhar, 0, 0, 0)
! 5306: ZEND_ARG_INFO(0, alias)
! 5307: ZEND_ARG_INFO(0, index)
! 5308: ZEND_ARG_INFO(0, f404)
! 5309: ZEND_ARG_INFO(0, mimetypes)
! 5310: ZEND_ARG_INFO(0, rewrites)
! 5311: ZEND_END_ARG_INFO()
! 5312:
! 5313: PHAR_ARG_INFO
! 5314: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_running, 0, 0, 1)
! 5315: ZEND_ARG_INFO(0, retphar)
! 5316: ZEND_END_ARG_INFO()
! 5317:
! 5318: PHAR_ARG_INFO
! 5319: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_ua, 0, 0, 1)
! 5320: ZEND_ARG_INFO(0, archive)
! 5321: ZEND_END_ARG_INFO()
! 5322:
! 5323: #if HAVE_SPL
! 5324: PHAR_ARG_INFO
! 5325: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_build, 0, 0, 1)
! 5326: ZEND_ARG_INFO(0, iterator)
! 5327: ZEND_ARG_INFO(0, base_directory)
! 5328: ZEND_END_ARG_INFO()
! 5329:
! 5330: PHAR_ARG_INFO
! 5331: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_conv, 0, 0, 0)
! 5332: ZEND_ARG_INFO(0, format)
! 5333: ZEND_ARG_INFO(0, compression_type)
! 5334: ZEND_ARG_INFO(0, file_ext)
! 5335: ZEND_END_ARG_INFO()
! 5336:
! 5337: PHAR_ARG_INFO
! 5338: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_comps, 0, 0, 1)
! 5339: ZEND_ARG_INFO(0, compression_type)
! 5340: ZEND_ARG_INFO(0, file_ext)
! 5341: ZEND_END_ARG_INFO()
! 5342:
! 5343: PHAR_ARG_INFO
! 5344: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_decomp, 0, 0, 0)
! 5345: ZEND_ARG_INFO(0, file_ext)
! 5346: ZEND_END_ARG_INFO()
! 5347:
! 5348: PHAR_ARG_INFO
! 5349: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_comp, 0, 0, 1)
! 5350: ZEND_ARG_INFO(0, compression_type)
! 5351: ZEND_END_ARG_INFO()
! 5352:
! 5353: PHAR_ARG_INFO
! 5354: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_compo, 0, 0, 0)
! 5355: ZEND_ARG_INFO(0, compression_type)
! 5356: ZEND_END_ARG_INFO()
! 5357:
! 5358: PHAR_ARG_INFO
! 5359: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_copy, 0, 0, 2)
! 5360: ZEND_ARG_INFO(0, newfile)
! 5361: ZEND_ARG_INFO(0, oldfile)
! 5362: ZEND_END_ARG_INFO()
! 5363:
! 5364: PHAR_ARG_INFO
! 5365: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_delete, 0, 0, 1)
! 5366: ZEND_ARG_INFO(0, entry)
! 5367: ZEND_END_ARG_INFO()
! 5368:
! 5369: PHAR_ARG_INFO
! 5370: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_fromdir, 0, 0, 1)
! 5371: ZEND_ARG_INFO(0, base_dir)
! 5372: ZEND_ARG_INFO(0, regex)
! 5373: ZEND_END_ARG_INFO()
! 5374:
! 5375: PHAR_ARG_INFO
! 5376: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_offsetExists, 0, 0, 1)
! 5377: ZEND_ARG_INFO(0, entry)
! 5378: ZEND_END_ARG_INFO()
! 5379:
! 5380: PHAR_ARG_INFO
! 5381: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_offsetSet, 0, 0, 2)
! 5382: ZEND_ARG_INFO(0, entry)
! 5383: ZEND_ARG_INFO(0, value)
! 5384: ZEND_END_ARG_INFO()
! 5385:
! 5386: PHAR_ARG_INFO
! 5387: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_setAlias, 0, 0, 1)
! 5388: ZEND_ARG_INFO(0, alias)
! 5389: ZEND_END_ARG_INFO()
! 5390:
! 5391: PHAR_ARG_INFO
! 5392: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_setMetadata, 0, 0, 1)
! 5393: ZEND_ARG_INFO(0, metadata)
! 5394: ZEND_END_ARG_INFO()
! 5395:
! 5396: PHAR_ARG_INFO
! 5397: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_setSigAlgo, 0, 0, 1)
! 5398: ZEND_ARG_INFO(0, algorithm)
! 5399: ZEND_ARG_INFO(0, privatekey)
! 5400: ZEND_END_ARG_INFO()
! 5401:
! 5402: PHAR_ARG_INFO
! 5403: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_setStub, 0, 0, 1)
! 5404: ZEND_ARG_INFO(0, newstub)
! 5405: ZEND_ARG_INFO(0, maxlen)
! 5406: ZEND_END_ARG_INFO()
! 5407:
! 5408: PHAR_ARG_INFO
! 5409: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_emptydir, 0, 0, 0)
! 5410: ZEND_ARG_INFO(0, dirname)
! 5411: ZEND_END_ARG_INFO()
! 5412:
! 5413: PHAR_ARG_INFO
! 5414: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_extract, 0, 0, 1)
! 5415: ZEND_ARG_INFO(0, pathto)
! 5416: ZEND_ARG_INFO(0, files)
! 5417: ZEND_ARG_INFO(0, overwrite)
! 5418: ZEND_END_ARG_INFO()
! 5419:
! 5420: PHAR_ARG_INFO
! 5421: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_addfile, 0, 0, 1)
! 5422: ZEND_ARG_INFO(0, filename)
! 5423: ZEND_ARG_INFO(0, localname)
! 5424: ZEND_END_ARG_INFO()
! 5425:
! 5426: PHAR_ARG_INFO
! 5427: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_fromstring, 0, 0, 1)
! 5428: ZEND_ARG_INFO(0, localname)
! 5429: ZEND_ARG_INFO(0, contents)
! 5430: ZEND_END_ARG_INFO()
! 5431:
! 5432: PHAR_ARG_INFO
! 5433: ZEND_BEGIN_ARG_INFO_EX(arginfo_phar_isff, 0, 0, 1)
! 5434: ZEND_ARG_INFO(0, fileformat)
! 5435: ZEND_END_ARG_INFO()
! 5436:
! 5437: PHAR_ARG_INFO
! 5438: ZEND_BEGIN_ARG_INFO(arginfo_phar__void, 0)
! 5439: ZEND_END_ARG_INFO()
! 5440:
! 5441:
! 5442: #endif /* HAVE_SPL */
! 5443:
! 5444: zend_function_entry php_archive_methods[] = {
! 5445: #if !HAVE_SPL
! 5446: PHP_ME(Phar, __construct, arginfo_phar___construct, ZEND_ACC_PRIVATE)
! 5447: #else
! 5448: PHP_ME(Phar, __construct, arginfo_phar___construct, ZEND_ACC_PUBLIC)
! 5449: PHP_ME(Phar, __destruct, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5450: PHP_ME(Phar, addEmptyDir, arginfo_phar_emptydir, ZEND_ACC_PUBLIC)
! 5451: PHP_ME(Phar, addFile, arginfo_phar_addfile, ZEND_ACC_PUBLIC)
! 5452: PHP_ME(Phar, addFromString, arginfo_phar_fromstring, ZEND_ACC_PUBLIC)
! 5453: PHP_ME(Phar, buildFromDirectory, arginfo_phar_fromdir, ZEND_ACC_PUBLIC)
! 5454: PHP_ME(Phar, buildFromIterator, arginfo_phar_build, ZEND_ACC_PUBLIC)
! 5455: PHP_ME(Phar, compressFiles, arginfo_phar_comp, ZEND_ACC_PUBLIC)
! 5456: PHP_ME(Phar, decompressFiles, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5457: PHP_ME(Phar, compress, arginfo_phar_comps, ZEND_ACC_PUBLIC)
! 5458: PHP_ME(Phar, decompress, arginfo_phar_decomp, ZEND_ACC_PUBLIC)
! 5459: PHP_ME(Phar, convertToExecutable, arginfo_phar_conv, ZEND_ACC_PUBLIC)
! 5460: PHP_ME(Phar, convertToData, arginfo_phar_conv, ZEND_ACC_PUBLIC)
! 5461: PHP_ME(Phar, copy, arginfo_phar_copy, ZEND_ACC_PUBLIC)
! 5462: PHP_ME(Phar, count, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5463: PHP_ME(Phar, delete, arginfo_phar_delete, ZEND_ACC_PUBLIC)
! 5464: PHP_ME(Phar, delMetadata, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5465: PHP_ME(Phar, extractTo, arginfo_phar_extract, ZEND_ACC_PUBLIC)
! 5466: PHP_ME(Phar, getAlias, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5467: PHP_ME(Phar, getPath, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5468: PHP_ME(Phar, getMetadata, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5469: PHP_ME(Phar, getModified, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5470: PHP_ME(Phar, getSignature, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5471: PHP_ME(Phar, getStub, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5472: PHP_ME(Phar, getVersion, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5473: PHP_ME(Phar, hasMetadata, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5474: PHP_ME(Phar, isBuffering, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5475: PHP_ME(Phar, isCompressed, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5476: PHP_ME(Phar, isFileFormat, arginfo_phar_isff, ZEND_ACC_PUBLIC)
! 5477: PHP_ME(Phar, isWritable, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5478: PHP_ME(Phar, offsetExists, arginfo_phar_offsetExists, ZEND_ACC_PUBLIC)
! 5479: PHP_ME(Phar, offsetGet, arginfo_phar_offsetExists, ZEND_ACC_PUBLIC)
! 5480: PHP_ME(Phar, offsetSet, arginfo_phar_offsetSet, ZEND_ACC_PUBLIC)
! 5481: PHP_ME(Phar, offsetUnset, arginfo_phar_offsetExists, ZEND_ACC_PUBLIC)
! 5482: PHP_ME(Phar, setAlias, arginfo_phar_setAlias, ZEND_ACC_PUBLIC)
! 5483: PHP_ME(Phar, setDefaultStub, arginfo_phar_createDS, ZEND_ACC_PUBLIC)
! 5484: PHP_ME(Phar, setMetadata, arginfo_phar_setMetadata, ZEND_ACC_PUBLIC)
! 5485: PHP_ME(Phar, setSignatureAlgorithm, arginfo_phar_setSigAlgo, ZEND_ACC_PUBLIC)
! 5486: PHP_ME(Phar, setStub, arginfo_phar_setStub, ZEND_ACC_PUBLIC)
! 5487: PHP_ME(Phar, startBuffering, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5488: PHP_ME(Phar, stopBuffering, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5489: #endif
! 5490: /* static member functions */
! 5491: PHP_ME(Phar, apiVersion, arginfo_phar__void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5492: PHP_ME(Phar, canCompress, arginfo_phar_cancompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5493: PHP_ME(Phar, canWrite, arginfo_phar__void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5494: PHP_ME(Phar, createDefaultStub, arginfo_phar_createDS, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5495: PHP_ME(Phar, getSupportedCompression,arginfo_phar__void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5496: PHP_ME(Phar, getSupportedSignatures,arginfo_phar__void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5497: PHP_ME(Phar, interceptFileFuncs, arginfo_phar__void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5498: PHP_ME(Phar, isValidPharFilename, arginfo_phar_isvalidpharfilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5499: PHP_ME(Phar, loadPhar, arginfo_phar_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5500: PHP_ME(Phar, mapPhar, arginfo_phar_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5501: PHP_ME(Phar, running, arginfo_phar_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5502: PHP_ME(Phar, mount, arginfo_phar_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5503: PHP_ME(Phar, mungServer, arginfo_phar_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5504: PHP_ME(Phar, unlinkArchive, arginfo_phar_ua, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5505: PHP_ME(Phar, webPhar, arginfo_phar_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
! 5506: PHP_FE_END
! 5507: };
! 5508:
! 5509: #if HAVE_SPL
! 5510: PHAR_ARG_INFO
! 5511: ZEND_BEGIN_ARG_INFO_EX(arginfo_entry___construct, 0, 0, 1)
! 5512: ZEND_ARG_INFO(0, filename)
! 5513: ZEND_END_ARG_INFO()
! 5514:
! 5515: PHAR_ARG_INFO
! 5516: ZEND_BEGIN_ARG_INFO_EX(arginfo_entry_chmod, 0, 0, 1)
! 5517: ZEND_ARG_INFO(0, perms)
! 5518: ZEND_END_ARG_INFO()
! 5519:
! 5520: zend_function_entry php_entry_methods[] = {
! 5521: PHP_ME(PharFileInfo, __construct, arginfo_entry___construct, ZEND_ACC_PUBLIC)
! 5522: PHP_ME(PharFileInfo, __destruct, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5523: PHP_ME(PharFileInfo, chmod, arginfo_entry_chmod, ZEND_ACC_PUBLIC)
! 5524: PHP_ME(PharFileInfo, compress, arginfo_phar_comp, ZEND_ACC_PUBLIC)
! 5525: PHP_ME(PharFileInfo, decompress, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5526: PHP_ME(PharFileInfo, delMetadata, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5527: PHP_ME(PharFileInfo, getCompressedSize, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5528: PHP_ME(PharFileInfo, getCRC32, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5529: PHP_ME(PharFileInfo, getContent, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5530: PHP_ME(PharFileInfo, getMetadata, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5531: PHP_ME(PharFileInfo, getPharFlags, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5532: PHP_ME(PharFileInfo, hasMetadata, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5533: PHP_ME(PharFileInfo, isCompressed, arginfo_phar_compo, ZEND_ACC_PUBLIC)
! 5534: PHP_ME(PharFileInfo, isCRCChecked, arginfo_phar__void, ZEND_ACC_PUBLIC)
! 5535: PHP_ME(PharFileInfo, setMetadata, arginfo_phar_setMetadata, ZEND_ACC_PUBLIC)
! 5536: PHP_FE_END
! 5537: };
! 5538: #endif /* HAVE_SPL */
! 5539:
! 5540: zend_function_entry phar_exception_methods[] = {
! 5541: PHP_FE_END
! 5542: };
! 5543: /* }}} */
! 5544:
! 5545: #define REGISTER_PHAR_CLASS_CONST_LONG(class_name, const_name, value) \
! 5546: zend_declare_class_constant_long(class_name, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC);
! 5547:
! 5548: #if PHP_VERSION_ID < 50200
! 5549: # define phar_exception_get_default() zend_exception_get_default()
! 5550: #else
! 5551: # define phar_exception_get_default() zend_exception_get_default(TSRMLS_C)
! 5552: #endif
! 5553:
! 5554: void phar_object_init(TSRMLS_D) /* {{{ */
! 5555: {
! 5556: zend_class_entry ce;
! 5557:
! 5558: INIT_CLASS_ENTRY(ce, "PharException", phar_exception_methods);
! 5559: phar_ce_PharException = zend_register_internal_class_ex(&ce, phar_exception_get_default(), NULL TSRMLS_CC);
! 5560:
! 5561: #if HAVE_SPL
! 5562: INIT_CLASS_ENTRY(ce, "Phar", php_archive_methods);
! 5563: phar_ce_archive = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator, NULL TSRMLS_CC);
! 5564:
! 5565: zend_class_implements(phar_ce_archive TSRMLS_CC, 2, spl_ce_Countable, zend_ce_arrayaccess);
! 5566:
! 5567: INIT_CLASS_ENTRY(ce, "PharData", php_archive_methods);
! 5568: phar_ce_data = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator, NULL TSRMLS_CC);
! 5569:
! 5570: zend_class_implements(phar_ce_data TSRMLS_CC, 2, spl_ce_Countable, zend_ce_arrayaccess);
! 5571:
! 5572: INIT_CLASS_ENTRY(ce, "PharFileInfo", php_entry_methods);
! 5573: phar_ce_entry = zend_register_internal_class_ex(&ce, spl_ce_SplFileInfo, NULL TSRMLS_CC);
! 5574: #else
! 5575: INIT_CLASS_ENTRY(ce, "Phar", php_archive_methods);
! 5576: phar_ce_archive = zend_register_internal_class(&ce TSRMLS_CC);
! 5577: phar_ce_archive->ce_flags |= ZEND_ACC_FINAL_CLASS;
! 5578:
! 5579: INIT_CLASS_ENTRY(ce, "PharData", php_archive_methods);
! 5580: phar_ce_data = zend_register_internal_class(&ce TSRMLS_CC);
! 5581: phar_ce_data->ce_flags |= ZEND_ACC_FINAL_CLASS;
! 5582: #endif
! 5583:
! 5584: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "BZ2", PHAR_ENT_COMPRESSED_BZ2)
! 5585: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "GZ", PHAR_ENT_COMPRESSED_GZ)
! 5586: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "NONE", PHAR_ENT_COMPRESSED_NONE)
! 5587: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "PHAR", PHAR_FORMAT_PHAR)
! 5588: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "TAR", PHAR_FORMAT_TAR)
! 5589: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "ZIP", PHAR_FORMAT_ZIP)
! 5590: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "COMPRESSED", PHAR_ENT_COMPRESSION_MASK)
! 5591: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "PHP", PHAR_MIME_PHP)
! 5592: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "PHPS", PHAR_MIME_PHPS)
! 5593: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "MD5", PHAR_SIG_MD5)
! 5594: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "OPENSSL", PHAR_SIG_OPENSSL)
! 5595: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "SHA1", PHAR_SIG_SHA1)
! 5596: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "SHA256", PHAR_SIG_SHA256)
! 5597: REGISTER_PHAR_CLASS_CONST_LONG(phar_ce_archive, "SHA512", PHAR_SIG_SHA512)
! 5598: }
! 5599: /* }}} */
! 5600:
! 5601: /*
! 5602: * Local variables:
! 5603: * tab-width: 4
! 5604: * c-basic-offset: 4
! 5605: * End:
! 5606: * vim600: noet sw=4 ts=4 fdm=marker
! 5607: * vim<600: noet sw=4 ts=4
! 5608: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to phar_object.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