Annotation of embedaddon/php/ext/phar/func_interceptors.c, revision 1.1.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: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: func_interceptors.c 321634 2012-01-01 13:15:04Z felipe $ */
20:
21: #include "phar_internal.h"
22:
23: #define PHAR_FUNC(name) \
24: static PHP_NAMED_FUNCTION(name)
25:
26: PHAR_FUNC(phar_opendir) /* {{{ */
27: {
28: char *filename;
29: int filename_len;
30: zval *zcontext = NULL;
31:
32: if (!PHAR_G(intercepted)) {
33: goto skip_phar;
34: }
35:
36: if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
37: && !cached_phars.arBuckets) {
38: goto skip_phar;
39: }
40:
41: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &filename, &filename_len, &zcontext) == FAILURE) {
42: return;
43: }
44:
45: if (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://")) {
46: char *arch, *entry, *fname;
47: int arch_len, entry_len, fname_len;
48: fname = zend_get_executed_filename(TSRMLS_C);
49:
50: /* we are checking for existence of a file within the relative path. Chances are good that this is
51: retrieving something from within the phar archive */
52:
53: if (strncasecmp(fname, "phar://", 7)) {
54: goto skip_phar;
55: }
56: fname_len = strlen(fname);
57: if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
58: php_stream_context *context = NULL;
59: php_stream *stream;
60: char *name;
61:
62: efree(entry);
63: entry = estrndup(filename, filename_len);
64: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
65: entry_len = filename_len;
66: /* retrieving a file within the current directory, so use this if possible */
67: entry = phar_fix_filepath(entry, &entry_len, 1 TSRMLS_CC);
68:
69: if (entry[0] == '/') {
70: spprintf(&name, 4096, "phar://%s%s", arch, entry);
71: } else {
72: spprintf(&name, 4096, "phar://%s/%s", arch, entry);
73: }
74: efree(entry);
75: efree(arch);
76: if (zcontext) {
77: context = php_stream_context_from_zval(zcontext, 0);
78: }
79: stream = php_stream_opendir(name, REPORT_ERRORS, context);
80: efree(name);
81: if (!stream) {
82: RETURN_FALSE;
83: }
84: php_stream_to_zval(stream, return_value);
85: return;
86: }
87: }
88: skip_phar:
89: PHAR_G(orig_opendir)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
90: return;
91: }
92: /* }}} */
93:
94: PHAR_FUNC(phar_file_get_contents) /* {{{ */
95: {
96: char *filename;
97: int filename_len;
98: char *contents;
99: zend_bool use_include_path = 0;
100: php_stream *stream;
101: int len;
102: long offset = -1;
103: long maxlen = PHP_STREAM_COPY_ALL;
104: zval *zcontext = NULL;
105:
106: if (!PHAR_G(intercepted)) {
107: goto skip_phar;
108: }
109:
110: if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
111: && !cached_phars.arBuckets) {
112: goto skip_phar;
113: }
114:
115: /* Parse arguments */
116: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|br!ll", &filename, &filename_len, &use_include_path, &zcontext, &offset, &maxlen) == FAILURE) {
117: goto skip_phar;
118: }
119:
120: if (use_include_path || (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://"))) {
121: char *arch, *entry, *fname;
122: int arch_len, entry_len, fname_len;
123: php_stream_context *context = NULL;
124:
125: fname = zend_get_executed_filename(TSRMLS_C);
126:
127: if (strncasecmp(fname, "phar://", 7)) {
128: goto skip_phar;
129: }
130: fname_len = strlen(fname);
131: if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
132: char *name;
133: phar_archive_data *phar;
134:
135: efree(entry);
136: entry = filename;
137: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
138: entry_len = filename_len;
139:
140: if (ZEND_NUM_ARGS() == 5 && maxlen < 0) {
141: efree(arch);
142: php_error_docref(NULL TSRMLS_CC, E_WARNING, "length must be greater than or equal to zero");
143: RETURN_FALSE;
144: }
145:
146: /* retrieving a file defaults to within the current directory, so use this if possible */
147: if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
148: efree(arch);
149: goto skip_phar;
150: }
151: if (use_include_path) {
152: if ((entry = phar_find_in_include_path(entry, entry_len, NULL TSRMLS_CC))) {
153: name = entry;
154: goto phar_it;
155: } else {
156: /* this file is not in the phar, use the original path */
157: efree(arch);
158: goto skip_phar;
159: }
160: } else {
161: entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC);
162: if (entry[0] == '/') {
163: if (!zend_hash_exists(&(phar->manifest), entry + 1, entry_len - 1)) {
164: /* this file is not in the phar, use the original path */
165: notfound:
166: efree(arch);
167: efree(entry);
168: goto skip_phar;
169: }
170: } else {
171: if (!zend_hash_exists(&(phar->manifest), entry, entry_len)) {
172: goto notfound;
173: }
174: }
175: /* auto-convert to phar:// */
176: if (entry[0] == '/') {
177: spprintf(&name, 4096, "phar://%s%s", arch, entry);
178: } else {
179: spprintf(&name, 4096, "phar://%s/%s", arch, entry);
180: }
181: if (entry != filename) {
182: efree(entry);
183: }
184: }
185:
186: phar_it:
187: efree(arch);
188: if (zcontext) {
189: context = php_stream_context_from_zval(zcontext, 0);
190: }
191: stream = php_stream_open_wrapper_ex(name, "rb", 0 | REPORT_ERRORS, NULL, context);
192: efree(name);
193:
194: if (!stream) {
195: RETURN_FALSE;
196: }
197:
198: if (offset > 0 && php_stream_seek(stream, offset, SEEK_SET) < 0) {
199: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to seek to position %ld in the stream", offset);
200: php_stream_close(stream);
201: RETURN_FALSE;
202: }
203:
204: /* uses mmap if possible */
205: if ((len = php_stream_copy_to_mem(stream, &contents, maxlen, 0)) > 0) {
206: #if PHP_MAJOR_VERSION < 6
207: if (PG(magic_quotes_runtime)) {
208: int newlen;
209: contents = php_addslashes(contents, len, &newlen, 1 TSRMLS_CC); /* 1 = free source string */
210: len = newlen;
211: }
212: #endif
213: RETVAL_STRINGL(contents, len, 0);
214: } else if (len == 0) {
215: RETVAL_EMPTY_STRING();
216: } else {
217: RETVAL_FALSE;
218: }
219:
220: php_stream_close(stream);
221: return;
222: }
223: }
224: skip_phar:
225: PHAR_G(orig_file_get_contents)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
226: return;
227: }
228: /* }}} */
229:
230: PHAR_FUNC(phar_readfile) /* {{{ */
231: {
232: char *filename;
233: int filename_len;
234: int size = 0;
235: zend_bool use_include_path = 0;
236: zval *zcontext = NULL;
237: php_stream *stream;
238:
239: if (!PHAR_G(intercepted)) {
240: goto skip_phar;
241: }
242:
243: if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
244: && !cached_phars.arBuckets) {
245: goto skip_phar;
246: }
247: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s|br!", &filename, &filename_len, &use_include_path, &zcontext) == FAILURE) {
248: goto skip_phar;
249: }
250: if (use_include_path || (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://"))) {
251: char *arch, *entry, *fname;
252: int arch_len, entry_len, fname_len;
253: php_stream_context *context = NULL;
254: char *name;
255: phar_archive_data *phar;
256: fname = zend_get_executed_filename(TSRMLS_C);
257:
258: if (strncasecmp(fname, "phar://", 7)) {
259: goto skip_phar;
260: }
261: fname_len = strlen(fname);
262: if (FAILURE == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
263: goto skip_phar;
264: }
265:
266: efree(entry);
267: entry = filename;
268: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
269: entry_len = filename_len;
270: /* retrieving a file defaults to within the current directory, so use this if possible */
271: if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
272: efree(arch);
273: goto skip_phar;
274: }
275: if (use_include_path) {
276: if (!(entry = phar_find_in_include_path(entry, entry_len, NULL TSRMLS_CC))) {
277: /* this file is not in the phar, use the original path */
278: efree(arch);
279: goto skip_phar;
280: } else {
281: name = entry;
282: }
283: } else {
284: entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC);
285: if (entry[0] == '/') {
286: if (!zend_hash_exists(&(phar->manifest), entry + 1, entry_len - 1)) {
287: /* this file is not in the phar, use the original path */
288: notfound:
289: efree(entry);
290: efree(arch);
291: goto skip_phar;
292: }
293: } else {
294: if (!zend_hash_exists(&(phar->manifest), entry, entry_len)) {
295: goto notfound;
296: }
297: }
298: /* auto-convert to phar:// */
299: if (entry[0] == '/') {
300: spprintf(&name, 4096, "phar://%s%s", arch, entry);
301: } else {
302: spprintf(&name, 4096, "phar://%s/%s", arch, entry);
303: }
304: efree(entry);
305: }
306:
307: efree(arch);
308: context = php_stream_context_from_zval(zcontext, 0);
309: stream = php_stream_open_wrapper_ex(name, "rb", 0 | REPORT_ERRORS, NULL, context);
310: efree(name);
311: if (stream == NULL) {
312: RETURN_FALSE;
313: }
314: size = php_stream_passthru(stream);
315: php_stream_close(stream);
316: RETURN_LONG(size);
317: }
318:
319: skip_phar:
320: PHAR_G(orig_readfile)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
321: return;
322:
323: }
324: /* }}} */
325:
326: PHAR_FUNC(phar_fopen) /* {{{ */
327: {
328: char *filename, *mode;
329: int filename_len, mode_len;
330: zend_bool use_include_path = 0;
331: zval *zcontext = NULL;
332: php_stream *stream;
333:
334: if (!PHAR_G(intercepted)) {
335: goto skip_phar;
336: }
337:
338: if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
339: && !cached_phars.arBuckets) {
340: /* no need to check, include_path not even specified in fopen/ no active phars */
341: goto skip_phar;
342: }
343: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "ss|br", &filename, &filename_len, &mode, &mode_len, &use_include_path, &zcontext) == FAILURE) {
344: goto skip_phar;
345: }
346: if (use_include_path || (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://"))) {
347: char *arch, *entry, *fname;
348: int arch_len, entry_len, fname_len;
349: php_stream_context *context = NULL;
350: char *name;
351: phar_archive_data *phar;
352: fname = zend_get_executed_filename(TSRMLS_C);
353:
354: if (strncasecmp(fname, "phar://", 7)) {
355: goto skip_phar;
356: }
357: fname_len = strlen(fname);
358: if (FAILURE == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
359: goto skip_phar;
360: }
361:
362: efree(entry);
363: entry = filename;
364: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
365: entry_len = filename_len;
366: /* retrieving a file defaults to within the current directory, so use this if possible */
367: if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
368: efree(arch);
369: goto skip_phar;
370: }
371: if (use_include_path) {
372: if (!(entry = phar_find_in_include_path(entry, entry_len, NULL TSRMLS_CC))) {
373: /* this file is not in the phar, use the original path */
374: efree(arch);
375: goto skip_phar;
376: } else {
377: name = entry;
378: }
379: } else {
380: entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC);
381: if (entry[0] == '/') {
382: if (!zend_hash_exists(&(phar->manifest), entry + 1, entry_len - 1)) {
383: /* this file is not in the phar, use the original path */
384: notfound:
385: efree(entry);
386: efree(arch);
387: goto skip_phar;
388: }
389: } else {
390: if (!zend_hash_exists(&(phar->manifest), entry, entry_len)) {
391: /* this file is not in the phar, use the original path */
392: goto notfound;
393: }
394: }
395: /* auto-convert to phar:// */
396: if (entry[0] == '/') {
397: spprintf(&name, 4096, "phar://%s%s", arch, entry);
398: } else {
399: spprintf(&name, 4096, "phar://%s/%s", arch, entry);
400: }
401: efree(entry);
402: }
403:
404: efree(arch);
405: context = php_stream_context_from_zval(zcontext, 0);
406: stream = php_stream_open_wrapper_ex(name, mode, 0 | REPORT_ERRORS, NULL, context);
407: efree(name);
408: if (stream == NULL) {
409: RETURN_FALSE;
410: }
411: php_stream_to_zval(stream, return_value);
412: if (zcontext) {
413: zend_list_addref(Z_RESVAL_P(zcontext));
414: }
415: return;
416: }
417: skip_phar:
418: PHAR_G(orig_fopen)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
419: return;
420: }
421: /* }}} */
422:
423: #ifndef S_ISDIR
424: #define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
425: #endif
426: #ifndef S_ISREG
427: #define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG)
428: #endif
429: #ifndef S_ISLNK
430: #define S_ISLNK(mode) (((mode)&S_IFMT) == S_IFLNK)
431: #endif
432:
433: #define S_IXROOT ( S_IXUSR | S_IXGRP | S_IXOTH )
434:
435: #define IS_LINK_OPERATION(__t) ((__t) == FS_TYPE || (__t) == FS_IS_LINK || (__t) == FS_LSTAT)
436: #define IS_EXISTS_CHECK(__t) ((__t) == FS_EXISTS || (__t) == FS_IS_W || (__t) == FS_IS_R || (__t) == FS_IS_X || (__t) == FS_IS_FILE || (__t) == FS_IS_DIR || (__t) == FS_IS_LINK)
437: #define IS_ABLE_CHECK(__t) ((__t) == FS_IS_R || (__t) == FS_IS_W || (__t) == FS_IS_X)
438: #define IS_ACCESS_CHECK(__t) (IS_ABLE_CHECK(type) || (__t) == FS_EXISTS)
439:
440: /* {{{ php_stat
441: */
442: static void phar_fancy_stat(struct stat *stat_sb, int type, zval *return_value TSRMLS_DC)
443: {
444: zval *stat_dev, *stat_ino, *stat_mode, *stat_nlink, *stat_uid, *stat_gid, *stat_rdev,
445: *stat_size, *stat_atime, *stat_mtime, *stat_ctime, *stat_blksize, *stat_blocks;
446: int rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */
447: char *stat_sb_names[13] = {
448: "dev", "ino", "mode", "nlink", "uid", "gid", "rdev",
449: "size", "atime", "mtime", "ctime", "blksize", "blocks"
450: };
451:
452: #ifndef NETWARE
453: if (type >= FS_IS_W && type <= FS_IS_X) {
454: if(stat_sb->st_uid==getuid()) {
455: rmask=S_IRUSR;
456: wmask=S_IWUSR;
457: xmask=S_IXUSR;
458: } else if(stat_sb->st_gid==getgid()) {
459: rmask=S_IRGRP;
460: wmask=S_IWGRP;
461: xmask=S_IXGRP;
462: } else {
463: int groups, n, i;
464: gid_t *gids;
465:
466: groups = getgroups(0, NULL);
467: if(groups > 0) {
468: gids=(gid_t *)safe_emalloc(groups, sizeof(gid_t), 0);
469: n=getgroups(groups, gids);
470: for(i=0;i<n;++i){
471: if(stat_sb->st_gid==gids[i]) {
472: rmask=S_IRGRP;
473: wmask=S_IWGRP;
474: xmask=S_IXGRP;
475: break;
476: }
477: }
478: efree(gids);
479: }
480: }
481: }
482: #endif
483:
484: switch (type) {
485: case FS_PERMS:
486: RETURN_LONG((long)stat_sb->st_mode);
487: case FS_INODE:
488: RETURN_LONG((long)stat_sb->st_ino);
489: case FS_SIZE:
490: RETURN_LONG((long)stat_sb->st_size);
491: case FS_OWNER:
492: RETURN_LONG((long)stat_sb->st_uid);
493: case FS_GROUP:
494: RETURN_LONG((long)stat_sb->st_gid);
495: case FS_ATIME:
496: #ifdef NETWARE
497: RETURN_LONG((long)stat_sb->st_atime.tv_sec);
498: #else
499: RETURN_LONG((long)stat_sb->st_atime);
500: #endif
501: case FS_MTIME:
502: #ifdef NETWARE
503: RETURN_LONG((long)stat_sb->st_mtime.tv_sec);
504: #else
505: RETURN_LONG((long)stat_sb->st_mtime);
506: #endif
507: case FS_CTIME:
508: #ifdef NETWARE
509: RETURN_LONG((long)stat_sb->st_ctime.tv_sec);
510: #else
511: RETURN_LONG((long)stat_sb->st_ctime);
512: #endif
513: case FS_TYPE:
514: if (S_ISLNK(stat_sb->st_mode)) {
515: RETURN_STRING("link", 1);
516: }
517: switch(stat_sb->st_mode & S_IFMT) {
518: case S_IFDIR: RETURN_STRING("dir", 1);
519: case S_IFREG: RETURN_STRING("file", 1);
520: }
521: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unknown file type (%u)", stat_sb->st_mode & S_IFMT);
522: RETURN_STRING("unknown", 1);
523: case FS_IS_W:
524: RETURN_BOOL((stat_sb->st_mode & wmask) != 0);
525: case FS_IS_R:
526: RETURN_BOOL((stat_sb->st_mode&rmask)!=0);
527: case FS_IS_X:
528: RETURN_BOOL((stat_sb->st_mode&xmask)!=0 && !S_ISDIR(stat_sb->st_mode));
529: case FS_IS_FILE:
530: RETURN_BOOL(S_ISREG(stat_sb->st_mode));
531: case FS_IS_DIR:
532: RETURN_BOOL(S_ISDIR(stat_sb->st_mode));
533: case FS_IS_LINK:
534: RETURN_BOOL(S_ISLNK(stat_sb->st_mode));
535: case FS_EXISTS:
536: RETURN_TRUE; /* the false case was done earlier */
537: case FS_LSTAT:
538: /* FALLTHROUGH */
539: case FS_STAT:
540: array_init(return_value);
541:
542: MAKE_LONG_ZVAL_INCREF(stat_dev, stat_sb->st_dev);
543: MAKE_LONG_ZVAL_INCREF(stat_ino, stat_sb->st_ino);
544: MAKE_LONG_ZVAL_INCREF(stat_mode, stat_sb->st_mode);
545: MAKE_LONG_ZVAL_INCREF(stat_nlink, stat_sb->st_nlink);
546: MAKE_LONG_ZVAL_INCREF(stat_uid, stat_sb->st_uid);
547: MAKE_LONG_ZVAL_INCREF(stat_gid, stat_sb->st_gid);
548: #ifdef HAVE_ST_RDEV
549: MAKE_LONG_ZVAL_INCREF(stat_rdev, stat_sb->st_rdev);
550: #else
551: MAKE_LONG_ZVAL_INCREF(stat_rdev, -1);
552: #endif
553: MAKE_LONG_ZVAL_INCREF(stat_size, stat_sb->st_size);
554: #ifdef NETWARE
555: MAKE_LONG_ZVAL_INCREF(stat_atime, (stat_sb->st_atime).tv_sec);
556: MAKE_LONG_ZVAL_INCREF(stat_mtime, (stat_sb->st_mtime).tv_sec);
557: MAKE_LONG_ZVAL_INCREF(stat_ctime, (stat_sb->st_ctime).tv_sec);
558: #else
559: MAKE_LONG_ZVAL_INCREF(stat_atime, stat_sb->st_atime);
560: MAKE_LONG_ZVAL_INCREF(stat_mtime, stat_sb->st_mtime);
561: MAKE_LONG_ZVAL_INCREF(stat_ctime, stat_sb->st_ctime);
562: #endif
563: #ifdef HAVE_ST_BLKSIZE
564: MAKE_LONG_ZVAL_INCREF(stat_blksize, stat_sb->st_blksize);
565: #else
566: MAKE_LONG_ZVAL_INCREF(stat_blksize,-1);
567: #endif
568: #ifdef HAVE_ST_BLOCKS
569: MAKE_LONG_ZVAL_INCREF(stat_blocks, stat_sb->st_blocks);
570: #else
571: MAKE_LONG_ZVAL_INCREF(stat_blocks,-1);
572: #endif
573: /* Store numeric indexes in propper order */
574: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_dev, sizeof(zval *), NULL);
575: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ino, sizeof(zval *), NULL);
576: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mode, sizeof(zval *), NULL);
577: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_nlink, sizeof(zval *), NULL);
578: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_uid, sizeof(zval *), NULL);
579: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_gid, sizeof(zval *), NULL);
580:
581: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_rdev, sizeof(zval *), NULL);
582: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_size, sizeof(zval *), NULL);
583: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_atime, sizeof(zval *), NULL);
584: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mtime, sizeof(zval *), NULL);
585: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ctime, sizeof(zval *), NULL);
586: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blksize, sizeof(zval *), NULL);
587: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL);
588:
589: /* Store string indexes referencing the same zval*/
590: zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL);
591: zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL);
592: zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL);
593: zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL);
594: zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL);
595: zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL);
596: zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL);
597: zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL);
598: zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL);
599: zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL);
600: zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL);
601: zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL);
602: zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL);
603:
604: return;
605: }
606: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Didn't understand stat call");
607: RETURN_FALSE;
608: }
609: /* }}} */
610:
611: static void phar_file_stat(const char *filename, php_stat_len filename_length, int type, void (*orig_stat_func)(INTERNAL_FUNCTION_PARAMETERS), INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
612: {
613: if (!filename_length) {
614: RETURN_FALSE;
615: }
616:
617: if (!IS_ABSOLUTE_PATH(filename, filename_length) && !strstr(filename, "://")) {
618: char *arch, *entry, *fname;
619: int arch_len, entry_len, fname_len;
620: struct stat sb = {0};
621: phar_entry_info *data = NULL;
622: phar_archive_data *phar;
623:
624: fname = zend_get_executed_filename(TSRMLS_C);
625:
626: /* we are checking for existence of a file within the relative path. Chances are good that this is
627: retrieving something from within the phar archive */
628:
629: if (strncasecmp(fname, "phar://", 7)) {
630: goto skip_phar;
631: }
632: fname_len = strlen(fname);
633: if (PHAR_G(last_phar) && fname_len - 7 >= PHAR_G(last_phar_name_len) && !memcmp(fname + 7, PHAR_G(last_phar_name), PHAR_G(last_phar_name_len))) {
634: arch = estrndup(PHAR_G(last_phar_name), PHAR_G(last_phar_name_len));
635: arch_len = PHAR_G(last_phar_name_len);
636: entry = estrndup(filename, filename_length);
637: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
638: entry_len = (int) filename_length;
639: phar = PHAR_G(last_phar);
640: goto splitted;
641: }
642: if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
643:
644: efree(entry);
645: entry = estrndup(filename, filename_length);
646: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
647: entry_len = (int) filename_length;
648: if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
649: efree(arch);
650: efree(entry);
651: goto skip_phar;
652: }
653: splitted:
654: entry = phar_fix_filepath(entry, &entry_len, 1 TSRMLS_CC);
655: if (entry[0] == '/') {
656: if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &data)) {
657: efree(entry);
658: goto stat_entry;
659: }
660: goto notfound;
661: }
662: if (SUCCESS == zend_hash_find(&(phar->manifest), entry, entry_len, (void **) &data)) {
663: efree(entry);
664: goto stat_entry;
665: }
666: if (zend_hash_exists(&(phar->virtual_dirs), entry, entry_len)) {
667: efree(entry);
668: efree(arch);
669: if (IS_EXISTS_CHECK(type)) {
670: RETURN_TRUE;
671: }
672: sb.st_size = 0;
673: sb.st_mode = 0777;
674: sb.st_mode |= S_IFDIR; /* regular directory */
675: #ifdef NETWARE
676: sb.st_mtime.tv_sec = phar->max_timestamp;
677: sb.st_atime.tv_sec = phar->max_timestamp;
678: sb.st_ctime.tv_sec = phar->max_timestamp;
679: #else
680: sb.st_mtime = phar->max_timestamp;
681: sb.st_atime = phar->max_timestamp;
682: sb.st_ctime = phar->max_timestamp;
683: #endif
684: goto statme_baby;
685: } else {
686: char *save;
687: int save_len;
688:
689: notfound:
690: efree(entry);
691: save = PHAR_G(cwd);
692: save_len = PHAR_G(cwd_len);
693: /* this file is not in the current directory, use the original path */
694: entry = estrndup(filename, filename_length);
695: entry_len = filename_length;
696: PHAR_G(cwd) = "/";
697: PHAR_G(cwd_len) = 0;
698: /* clean path without cwd */
699: entry = phar_fix_filepath(entry, &entry_len, 1 TSRMLS_CC);
700: if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &data)) {
701: PHAR_G(cwd) = save;
702: PHAR_G(cwd_len) = save_len;
703: efree(entry);
704: if (IS_EXISTS_CHECK(type)) {
705: efree(arch);
706: RETURN_TRUE;
707: }
708: goto stat_entry;
709: }
710: if (zend_hash_exists(&(phar->virtual_dirs), entry + 1, entry_len - 1)) {
711: PHAR_G(cwd) = save;
712: PHAR_G(cwd_len) = save_len;
713: efree(entry);
714: efree(arch);
715: if (IS_EXISTS_CHECK(type)) {
716: RETURN_TRUE;
717: }
718: sb.st_size = 0;
719: sb.st_mode = 0777;
720: sb.st_mode |= S_IFDIR; /* regular directory */
721: #ifdef NETWARE
722: sb.st_mtime.tv_sec = phar->max_timestamp;
723: sb.st_atime.tv_sec = phar->max_timestamp;
724: sb.st_ctime.tv_sec = phar->max_timestamp;
725: #else
726: sb.st_mtime = phar->max_timestamp;
727: sb.st_atime = phar->max_timestamp;
728: sb.st_ctime = phar->max_timestamp;
729: #endif
730: goto statme_baby;
731: }
732: PHAR_G(cwd) = save;
733: PHAR_G(cwd_len) = save_len;
734: efree(entry);
735: efree(arch);
736: /* Error Occured */
737: if (!IS_EXISTS_CHECK(type)) {
738: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%sstat failed for %s", IS_LINK_OPERATION(type) ? "L" : "", filename);
739: }
740: RETURN_FALSE;
741: }
742: stat_entry:
743: efree(arch);
744: if (!data->is_dir) {
745: sb.st_size = data->uncompressed_filesize;
746: sb.st_mode = data->flags & PHAR_ENT_PERM_MASK;
747: if (data->link) {
748: sb.st_mode |= S_IFREG|S_IFLNK; /* regular file */
749: } else {
750: sb.st_mode |= S_IFREG; /* regular file */
751: }
752: /* timestamp is just the timestamp when this was added to the phar */
753: #ifdef NETWARE
754: sb.st_mtime.tv_sec = data->timestamp;
755: sb.st_atime.tv_sec = data->timestamp;
756: sb.st_ctime.tv_sec = data->timestamp;
757: #else
758: sb.st_mtime = data->timestamp;
759: sb.st_atime = data->timestamp;
760: sb.st_ctime = data->timestamp;
761: #endif
762: } else {
763: sb.st_size = 0;
764: sb.st_mode = data->flags & PHAR_ENT_PERM_MASK;
765: sb.st_mode |= S_IFDIR; /* regular directory */
766: if (data->link) {
767: sb.st_mode |= S_IFLNK;
768: }
769: /* timestamp is just the timestamp when this was added to the phar */
770: #ifdef NETWARE
771: sb.st_mtime.tv_sec = data->timestamp;
772: sb.st_atime.tv_sec = data->timestamp;
773: sb.st_ctime.tv_sec = data->timestamp;
774: #else
775: sb.st_mtime = data->timestamp;
776: sb.st_atime = data->timestamp;
777: sb.st_ctime = data->timestamp;
778: #endif
779: }
780:
781: statme_baby:
782: if (!phar->is_writeable) {
783: sb.st_mode = (sb.st_mode & 0555) | (sb.st_mode & ~0777);
784: }
785:
786: sb.st_nlink = 1;
787: sb.st_rdev = -1;
788: /* this is only for APC, so use /dev/null device - no chance of conflict there! */
789: sb.st_dev = 0xc;
790: /* generate unique inode number for alias/filename, so no phars will conflict */
791: if (data) {
792: sb.st_ino = data->inode;
793: }
794: #ifndef PHP_WIN32
795: sb.st_blksize = -1;
796: sb.st_blocks = -1;
797: #endif
798: phar_fancy_stat(&sb, type, return_value TSRMLS_CC);
799: return;
800: }
801: }
802: skip_phar:
803: orig_stat_func(INTERNAL_FUNCTION_PARAM_PASSTHRU);
804: return;
805: }
806: /* }}} */
807:
808: #define PharFileFunction(fname, funcnum, orig) \
809: void fname(INTERNAL_FUNCTION_PARAMETERS) { \
810: if (!PHAR_G(intercepted)) { \
811: PHAR_G(orig)(INTERNAL_FUNCTION_PARAM_PASSTHRU); \
812: } else { \
813: char *filename; \
814: int filename_len; \
815: \
816: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) { \
817: return; \
818: } \
819: \
820: phar_file_stat(filename, (php_stat_len) filename_len, funcnum, PHAR_G(orig), INTERNAL_FUNCTION_PARAM_PASSTHRU); \
821: } \
822: }
823: /* }}} */
824:
825: /* {{{ proto int fileperms(string filename)
826: Get file permissions */
827: PharFileFunction(phar_fileperms, FS_PERMS, orig_fileperms)
828: /* }}} */
829:
830: /* {{{ proto int fileinode(string filename)
831: Get file inode */
832: PharFileFunction(phar_fileinode, FS_INODE, orig_fileinode)
833: /* }}} */
834:
835: /* {{{ proto int filesize(string filename)
836: Get file size */
837: PharFileFunction(phar_filesize, FS_SIZE, orig_filesize)
838: /* }}} */
839:
840: /* {{{ proto int fileowner(string filename)
841: Get file owner */
842: PharFileFunction(phar_fileowner, FS_OWNER, orig_fileowner)
843: /* }}} */
844:
845: /* {{{ proto int filegroup(string filename)
846: Get file group */
847: PharFileFunction(phar_filegroup, FS_GROUP, orig_filegroup)
848: /* }}} */
849:
850: /* {{{ proto int fileatime(string filename)
851: Get last access time of file */
852: PharFileFunction(phar_fileatime, FS_ATIME, orig_fileatime)
853: /* }}} */
854:
855: /* {{{ proto int filemtime(string filename)
856: Get last modification time of file */
857: PharFileFunction(phar_filemtime, FS_MTIME, orig_filemtime)
858: /* }}} */
859:
860: /* {{{ proto int filectime(string filename)
861: Get inode modification time of file */
862: PharFileFunction(phar_filectime, FS_CTIME, orig_filectime)
863: /* }}} */
864:
865: /* {{{ proto string filetype(string filename)
866: Get file type */
867: PharFileFunction(phar_filetype, FS_TYPE, orig_filetype)
868: /* }}} */
869:
870: /* {{{ proto bool is_writable(string filename)
871: Returns true if file can be written */
872: PharFileFunction(phar_is_writable, FS_IS_W, orig_is_writable)
873: /* }}} */
874:
875: /* {{{ proto bool is_readable(string filename)
876: Returns true if file can be read */
877: PharFileFunction(phar_is_readable, FS_IS_R, orig_is_readable)
878: /* }}} */
879:
880: /* {{{ proto bool is_executable(string filename)
881: Returns true if file is executable */
882: PharFileFunction(phar_is_executable, FS_IS_X, orig_is_executable)
883: /* }}} */
884:
885: /* {{{ proto bool file_exists(string filename)
886: Returns true if filename exists */
887: PharFileFunction(phar_file_exists, FS_EXISTS, orig_file_exists)
888: /* }}} */
889:
890: /* {{{ proto bool is_dir(string filename)
891: Returns true if file is directory */
892: PharFileFunction(phar_is_dir, FS_IS_DIR, orig_is_dir)
893: /* }}} */
894:
895: PHAR_FUNC(phar_is_file) /* {{{ */
896: {
897: char *filename;
898: int filename_len;
899:
900: if (!PHAR_G(intercepted)) {
901: goto skip_phar;
902: }
903:
904: if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
905: && !cached_phars.arBuckets) {
906: goto skip_phar;
907: }
908: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
909: goto skip_phar;
910: }
911: if (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://")) {
912: char *arch, *entry, *fname;
913: int arch_len, entry_len, fname_len;
914: fname = zend_get_executed_filename(TSRMLS_C);
915:
916: /* we are checking for existence of a file within the relative path. Chances are good that this is
917: retrieving something from within the phar archive */
918:
919: if (strncasecmp(fname, "phar://", 7)) {
920: goto skip_phar;
921: }
922: fname_len = strlen(fname);
923: if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
924: phar_archive_data *phar;
925:
926: efree(entry);
927: entry = filename;
928: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
929: entry_len = filename_len;
930: /* retrieving a file within the current directory, so use this if possible */
931: if (SUCCESS == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
932: phar_entry_info *etemp;
933:
934: entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC);
935: if (entry[0] == '/') {
936: if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &etemp)) {
937: /* this file is not in the current directory, use the original path */
938: found_it:
939: efree(entry);
940: efree(arch);
941: RETURN_BOOL(!etemp->is_dir);
942: }
943: } else {
944: if (SUCCESS == zend_hash_find(&(phar->manifest), entry, entry_len, (void **) &etemp)) {
945: goto found_it;
946: }
947: }
948: }
949: if (entry != filename) {
950: efree(entry);
951: }
952: efree(arch);
953: RETURN_FALSE;
954: }
955: }
956: skip_phar:
957: PHAR_G(orig_is_file)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
958: return;
959: }
960: /* }}} */
961:
962: PHAR_FUNC(phar_is_link) /* {{{ */
963: {
964: char *filename;
965: int filename_len;
966:
967: if (!PHAR_G(intercepted)) {
968: goto skip_phar;
969: }
970:
971: if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
972: && !cached_phars.arBuckets) {
973: goto skip_phar;
974: }
975: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
976: goto skip_phar;
977: }
978: if (!IS_ABSOLUTE_PATH(filename, filename_len) && !strstr(filename, "://")) {
979: char *arch, *entry, *fname;
980: int arch_len, entry_len, fname_len;
981: fname = zend_get_executed_filename(TSRMLS_C);
982:
983: /* we are checking for existence of a file within the relative path. Chances are good that this is
984: retrieving something from within the phar archive */
985:
986: if (strncasecmp(fname, "phar://", 7)) {
987: goto skip_phar;
988: }
989: fname_len = strlen(fname);
990: if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0 TSRMLS_CC)) {
991: phar_archive_data *phar;
992:
993: efree(entry);
994: entry = filename;
995: /* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
996: entry_len = filename_len;
997: /* retrieving a file within the current directory, so use this if possible */
998: if (SUCCESS == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL TSRMLS_CC)) {
999: phar_entry_info *etemp;
1000:
1001: entry = phar_fix_filepath(estrndup(entry, entry_len), &entry_len, 1 TSRMLS_CC);
1002: if (entry[0] == '/') {
1003: if (SUCCESS == zend_hash_find(&(phar->manifest), entry + 1, entry_len - 1, (void **) &etemp)) {
1004: /* this file is not in the current directory, use the original path */
1005: found_it:
1006: efree(entry);
1007: efree(arch);
1008: RETURN_BOOL(etemp->link);
1009: }
1010: } else {
1011: if (SUCCESS == zend_hash_find(&(phar->manifest), entry, entry_len, (void **) &etemp)) {
1012: goto found_it;
1013: }
1014: }
1015: }
1016: efree(entry);
1017: efree(arch);
1018: RETURN_FALSE;
1019: }
1020: }
1021: skip_phar:
1022: PHAR_G(orig_is_link)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
1023: return;
1024: }
1025: /* }}} */
1026:
1027: /* {{{ proto array lstat(string filename)
1028: Give information about a file or symbolic link */
1029: PharFileFunction(phar_lstat, FS_LSTAT, orig_lstat)
1030: /* }}} */
1031:
1032: /* {{{ proto array stat(string filename)
1033: Give information about a file */
1034: PharFileFunction(phar_stat, FS_STAT, orig_stat)
1035: /* }}} */
1036:
1037: /* {{{ void phar_intercept_functions(TSRMLS_D) */
1038: void phar_intercept_functions(TSRMLS_D)
1039: {
1040: if (!PHAR_G(request_init)) {
1041: PHAR_G(cwd) = NULL;
1042: PHAR_G(cwd_len) = 0;
1043: }
1044: PHAR_G(intercepted) = 1;
1045: }
1046: /* }}} */
1047:
1048: /* {{{ void phar_release_functions(TSRMLS_D) */
1049: void phar_release_functions(TSRMLS_D)
1050: {
1051: PHAR_G(intercepted) = 0;
1052: }
1053: /* }}} */
1054:
1055: /* {{{ void phar_intercept_functions_init(TSRMLS_D) */
1056: #define PHAR_INTERCEPT(func) \
1057: PHAR_G(orig_##func) = NULL; \
1058: if (SUCCESS == zend_hash_find(CG(function_table), #func, sizeof(#func), (void **)&orig)) { \
1059: PHAR_G(orig_##func) = orig->internal_function.handler; \
1060: orig->internal_function.handler = phar_##func; \
1061: }
1062:
1063: void phar_intercept_functions_init(TSRMLS_D)
1064: {
1065: zend_function *orig;
1066:
1067: PHAR_INTERCEPT(fopen);
1068: PHAR_INTERCEPT(file_get_contents);
1069: PHAR_INTERCEPT(is_file);
1070: PHAR_INTERCEPT(is_link);
1071: PHAR_INTERCEPT(is_dir);
1072: PHAR_INTERCEPT(opendir);
1073: PHAR_INTERCEPT(file_exists);
1074: PHAR_INTERCEPT(fileperms);
1075: PHAR_INTERCEPT(fileinode);
1076: PHAR_INTERCEPT(filesize);
1077: PHAR_INTERCEPT(fileowner);
1078: PHAR_INTERCEPT(filegroup);
1079: PHAR_INTERCEPT(fileatime);
1080: PHAR_INTERCEPT(filemtime);
1081: PHAR_INTERCEPT(filectime);
1082: PHAR_INTERCEPT(filetype);
1083: PHAR_INTERCEPT(is_writable);
1084: PHAR_INTERCEPT(is_readable);
1085: PHAR_INTERCEPT(is_executable);
1086: PHAR_INTERCEPT(lstat);
1087: PHAR_INTERCEPT(stat);
1088: PHAR_INTERCEPT(readfile);
1089: PHAR_G(intercepted) = 0;
1090: }
1091: /* }}} */
1092:
1093: /* {{{ void phar_intercept_functions_shutdown(TSRMLS_D) */
1094: #define PHAR_RELEASE(func) \
1095: if (PHAR_G(orig_##func) && SUCCESS == zend_hash_find(CG(function_table), #func, sizeof(#func), (void **)&orig)) { \
1096: orig->internal_function.handler = PHAR_G(orig_##func); \
1097: } \
1098: PHAR_G(orig_##func) = NULL;
1099:
1100: void phar_intercept_functions_shutdown(TSRMLS_D)
1101: {
1102: zend_function *orig;
1103:
1104: PHAR_RELEASE(fopen);
1105: PHAR_RELEASE(file_get_contents);
1106: PHAR_RELEASE(is_file);
1107: PHAR_RELEASE(is_dir);
1108: PHAR_RELEASE(opendir);
1109: PHAR_RELEASE(file_exists);
1110: PHAR_RELEASE(fileperms);
1111: PHAR_RELEASE(fileinode);
1112: PHAR_RELEASE(filesize);
1113: PHAR_RELEASE(fileowner);
1114: PHAR_RELEASE(filegroup);
1115: PHAR_RELEASE(fileatime);
1116: PHAR_RELEASE(filemtime);
1117: PHAR_RELEASE(filectime);
1118: PHAR_RELEASE(filetype);
1119: PHAR_RELEASE(is_writable);
1120: PHAR_RELEASE(is_readable);
1121: PHAR_RELEASE(is_executable);
1122: PHAR_RELEASE(lstat);
1123: PHAR_RELEASE(stat);
1124: PHAR_RELEASE(readfile);
1125: PHAR_G(intercepted) = 0;
1126: }
1127: /* }}} */
1128:
1129: static struct _phar_orig_functions {
1130: void (*orig_fopen)(INTERNAL_FUNCTION_PARAMETERS);
1131: void (*orig_file_get_contents)(INTERNAL_FUNCTION_PARAMETERS);
1132: void (*orig_is_file)(INTERNAL_FUNCTION_PARAMETERS);
1133: void (*orig_is_link)(INTERNAL_FUNCTION_PARAMETERS);
1134: void (*orig_is_dir)(INTERNAL_FUNCTION_PARAMETERS);
1135: void (*orig_opendir)(INTERNAL_FUNCTION_PARAMETERS);
1136: void (*orig_file_exists)(INTERNAL_FUNCTION_PARAMETERS);
1137: void (*orig_fileperms)(INTERNAL_FUNCTION_PARAMETERS);
1138: void (*orig_fileinode)(INTERNAL_FUNCTION_PARAMETERS);
1139: void (*orig_filesize)(INTERNAL_FUNCTION_PARAMETERS);
1140: void (*orig_fileowner)(INTERNAL_FUNCTION_PARAMETERS);
1141: void (*orig_filegroup)(INTERNAL_FUNCTION_PARAMETERS);
1142: void (*orig_fileatime)(INTERNAL_FUNCTION_PARAMETERS);
1143: void (*orig_filemtime)(INTERNAL_FUNCTION_PARAMETERS);
1144: void (*orig_filectime)(INTERNAL_FUNCTION_PARAMETERS);
1145: void (*orig_filetype)(INTERNAL_FUNCTION_PARAMETERS);
1146: void (*orig_is_writable)(INTERNAL_FUNCTION_PARAMETERS);
1147: void (*orig_is_readable)(INTERNAL_FUNCTION_PARAMETERS);
1148: void (*orig_is_executable)(INTERNAL_FUNCTION_PARAMETERS);
1149: void (*orig_lstat)(INTERNAL_FUNCTION_PARAMETERS);
1150: void (*orig_readfile)(INTERNAL_FUNCTION_PARAMETERS);
1151: void (*orig_stat)(INTERNAL_FUNCTION_PARAMETERS);
1152: } phar_orig_functions = {NULL};
1153:
1154: void phar_save_orig_functions(TSRMLS_D) /* {{{ */
1155: {
1156: phar_orig_functions.orig_fopen = PHAR_G(orig_fopen);
1157: phar_orig_functions.orig_file_get_contents = PHAR_G(orig_file_get_contents);
1158: phar_orig_functions.orig_is_file = PHAR_G(orig_is_file);
1159: phar_orig_functions.orig_is_link = PHAR_G(orig_is_link);
1160: phar_orig_functions.orig_is_dir = PHAR_G(orig_is_dir);
1161: phar_orig_functions.orig_opendir = PHAR_G(orig_opendir);
1162: phar_orig_functions.orig_file_exists = PHAR_G(orig_file_exists);
1163: phar_orig_functions.orig_fileperms = PHAR_G(orig_fileperms);
1164: phar_orig_functions.orig_fileinode = PHAR_G(orig_fileinode);
1165: phar_orig_functions.orig_filesize = PHAR_G(orig_filesize);
1166: phar_orig_functions.orig_fileowner = PHAR_G(orig_fileowner);
1167: phar_orig_functions.orig_filegroup = PHAR_G(orig_filegroup);
1168: phar_orig_functions.orig_fileatime = PHAR_G(orig_fileatime);
1169: phar_orig_functions.orig_filemtime = PHAR_G(orig_filemtime);
1170: phar_orig_functions.orig_filectime = PHAR_G(orig_filectime);
1171: phar_orig_functions.orig_filetype = PHAR_G(orig_filetype);
1172: phar_orig_functions.orig_is_writable = PHAR_G(orig_is_writable);
1173: phar_orig_functions.orig_is_readable = PHAR_G(orig_is_readable);
1174: phar_orig_functions.orig_is_executable = PHAR_G(orig_is_executable);
1175: phar_orig_functions.orig_lstat = PHAR_G(orig_lstat);
1176: phar_orig_functions.orig_readfile = PHAR_G(orig_readfile);
1177: phar_orig_functions.orig_stat = PHAR_G(orig_stat);
1178: }
1179: /* }}} */
1180:
1181: void phar_restore_orig_functions(TSRMLS_D) /* {{{ */
1182: {
1183: PHAR_G(orig_fopen) = phar_orig_functions.orig_fopen;
1184: PHAR_G(orig_file_get_contents) = phar_orig_functions.orig_file_get_contents;
1185: PHAR_G(orig_is_file) = phar_orig_functions.orig_is_file;
1186: PHAR_G(orig_is_link) = phar_orig_functions.orig_is_link;
1187: PHAR_G(orig_is_dir) = phar_orig_functions.orig_is_dir;
1188: PHAR_G(orig_opendir) = phar_orig_functions.orig_opendir;
1189: PHAR_G(orig_file_exists) = phar_orig_functions.orig_file_exists;
1190: PHAR_G(orig_fileperms) = phar_orig_functions.orig_fileperms;
1191: PHAR_G(orig_fileinode) = phar_orig_functions.orig_fileinode;
1192: PHAR_G(orig_filesize) = phar_orig_functions.orig_filesize;
1193: PHAR_G(orig_fileowner) = phar_orig_functions.orig_fileowner;
1194: PHAR_G(orig_filegroup) = phar_orig_functions.orig_filegroup;
1195: PHAR_G(orig_fileatime) = phar_orig_functions.orig_fileatime;
1196: PHAR_G(orig_filemtime) = phar_orig_functions.orig_filemtime;
1197: PHAR_G(orig_filectime) = phar_orig_functions.orig_filectime;
1198: PHAR_G(orig_filetype) = phar_orig_functions.orig_filetype;
1199: PHAR_G(orig_is_writable) = phar_orig_functions.orig_is_writable;
1200: PHAR_G(orig_is_readable) = phar_orig_functions.orig_is_readable;
1201: PHAR_G(orig_is_executable) = phar_orig_functions.orig_is_executable;
1202: PHAR_G(orig_lstat) = phar_orig_functions.orig_lstat;
1203: PHAR_G(orig_readfile) = phar_orig_functions.orig_readfile;
1204: PHAR_G(orig_stat) = phar_orig_functions.orig_stat;
1205: }
1206: /* }}} */
1207:
1208: /*
1209: * Local variables:
1210: * tab-width: 4
1211: * c-basic-offset: 4
1212: * End:
1213: * vim600: noet sw=4 ts=4 fdm=marker
1214: * vim<600: noet sw=4 ts=4
1215: */
1216:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to func_interceptors.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