PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - main/streams - plain_wrapper.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 372 567 65.6 %
Date: 2014-07-21 Functions: 28 30 93.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Wez Furlong <wez@thebrainroom.com>                          |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #include "php.h"
      22             : #include "php_globals.h"
      23             : #include "php_network.h"
      24             : #include "php_open_temporary_file.h"
      25             : #include "ext/standard/file.h"
      26             : #include "ext/standard/flock_compat.h"
      27             : #include "ext/standard/php_filestat.h"
      28             : #include <stddef.h>
      29             : #include <fcntl.h>
      30             : #if HAVE_SYS_WAIT_H
      31             : #include <sys/wait.h>
      32             : #endif
      33             : #if HAVE_SYS_FILE_H
      34             : #include <sys/file.h>
      35             : #endif
      36             : #ifdef HAVE_SYS_MMAN_H
      37             : #include <sys/mman.h>
      38             : #endif
      39             : #include "SAPI.h"
      40             : 
      41             : #include "php_streams_int.h"
      42             : #ifdef PHP_WIN32
      43             : # include "win32/winutil.h"
      44             : #endif
      45             : 
      46             : #define php_stream_fopen_from_fd_int(fd, mode, persistent_id)   _php_stream_fopen_from_fd_int((fd), (mode), (persistent_id) STREAMS_CC TSRMLS_CC)
      47             : #define php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id)        _php_stream_fopen_from_fd_int((fd), (mode), (persistent_id) STREAMS_REL_CC TSRMLS_CC)
      48             : #define php_stream_fopen_from_file_int(file, mode)      _php_stream_fopen_from_file_int((file), (mode) STREAMS_CC TSRMLS_CC)
      49             : #define php_stream_fopen_from_file_int_rel(file, mode)   _php_stream_fopen_from_file_int((file), (mode) STREAMS_REL_CC TSRMLS_CC)
      50             : 
      51             : #if !defined(WINDOWS) && !defined(NETWARE)
      52             : extern int php_get_uid_by_name(const char *name, uid_t *uid TSRMLS_DC);
      53             : extern int php_get_gid_by_name(const char *name, gid_t *gid TSRMLS_DC);
      54             : #endif
      55             : 
      56             : /* parse standard "fopen" modes into open() flags */
      57       80615 : PHPAPI int php_stream_parse_fopen_modes(const char *mode, int *open_flags)
      58             : {
      59             :         int flags;
      60             : 
      61       80615 :         switch (mode[0]) {
      62             :                 case 'r':
      63       39663 :                         flags = 0;
      64       39663 :                         break;
      65             :                 case 'w':
      66       37902 :                         flags = O_TRUNC|O_CREAT;
      67       37902 :                         break;
      68             :                 case 'a':
      69        1595 :                         flags = O_CREAT|O_APPEND;
      70        1595 :                         break;
      71             :                 case 'x':
      72        1431 :                         flags = O_CREAT|O_EXCL;
      73        1431 :                         break;
      74             :                 case 'c':
      75           1 :                         flags = O_CREAT;
      76           1 :                         break;
      77             :                 default:
      78             :                         /* unknown mode */
      79          23 :                         return FAILURE;
      80             :         }
      81             : 
      82       80592 :         if (strchr(mode, '+')) {
      83        9546 :                 flags |= O_RDWR;
      84       71046 :         } else if (flags) {
      85       32065 :                 flags |= O_WRONLY;
      86             :         } else {
      87       38981 :                 flags |= O_RDONLY;
      88             :         }
      89             : 
      90             : #if defined(O_NONBLOCK)
      91       80592 :         if (strchr(mode, 'n')) {
      92           0 :                 flags |= O_NONBLOCK;
      93             :         }
      94             : #endif
      95             : 
      96             : #if defined(_O_TEXT) && defined(O_BINARY)
      97             :         if (strchr(mode, 't')) {
      98             :                 flags |= _O_TEXT;
      99             :         } else {
     100             :                 flags |= O_BINARY;
     101             :         }
     102             : #endif
     103             : 
     104       80592 :         *open_flags = flags;
     105       80592 :         return SUCCESS;
     106             : }
     107             : 
     108             : 
     109             : /* {{{ ------- STDIO stream implementation -------*/
     110             : 
     111             : typedef struct {
     112             :         FILE *file;
     113             :         int fd;                                 /* underlying file descriptor */
     114             :         unsigned is_process_pipe:1;     /* use pclose instead of fclose */
     115             :         unsigned is_pipe:1;                     /* don't try and seek */
     116             :         unsigned cached_fstat:1;        /* sb is valid */
     117             :         unsigned _reserved:29;
     118             :         
     119             :         int lock_flag;                  /* stores the lock state */
     120             :         char *temp_file_name;   /* if non-null, this is the path to a temporary file that
     121             :                                                          * is to be deleted when the stream is closed */
     122             : #if HAVE_FLUSHIO
     123             :         char last_op;
     124             : #endif
     125             : 
     126             : #if HAVE_MMAP
     127             :         char *last_mapped_addr;
     128             :         size_t last_mapped_len;
     129             : #endif
     130             : #ifdef PHP_WIN32
     131             :         char *last_mapped_addr;
     132             :         HANDLE file_mapping;
     133             : #endif
     134             : 
     135             :         struct stat sb;
     136             : } php_stdio_stream_data;
     137             : #define PHP_STDIOP_GET_FD(anfd, data)   anfd = (data)->file ? fileno((data)->file) : (data)->fd
     138             : 
     139      277669 : static int do_fstat(php_stdio_stream_data *d, int force)
     140             : {
     141      277669 :         if (!d->cached_fstat || force) {
     142             :                 int fd;
     143             :                 int r;
     144             :            
     145      277669 :                 PHP_STDIOP_GET_FD(fd, d);
     146      277669 :                 r = fstat(fd, &d->sb);
     147      277669 :                 d->cached_fstat = r == 0;
     148             : 
     149      277669 :                 return r;
     150             :         }
     151           0 :         return 0;
     152             : }
     153             : 
     154      157466 : static php_stream *_php_stream_fopen_from_fd_int(int fd, const char *mode, const char *persistent_id STREAMS_DC TSRMLS_DC)
     155             : {
     156             :         php_stdio_stream_data *self;
     157             :         
     158      157466 :         self = pemalloc_rel_orig(sizeof(*self), persistent_id);
     159      157466 :         memset(self, 0, sizeof(*self));
     160      157466 :         self->file = NULL;
     161      157466 :         self->is_pipe = 0;
     162      157466 :         self->lock_flag = LOCK_UN;
     163      157466 :         self->is_process_pipe = 0;
     164      157466 :         self->temp_file_name = NULL;
     165      157466 :         self->fd = fd;
     166             :         
     167      157466 :         return php_stream_alloc_rel(&php_stream_stdio_ops, self, persistent_id, mode);
     168             : }
     169             : 
     170       62352 : static php_stream *_php_stream_fopen_from_file_int(FILE *file, const char *mode STREAMS_DC TSRMLS_DC)
     171             : {
     172             :         php_stdio_stream_data *self;
     173             :         
     174       62352 :         self = emalloc_rel_orig(sizeof(*self));
     175       62352 :         memset(self, 0, sizeof(*self));
     176       62352 :         self->file = file;
     177       62352 :         self->is_pipe = 0;
     178       62352 :         self->lock_flag = LOCK_UN;
     179       62352 :         self->is_process_pipe = 0;
     180       62352 :         self->temp_file_name = NULL;
     181       62352 :         self->fd = fileno(file);
     182             : 
     183       62352 :         return php_stream_alloc_rel(&php_stream_stdio_ops, self, 0, mode);
     184             : }
     185             : 
     186       14095 : PHPAPI php_stream *_php_stream_fopen_temporary_file(const char *dir, const char *pfx, char **opened_path_ptr STREAMS_DC TSRMLS_DC)
     187             : {
     188       14095 :         char *opened_path = NULL;
     189             :         int fd;
     190             : 
     191       14095 :         fd = php_open_temporary_fd(dir, pfx, &opened_path TSRMLS_CC);
     192       14095 :         if (fd != -1)   {
     193             :                 php_stream *stream;
     194             : 
     195       14095 :                 if (opened_path_ptr) {
     196           0 :                         *opened_path_ptr = opened_path;
     197             :                 }
     198             : 
     199       14095 :                 stream = php_stream_fopen_from_fd_int_rel(fd, "r+b", NULL);
     200       14095 :                 if (stream) {
     201       14095 :                         php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     202       14095 :                         stream->wrapper = &php_plain_files_wrapper;
     203       14095 :                         stream->orig_path = estrdup(opened_path);
     204             : 
     205       14095 :                         self->temp_file_name = opened_path;
     206       14095 :                         self->lock_flag = LOCK_UN;
     207             :                         
     208       14095 :                         return stream;
     209             :                 }
     210           0 :                 close(fd);
     211             : 
     212           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to allocate stream");
     213             : 
     214           0 :                 return NULL;
     215             :         }
     216           0 :         return NULL;
     217             : }
     218             : 
     219       14094 : PHPAPI php_stream *_php_stream_fopen_tmpfile(int dummy STREAMS_DC TSRMLS_DC)
     220             : {
     221       14094 :         return php_stream_fopen_temporary_file(NULL, "php", NULL);
     222             : }
     223             : 
     224      133282 : PHPAPI php_stream *_php_stream_fopen_from_fd(int fd, const char *mode, const char *persistent_id STREAMS_DC TSRMLS_DC)
     225             : {
     226      133282 :         php_stream *stream = php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id);
     227             : 
     228      133282 :         if (stream) {
     229      133282 :                 php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     230             : 
     231             : #ifdef S_ISFIFO
     232             :                 /* detect if this is a pipe */
     233      133282 :                 if (self->fd >= 0) {
     234      133282 :                         self->is_pipe = (do_fstat(self, 0) == 0 && S_ISFIFO(self->sb.st_mode)) ? 1 : 0;
     235             :                 }
     236             : #elif defined(PHP_WIN32)
     237             :                 {
     238             :                         zend_uintptr_t handle = _get_osfhandle(self->fd);
     239             : 
     240             :                         if (handle != (zend_uintptr_t)INVALID_HANDLE_VALUE) {
     241             :                                 self->is_pipe = GetFileType((HANDLE)handle) == FILE_TYPE_PIPE;
     242             :                         }
     243             :                 }
     244             : #endif
     245             :         
     246      133282 :                 if (self->is_pipe) {
     247       63411 :                         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     248             :                 } else {
     249       69871 :                         stream->position = lseek(self->fd, 0, SEEK_CUR);
     250             : #ifdef ESPIPE
     251       69871 :                         if (stream->position == (off_t)-1 && errno == ESPIPE) {
     252           0 :                                 stream->position = 0;
     253           0 :                                 stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     254           0 :                                 self->is_pipe = 1;
     255             :                         }
     256             : #endif
     257             :                 }
     258             :         }
     259             : 
     260      133282 :         return stream;
     261             : }
     262             : 
     263       62352 : PHPAPI php_stream *_php_stream_fopen_from_file(FILE *file, const char *mode STREAMS_DC TSRMLS_DC)
     264             : {
     265       62352 :         php_stream *stream = php_stream_fopen_from_file_int_rel(file, mode);
     266             : 
     267       62352 :         if (stream) {
     268       62352 :                 php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     269             : 
     270             : #ifdef S_ISFIFO
     271             :                 /* detect if this is a pipe */
     272       62352 :                 if (self->fd >= 0) {
     273       62352 :                         self->is_pipe = (do_fstat(self, 0) == 0 && S_ISFIFO(self->sb.st_mode)) ? 1 : 0;
     274             :                 }
     275             : #elif defined(PHP_WIN32)
     276             :                 {
     277             :                         zend_uintptr_t handle = _get_osfhandle(self->fd);
     278             : 
     279             :                         if (handle != (zend_uintptr_t)INVALID_HANDLE_VALUE) {
     280             :                                 self->is_pipe = GetFileType((HANDLE)handle) == FILE_TYPE_PIPE;
     281             :                         }
     282             :                 }
     283             : #endif
     284             :         
     285       62352 :                 if (self->is_pipe) {
     286       62344 :                         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     287             :                 } else {
     288           8 :                         stream->position = ftell(file);
     289             :                 }
     290             :         }
     291             : 
     292       62352 :         return stream;
     293             : }
     294             : 
     295         158 : PHPAPI php_stream *_php_stream_fopen_from_pipe(FILE *file, const char *mode STREAMS_DC TSRMLS_DC)
     296             : {
     297             :         php_stdio_stream_data *self;
     298             :         php_stream *stream;
     299             : 
     300         158 :         self = emalloc_rel_orig(sizeof(*self));
     301         158 :         memset(self, 0, sizeof(*self));
     302         158 :         self->file = file;
     303         158 :         self->is_pipe = 1;
     304         158 :         self->lock_flag = LOCK_UN;
     305         158 :         self->is_process_pipe = 1;
     306         158 :         self->fd = fileno(file);
     307         158 :         self->temp_file_name = NULL;
     308             : 
     309         158 :         stream = php_stream_alloc_rel(&php_stream_stdio_ops, self, 0, mode);
     310         158 :         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     311         158 :         return stream;
     312             : }
     313             : 
     314      201988 : static size_t php_stdiop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
     315             : {
     316      201988 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     317             : 
     318             :         assert(data != NULL);
     319             : 
     320      201988 :         if (data->fd >= 0) {
     321      201988 :                 int bytes_written = write(data->fd, buf, count);
     322      201988 :                 if (bytes_written < 0) return 0;
     323      201933 :                 return (size_t) bytes_written;
     324             :         } else {
     325             : 
     326             : #if HAVE_FLUSHIO
     327             :                 if (!data->is_pipe && data->last_op == 'r') {
     328             :                         fseek(data->file, 0, SEEK_CUR);
     329             :                 }
     330             :                 data->last_op = 'w';
     331             : #endif
     332             : 
     333           0 :                 return fwrite(buf, 1, count, data->file);
     334             :         }
     335             : }
     336             : 
     337      976114 : static size_t php_stdiop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
     338             : {
     339      976114 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     340             :         size_t ret;
     341             : 
     342             :         assert(data != NULL);
     343             : 
     344      976114 :         if (data->fd >= 0) {
     345      976111 :                 ret = read(data->fd, buf, count);
     346             : 
     347      976111 :                 if (ret == (size_t)-1 && errno == EINTR) {
     348             :                         /* Read was interrupted, retry once,
     349             :                            If read still fails, giveup with feof==0
     350             :                            so script can retry if desired */
     351           0 :                         ret = read(data->fd, buf, count);
     352             :                 }
     353             :                 
     354      976111 :                 stream->eof = (ret == 0 || (ret == (size_t)-1 && errno != EWOULDBLOCK && errno != EINTR && errno != EBADF));
     355             :                                 
     356             :         } else {
     357             : #if HAVE_FLUSHIO
     358             :                 if (!data->is_pipe && data->last_op == 'w')
     359             :                         fseek(data->file, 0, SEEK_CUR);
     360             :                 data->last_op = 'r';
     361             : #endif
     362             : 
     363           3 :                 ret = fread(buf, 1, count, data->file);
     364             : 
     365           3 :                 stream->eof = feof(data->file);
     366             :         }
     367      976114 :         return ret;
     368             : }
     369             : 
     370      220090 : static int php_stdiop_close(php_stream *stream, int close_handle TSRMLS_DC)
     371             : {
     372             :         int ret;
     373      220090 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     374             : 
     375             :         assert(data != NULL);
     376             : 
     377             : #if HAVE_MMAP
     378      220090 :         if (data->last_mapped_addr) {
     379          33 :                 munmap(data->last_mapped_addr, data->last_mapped_len);
     380          33 :                 data->last_mapped_addr = NULL;
     381             :         }
     382             : #elif defined(PHP_WIN32)
     383             :         if (data->last_mapped_addr) {
     384             :                 UnmapViewOfFile(data->last_mapped_addr);
     385             :                 data->last_mapped_addr = NULL;
     386             :         }
     387             :         if (data->file_mapping) {
     388             :                 CloseHandle(data->file_mapping);
     389             :                 data->file_mapping = NULL;
     390             :         }
     391             : #endif
     392             :         
     393      220090 :         if (close_handle) {
     394      220090 :                 if (data->file) {
     395       62711 :                         if (data->is_process_pipe) {
     396         158 :                                 errno = 0;
     397         158 :                                 ret = pclose(data->file);
     398             : 
     399             : #if HAVE_SYS_WAIT_H
     400         158 :                                 if (WIFEXITED(ret)) {
     401         158 :                                         ret = WEXITSTATUS(ret);
     402             :                                 }
     403             : #endif
     404             :                         } else {
     405       62553 :                                 ret = fclose(data->file);
     406       62553 :                                 data->file = NULL;
     407             :                         }
     408      157379 :                 } else if (data->fd != -1) {
     409      157379 :                         ret = close(data->fd);
     410      157379 :                         data->fd = -1;
     411             :                 } else {
     412           0 :                         return 0; /* everything should be closed already -> success */
     413             :                 }
     414      220090 :                 if (data->temp_file_name) {
     415       14095 :                         unlink(data->temp_file_name);
     416             :                         /* temporary streams are never persistent */
     417       14095 :                         efree(data->temp_file_name);
     418       14095 :                         data->temp_file_name = NULL;
     419             :                 }
     420             :         } else {
     421           0 :                 ret = 0;
     422           0 :                 data->file = NULL;
     423           0 :                 data->fd = -1;
     424             :         }
     425             : 
     426      220090 :         pefree(data, stream->is_persistent);
     427             : 
     428      220090 :         return ret;
     429             : }
     430             : 
     431      222239 : static int php_stdiop_flush(php_stream *stream TSRMLS_DC)
     432             : {
     433      222239 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     434             : 
     435             :         assert(data != NULL);
     436             : 
     437             :         /*
     438             :          * stdio buffers data in user land. By calling fflush(3), this
     439             :          * data is send to the kernel using write(2). fsync'ing is
     440             :          * something completely different.
     441             :          */
     442      222239 :         if (data->file) {
     443       63857 :                 return fflush(data->file);
     444             :         }
     445      158382 :         return 0;
     446             : }
     447             : 
     448       79351 : static int php_stdiop_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC)
     449             : {
     450       79351 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     451             :         int ret;
     452             : 
     453             :         assert(data != NULL);
     454             : 
     455       79351 :         if (data->is_pipe) {
     456           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot seek on a pipe");
     457           0 :                 return -1;
     458             :         }
     459             : 
     460       79351 :         if (data->fd >= 0) {
     461             :                 off_t result;
     462             :                 
     463       78324 :                 result = lseek(data->fd, offset, whence);
     464       78324 :                 if (result == (off_t)-1)
     465         189 :                         return -1;
     466             : 
     467       78135 :                 *newoffset = result;
     468       78135 :                 return 0;
     469             :                 
     470             :         } else {
     471        1027 :                 ret = fseek(data->file, offset, whence);
     472        1027 :                 *newoffset = ftell(data->file);
     473        1027 :                 return ret;
     474             :         }
     475             : }
     476             : 
     477     3430386 : static int php_stdiop_cast(php_stream *stream, int castas, void **ret TSRMLS_DC)
     478             : {
     479             :         php_socket_t fd;
     480     3430386 :         php_stdio_stream_data *data = (php_stdio_stream_data*) stream->abstract;
     481             : 
     482             :         assert(data != NULL);
     483             :         
     484             :         /* as soon as someone touches the stdio layer, buffering may ensue,
     485             :          * so we need to stop using the fd directly in that case */
     486             : 
     487     3430386 :         switch (castas) {
     488             :                 case PHP_STREAM_AS_STDIO:
     489          88 :                         if (ret) {
     490             : 
     491          88 :                                 if (data->file == NULL) {
     492             :                                         /* we were opened as a plain file descriptor, so we
     493             :                                          * need fdopen now */
     494             :                                         char fixed_mode[5];
     495          87 :                                         php_stream_mode_sanitize_fdopen_fopencookie(stream, fixed_mode);
     496          87 :                                         data->file = fdopen(data->fd, fixed_mode);
     497          87 :                                         if (data->file == NULL) {
     498           0 :                                                 return FAILURE;
     499             :                                         }
     500             :                                 }
     501             :                                 
     502          88 :                                 *(FILE**)ret = data->file;
     503          88 :                                 data->fd = SOCK_ERR;
     504             :                         }
     505          88 :                         return SUCCESS;
     506             : 
     507             :                 case PHP_STREAM_AS_FD_FOR_SELECT:
     508     3429896 :                         PHP_STDIOP_GET_FD(fd, data);
     509     3429896 :                         if (SOCK_ERR == fd) {
     510           0 :                                 return FAILURE;
     511             :                         }
     512     3429896 :                         if (ret) {
     513     3429893 :                                 *(php_socket_t *)ret = fd;
     514             :                         }
     515     3429896 :                         return SUCCESS;
     516             : 
     517             :                 case PHP_STREAM_AS_FD:
     518         401 :                         PHP_STDIOP_GET_FD(fd, data);
     519             : 
     520         401 :                         if (SOCK_ERR == fd) {
     521           0 :                                 return FAILURE;
     522             :                         }
     523         401 :                         if (data->file) {
     524         116 :                                 fflush(data->file);
     525             :                         }
     526         401 :                         if (ret) {
     527         401 :                                 *(php_socket_t *)ret = fd;
     528             :                         }
     529         401 :                         return SUCCESS;
     530             :                 default:
     531           1 :                         return FAILURE;
     532             :         }
     533             : }
     534             : 
     535       42630 : static int php_stdiop_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
     536             : {
     537             :         int ret;
     538       42630 :         php_stdio_stream_data *data = (php_stdio_stream_data*) stream->abstract;
     539             : 
     540             :         assert(data != NULL);
     541             : 
     542       42630 :         ret = do_fstat(data, 1);
     543       42630 :         memcpy(&ssb->sb, &data->sb, sizeof(ssb->sb));
     544       42630 :         return ret;
     545             : }
     546             : 
     547      117576 : static int php_stdiop_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
     548             : {
     549      117576 :         php_stdio_stream_data *data = (php_stdio_stream_data*) stream->abstract;
     550             :         size_t size;
     551             :         int fd;
     552             : #ifdef O_NONBLOCK
     553             :         /* FIXME: make this work for win32 */
     554             :         int flags;
     555             :         int oldval;
     556             : #endif
     557             :         
     558      117576 :         PHP_STDIOP_GET_FD(fd, data);
     559             :         
     560      117576 :         switch(option) {
     561             :                 case PHP_STREAM_OPTION_BLOCKING:
     562           4 :                         if (fd == -1)
     563           0 :                                 return -1;
     564             : #ifdef O_NONBLOCK
     565           4 :                         flags = fcntl(fd, F_GETFL, 0);
     566           4 :                         oldval = (flags & O_NONBLOCK) ? 0 : 1;
     567           4 :                         if (value)
     568           0 :                                 flags &= ~O_NONBLOCK;
     569             :                         else
     570           4 :                                 flags |= O_NONBLOCK;
     571             :                         
     572           4 :                         if (-1 == fcntl(fd, F_SETFL, flags))
     573           0 :                                 return -1;
     574           4 :                         return oldval;
     575             : #else
     576             :                         return -1; /* not yet implemented */
     577             : #endif
     578             :                         
     579             :                 case PHP_STREAM_OPTION_WRITE_BUFFER:
     580             : 
     581           1 :                         if (data->file == NULL) {
     582           1 :                                 return -1;
     583             :                         }
     584             :                         
     585           0 :                         if (ptrparam)
     586           0 :                                 size = *(size_t *)ptrparam;
     587             :                         else
     588           0 :                                 size = BUFSIZ;
     589             : 
     590           0 :                         switch(value) {
     591             :                                 case PHP_STREAM_BUFFER_NONE:
     592           0 :                                         return setvbuf(data->file, NULL, _IONBF, 0);
     593             :                                         
     594             :                                 case PHP_STREAM_BUFFER_LINE:
     595           0 :                                         return setvbuf(data->file, NULL, _IOLBF, size);
     596             :                                         
     597             :                                 case PHP_STREAM_BUFFER_FULL:
     598           0 :                                         return setvbuf(data->file, NULL, _IOFBF, size);
     599             : 
     600             :                                 default:
     601           0 :                                         return -1;
     602             :                         }
     603             :                         break;
     604             :                 
     605             :                 case PHP_STREAM_OPTION_LOCKING:
     606         343 :                         if (fd == -1) {
     607           0 :                                 return -1;
     608             :                         }
     609             : 
     610         343 :                         if ((zend_uintptr_t) ptrparam == PHP_STREAM_LOCK_SUPPORTED) {
     611          91 :                                 return 0;
     612             :                         }
     613             : 
     614         252 :                         if (!flock(fd, value)) {
     615         252 :                                 data->lock_flag = value;
     616         252 :                                 return 0;
     617             :                         } else {
     618           0 :                                 return -1;
     619             :                         }
     620             :                         break;
     621             : 
     622             :                 case PHP_STREAM_OPTION_MMAP_API:
     623             : #if HAVE_MMAP
     624             :                         {
     625       83246 :                                 php_stream_mmap_range *range = (php_stream_mmap_range*)ptrparam;
     626             :                                 int prot, flags;
     627             :                                 
     628       83246 :                                 switch (value) {
     629             :                                         case PHP_STREAM_MMAP_SUPPORTED:
     630       29316 :                                                 return fd == -1 ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
     631             : 
     632             :                                         case PHP_STREAM_MMAP_MAP_RANGE:
     633       29316 :                                                 do_fstat(data, 1);
     634       29316 :                                                 if (range->length == 0 && range->offset > 0 && range->offset < data->sb.st_size) {
     635          17 :                                                         range->length = data->sb.st_size - range->offset;
     636             :                                                 }
     637       29316 :                                                 if (range->length == 0 || range->length > data->sb.st_size) {
     638        8822 :                                                         range->length = data->sb.st_size;
     639             :                                                 }
     640       29316 :                                                 if (range->offset >= data->sb.st_size) {
     641          89 :                                                         range->offset = data->sb.st_size;
     642          89 :                                                         range->length = 0;
     643             :                                                 }
     644       29316 :                                                 switch (range->mode) {
     645             :                                                         case PHP_STREAM_MAP_MODE_READONLY:
     646           0 :                                                                 prot = PROT_READ;
     647           0 :                                                                 flags = MAP_PRIVATE;
     648           0 :                                                                 break;
     649             :                                                         case PHP_STREAM_MAP_MODE_READWRITE:
     650           0 :                                                                 prot = PROT_READ | PROT_WRITE;
     651           0 :                                                                 flags = MAP_PRIVATE;
     652           0 :                                                                 break;
     653             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READONLY:
     654       29316 :                                                                 prot = PROT_READ;
     655       29316 :                                                                 flags = MAP_SHARED;
     656       29316 :                                                                 break;
     657             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READWRITE:
     658           0 :                                                                 prot = PROT_READ | PROT_WRITE;
     659           0 :                                                                 flags = MAP_SHARED;
     660           0 :                                                                 break;
     661             :                                                         default:
     662           0 :                                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     663             :                                                 }
     664       29316 :                                                 range->mapped = (char*)mmap(NULL, range->length, prot, flags, fd, range->offset);
     665       29316 :                                                 if (range->mapped == (char*)MAP_FAILED) {
     666        4669 :                                                         range->mapped = NULL;
     667        4669 :                                                         return PHP_STREAM_OPTION_RETURN_ERR;
     668             :                                                 }
     669             :                                                 /* remember the mapping */
     670       24647 :                                                 data->last_mapped_addr = range->mapped;
     671       24647 :                                                 data->last_mapped_len = range->length;
     672       24647 :                                                 return PHP_STREAM_OPTION_RETURN_OK;
     673             : 
     674             :                                         case PHP_STREAM_MMAP_UNMAP:
     675       24614 :                                                 if (data->last_mapped_addr) {
     676       24614 :                                                         munmap(data->last_mapped_addr, data->last_mapped_len);
     677       24614 :                                                         data->last_mapped_addr = NULL;
     678             : 
     679       24614 :                                                         return PHP_STREAM_OPTION_RETURN_OK;
     680             :                                                 }
     681           0 :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     682             :                                 }
     683             :                         }
     684             : #elif defined(PHP_WIN32)
     685             :                         {
     686             :                                 php_stream_mmap_range *range = (php_stream_mmap_range*)ptrparam;
     687             :                                 HANDLE hfile = (HANDLE)_get_osfhandle(fd);
     688             :                                 DWORD prot, acc, loffs = 0, delta = 0;
     689             : 
     690             :                                 switch (value) {
     691             :                                         case PHP_STREAM_MMAP_SUPPORTED:
     692             :                                                 return hfile == INVALID_HANDLE_VALUE ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
     693             : 
     694             :                                         case PHP_STREAM_MMAP_MAP_RANGE:
     695             :                                                 switch (range->mode) {
     696             :                                                         case PHP_STREAM_MAP_MODE_READONLY:
     697             :                                                                 prot = PAGE_READONLY;
     698             :                                                                 acc = FILE_MAP_READ;
     699             :                                                                 break;
     700             :                                                         case PHP_STREAM_MAP_MODE_READWRITE:
     701             :                                                                 prot = PAGE_READWRITE;
     702             :                                                                 acc = FILE_MAP_READ | FILE_MAP_WRITE;
     703             :                                                                 break;
     704             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READONLY:
     705             :                                                                 prot = PAGE_READONLY;
     706             :                                                                 acc = FILE_MAP_READ;
     707             :                                                                 /* TODO: we should assign a name for the mapping */
     708             :                                                                 break;
     709             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READWRITE:
     710             :                                                                 prot = PAGE_READWRITE;
     711             :                                                                 acc = FILE_MAP_READ | FILE_MAP_WRITE;
     712             :                                                                 /* TODO: we should assign a name for the mapping */
     713             :                                                                 break;
     714             :                                                         default:
     715             :                                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     716             :                                                 }
     717             : 
     718             :                                                 /* create a mapping capable of viewing the whole file (this costs no real resources) */
     719             :                                                 data->file_mapping = CreateFileMapping(hfile, NULL, prot, 0, 0, NULL);
     720             : 
     721             :                                                 if (data->file_mapping == NULL) {
     722             :                                                         return PHP_STREAM_OPTION_RETURN_ERR;
     723             :                                                 }
     724             : 
     725             :                                                 size = GetFileSize(hfile, NULL);
     726             :                                                 if (range->length == 0 && range->offset > 0 && range->offset < size) {
     727             :                                                         range->length = size - range->offset;
     728             :                                                 }
     729             :                                                 if (range->length == 0 || range->length > size) {
     730             :                                                         range->length = size;
     731             :                                                 }
     732             :                                                 if (range->offset >= size) {
     733             :                                                         range->offset = size;
     734             :                                                         range->length = 0;
     735             :                                                 }
     736             : 
     737             :                                                 /* figure out how big a chunk to map to be able to view the part that we need */
     738             :                                                 if (range->offset != 0) {
     739             :                                                         SYSTEM_INFO info;
     740             :                                                         DWORD gran;
     741             : 
     742             :                                                         GetSystemInfo(&info);
     743             :                                                         gran = info.dwAllocationGranularity;
     744             :                                                         loffs = (range->offset / gran) * gran;
     745             :                                                         delta = range->offset - loffs;
     746             :                                                 }
     747             : 
     748             :                                                 data->last_mapped_addr = MapViewOfFile(data->file_mapping, acc, 0, loffs, range->length + delta);
     749             : 
     750             :                                                 if (data->last_mapped_addr) {
     751             :                                                         /* give them back the address of the start offset they requested */
     752             :                                                         range->mapped = data->last_mapped_addr + delta;
     753             :                                                         return PHP_STREAM_OPTION_RETURN_OK;
     754             :                                                 }
     755             : 
     756             :                                                 CloseHandle(data->file_mapping);
     757             :                                                 data->file_mapping = NULL;
     758             : 
     759             :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     760             : 
     761             :                                         case PHP_STREAM_MMAP_UNMAP:
     762             :                                                 if (data->last_mapped_addr) {
     763             :                                                         UnmapViewOfFile(data->last_mapped_addr);
     764             :                                                         data->last_mapped_addr = NULL;
     765             :                                                         CloseHandle(data->file_mapping);
     766             :                                                         data->file_mapping = NULL;
     767             :                                                         return PHP_STREAM_OPTION_RETURN_OK;
     768             :                                                 }
     769             :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     770             : 
     771             :                                         default:
     772             :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     773             :                                 }
     774             :                         }
     775             : 
     776             : #endif
     777           0 :                         return PHP_STREAM_OPTION_RETURN_NOTIMPL;
     778             : 
     779             :                 case PHP_STREAM_OPTION_TRUNCATE_API:
     780         782 :                         switch (value) {
     781             :                                 case PHP_STREAM_TRUNCATE_SUPPORTED:
     782         379 :                                         return fd == -1 ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
     783             : 
     784             :                                 case PHP_STREAM_TRUNCATE_SET_SIZE: {
     785         403 :                                         ptrdiff_t new_size = *(ptrdiff_t*)ptrparam;
     786         403 :                                         if (new_size < 0) {
     787          50 :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     788             :                                         }
     789         353 :                                         return ftruncate(fd, new_size) == 0 ? PHP_STREAM_OPTION_RETURN_OK : PHP_STREAM_OPTION_RETURN_ERR;
     790             :                                 }
     791             :                         }
     792             :                         
     793             :                 default:
     794       33200 :                         return PHP_STREAM_OPTION_RETURN_NOTIMPL;
     795             :         }
     796             : }
     797             : 
     798             : PHPAPI php_stream_ops   php_stream_stdio_ops = {
     799             :         php_stdiop_write, php_stdiop_read,
     800             :         php_stdiop_close, php_stdiop_flush,
     801             :         "STDIO",
     802             :         php_stdiop_seek,
     803             :         php_stdiop_cast,
     804             :         php_stdiop_stat,
     805             :         php_stdiop_set_option
     806             : };
     807             : /* }}} */
     808             : 
     809             : /* {{{ plain files opendir/readdir implementation */
     810       37202 : static size_t php_plain_files_dirstream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
     811             : {
     812       37202 :         DIR *dir = (DIR*)stream->abstract;
     813             :         /* avoid libc5 readdir problems */
     814             :         char entry[sizeof(struct dirent)+MAXPATHLEN];
     815       37202 :         struct dirent *result = (struct dirent *)&entry;
     816       37202 :         php_stream_dirent *ent = (php_stream_dirent*)buf;
     817             : 
     818             :         /* avoid problems if someone mis-uses the stream */
     819       37202 :         if (count != sizeof(php_stream_dirent))
     820           0 :                 return 0;
     821             : 
     822       37202 :         if (php_readdir_r(dir, (struct dirent *)entry, &result) == 0 && result) {
     823       36501 :                 PHP_STRLCPY(ent->d_name, result->d_name, sizeof(ent->d_name), strlen(result->d_name));
     824       36501 :                 return sizeof(php_stream_dirent);
     825             :         }
     826         701 :         return 0;
     827             : }
     828             : 
     829         836 : static int php_plain_files_dirstream_close(php_stream *stream, int close_handle TSRMLS_DC)
     830             : {
     831         836 :         return closedir((DIR *)stream->abstract);
     832             : }
     833             : 
     834          53 : static int php_plain_files_dirstream_rewind(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
     835             : {
     836          53 :         rewinddir((DIR *)stream->abstract);
     837          53 :         return 0;
     838             : }
     839             : 
     840             : static php_stream_ops   php_plain_files_dirstream_ops = {
     841             :         NULL, php_plain_files_dirstream_read,
     842             :         php_plain_files_dirstream_close, NULL,
     843             :         "dir",
     844             :         php_plain_files_dirstream_rewind,
     845             :         NULL, /* cast */
     846             :         NULL, /* stat */
     847             :         NULL  /* set_option */
     848             : };
     849             : 
     850         921 : static php_stream *php_plain_files_dir_opener(php_stream_wrapper *wrapper, const char *path, const char *mode,
     851             :                 int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
     852             : {
     853         921 :         DIR *dir = NULL;
     854         921 :         php_stream *stream = NULL;
     855             : 
     856             : #ifdef HAVE_GLOB
     857         921 :         if (options & STREAM_USE_GLOB_DIR_OPEN) {
     858           0 :                 return php_glob_stream_wrapper.wops->dir_opener(&php_glob_stream_wrapper, path, mode, options, opened_path, context STREAMS_REL_CC TSRMLS_CC);
     859             :         }
     860             : #endif
     861             : 
     862         921 :         if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(path TSRMLS_CC)) {
     863          24 :                 return NULL;
     864             :         }
     865             :         
     866         897 :         dir = VCWD_OPENDIR(path);
     867             : 
     868             : #ifdef PHP_WIN32
     869             :         if (!dir) {
     870             :                 php_win32_docref2_from_error(GetLastError(), path, path TSRMLS_CC);
     871             :         }
     872             : 
     873             :         if (dir && dir->finished) {
     874             :                 closedir(dir);
     875             :                 dir = NULL;
     876             :         }
     877             : #endif
     878         897 :         if (dir) {
     879         836 :                 stream = php_stream_alloc(&php_plain_files_dirstream_ops, dir, 0, mode);
     880         836 :                 if (stream == NULL)
     881           0 :                         closedir(dir);
     882             :         }
     883             :                 
     884         897 :         return stream;
     885             : }
     886             : /* }}} */
     887             : 
     888             : /* {{{ php_stream_fopen */
     889       80615 : PHPAPI php_stream *_php_stream_fopen(const char *filename, const char *mode, char **opened_path, int options STREAMS_DC TSRMLS_DC)
     890             : {
     891       80615 :         char *realpath = NULL;
     892             :         int open_flags;
     893             :         int fd;
     894             :         php_stream *ret;
     895       80615 :         int persistent = options & STREAM_OPEN_PERSISTENT;
     896       80615 :         char *persistent_id = NULL;
     897             : 
     898       80615 :         if (FAILURE == php_stream_parse_fopen_modes(mode, &open_flags)) {
     899          23 :                 if (options & REPORT_ERRORS) {
     900           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "`%s' is not a valid mode for fopen", mode);
     901             :                 }
     902          23 :                 return NULL;
     903             :         }
     904             : 
     905       80592 :         if (options & STREAM_ASSUME_REALPATH) {
     906       10242 :                 realpath = estrdup(filename);
     907             :         } else {
     908       70350 :                 if ((realpath = expand_filepath(filename, NULL TSRMLS_CC)) == NULL) {
     909           0 :                         return NULL;
     910             :                 }
     911             :         }
     912             : 
     913       80592 :         if (persistent) {
     914          25 :                 spprintf(&persistent_id, 0, "streams_stdio_%d_%s", open_flags, realpath);
     915          25 :                 switch (php_stream_from_persistent_id(persistent_id, &ret TSRMLS_CC)) {
     916             :                         case PHP_STREAM_PERSISTENT_SUCCESS:
     917           0 :                                 if (opened_path) {
     918           0 :                                         *opened_path = realpath;
     919           0 :                                         realpath = NULL;
     920             :                                 }
     921             :                                 /* fall through */
     922             : 
     923             :                         case PHP_STREAM_PERSISTENT_FAILURE:
     924           0 :                                 if (realpath) {
     925           0 :                                         efree(realpath);
     926             :                                 }
     927           0 :                                 efree(persistent_id);;
     928           0 :                                 return ret;
     929             :                 }
     930             :         }
     931             :         
     932       80592 :         fd = open(realpath, open_flags, 0666);
     933             : 
     934       80592 :         if (fd != -1)   {
     935             : 
     936       79960 :                 if (options & STREAM_OPEN_FOR_INCLUDE) {
     937       10089 :                         ret = php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id);
     938             :                 } else {
     939       69871 :                         ret = php_stream_fopen_from_fd_rel(fd, mode, persistent_id);
     940             :                 }
     941             : 
     942       79960 :                 if (ret)        {
     943       79960 :                         if (opened_path) {
     944       13837 :                                 *opened_path = realpath;
     945       13837 :                                 realpath = NULL;
     946             :                         }
     947       79960 :                         if (realpath) {
     948       66123 :                                 efree(realpath);
     949             :                         }
     950       79960 :                         if (persistent_id) {
     951          24 :                                 efree(persistent_id);
     952             :                         }
     953             : 
     954             :                         /* WIN32 always set ISREG flag */
     955             : #ifndef PHP_WIN32
     956             :                         /* sanity checks for include/require.
     957             :                          * We check these after opening the stream, so that we save
     958             :                          * on fstat() syscalls */
     959       79960 :                         if (options & STREAM_OPEN_FOR_INCLUDE) {
     960       10089 :                                 php_stdio_stream_data *self = (php_stdio_stream_data*)ret->abstract;
     961             :                                 int r;
     962             : 
     963       10089 :                                 r = do_fstat(self, 0);
     964       10089 :                                 if ((r == 0 && !S_ISREG(self->sb.st_mode))) {
     965           1 :                                         if (opened_path) {
     966           1 :                                                 efree(*opened_path);
     967           1 :                                                 *opened_path = NULL;
     968             :                                         }
     969           1 :                                         php_stream_close(ret);
     970           1 :                                         return NULL;
     971             :                                 }
     972             :                         }
     973             : #endif
     974             : 
     975       79959 :                         return ret;
     976             :                 }
     977           0 :                 close(fd);
     978             :         }
     979         632 :         efree(realpath);
     980         632 :         if (persistent_id) {
     981           1 :                 efree(persistent_id);
     982             :         }
     983         632 :         return NULL;
     984             : }
     985             : /* }}} */
     986             : 
     987             : 
     988       80656 : static php_stream *php_plain_files_stream_opener(php_stream_wrapper *wrapper, const char *path, const char *mode,
     989             :                 int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
     990             : {
     991       80656 :         if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(path TSRMLS_CC)) {
     992          41 :                 return NULL;
     993             :         }
     994             : 
     995       80615 :         return php_stream_fopen_rel(path, mode, opened_path, options);
     996             : }
     997             : 
     998       55055 : static int php_plain_files_url_stater(php_stream_wrapper *wrapper, const char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
     999             : {
    1000             :         char *p;
    1001             : 
    1002       55055 :         if ((p = strstr(url, "://")) != NULL) {
    1003           1 :                 if (p < strchr(url, '/')) {
    1004           1 :                         url = p + 3;
    1005             :                 }
    1006             :         }
    1007             : 
    1008       55055 :         if (php_check_open_basedir_ex(url, (flags & PHP_STREAM_URL_STAT_QUIET) ? 0 : 1 TSRMLS_CC)) {
    1009           9 :                 return -1;
    1010             :         }
    1011             : 
    1012             : #ifdef PHP_WIN32
    1013             :         if (EG(windows_version_info).dwMajorVersion >= 5) {
    1014             :                 if (flags & PHP_STREAM_URL_STAT_LINK) {
    1015             :                         return VCWD_LSTAT(url, &ssb->sb);
    1016             :                 }
    1017             :         }
    1018             : #else
    1019             : # ifdef HAVE_SYMLINK
    1020       55046 :         if (flags & PHP_STREAM_URL_STAT_LINK) {
    1021        2515 :                 return VCWD_LSTAT(url, &ssb->sb);
    1022             :         } else
    1023             : # endif
    1024             : #endif
    1025       52531 :                 return VCWD_STAT(url, &ssb->sb);
    1026             : }
    1027             : 
    1028      216083 : static int php_plain_files_unlink(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context TSRMLS_DC)
    1029             : {
    1030             :         char *p;
    1031             :         int ret;
    1032             : 
    1033      216083 :         if ((p = strstr(url, "://")) != NULL) {
    1034           0 :                 if (p < strchr(url, '/')) {
    1035           0 :                         url = p + 3;
    1036             :                 }
    1037             :         }
    1038             : 
    1039      216083 :         if (php_check_open_basedir(url TSRMLS_CC)) {
    1040           6 :                 return 0;
    1041             :         }
    1042             : 
    1043      216077 :         ret = VCWD_UNLINK(url);
    1044      216077 :         if (ret == -1) {
    1045      188777 :                 if (options & REPORT_ERRORS) {
    1046      188777 :                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(errno));
    1047             :                 }
    1048      188777 :                 return 0;
    1049             :         }
    1050             : 
    1051             :         /* Clear stat cache (and realpath cache) */
    1052       27300 :         php_clear_stat_cache(1, NULL, 0 TSRMLS_CC);
    1053             : 
    1054       27300 :         return 1;
    1055             : }
    1056             : 
    1057          79 : static int php_plain_files_rename(php_stream_wrapper *wrapper, const char *url_from, const char *url_to, int options, php_stream_context *context TSRMLS_DC)
    1058             : {
    1059             :         char *p;
    1060             :         int ret;
    1061             : 
    1062          79 :         if (!url_from || !url_to) {
    1063           0 :                 return 0;
    1064             :         }
    1065             : 
    1066             : #ifdef PHP_WIN32
    1067             :         if (!php_win32_check_trailing_space(url_from, strlen(url_from))) {
    1068             :                 php_win32_docref2_from_error(ERROR_INVALID_NAME, url_from, url_to TSRMLS_CC);
    1069             :                 return 0;
    1070             :         }
    1071             :         if (!php_win32_check_trailing_space(url_to, strlen(url_to))) {
    1072             :                 php_win32_docref2_from_error(ERROR_INVALID_NAME, url_from, url_to TSRMLS_CC);
    1073             :                 return 0;
    1074             :         }
    1075             : #endif
    1076             : 
    1077          79 :         if ((p = strstr(url_from, "://")) != NULL) {
    1078           0 :                 if (p < strchr(url_from, '/')) {
    1079           0 :                         url_from = p + 3;
    1080             :                 }
    1081             :         }
    1082             : 
    1083          79 :         if ((p = strstr(url_to, "://")) != NULL) {
    1084           0 :                 if (p < strchr(url_to, '/')) {
    1085           0 :                         url_to = p + 3;
    1086             :                 }
    1087             :         }
    1088             : 
    1089          79 :         if (php_check_open_basedir(url_from TSRMLS_CC) || php_check_open_basedir(url_to TSRMLS_CC)) {
    1090           5 :                 return 0;
    1091             :         }
    1092             : 
    1093          74 :         ret = VCWD_RENAME(url_from, url_to);
    1094             : 
    1095          74 :         if (ret == -1) {
    1096             : #ifndef PHP_WIN32
    1097             : # ifdef EXDEV
    1098          24 :                 if (errno == EXDEV) {
    1099             :                         struct stat sb;
    1100           0 :                         if (php_copy_file(url_from, url_to TSRMLS_CC) == SUCCESS) {
    1101           0 :                                 if (VCWD_STAT(url_from, &sb) == 0) {
    1102             : #  if !defined(TSRM_WIN32) && !defined(NETWARE)
    1103           0 :                                         if (VCWD_CHMOD(url_to, sb.st_mode)) {
    1104           0 :                                                 if (errno == EPERM) {
    1105           0 :                                                         php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1106           0 :                                                         VCWD_UNLINK(url_from);
    1107           0 :                                                         return 1;
    1108             :                                                 }
    1109           0 :                                                 php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1110           0 :                                                 return 0;
    1111             :                                         }
    1112           0 :                                         if (VCWD_CHOWN(url_to, sb.st_uid, sb.st_gid)) {
    1113           0 :                                                 if (errno == EPERM) {
    1114           0 :                                                         php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1115           0 :                                                         VCWD_UNLINK(url_from);
    1116           0 :                                                         return 1;
    1117             :                                                 }
    1118           0 :                                                 php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1119           0 :                                                 return 0;
    1120             :                                         }
    1121             : #  endif
    1122           0 :                                         VCWD_UNLINK(url_from);
    1123           0 :                                         return 1;
    1124             :                                 }
    1125             :                         }
    1126           0 :                         php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1127           0 :                         return 0;
    1128             :                 }
    1129             : # endif
    1130             : #endif
    1131             : 
    1132             : #ifdef PHP_WIN32
    1133             :                 php_win32_docref2_from_error(GetLastError(), url_from, url_to TSRMLS_CC);
    1134             : #else
    1135          24 :                 php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1136             : #endif
    1137          24 :                 return 0;
    1138             :         }
    1139             : 
    1140             :         /* Clear stat cache (and realpath cache) */
    1141          50 :         php_clear_stat_cache(1, NULL, 0 TSRMLS_CC);
    1142             : 
    1143          50 :         return 1;
    1144             : }
    1145             : 
    1146        1675 : static int php_plain_files_mkdir(php_stream_wrapper *wrapper, const char *dir, int mode, int options, php_stream_context *context TSRMLS_DC)
    1147             : {
    1148        1675 :         int ret, recursive = options & PHP_STREAM_MKDIR_RECURSIVE;
    1149             :         char *p;
    1150             : 
    1151        1675 :         if ((p = strstr(dir, "://")) != NULL) {
    1152           0 :                 if (p < strchr(dir, '/')) {
    1153           0 :                         dir = p + 3;
    1154             :                 }
    1155             :         }
    1156             : 
    1157        1675 :         if (!recursive) {
    1158        1112 :                 ret = php_mkdir(dir, mode TSRMLS_CC);
    1159             :         } else {
    1160             :                 /* we look for directory separator from the end of string, thus hopefuly reducing our work load */
    1161             :                 char *e;
    1162             :                 struct stat sb;
    1163         563 :                 int dir_len = strlen(dir);
    1164         563 :                 int offset = 0;
    1165             :                 char buf[MAXPATHLEN];
    1166             : 
    1167         563 :                 if (!expand_filepath_with_mode(dir, buf, NULL, 0, CWD_EXPAND  TSRMLS_CC)) {
    1168           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid path");
    1169           0 :                         return 0;
    1170             :                 }
    1171             : 
    1172         563 :                 e = buf +  strlen(buf);
    1173             : 
    1174         563 :                 if ((p = memchr(buf, DEFAULT_SLASH, dir_len))) {
    1175         563 :                         offset = p - buf + 1;
    1176             :                 }
    1177             : 
    1178         563 :                 if (p && dir_len == 1) {
    1179             :                         /* buf == "DEFAULT_SLASH" */  
    1180             :                 }
    1181             :                 else {
    1182             :                         /* find a top level directory we need to create */
    1183        1683 :                         while ( (p = strrchr(buf + offset, DEFAULT_SLASH)) || (offset != 1 && (p = strrchr(buf, DEFAULT_SLASH))) ) {
    1184        1120 :                                 int n = 0;
    1185             : 
    1186        1120 :                                 *p = '\0';
    1187        2240 :                                 while (p > buf && *(p-1) == DEFAULT_SLASH) {
    1188           0 :                                         ++n;
    1189           0 :                                         --p;
    1190           0 :                                         *p = '\0';
    1191             :                                 }
    1192        1120 :                                 if (VCWD_STAT(buf, &sb) == 0) {
    1193             :                                         while (1) {
    1194         563 :                                                 *p = DEFAULT_SLASH;
    1195         563 :                                                 if (!n) break;
    1196           0 :                                                 --n;
    1197           0 :                                                 ++p;
    1198           0 :                                         }
    1199         563 :                                         break;
    1200             :                                 }
    1201             :                         }
    1202             :                 }
    1203             : 
    1204         563 :                 if (p == buf) {
    1205           0 :                         ret = php_mkdir(dir, mode TSRMLS_CC);
    1206         563 :                 } else if (!(ret = php_mkdir(buf, mode TSRMLS_CC))) {
    1207         562 :                         if (!p) {
    1208           0 :                                 p = buf;
    1209             :                         }
    1210             :                         /* create any needed directories if the creation of the 1st directory worked */
    1211       10635 :                         while (++p != e) {
    1212        9511 :                                 if (*p == '\0') {
    1213         557 :                                         *p = DEFAULT_SLASH;
    1214         592 :                                         if ((*(p+1) != '\0') &&
    1215          35 :                                                 (ret = VCWD_MKDIR(buf, (mode_t)mode)) < 0) {
    1216           0 :                                                 if (options & REPORT_ERRORS) {
    1217           0 :                                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
    1218             :                                                 }
    1219           0 :                                                 break;
    1220             :                                         }
    1221             :                                 }
    1222             :                         }
    1223             :                 }
    1224             :         }
    1225        1675 :         if (ret < 0) {
    1226             :                 /* Failure */
    1227          50 :                 return 0;
    1228             :         } else {
    1229             :                 /* Success */
    1230        1625 :                 return 1;
    1231             :         }
    1232             : }
    1233             : 
    1234        1696 : static int php_plain_files_rmdir(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context TSRMLS_DC)
    1235             : {
    1236             : #if PHP_WIN32
    1237             :         int url_len = strlen(url);
    1238             : #endif
    1239        1696 :         if (php_check_open_basedir(url TSRMLS_CC)) {
    1240           5 :                 return 0;
    1241             :         }
    1242             : 
    1243             : #if PHP_WIN32
    1244             :         if (!php_win32_check_trailing_space(url, url_len)) {
    1245             :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(ENOENT));
    1246             :                 return 0;
    1247             :         }
    1248             : #endif
    1249             : 
    1250        1691 :         if (VCWD_RMDIR(url) < 0) {
    1251          31 :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(errno));
    1252          31 :                 return 0;
    1253             :         }
    1254             : 
    1255             :         /* Clear stat cache (and realpath cache) */
    1256        1660 :         php_clear_stat_cache(1, NULL, 0 TSRMLS_CC);
    1257             : 
    1258        1660 :         return 1;
    1259             : }
    1260             : 
    1261           0 : static int php_plain_files_metadata(php_stream_wrapper *wrapper, const char *url, int option, void *value, php_stream_context *context TSRMLS_DC)
    1262             : {
    1263             :         struct utimbuf *newtime;
    1264             :         char *p;
    1265             : #if !defined(WINDOWS) && !defined(NETWARE)
    1266             :         uid_t uid;
    1267             :         gid_t gid;
    1268             : #endif
    1269             :         mode_t mode;
    1270           0 :         int ret = 0;
    1271             : #if PHP_WIN32
    1272             :         int url_len = strlen(url);
    1273             : #endif
    1274             : 
    1275             : #if PHP_WIN32
    1276             :         if (!php_win32_check_trailing_space(url, url_len)) {
    1277             :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(ENOENT));
    1278             :                 return 0;
    1279             :         }
    1280             : #endif
    1281             : 
    1282           0 :         if ((p = strstr(url, "://")) != NULL) {
    1283           0 :                 if (p < strchr(url, '/')) {
    1284           0 :                         url = p + 3;
    1285             :                 }
    1286             :         }
    1287             : 
    1288           0 :         if (php_check_open_basedir(url TSRMLS_CC)) {
    1289           0 :                 return 0;
    1290             :         }
    1291             : 
    1292           0 :         switch(option) {
    1293             :                 case PHP_STREAM_META_TOUCH:
    1294           0 :                         newtime = (struct utimbuf *)value;
    1295           0 :                         if (VCWD_ACCESS(url, F_OK) != 0) {
    1296           0 :                                 FILE *file = VCWD_FOPEN(url, "w");
    1297           0 :                                 if (file == NULL) {
    1298           0 :                                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unable to create file %s because %s", url, strerror(errno));
    1299           0 :                                         return 0;
    1300             :                                 }
    1301           0 :                                 fclose(file);
    1302             :                         }
    1303             : 
    1304           0 :                         ret = VCWD_UTIME(url, newtime);
    1305           0 :                         break;
    1306             : #if !defined(WINDOWS) && !defined(NETWARE)
    1307             :                 case PHP_STREAM_META_OWNER_NAME:
    1308             :                 case PHP_STREAM_META_OWNER:
    1309           0 :                         if(option == PHP_STREAM_META_OWNER_NAME) {
    1310           0 :                                 if(php_get_uid_by_name((char *)value, &uid TSRMLS_CC) != SUCCESS) {
    1311           0 :                                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unable to find uid for %s", (char *)value);
    1312           0 :                                         return 0;
    1313             :                                 }
    1314             :                         } else {
    1315           0 :                                 uid = (uid_t)*(long *)value;
    1316             :                         }
    1317           0 :                         ret = VCWD_CHOWN(url, uid, -1);
    1318           0 :                         break;
    1319             :                 case PHP_STREAM_META_GROUP:
    1320             :                 case PHP_STREAM_META_GROUP_NAME:
    1321           0 :                         if(option == PHP_STREAM_META_OWNER_NAME) {
    1322           0 :                                 if(php_get_gid_by_name((char *)value, &gid TSRMLS_CC) != SUCCESS) {
    1323           0 :                                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unable to find gid for %s", (char *)value);
    1324           0 :                                         return 0;
    1325             :                                 }
    1326             :                         } else {
    1327           0 :                                 gid = (gid_t)*(long *)value;
    1328             :                         }
    1329           0 :                         ret = VCWD_CHOWN(url, -1, gid);
    1330           0 :                         break;
    1331             : #endif
    1332             :                 case PHP_STREAM_META_ACCESS:
    1333           0 :                         mode = (mode_t)*(long *)value;
    1334           0 :                         ret = VCWD_CHMOD(url, mode);
    1335           0 :                         break;
    1336             :                 default:
    1337           0 :                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unknown option %d for stream_metadata", option);
    1338           0 :                         return 0;
    1339             :         }
    1340           0 :         if (ret == -1) {
    1341           0 :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Operation failed: %s", strerror(errno));
    1342           0 :                 return 0;
    1343             :         }
    1344           0 :         php_clear_stat_cache(0, NULL, 0 TSRMLS_CC);
    1345           0 :         return 1;
    1346             : }
    1347             : 
    1348             : 
    1349             : static php_stream_wrapper_ops php_plain_files_wrapper_ops = {
    1350             :         php_plain_files_stream_opener,
    1351             :         NULL,
    1352             :         NULL,
    1353             :         php_plain_files_url_stater,
    1354             :         php_plain_files_dir_opener,
    1355             :         "plainfile",
    1356             :         php_plain_files_unlink,
    1357             :         php_plain_files_rename,
    1358             :         php_plain_files_mkdir,
    1359             :         php_plain_files_rmdir,
    1360             :         php_plain_files_metadata
    1361             : };
    1362             : 
    1363             : php_stream_wrapper php_plain_files_wrapper = {
    1364             :         &php_plain_files_wrapper_ops,
    1365             :         NULL,
    1366             :         0
    1367             : };
    1368             : 
    1369             : /* {{{ php_stream_fopen_with_path */
    1370           0 : PHPAPI php_stream *_php_stream_fopen_with_path(const char *filename, const char *mode, const char *path, char **opened_path, int options STREAMS_DC TSRMLS_DC)
    1371             : {
    1372             :         /* code ripped off from fopen_wrappers.c */
    1373             :         char *pathbuf, *end;
    1374             :         const char *ptr;
    1375             :         const char *exec_fname;
    1376             :         char trypath[MAXPATHLEN];
    1377             :         php_stream *stream;
    1378             :         int path_length;
    1379             :         int filename_length;
    1380             :         int exec_fname_length;
    1381             : 
    1382           0 :         if (opened_path) {
    1383           0 :                 *opened_path = NULL;
    1384             :         }
    1385             : 
    1386           0 :         if(!filename) {
    1387           0 :                 return NULL;
    1388             :         }
    1389             : 
    1390           0 :         filename_length = strlen(filename);
    1391             : 
    1392             :         /* Relative path open */
    1393           0 :         if (*filename == '.' && (IS_SLASH(filename[1]) || filename[1] == '.')) {
    1394             :                 /* further checks, we could have ....... filenames */
    1395           0 :                 ptr = filename + 1;
    1396           0 :                 if (*ptr == '.') {
    1397           0 :                         while (*(++ptr) == '.');
    1398           0 :                         if (!IS_SLASH(*ptr)) { /* not a relative path after all */
    1399           0 :                                 goto not_relative_path;
    1400             :                         }
    1401             :                 }
    1402             : 
    1403             : 
    1404           0 :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(filename TSRMLS_CC)) {
    1405           0 :                         return NULL;
    1406             :                 }
    1407             : 
    1408           0 :                 return php_stream_fopen_rel(filename, mode, opened_path, options);
    1409             :         }
    1410             : 
    1411             : not_relative_path:
    1412             : 
    1413             :         /* Absolute path open */
    1414           0 :         if (IS_ABSOLUTE_PATH(filename, filename_length)) {
    1415             : 
    1416           0 :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(filename TSRMLS_CC)) {
    1417           0 :                         return NULL;
    1418             :                 }
    1419             : 
    1420           0 :                 return php_stream_fopen_rel(filename, mode, opened_path, options);
    1421             :         }
    1422             :         
    1423             : #ifdef PHP_WIN32
    1424             :         if (IS_SLASH(filename[0])) {
    1425             :                 size_t cwd_len;
    1426             :                 char *cwd;
    1427             :                 cwd = virtual_getcwd_ex(&cwd_len TSRMLS_CC);
    1428             :                 /* getcwd() will return always return [DRIVE_LETTER]:/) on windows. */
    1429             :                 *(cwd+3) = '\0';
    1430             :         
    1431             :                 if (snprintf(trypath, MAXPATHLEN, "%s%s", cwd, filename) >= MAXPATHLEN) {
    1432             :                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s/%s path was truncated to %d", cwd, filename, MAXPATHLEN);
    1433             :                 }
    1434             :                 
    1435             :                 efree(cwd);
    1436             :                 
    1437             :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(trypath TSRMLS_CC)) {
    1438             :                         return NULL;
    1439             :                 }
    1440             :                 
    1441             :                 return php_stream_fopen_rel(trypath, mode, opened_path, options);
    1442             :         }
    1443             : #endif
    1444             : 
    1445           0 :         if (!path || (path && !*path)) {
    1446           0 :                 return php_stream_fopen_rel(filename, mode, opened_path, options);
    1447             :         }
    1448             : 
    1449             :         /* check in provided path */
    1450             :         /* append the calling scripts' current working directory
    1451             :          * as a fall back case
    1452             :          */
    1453           0 :         if (zend_is_executing(TSRMLS_C)) {
    1454           0 :                 exec_fname = zend_get_executed_filename(TSRMLS_C);
    1455           0 :                 exec_fname_length = strlen(exec_fname);
    1456           0 :                 path_length = strlen(path);
    1457             : 
    1458           0 :                 while ((--exec_fname_length >= 0) && !IS_SLASH(exec_fname[exec_fname_length]));
    1459           0 :                 if ((exec_fname && exec_fname[0] == '[')
    1460             :                                 || exec_fname_length<=0) {
    1461             :                         /* [no active file] or no path */
    1462           0 :                         pathbuf = estrdup(path);
    1463             :                 } else {
    1464           0 :                         pathbuf = (char *) emalloc(exec_fname_length + path_length +1 +1);
    1465           0 :                         memcpy(pathbuf, path, path_length);
    1466           0 :                         pathbuf[path_length] = DEFAULT_DIR_SEPARATOR;
    1467           0 :                         memcpy(pathbuf+path_length+1, exec_fname, exec_fname_length);
    1468           0 :                         pathbuf[path_length + exec_fname_length +1] = '\0';
    1469             :                 }
    1470             :         } else {
    1471           0 :                 pathbuf = estrdup(path);
    1472             :         }
    1473             : 
    1474           0 :         ptr = pathbuf;
    1475             : 
    1476           0 :         while (ptr && *ptr) {
    1477           0 :                 end = strchr(ptr, DEFAULT_DIR_SEPARATOR);
    1478           0 :                 if (end != NULL) {
    1479           0 :                         *end = '\0';
    1480           0 :                         end++;
    1481             :                 }
    1482           0 :                 if (*ptr == '\0') {
    1483           0 :                         goto stream_skip;
    1484             :                 }
    1485           0 :                 if (snprintf(trypath, MAXPATHLEN, "%s/%s", ptr, filename) >= MAXPATHLEN) {
    1486           0 :                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s/%s path was truncated to %d", ptr, filename, MAXPATHLEN);
    1487             :                 }
    1488             : 
    1489           0 :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir_ex(trypath, 0 TSRMLS_CC)) {
    1490           0 :                         goto stream_skip;
    1491             :                 }
    1492             :                 
    1493           0 :                 stream = php_stream_fopen_rel(trypath, mode, opened_path, options);
    1494           0 :                 if (stream) {
    1495           0 :                         efree(pathbuf);
    1496           0 :                         return stream;
    1497             :                 }
    1498             : stream_skip:
    1499           0 :                 ptr = end;
    1500             :         } /* end provided path */
    1501             : 
    1502           0 :         efree(pathbuf);
    1503           0 :         return NULL;
    1504             : 
    1505             : }
    1506             : /* }}} */
    1507             : 
    1508             : /*
    1509             :  * Local variables:
    1510             :  * tab-width: 4
    1511             :  * c-basic-offset: 4
    1512             :  * End:
    1513             :  * vim600: noet sw=4 ts=4 fdm=marker
    1514             :  * vim<600: noet sw=4 ts=4
    1515             :  */

Generated by: LCOV version 1.10

Generated at Tue, 22 Jul 2014 01:33:25 +0000 (4 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.