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