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