Annotation of embedaddon/php/ext/standard/filestat.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-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: | Author: Jim Winstead <jimw@php.net> |
16: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: filestat.c 321634 2012-01-01 13:15:04Z felipe $ */
20:
21: #include "php.h"
22: #include "safe_mode.h"
23: #include "fopen_wrappers.h"
24: #include "php_globals.h"
25:
26: #include <stdlib.h>
27: #include <sys/stat.h>
28: #include <string.h>
29: #include <errno.h>
30: #include <ctype.h>
31: #include <time.h>
32:
33: #if HAVE_UNISTD_H
34: # include <unistd.h>
35: #endif
36:
37: #if HAVE_SYS_PARAM_H
38: # include <sys/param.h>
39: #endif
40:
41: #if HAVE_SYS_VFS_H
42: # include <sys/vfs.h>
43: #endif
44:
45: #ifdef OS2
46: # define INCL_DOS
47: # include <os2.h>
48: #endif
49:
50: #if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)
51: # include <sys/statvfs.h>
52: #elif defined(HAVE_SYS_STATFS_H) && defined(HAVE_STATFS)
53: # include <sys/statfs.h>
54: #elif defined(HAVE_SYS_MOUNT_H) && defined(HAVE_STATFS)
55: # include <sys/mount.h>
56: #endif
57:
58: #if HAVE_PWD_H
59: # ifdef PHP_WIN32
60: # include "win32/pwd.h"
61: # else
62: # include <pwd.h>
63: # endif
64: #endif
65:
66: #if HAVE_GRP_H
67: # ifdef PHP_WIN32
68: # include "win32/grp.h"
69: # else
70: # include <grp.h>
71: # endif
72: #endif
73:
74: #if HAVE_UTIME
75: # ifdef PHP_WIN32
76: # include <sys/utime.h>
77: # else
78: # include <utime.h>
79: # endif
80: #endif
81:
82: #ifdef PHP_WIN32
83: #include "win32/winutil.h"
84: #endif
85:
86: #include "basic_functions.h"
87: #include "php_filestat.h"
88:
89: #ifndef S_ISDIR
90: #define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
91: #endif
92: #ifndef S_ISREG
93: #define S_ISREG(mode) (((mode)&S_IFMT) == S_IFREG)
94: #endif
95: #ifndef S_ISLNK
96: #define S_ISLNK(mode) (((mode)&S_IFMT) == S_IFLNK)
97: #endif
98:
99: #define S_IXROOT ( S_IXUSR | S_IXGRP | S_IXOTH )
100:
101: PHP_RINIT_FUNCTION(filestat) /* {{{ */
102: {
103: BG(CurrentStatFile)=NULL;
104: BG(CurrentLStatFile)=NULL;
105: return SUCCESS;
106: }
107: /* }}} */
108:
109: PHP_RSHUTDOWN_FUNCTION(filestat) /* {{{ */
110: {
111: if (BG(CurrentStatFile)) {
112: efree (BG(CurrentStatFile));
113: BG(CurrentStatFile) = NULL;
114: }
115: if (BG(CurrentLStatFile)) {
116: efree (BG(CurrentLStatFile));
117: BG(CurrentLStatFile) = NULL;
118: }
119: return SUCCESS;
120: }
121: /* }}} */
122:
123: static int php_disk_total_space(char *path, double *space TSRMLS_DC) /* {{{ */
124: #if defined(WINDOWS) /* {{{ */
125: {
126: double bytestotal = 0;
127: HINSTANCE kernel32;
128: FARPROC gdfse;
129: typedef BOOL (WINAPI *gdfse_func)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
130: gdfse_func func;
131:
132: /* These are used by GetDiskFreeSpaceEx, if available. */
133: ULARGE_INTEGER FreeBytesAvailableToCaller;
134: ULARGE_INTEGER TotalNumberOfBytes;
135: ULARGE_INTEGER TotalNumberOfFreeBytes;
136:
137: /* These are used by GetDiskFreeSpace otherwise. */
138: DWORD SectorsPerCluster;
139: DWORD BytesPerSector;
140: DWORD NumberOfFreeClusters;
141: DWORD TotalNumberOfClusters;
142:
143: /* GetDiskFreeSpaceEx is only available in NT and Win95 post-OSR2,
144: so we have to jump through some hoops to see if the function
145: exists. */
146: kernel32 = LoadLibrary("kernel32.dll");
147: if (kernel32) {
148: gdfse = GetProcAddress(kernel32, "GetDiskFreeSpaceExA");
149: /* It's available, so we can call it. */
150: if (gdfse) {
151: func = (gdfse_func)gdfse;
152: if (func(path,
153: &FreeBytesAvailableToCaller,
154: &TotalNumberOfBytes,
155: &TotalNumberOfFreeBytes) == 0) {
156: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", php_win_err());
157: return FAILURE;
158: }
159:
160: /* i know - this is ugly, but i works <thies@thieso.net> */
161: bytestotal = TotalNumberOfBytes.HighPart *
162: (double) (((unsigned long)1) << 31) * 2.0 +
163: TotalNumberOfBytes.LowPart;
164: } else { /* If it's not available, we just use GetDiskFreeSpace */
165: if (GetDiskFreeSpace(path,
166: &SectorsPerCluster, &BytesPerSector,
167: &NumberOfFreeClusters, &TotalNumberOfClusters) == 0) {
168: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", php_win_err());
169: return FAILURE;
170: }
171: bytestotal = (double)TotalNumberOfClusters * (double)SectorsPerCluster * (double)BytesPerSector;
172: }
173: } else {
174: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to load kernel32.dll");
175: return FAILURE;
176: }
177:
178: *space = bytestotal;
179: return SUCCESS;
180: }
181: /* }}} */
182: #elif defined(OS2) /* {{{ */
183: {
184: double bytestotal = 0;
185: FSALLOCATE fsinfo;
186: char drive = path[0] & 95;
187:
188: if (DosQueryFSInfo( drive ? drive - 64 : 0, FSIL_ALLOC, &fsinfo, sizeof( fsinfo ) ) == 0) {
189: bytestotal = (double)fsinfo.cbSector * fsinfo.cSectorUnit * fsinfo.cUnit;
190: *space = bytestotal;
191: return SUCCESS;
192: }
193: return FAILURE;
194: }
195: /* }}} */
196: #else /* {{{ if !defined(OS2) && !defined(WINDOWS) */
197: {
198: double bytestotal = 0;
199: #if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)
200: struct statvfs buf;
201: #elif (defined(HAVE_SYS_STATFS_H) || defined(HAVE_SYS_MOUNT_H)) && defined(HAVE_STATFS)
202: struct statfs buf;
203: #endif
204:
205: #if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)
206: if (statvfs(path, &buf)) {
207: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
208: return FAILURE;
209: }
210: if (buf.f_frsize) {
211: bytestotal = (((double)buf.f_blocks) * ((double)buf.f_frsize));
212: } else {
213: bytestotal = (((double)buf.f_blocks) * ((double)buf.f_bsize));
214: }
215:
216: #elif (defined(HAVE_SYS_STATFS_H) || defined(HAVE_SYS_MOUNT_H)) && defined(HAVE_STATFS)
217: if (statfs(path, &buf)) {
218: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
219: return FAILURE;
220: }
221: bytestotal = (((double)buf.f_bsize) * ((double)buf.f_blocks));
222: #endif
223:
224: *space = bytestotal;
225: return SUCCESS;
226: }
227: #endif
228: /* }}} */
229: /* }}} */
230:
231: /* {{{ proto float disk_total_space(string path)
232: Get total disk space for filesystem that path is on */
233: PHP_FUNCTION(disk_total_space)
234: {
235: double bytestotal;
236: char *path;
237: int path_len;
238:
239: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
240: return;
241: }
242:
243: if (php_check_open_basedir(path TSRMLS_CC)) {
244: RETURN_FALSE;
245: }
246:
247: if (php_disk_total_space(path, &bytestotal TSRMLS_CC) == SUCCESS) {
248: RETURN_DOUBLE(bytestotal);
249: }
250: RETURN_FALSE;
251: }
252: /* }}} */
253:
254: static int php_disk_free_space(char *path, double *space TSRMLS_DC) /* {{{ */
255: #if defined(WINDOWS) /* {{{ */
256: {
257: double bytesfree = 0;
258:
259: HINSTANCE kernel32;
260: FARPROC gdfse;
261: typedef BOOL (WINAPI *gdfse_func)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
262: gdfse_func func;
263:
264: /* These are used by GetDiskFreeSpaceEx, if available. */
265: ULARGE_INTEGER FreeBytesAvailableToCaller;
266: ULARGE_INTEGER TotalNumberOfBytes;
267: ULARGE_INTEGER TotalNumberOfFreeBytes;
268:
269: /* These are used by GetDiskFreeSpace otherwise. */
270: DWORD SectorsPerCluster;
271: DWORD BytesPerSector;
272: DWORD NumberOfFreeClusters;
273: DWORD TotalNumberOfClusters;
274:
275: /* GetDiskFreeSpaceEx is only available in NT and Win95 post-OSR2,
276: so we have to jump through some hoops to see if the function
277: exists. */
278: kernel32 = LoadLibrary("kernel32.dll");
279: if (kernel32) {
280: gdfse = GetProcAddress(kernel32, "GetDiskFreeSpaceExA");
281: /* It's available, so we can call it. */
282: if (gdfse) {
283: func = (gdfse_func)gdfse;
284: if (func(path,
285: &FreeBytesAvailableToCaller,
286: &TotalNumberOfBytes,
287: &TotalNumberOfFreeBytes) == 0) {
288: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", php_win_err());
289: return FAILURE;
290: }
291:
292: /* i know - this is ugly, but i works <thies@thieso.net> */
293: bytesfree = FreeBytesAvailableToCaller.HighPart *
294: (double) (((unsigned long)1) << 31) * 2.0 +
295: FreeBytesAvailableToCaller.LowPart;
296: } else { /* If it's not available, we just use GetDiskFreeSpace */
297: if (GetDiskFreeSpace(path,
298: &SectorsPerCluster, &BytesPerSector,
299: &NumberOfFreeClusters, &TotalNumberOfClusters) == 0) {
300: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", php_win_err());
301: return FAILURE;
302: }
303: bytesfree = (double)NumberOfFreeClusters * (double)SectorsPerCluster * (double)BytesPerSector;
304: }
305: } else {
306: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to load kernel32.dll");
307: return FAILURE;
308: }
309:
310: *space = bytesfree;
311: return SUCCESS;
312: }
313: /* }}} */
314: #elif defined(OS2) /* {{{ */
315: {
316: double bytesfree = 0;
317: FSALLOCATE fsinfo;
318: char drive = path[0] & 95;
319:
320: if (DosQueryFSInfo( drive ? drive - 64 : 0, FSIL_ALLOC, &fsinfo, sizeof( fsinfo ) ) == 0) {
321: bytesfree = (double)fsinfo.cbSector * fsinfo.cSectorUnit * fsinfo.cUnitAvail;
322: *space = bytesfree;
323: return SUCCESS;
324: }
325: return FAILURE;
326: }
327: /* }}} */
328: #else /* {{{ if !defined(OS2) && !defined(WINDOWS) */
329: {
330: double bytesfree = 0;
331: #if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)
332: struct statvfs buf;
333: #elif (defined(HAVE_SYS_STATFS_H) || defined(HAVE_SYS_MOUNT_H)) && defined(HAVE_STATFS)
334: struct statfs buf;
335: #endif
336:
337: #if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)
338: if (statvfs(path, &buf)) {
339: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
340: return FAILURE;
341: }
342: if (buf.f_frsize) {
343: bytesfree = (((double)buf.f_bavail) * ((double)buf.f_frsize));
344: } else {
345: bytesfree = (((double)buf.f_bavail) * ((double)buf.f_bsize));
346: }
347: #elif (defined(HAVE_SYS_STATFS_H) || defined(HAVE_SYS_MOUNT_H)) && defined(HAVE_STATFS)
348: if (statfs(path, &buf)) {
349: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
350: return FAILURE;
351: }
352: #ifdef NETWARE
353: bytesfree = (((double)buf.f_bsize) * ((double)buf.f_bfree));
354: #else
355: bytesfree = (((double)buf.f_bsize) * ((double)buf.f_bavail));
356: #endif
357: #endif
358:
359: *space = bytesfree;
360: return SUCCESS;
361: }
362: #endif
363: /* }}} */
364: /* }}} */
365:
366: /* {{{ proto float disk_free_space(string path)
367: Get free disk space for filesystem that path is on */
368: PHP_FUNCTION(disk_free_space)
369: {
370: double bytesfree;
371: char *path;
372: int path_len;
373:
374: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
375: return;
376: }
377:
378: if (php_check_open_basedir(path TSRMLS_CC)) {
379: RETURN_FALSE;
380: }
381:
382: if (strlen(path) != path_len) {
383: RETURN_FALSE;
384: }
385:
386: if (php_disk_free_space(path, &bytesfree TSRMLS_CC) == SUCCESS) {
387: RETURN_DOUBLE(bytesfree);
388: }
389: RETURN_FALSE;
390: }
391: /* }}} */
392:
393: #if !defined(WINDOWS) && !defined(NETWARE)
394: static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */
395: {
396: char *filename;
397: int filename_len;
398: zval *group;
399: gid_t gid;
400: int ret;
401:
402: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/", &filename, &filename_len, &group) == FAILURE) {
403: RETURN_FALSE;
404: }
405:
406: if (strlen(filename) != filename_len) {
407: RETURN_FALSE;
408: }
409:
410: if (Z_TYPE_P(group) == IS_LONG) {
411: gid = (gid_t)Z_LVAL_P(group);
412: } else if (Z_TYPE_P(group) == IS_STRING) {
413: #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
414: struct group gr;
415: struct group *retgrptr;
416: long grbuflen = sysconf(_SC_GETGR_R_SIZE_MAX);
417: char *grbuf;
418:
419: if (grbuflen < 1) {
420: RETURN_FALSE;
421: }
422:
423: grbuf = emalloc(grbuflen);
424: if (getgrnam_r(Z_STRVAL_P(group), &gr, grbuf, grbuflen, &retgrptr) != 0 || retgrptr == NULL) {
425: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find gid for %s", Z_STRVAL_P(group));
426: efree(grbuf);
427: RETURN_FALSE;
428: }
429: efree(grbuf);
430: gid = gr.gr_gid;
431: #else
432: struct group *gr = getgrnam(Z_STRVAL_P(group));
433:
434: if (!gr) {
435: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find gid for %s", Z_STRVAL_P(group));
436: RETURN_FALSE;
437: }
438: gid = gr->gr_gid;
439: #endif
440: } else {
441: php_error_docref(NULL TSRMLS_CC, E_WARNING, "parameter 2 should be string or integer, %s given", zend_zval_type_name(group));
442: RETURN_FALSE;
443: }
444:
445: if (PG(safe_mode) &&(!php_checkuid(filename, NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS))) {
446: RETURN_FALSE;
447: }
448:
449: /* Check the basedir */
450: if (php_check_open_basedir(filename TSRMLS_CC)) {
451: RETURN_FALSE;
452: }
453:
454: if (do_lchgrp) {
455: #if HAVE_LCHOWN
456: ret = VCWD_LCHOWN(filename, -1, gid);
457: #endif
458: } else {
459: ret = VCWD_CHOWN(filename, -1, gid);
460: }
461: if (ret == -1) {
462: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
463: RETURN_FALSE;
464: }
465: RETURN_TRUE;
466: }
467: /* }}} */
468: #endif
469:
470: #ifndef NETWARE
471: /* {{{ proto bool chgrp(string filename, mixed group)
472: Change file group */
473: PHP_FUNCTION(chgrp)
474: {
475: #if !defined(WINDOWS)
476: php_do_chgrp(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
477: #else
478: RETURN_FALSE;
479: #endif
480: }
481: /* }}} */
482:
483: /* {{{ proto bool lchgrp(string filename, mixed group)
484: Change symlink group */
485: #if HAVE_LCHOWN
486: PHP_FUNCTION(lchgrp)
487: {
488: # if !defined(WINDOWS)
489: php_do_chgrp(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
490: # else
491: RETURN_FALSE;
492: # endif
493: }
494: #endif
495: /* }}} */
496: #endif /* !NETWARE */
497:
498: #if !defined(WINDOWS) && !defined(NETWARE)
499: static void php_do_chown(INTERNAL_FUNCTION_PARAMETERS, int do_lchown) /* {{{ */
500: {
501: char *filename;
502: int filename_len;
503: zval *user;
504: uid_t uid;
505: int ret;
506:
507: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/", &filename, &filename_len, &user) == FAILURE) {
508: return;
509: }
510:
511: if (strlen(filename) != filename_len) {
512: RETURN_FALSE;
513: }
514:
515: if (Z_TYPE_P(user) == IS_LONG) {
516: uid = (uid_t)Z_LVAL_P(user);
517: } else if (Z_TYPE_P(user) == IS_STRING) {
518: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
519: struct passwd pw;
520: struct passwd *retpwptr = NULL;
521: long pwbuflen = sysconf(_SC_GETPW_R_SIZE_MAX);
522: char *pwbuf;
523:
524: if (pwbuflen < 1) {
525: RETURN_FALSE;
526: }
527:
528: pwbuf = emalloc(pwbuflen);
529: if (getpwnam_r(Z_STRVAL_P(user), &pw, pwbuf, pwbuflen, &retpwptr) != 0 || retpwptr == NULL) {
530: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find uid for %s", Z_STRVAL_P(user));
531: efree(pwbuf);
532: RETURN_FALSE;
533: }
534: efree(pwbuf);
535: uid = pw.pw_uid;
536: #else
537: struct passwd *pw = getpwnam(Z_STRVAL_P(user));
538:
539: if (!pw) {
540: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find uid for %s", Z_STRVAL_P(user));
541: RETURN_FALSE;
542: }
543: uid = pw->pw_uid;
544: #endif
545: } else {
546: php_error_docref(NULL TSRMLS_CC, E_WARNING, "parameter 2 should be string or integer, %s given", zend_zval_type_name(user));
547: RETURN_FALSE;
548: }
549:
550: if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS))) {
551: RETURN_FALSE;
552: }
553:
554: /* Check the basedir */
555: if (php_check_open_basedir(filename TSRMLS_CC)) {
556: RETURN_FALSE;
557: }
558:
559: if (do_lchown) {
560: #if HAVE_LCHOWN
561: ret = VCWD_LCHOWN(filename, uid, -1);
562: #endif
563: } else {
564: ret = VCWD_CHOWN(filename, uid, -1);
565: }
566: if (ret == -1) {
567: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
568: RETURN_FALSE;
569: }
570: }
571: /* }}} */
572: #endif
573:
574: #ifndef NETWARE
575: /* {{{ proto bool chown (string filename, mixed user)
576: Change file owner */
577: PHP_FUNCTION(chown)
578: {
579: #if !defined(WINDOWS)
580: RETVAL_TRUE;
581: php_do_chown(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
582: #else
583: RETURN_FALSE;
584: #endif
585: }
586: /* }}} */
587:
588: /* {{{ proto bool chown (string filename, mixed user)
589: Change file owner */
590: #if HAVE_LCHOWN
591: PHP_FUNCTION(lchown)
592: {
593: # if !defined(WINDOWS)
594: RETVAL_TRUE;
595: php_do_chown(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
596: # else
597: RETURN_FALSE;
598: # endif
599: }
600: #endif
601: /* }}} */
602: #endif /* !NETWARE */
603:
604: /* {{{ proto bool chmod(string filename, int mode)
605: Change file mode */
606: PHP_FUNCTION(chmod)
607: {
608: char *filename;
609: int filename_len;
610: long mode;
611: int ret;
612: mode_t imode;
613:
614: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &filename, &filename_len, &mode) == FAILURE) {
615: return;
616: }
617:
618: if (PG(safe_mode) &&(!php_checkuid(filename, NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS))) {
619: RETURN_FALSE;
620: }
621:
622: if (strlen(filename) != filename_len) {
623: RETURN_FALSE;
624: }
625:
626: /* Check the basedir */
627: if (php_check_open_basedir(filename TSRMLS_CC)) {
628: RETURN_FALSE;
629: }
630:
631: imode = (mode_t) mode;
632: /* In safe mode, do not allow to setuid files.
633: * Setuiding files could allow users to gain privileges
634: * that safe mode doesn't give them. */
635:
636: if (PG(safe_mode)) {
637: php_stream_statbuf ssb;
638: if (php_stream_stat_path_ex(filename, 0, &ssb, NULL)) {
639: php_error_docref(NULL TSRMLS_CC, E_WARNING, "stat failed for %s", filename);
640: RETURN_FALSE;
641: }
642: if ((imode & 04000) != 0 && (ssb.sb.st_mode & 04000) == 0) {
643: imode ^= 04000;
644: }
645: if ((imode & 02000) != 0 && (ssb.sb.st_mode & 02000) == 0) {
646: imode ^= 02000;
647: }
648: if ((imode & 01000) != 0 && (ssb.sb.st_mode & 01000) == 0) {
649: imode ^= 01000;
650: }
651: }
652:
653: ret = VCWD_CHMOD(filename, imode);
654: if (ret == -1) {
655: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
656: RETURN_FALSE;
657: }
658: RETURN_TRUE;
659: }
660: /* }}} */
661:
662: #if HAVE_UTIME
663: /* {{{ proto bool touch(string filename [, int time [, int atime]])
664: Set modification time of file */
665: PHP_FUNCTION(touch)
666: {
667: char *filename;
668: int filename_len;
669: long filetime = 0, fileatime = 0;
670: int ret, argc = ZEND_NUM_ARGS();
671: FILE *file;
672: struct utimbuf newtimebuf;
673: struct utimbuf *newtime = &newtimebuf;
674:
675: if (zend_parse_parameters(argc TSRMLS_CC, "s|ll", &filename, &filename_len, &filetime, &fileatime) == FAILURE) {
676: return;
677: }
678:
679: if (strlen(filename) != filename_len) {
680: RETURN_FALSE;
681: }
682:
683: switch (argc) {
684: case 1:
685: #ifdef HAVE_UTIME_NULL
686: newtime = NULL;
687: #else
688: newtime->modtime = newtime->actime = time(NULL);
689: #endif
690: break;
691: case 2:
692: newtime->modtime = newtime->actime = filetime;
693: break;
694: case 3:
695: newtime->modtime = filetime;
696: newtime->actime = fileatime;
697: break;
698: default:
699: /* Never reached */
700: WRONG_PARAM_COUNT;
701: }
702:
703: /* Safe-mode */
704: if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
705: RETURN_FALSE;
706: }
707:
708: /* Check the basedir */
709: if (php_check_open_basedir(filename TSRMLS_CC)) {
710: RETURN_FALSE;
711: }
712:
713: /* create the file if it doesn't exist already */
714: if (VCWD_ACCESS(filename, F_OK) != 0) {
715: file = VCWD_FOPEN(filename, "w");
716: if (file == NULL) {
717: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to create file %s because %s", filename, strerror(errno));
718: RETURN_FALSE;
719: }
720: fclose(file);
721: }
722:
723: ret = VCWD_UTIME(filename, newtime);
724: if (ret == -1) {
725: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Utime failed: %s", strerror(errno));
726: RETURN_FALSE;
727: }
728: RETURN_TRUE;
729: }
730: /* }}} */
731: #endif
732:
733: /* {{{ php_clear_stat_cache()
734: */
735: PHPAPI void php_clear_stat_cache(zend_bool clear_realpath_cache, const char *filename, int filename_len TSRMLS_DC)
736: {
737: /* always clear CurrentStatFile and CurrentLStatFile even if filename is not NULL
738: * as it may contain outdated data (e.g. "nlink" for a directory when deleting a file
739: * in this directory, as shown by lstat_stat_variation9.phpt) */
740:
741: if (BG(CurrentStatFile)) {
742: efree(BG(CurrentStatFile));
743: BG(CurrentStatFile) = NULL;
744: }
745: if (BG(CurrentLStatFile)) {
746: efree(BG(CurrentLStatFile));
747: BG(CurrentLStatFile) = NULL;
748: }
749: if (clear_realpath_cache) {
750: if (filename != NULL) {
751: realpath_cache_del(filename, filename_len TSRMLS_CC);
752: } else {
753: realpath_cache_clean(TSRMLS_C);
754: }
755: }
756: }
757: /* }}} */
758:
759: /* {{{ proto void clearstatcache([bool clear_realpath_cache[, string filename]])
760: Clear file stat cache */
761: PHP_FUNCTION(clearstatcache)
762: {
763: zend_bool clear_realpath_cache = 0;
764: char *filename = NULL;
765: int filename_len = 0;
766:
767: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|bs", &clear_realpath_cache, &filename, &filename_len) == FAILURE) {
768: return;
769: }
770:
771: php_clear_stat_cache(clear_realpath_cache, filename, filename_len TSRMLS_CC);
772: }
773: /* }}} */
774:
775: #define IS_LINK_OPERATION(__t) ((__t) == FS_TYPE || (__t) == FS_IS_LINK || (__t) == FS_LSTAT)
776: #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)
777: #define IS_ABLE_CHECK(__t) ((__t) == FS_IS_R || (__t) == FS_IS_W || (__t) == FS_IS_X)
778: #define IS_ACCESS_CHECK(__t) (IS_ABLE_CHECK(type) || (__t) == FS_EXISTS)
779:
780: /* {{{ php_stat
781: */
782: PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int type, zval *return_value TSRMLS_DC)
783: {
784: zval *stat_dev, *stat_ino, *stat_mode, *stat_nlink, *stat_uid, *stat_gid, *stat_rdev,
785: *stat_size, *stat_atime, *stat_mtime, *stat_ctime, *stat_blksize, *stat_blocks;
786: struct stat *stat_sb;
787: php_stream_statbuf ssb;
788: int flags = 0, rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */
789: char *stat_sb_names[13] = {
790: "dev", "ino", "mode", "nlink", "uid", "gid", "rdev",
791: "size", "atime", "mtime", "ctime", "blksize", "blocks"
792: };
793: char *local;
794: php_stream_wrapper *wrapper;
795: char safe_mode_buf[MAXPATHLEN];
796:
797: if (!filename_length) {
798: RETURN_FALSE;
799: }
800:
801: if (strlen(filename) != filename_length) {
802: RETURN_FALSE;
803: }
804:
805: if ((wrapper = php_stream_locate_url_wrapper(filename, &local, 0 TSRMLS_CC)) == &php_plain_files_wrapper) {
806: if (php_check_open_basedir(local TSRMLS_CC)) {
807: RETURN_FALSE;
808: } else if (PG(safe_mode)) {
809: if (type == FS_IS_X) {
810: if (strstr(local, "..")) {
811: RETURN_FALSE;
812: } else {
813: char *b = strrchr(local, PHP_DIR_SEPARATOR);
814: snprintf(safe_mode_buf, MAXPATHLEN, "%s%s%s", PG(safe_mode_exec_dir), (b ? "" : "/"), (b ? b : local));
815: local = (char *)&safe_mode_buf;
816: }
817: } else if (!php_checkuid_ex(local, NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS, CHECKUID_NO_ERRORS)) {
818: RETURN_FALSE;
819: }
820: }
821: }
822:
823: if (IS_ACCESS_CHECK(type)) {
824: if (wrapper == &php_plain_files_wrapper) {
825:
826: switch (type) {
827: #ifdef F_OK
828: case FS_EXISTS:
829: RETURN_BOOL(VCWD_ACCESS(local, F_OK) == 0);
830: break;
831: #endif
832: #ifdef W_OK
833: case FS_IS_W:
834: RETURN_BOOL(VCWD_ACCESS(local, W_OK) == 0);
835: break;
836: #endif
837: #ifdef R_OK
838: case FS_IS_R:
839: RETURN_BOOL(VCWD_ACCESS(local, R_OK) == 0);
840: break;
841: #endif
842: #ifdef X_OK
843: case FS_IS_X:
844: RETURN_BOOL(VCWD_ACCESS(local, X_OK) == 0);
845: break;
846: #endif
847: }
848: }
849: }
850:
851: if (IS_LINK_OPERATION(type)) {
852: flags |= PHP_STREAM_URL_STAT_LINK;
853: }
854: if (IS_EXISTS_CHECK(type)) {
855: flags |= PHP_STREAM_URL_STAT_QUIET;
856: }
857:
858: if (php_stream_stat_path_ex((char *)filename, flags, &ssb, NULL)) {
859: /* Error Occured */
860: if (!IS_EXISTS_CHECK(type)) {
861: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%sstat failed for %s", IS_LINK_OPERATION(type) ? "L" : "", filename);
862: }
863: RETURN_FALSE;
864: }
865:
866: stat_sb = &ssb.sb;
867:
868:
869: #ifndef NETWARE
870: if (type >= FS_IS_W && type <= FS_IS_X) {
871: if(ssb.sb.st_uid==getuid()) {
872: rmask=S_IRUSR;
873: wmask=S_IWUSR;
874: xmask=S_IXUSR;
875: } else if(ssb.sb.st_gid==getgid()) {
876: rmask=S_IRGRP;
877: wmask=S_IWGRP;
878: xmask=S_IXGRP;
879: } else {
880: int groups, n, i;
881: gid_t *gids;
882:
883: groups = getgroups(0, NULL);
884: if(groups > 0) {
885: gids=(gid_t *)safe_emalloc(groups, sizeof(gid_t), 0);
886: n=getgroups(groups, gids);
887: for(i=0;i<n;i++){
888: if(ssb.sb.st_gid==gids[i]) {
889: rmask=S_IRGRP;
890: wmask=S_IWGRP;
891: xmask=S_IXGRP;
892: break;
893: }
894: }
895: efree(gids);
896: }
897: }
898: }
899: #endif
900:
901: #ifndef NETWARE
902: if (IS_ABLE_CHECK(type) && getuid() == 0) {
903: /* root has special perms on plain_wrapper
904: But we don't know about root under Netware */
905: if (wrapper == &php_plain_files_wrapper) {
906: if (type == FS_IS_X) {
907: xmask = S_IXROOT;
908: } else {
909: RETURN_TRUE;
910: }
911: }
912: }
913: #endif
914:
915: switch (type) {
916: case FS_PERMS:
917: RETURN_LONG((long)ssb.sb.st_mode);
918: case FS_INODE:
919: RETURN_LONG((long)ssb.sb.st_ino);
920: case FS_SIZE:
921: RETURN_LONG((long)ssb.sb.st_size);
922: case FS_OWNER:
923: RETURN_LONG((long)ssb.sb.st_uid);
924: case FS_GROUP:
925: RETURN_LONG((long)ssb.sb.st_gid);
926: case FS_ATIME:
927: RETURN_LONG((long)ssb.sb.st_atime);
928: case FS_MTIME:
929: RETURN_LONG((long)ssb.sb.st_mtime);
930: case FS_CTIME:
931: RETURN_LONG((long)ssb.sb.st_ctime);
932: case FS_TYPE:
933: if (S_ISLNK(ssb.sb.st_mode)) {
934: RETURN_STRING("link", 1);
935: }
936: switch(ssb.sb.st_mode & S_IFMT) {
937: case S_IFIFO: RETURN_STRING("fifo", 1);
938: case S_IFCHR: RETURN_STRING("char", 1);
939: case S_IFDIR: RETURN_STRING("dir", 1);
940: case S_IFBLK: RETURN_STRING("block", 1);
941: case S_IFREG: RETURN_STRING("file", 1);
942: #if defined(S_IFSOCK) && !defined(ZEND_WIN32)&&!defined(__BEOS__)
943: case S_IFSOCK: RETURN_STRING("socket", 1);
944: #endif
945: }
946: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unknown file type (%d)", ssb.sb.st_mode&S_IFMT);
947: RETURN_STRING("unknown", 1);
948: case FS_IS_W:
949: RETURN_BOOL((ssb.sb.st_mode & wmask) != 0);
950: case FS_IS_R:
951: RETURN_BOOL((ssb.sb.st_mode&rmask)!=0);
952: case FS_IS_X:
953: RETURN_BOOL((ssb.sb.st_mode&xmask)!=0 && !S_ISDIR(ssb.sb.st_mode));
954: case FS_IS_FILE:
955: RETURN_BOOL(S_ISREG(ssb.sb.st_mode));
956: case FS_IS_DIR:
957: RETURN_BOOL(S_ISDIR(ssb.sb.st_mode));
958: case FS_IS_LINK:
959: RETURN_BOOL(S_ISLNK(ssb.sb.st_mode));
960: case FS_EXISTS:
961: RETURN_TRUE; /* the false case was done earlier */
962: case FS_LSTAT:
963: /* FALLTHROUGH */
964: case FS_STAT:
965: array_init(return_value);
966:
967: MAKE_LONG_ZVAL_INCREF(stat_dev, stat_sb->st_dev);
968: MAKE_LONG_ZVAL_INCREF(stat_ino, stat_sb->st_ino);
969: MAKE_LONG_ZVAL_INCREF(stat_mode, stat_sb->st_mode);
970: MAKE_LONG_ZVAL_INCREF(stat_nlink, stat_sb->st_nlink);
971: MAKE_LONG_ZVAL_INCREF(stat_uid, stat_sb->st_uid);
972: MAKE_LONG_ZVAL_INCREF(stat_gid, stat_sb->st_gid);
973: #ifdef HAVE_ST_RDEV
974: MAKE_LONG_ZVAL_INCREF(stat_rdev, stat_sb->st_rdev);
975: #else
976: MAKE_LONG_ZVAL_INCREF(stat_rdev, -1);
977: #endif
978: MAKE_LONG_ZVAL_INCREF(stat_size, stat_sb->st_size);
979: MAKE_LONG_ZVAL_INCREF(stat_atime, stat_sb->st_atime);
980: MAKE_LONG_ZVAL_INCREF(stat_mtime, stat_sb->st_mtime);
981: MAKE_LONG_ZVAL_INCREF(stat_ctime, stat_sb->st_ctime);
982: #ifdef HAVE_ST_BLKSIZE
983: MAKE_LONG_ZVAL_INCREF(stat_blksize, stat_sb->st_blksize);
984: #else
985: MAKE_LONG_ZVAL_INCREF(stat_blksize,-1);
986: #endif
987: #ifdef HAVE_ST_BLOCKS
988: MAKE_LONG_ZVAL_INCREF(stat_blocks, stat_sb->st_blocks);
989: #else
990: MAKE_LONG_ZVAL_INCREF(stat_blocks,-1);
991: #endif
992: /* Store numeric indexes in propper order */
993: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_dev, sizeof(zval *), NULL);
994: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ino, sizeof(zval *), NULL);
995: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mode, sizeof(zval *), NULL);
996: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_nlink, sizeof(zval *), NULL);
997: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_uid, sizeof(zval *), NULL);
998: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_gid, sizeof(zval *), NULL);
999:
1000: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_rdev, sizeof(zval *), NULL);
1001: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_size, sizeof(zval *), NULL);
1002: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_atime, sizeof(zval *), NULL);
1003: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mtime, sizeof(zval *), NULL);
1004: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ctime, sizeof(zval *), NULL);
1005: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blksize, sizeof(zval *), NULL);
1006: zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL);
1007:
1008: /* Store string indexes referencing the same zval*/
1009: zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL);
1010: zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL);
1011: zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL);
1012: zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL);
1013: zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL);
1014: zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL);
1015: zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL);
1016: zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL);
1017: zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL);
1018: zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL);
1019: zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL);
1020: zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL);
1021: zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL);
1022:
1023: return;
1024: }
1025: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Didn't understand stat call");
1026: RETURN_FALSE;
1027: }
1028: /* }}} */
1029:
1030: /* another quickie macro to make defining similar functions easier */
1031: /* {{{ FileFunction(name, funcnum) */
1032: #define FileFunction(name, funcnum) \
1033: void name(INTERNAL_FUNCTION_PARAMETERS) { \
1034: char *filename; \
1035: int filename_len; \
1036: \
1037: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) { \
1038: return; \
1039: } \
1040: \
1041: php_stat(filename, (php_stat_len) filename_len, funcnum, return_value TSRMLS_CC); \
1042: }
1043: /* }}} */
1044:
1045: /* {{{ proto int fileperms(string filename)
1046: Get file permissions */
1047: FileFunction(PHP_FN(fileperms), FS_PERMS)
1048: /* }}} */
1049:
1050: /* {{{ proto int fileinode(string filename)
1051: Get file inode */
1052: FileFunction(PHP_FN(fileinode), FS_INODE)
1053: /* }}} */
1054:
1055: /* {{{ proto int filesize(string filename)
1056: Get file size */
1057: FileFunction(PHP_FN(filesize), FS_SIZE)
1058: /* }}} */
1059:
1060: /* {{{ proto int fileowner(string filename)
1061: Get file owner */
1062: FileFunction(PHP_FN(fileowner), FS_OWNER)
1063: /* }}} */
1064:
1065: /* {{{ proto int filegroup(string filename)
1066: Get file group */
1067: FileFunction(PHP_FN(filegroup), FS_GROUP)
1068: /* }}} */
1069:
1070: /* {{{ proto int fileatime(string filename)
1071: Get last access time of file */
1072: FileFunction(PHP_FN(fileatime), FS_ATIME)
1073: /* }}} */
1074:
1075: /* {{{ proto int filemtime(string filename)
1076: Get last modification time of file */
1077: FileFunction(PHP_FN(filemtime), FS_MTIME)
1078: /* }}} */
1079:
1080: /* {{{ proto int filectime(string filename)
1081: Get inode modification time of file */
1082: FileFunction(PHP_FN(filectime), FS_CTIME)
1083: /* }}} */
1084:
1085: /* {{{ proto string filetype(string filename)
1086: Get file type */
1087: FileFunction(PHP_FN(filetype), FS_TYPE)
1088: /* }}} */
1089:
1090: /* {{{ proto bool is_writable(string filename)
1091: Returns true if file can be written */
1092: FileFunction(PHP_FN(is_writable), FS_IS_W)
1093: /* }}} */
1094:
1095: /* {{{ proto bool is_readable(string filename)
1096: Returns true if file can be read */
1097: FileFunction(PHP_FN(is_readable), FS_IS_R)
1098: /* }}} */
1099:
1100: /* {{{ proto bool is_executable(string filename)
1101: Returns true if file is executable */
1102: FileFunction(PHP_FN(is_executable), FS_IS_X)
1103: /* }}} */
1104:
1105: /* {{{ proto bool is_file(string filename)
1106: Returns true if file is a regular file */
1107: FileFunction(PHP_FN(is_file), FS_IS_FILE)
1108: /* }}} */
1109:
1110: /* {{{ proto bool is_dir(string filename)
1111: Returns true if file is directory */
1112: FileFunction(PHP_FN(is_dir), FS_IS_DIR)
1113: /* }}} */
1114:
1115: /* {{{ proto bool is_link(string filename)
1116: Returns true if file is symbolic link */
1117: FileFunction(PHP_FN(is_link), FS_IS_LINK)
1118: /* }}} */
1119:
1120: /* {{{ proto bool file_exists(string filename)
1121: Returns true if filename exists */
1122: FileFunction(PHP_FN(file_exists), FS_EXISTS)
1123: /* }}} */
1124:
1125: /* {{{ proto array lstat(string filename)
1126: Give information about a file or symbolic link */
1127: FileFunction(php_if_lstat, FS_LSTAT)
1128: /* }}} */
1129:
1130: /* {{{ proto array stat(string filename)
1131: Give information about a file */
1132: FileFunction(php_if_stat, FS_STAT)
1133: /* }}} */
1134:
1135: /* {{{ proto bool realpath_cache_size()
1136: Get current size of realpath cache */
1137: PHP_FUNCTION(realpath_cache_size)
1138: {
1139: if (zend_parse_parameters_none() == FAILURE) {
1140: return;
1141: }
1142: RETURN_LONG(realpath_cache_size(TSRMLS_C));
1143: }
1144:
1145: /* {{{ proto bool realpath_cache_get()
1146: Get current size of realpath cache */
1147: PHP_FUNCTION(realpath_cache_get)
1148: {
1149: realpath_cache_bucket **buckets = realpath_cache_get_buckets(TSRMLS_C), **end = buckets + realpath_cache_max_buckets(TSRMLS_C);
1150:
1151: if (zend_parse_parameters_none() == FAILURE) {
1152: return;
1153: }
1154:
1155: array_init(return_value);
1156: while(buckets < end) {
1157: realpath_cache_bucket *bucket = *buckets;
1158: while(bucket) {
1159: zval *entry;
1160: MAKE_STD_ZVAL(entry);
1161: array_init(entry);
1162:
1163: add_assoc_long(entry, "key", bucket->key);
1164: add_assoc_bool(entry, "is_dir", bucket->is_dir);
1165: add_assoc_stringl(entry, "realpath", bucket->realpath, bucket->realpath_len, 1);
1166: add_assoc_long(entry, "expires", bucket->expires);
1167: #ifdef PHP_WIN32
1168: add_assoc_bool(entry, "is_rvalid", bucket->is_rvalid);
1169: add_assoc_bool(entry, "is_wvalid", bucket->is_wvalid);
1170: add_assoc_bool(entry, "is_readable", bucket->is_readable);
1171: add_assoc_bool(entry, "is_writable", bucket->is_writable);
1172: #endif
1173: zend_hash_update(Z_ARRVAL_P(return_value), bucket->path, bucket->path_len+1, &entry, sizeof(zval *), NULL);
1174: bucket = bucket->next;
1175: }
1176: buckets++;
1177: }
1178: }
1179:
1180: /*
1181: * Local variables:
1182: * tab-width: 4
1183: * c-basic-offset: 4
1184: * End:
1185: * vim600: sw=4 ts=4 fdm=marker
1186: * vim<600: sw=4 ts=4
1187: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to filestat.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 / standard